[backend] fix contextual team while duplicating scenario #1303

openbas-api/src/main/java/io/openbas/rest/exercise/ExerciseService.java

@@ -3,14 +3,15 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import io.openbas.config.OpenBASConfig;
-import io.openbas.database.criteria.GenericCriteria;
 import io.openbas.database.model.*;
 import io.openbas.database.repository.ArticleRepository;
 import io.openbas.database.repository.ExerciseRepository;
+import io.openbas.database.repository.TeamRepository;
 import io.openbas.rest.exercise.form.ExerciseSimple;
 import io.openbas.rest.inject.service.InjectDuplicateService;
 import io.openbas.service.GrantService;
 import io.openbas.service.InjectService;
+import io.openbas.service.TeamService;
 import io.openbas.service.VariableService;
 import jakarta.annotation.Resource;
 import jakarta.persistence.EntityManager;
@@ -56,10 +57,12 @@
     private final GrantService grantService;
     private final InjectService injectService;
     private final InjectDuplicateService injectDuplicateService;
+    private final TeamService teamService;
     private final VariableService variableService;
 
     private final ArticleRepository articleRepository;
     private final ExerciseRepository exerciseRepository;
+    private final TeamRepository teamRepository;
 
     // region properties
     @Value("${openbas.mail.imap.enabled}")
@@ -211,6 +214,7 @@
         Exercise exercise = copyExercice(exerciseOrigin);
         Exercise exerciseDuplicate = exerciseRepository.save(exercise);
         getListOfDuplicatedInjects(exerciseDuplicate, exerciseOrigin);
+        getListOfExerciseTeams(exerciseDuplicate, exerciseOrigin);
         getListOfArticles(exerciseDuplicate, exerciseOrigin);
         getListOfVariables(exerciseDuplicate, exerciseOrigin);
         return exerciseRepository.save(exercise);
@@ -232,14 +236,41 @@
         exerciseDuplicate.setLogoLight(exerciseOrigin.getLogoLight());
         exerciseDuplicate.setGrants(new ArrayList<>(exerciseOrigin.getGrants()));
         exerciseDuplicate.setTags(new HashSet<>(exerciseOrigin.getTags()));
-        exerciseDuplicate.setTeams(new ArrayList<>(exerciseOrigin.getTeams()));
         exerciseDuplicate.setTeamUsers(new ArrayList<>(exerciseOrigin.getTeamUsers()));
         exerciseDuplicate.setReplyTos(new ArrayList<>(exerciseOrigin.getReplyTos()));
         exerciseDuplicate.setDocuments(new ArrayList<>(exerciseOrigin.getDocuments()));
         exerciseDuplicate.setObjectives(new ArrayList<>(exerciseOrigin.getObjectives()));
         return exerciseDuplicate;
     }
 
+    private void getListOfExerciseTeams(@NotNull Exercise exercise,@NotNull Exercise exerciseOrigin){
+        Map<String, Team> contextualTeams = new HashMap<>();
+        List<Team> exerciseTeams = new ArrayList<>();
+        exerciseOrigin.getTeams().forEach(scenarioTeam -> {
+            if (scenarioTeam.getContextual()) {
+                Team team = teamService.copyContextualTeam(scenarioTeam);
+                Team teamSaved = this.teamRepository.save(team);
+                exerciseTeams.add(teamSaved);
+                contextualTeams.put(scenarioTeam.getId(), teamSaved);
+            } else {
+                exerciseTeams.add(scenarioTeam);
+            }
+        });
+        exercise.setTeams(new ArrayList<>(exerciseTeams));
+
+        exercise.getInjects().forEach(inject -> {
+            List<Team> teams = new ArrayList<>();
+            inject.getTeams().forEach(team -> {
+                if (team.getContextual()) {
+                    teams.add(contextualTeams.get(team.getId()));
+                } else {
+                    teams.add(team);
+                }
+            });
+            inject.setTeams(teams);
+        });
+    }
+
     private void getListOfDuplicatedInjects(Exercise exercise, Exercise exerciseOrigin) {
         List<Inject> injectListForExercise = exerciseOrigin.getInjects()
                 .stream().map(inject -> injectDuplicateService.createInjectForExercise(exercise.getId(), inject.getId(), false))

openbas-api/src/main/java/io/openbas/service/ScenarioService.java

@@ -4,7 +4,6 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import io.openbas.config.OpenBASConfig;
-import io.openbas.database.criteria.GenericCriteria;
 import io.openbas.database.model.*;
 import io.openbas.database.raw.RawPaginationScenario;
 import io.openbas.database.raw.RawScenario;
@@ -86,16 +85,18 @@ public class ScenarioService {
   private EntityManager entityManager;
 
   private final ScenarioRepository scenarioRepository;
-  private final GrantService grantService;
-  private final VariableService variableService;
-  private final ChallengeService challengeService;
-  private final DocumentRepository documentRepository;
   private final TeamRepository teamRepository;
   private final UserRepository userRepository;
+  private final DocumentRepository documentRepository;
   private final ScenarioTeamUserRepository scenarioTeamUserRepository;
+  private final ArticleRepository articleRepository;
+
+  private final GrantService grantService;
+  private final VariableService variableService;
+  private final ChallengeService challengeService;
+  private final TeamService teamService;
   private final FileService fileService;
   private final InjectDuplicateService injectDuplicateService;
-  private final ArticleRepository articleRepository;
 
   @Transactional
   public Scenario createScenario(@NotNull final Scenario scenario) {
@@ -485,13 +486,43 @@ public Scenario getDuplicateScenario(@NotBlank String scenarioId) {
       Scenario scenario = copyScenario(scenarioOrigin);
       Scenario scenarioDuplicate = scenarioRepository.save(scenario);
       getListOfDuplicatedInjects(scenarioDuplicate, scenarioOrigin);
+      getListOfScenarioTeams(scenarioDuplicate, scenarioOrigin);
       getListOfArticles(scenarioDuplicate, scenarioOrigin);
       getListOfVariables(scenarioDuplicate, scenarioOrigin);
       return scenarioRepository.save(scenario);
     }
     throw new ElementNotFoundException();
   }
 
+  private void getListOfScenarioTeams(@NotNull Scenario scenario, @NotNull Scenario scenarioOrigin) {
+    Map<String, Team> contextualTeams = new HashMap<>();
+    List<Team> scenarioTeams = new ArrayList<>();
+    scenarioOrigin.getTeams().forEach(scenarioTeam -> {
+      if (scenarioTeam.getContextual()) {
+        Team team = teamService.copyContextualTeam(scenarioTeam);
+        Team teamSaved = this.teamRepository.save(team);
+        scenarioTeams.add(teamSaved);
+        contextualTeams.put(scenarioTeam.getId(), teamSaved);
+      } else {
+        scenarioTeams.add(scenarioTeam);
+      }
+    });
+    scenario.setTeams(new ArrayList<>(scenarioTeams));
+
+    List<Inject> scenarioInjects = scenario.getInjects();
+    scenarioInjects.forEach(scenarioInject -> {
+      List<Team> teams = new ArrayList<>();
+      scenarioInject.getTeams().forEach(team -> {
+        if (team.getContextual()) {
+          teams.add(contextualTeams.get(team.getId()));
+        } else {
+          teams.add(team);
+        }
+      });
+      scenarioInject.setTeams(teams);
+    });
+  }
+
   private Scenario copyScenario(Scenario scenario) {
     Scenario scenarioDuplicate = new Scenario();
     scenarioDuplicate.setName(duplicateString(scenario.getName()));
@@ -507,7 +538,6 @@ private Scenario copyScenario(Scenario scenario) {
     scenarioDuplicate.setInjects(new HashSet<>(scenario.getInjects()));
     scenarioDuplicate.setExternalReference(scenario.getExternalReference());
     scenarioDuplicate.setTeamUsers(new ArrayList<>(scenario.getTeamUsers()));
-    scenarioDuplicate.setTeams(new ArrayList<>(scenario.getTeams()));
     scenarioDuplicate.setReplyTos(new ArrayList<>(scenario.getReplyTos()));
     scenarioDuplicate.setLessonsCategories(new ArrayList<>(scenario.getLessonsCategories()));
     scenarioDuplicate.setObjectives(new ArrayList<>(scenario.getObjectives()));

openbas-api/src/main/java/io/openbas/service/ScenarioToExerciseService.java

@@ -6,6 +6,7 @@
 import io.openbas.database.repository.*;
 import io.openbas.injectors.channel.ChannelContract;
 import io.openbas.injectors.channel.model.ChannelContent;
+import io.openbas.utils.CopyObjectListUtils;
 import jakarta.annotation.Nullable;
 import jakarta.annotation.Resource;
 import jakarta.validation.constraints.NotBlank;
@@ -37,6 +38,7 @@ public class ScenarioToExerciseService {
     private final LessonsQuestionRepository lessonsQuestionRepository;
     private final InjectRepository injectRepository;
     private final InjectDocumentRepository injectDocumentRepository;
+    private final TeamService teamService;
     private final VariableService variableService;
 
     @Transactional(rollbackFor = Exception.class)
@@ -58,7 +60,7 @@ public Exercise toExercise(
         exercise.setStart(start);
 
         // Tags
-        exercise.setTags(copy(scenario.getTags(), Tag.class));
+        exercise.setTags(CopyObjectListUtils.copy(scenario.getTags(), Tag.class));
 
         Exercise exerciseSaved = this.exerciseRepository.save(exercise);
 
@@ -78,17 +80,10 @@ public Exercise toExercise(
         Map<String, Team> contextualTeams = new HashMap<>();
         scenario.getTeams().forEach(scenarioTeam -> {
             if (scenarioTeam.getContextual()) {
-                Team team = new Team();
-                team.setName(scenarioTeam.getName());
-                team.setDescription(scenarioTeam.getDescription());
-                team.setTags(copy(scenarioTeam.getTags(), Tag.class));
-                team.setOrganization(scenarioTeam.getOrganization());
-
-                team.setUsers(copy(scenarioTeam.getUsers(), User.class));
+                Team team = teamService.copyContextualTeam(scenarioTeam);
                 team.setExercises(new ArrayList<>() {{
                     add(exerciseSaved);
                 }});
-                team.setContextual(scenarioTeam.getContextual());
                 Team teamSaved = this.teamRepository.save(team);
                 contextualTeams.put(scenarioTeam.getId(), teamSaved);
             } else {
@@ -198,7 +193,7 @@ public Exercise toExercise(
             exerciseInject.setDependsDuration(scenarioInject.getDependsDuration());
             exerciseInject.setUser(scenarioInject.getUser());
             exerciseInject.setStatus(scenarioInject.getStatus().orElse(null));
-            exerciseInject.setTags(copy(scenarioInject.getTags(), Tag.class));
+            exerciseInject.setTags(CopyObjectListUtils.copy(scenarioInject.getTags(), Tag.class));
             exerciseInject.setContent(scenarioInject.getContent());
 
             // Content
@@ -223,8 +218,8 @@ public Exercise toExercise(
             exerciseInject.setTeams(teams);
 
             // Assets & Asset Groups
-            exerciseInject.setAssets(copy(scenarioInject.getAssets(), Asset.class));
-            exerciseInject.setAssetGroups(copy(scenarioInject.getAssetGroups(), AssetGroup.class));
+            exerciseInject.setAssets(CopyObjectListUtils.copy(scenarioInject.getAssets(), Asset.class));
+            exerciseInject.setAssetGroups(CopyObjectListUtils.copy(scenarioInject.getAssetGroups(), AssetGroup.class));
             Inject injectSaved = this.injectRepository.save(exerciseInject);
 
             // Documents
@@ -257,35 +252,7 @@ public Exercise toExercise(
         return exerciseSaved;
     }
 
-    private <T extends Base> List<T> copy(@NotNull final List<T> origins, Class<T> clazz) {
-        List<T> destinations = new ArrayList<>();
-        origins.forEach(origin -> {
-            try {
-                T destination = clazz.getDeclaredConstructor().newInstance();
-                BeanUtils.copyProperties(destination, origin);
-                destinations.add(destination);
-            } catch (IllegalAccessException | InvocationTargetException | InstantiationException |
-                     NoSuchMethodException e) {
-                throw new RuntimeException(e);
-            }
-        });
-        return destinations;
-    }
 
-    private <T extends Base> Set<T> copy(@NotNull final Set<T> origins, Class<T> clazz) {
-        Set<T> destinations = new HashSet<>();
-        origins.forEach(origin -> {
-            try {
-                T destination = clazz.getDeclaredConstructor().newInstance();
-                BeanUtils.copyProperties(destination, origin);
-                destinations.add(destination);
-            } catch (IllegalAccessException | InvocationTargetException | InstantiationException |
-                     NoSuchMethodException e) {
-                throw new RuntimeException(e);
-            }
-        });
-        return destinations;
-    }
 
     private List<Document> addExerciseToDocuments(
             @NotNull final List<Document> origDocuments,

openbas-api/src/main/java/io/openbas/service/TeamService.java

@@ -0,0 +1,21 @@
+package io.openbas.service;
+
+import io.openbas.database.model.*;
+import io.openbas.utils.CopyObjectListUtils;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TeamService {
+
+    public Team copyContextualTeam(Team teamToCopy) {
+        Team newTeam = new Team();
+        newTeam.setName(teamToCopy.getName());
+        newTeam.setDescription(teamToCopy.getDescription());
+        newTeam.setTags(CopyObjectListUtils.copy(teamToCopy.getTags(), Tag.class));
+        newTeam.setOrganization(teamToCopy.getOrganization());
+        newTeam.setUsers(CopyObjectListUtils.copy(teamToCopy.getUsers(), User.class));
+        newTeam.setContextual(teamToCopy.getContextual());
+        return newTeam;
+    }
+
+}

openbas-api/src/main/java/io/openbas/utils/CopyObjectListUtils.java

@@ -0,0 +1,36 @@
+package io.openbas.utils;
+
+import io.openbas.database.model.Base;
+import jakarta.validation.constraints.NotNull;
+import org.apache.commons.beanutils.BeanUtils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
+
+public class CopyObjectListUtils {
+
+    public static <T extends Base> List<T> copy(@NotNull final List<T> origins, Class<T> clazz) {
+        List<T> destinations = new ArrayList<>();
+        return copyCollection(origins, clazz, destinations);
+    }
+
+    public static <T extends Base> Set<T> copy(@NotNull final Set<T> origins, Class<T> clazz) {
+        Set<T> destinations = new HashSet<>();
+        return copyCollection(origins, clazz, destinations);
+    }
+
+    public static <T extends Base, C extends Collection<T>> C copyCollection(@NotNull final C origins, Class<T> clazz, C destinations) {
+        origins.forEach(origin -> {
+            try {
+                T destination = clazz.getDeclaredConstructor().newInstance();
+                BeanUtils.copyProperties(destination, origin);
+                destinations.add(destination);
+            } catch (IllegalAccessException | InvocationTargetException | InstantiationException |
+                     NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        return destinations;
+    }
+
+}