[backend/frontend] Restarting an atomic testing keeps the same Inject…

… UUID (#1847)

openbas-api/src/main/java/io/openbas/rest/atomic_testing/AtomicTestingApi.java

@@ -1,7 +1,6 @@
 package io.openbas.rest.atomic_testing;
 
 import io.openbas.aop.LogExecutionTime;
-import io.openbas.database.model.Inject;
 import io.openbas.database.model.InjectExpectation;
 import io.openbas.inject_expectation.InjectExpectationService;
 import io.openbas.rest.atomic_testing.form.AtomicTestingInput;
@@ -55,12 +54,6 @@ public InjectResultOverviewOutput createAtomicTesting(
     return this.atomicTestingService.createOrUpdate(input, null);
   }
 
-  @PostMapping("/{atomicTestingId}")
-  public InjectResultOverviewOutput duplicateAtomicTesting(
-      @PathVariable final String atomicTestingId) {
-    return atomicTestingService.getDuplicateAtomicTesting(atomicTestingId);
-  }
-
   @PutMapping("/{injectId}")
   @Transactional(rollbackFor = Exception.class)
   public InjectResultOverviewOutput updateAtomicTesting(
@@ -74,9 +67,25 @@ public void deleteAtomicTesting(@PathVariable @NotBlank final String injectId) {
     atomicTestingService.deleteAtomicTesting(injectId);
   }
 
-  @GetMapping("/try/{injectId}")
-  public Inject tryAtomicTesting(@PathVariable String injectId) {
-    return atomicTestingService.tryInject(injectId);
+  @Tracing(name = "Duplicate an atomic testing", layer = "api", operation = "POST")
+  @PostMapping("/{atomicTestingId}/duplicate")
+  public InjectResultOverviewOutput duplicateAtomicTesting(
+      @PathVariable @NotBlank final String atomicTestingId) {
+    return atomicTestingService.duplicate(atomicTestingId);
+  }
+
+  @Tracing(name = "Launch an atomic testing", layer = "api", operation = "POST")
+  @PostMapping("/{atomicTestingId}/launch")
+  public InjectResultOverviewOutput launchAtomicTesting(
+      @PathVariable @NotBlank final String atomicTestingId) {
+    return atomicTestingService.launch(atomicTestingId);
+  }
+
+  @Tracing(name = "Relaunch an atomic testing", layer = "api", operation = "POST")
+  @PostMapping("/{atomicTestingId}/relaunch")
+  public InjectResultOverviewOutput relaunchAtomicTesting(
+      @PathVariable @NotBlank final String atomicTestingId) {
+    return atomicTestingService.relaunch(atomicTestingId);
   }
 
   @GetMapping("/{injectId}/target_results/{targetId}/types/{targetType}")

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

@@ -201,10 +201,7 @@ private void getListOfExerciseTeams(
   private void getListOfDuplicatedInjects(Exercise exercise, Exercise exerciseOrigin) {
     List<Inject> injectListForExercise =
         exerciseOrigin.getInjects().stream()
-            .map(
-                inject ->
-                    injectDuplicateService.createInjectForExercise(
-                        exercise.getId(), inject.getId(), false))
+            .map(inject -> injectDuplicateService.duplicateInjectForExercise(exercise, inject))
             .toList();
     exercise.setInjects(new ArrayList<>(injectListForExercise));
   }

openbas-api/src/main/java/io/openbas/rest/inject/InjectApi.java

@@ -29,7 +29,6 @@
 import io.openbas.rest.helper.RestBehavior;
 import io.openbas.rest.inject.form.*;
 import io.openbas.rest.inject.service.InjectDuplicateService;
-import io.openbas.service.AtomicTestingService;
 import io.openbas.service.InjectSearchService;
 import io.openbas.service.InjectService;
 import io.openbas.service.ScenarioService;
@@ -82,7 +81,6 @@ public class InjectApi extends RestBehavior {
   private final ScenarioService scenarioService;
   private final InjectService injectService;
   private final InjectSearchService injectSearchService;
-  private final AtomicTestingService atomicTestingService;
   private final InjectDuplicateService injectDuplicateService;
 
   // -- INJECTS --
@@ -165,11 +163,6 @@ public Inject injectExecutionCallback(
     return injectRepository.save(inject);
   }
 
-  @GetMapping("/api/injects/try/{injectId}")
-  public Inject tryInject(@PathVariable String injectId) {
-    return atomicTestingService.tryInject(injectId);
-  }
-
   @Transactional(rollbackFor = Exception.class)
   @PutMapping(INJECT_URI + "/{exerciseId}/{injectId}")
   @PreAuthorize("isExercisePlanner(#exerciseId)")
@@ -375,8 +368,10 @@ public Inject createInjectForExercise(
   @PostMapping(EXERCISE_URI + "/{exerciseId}/injects/{injectId}")
   @PreAuthorize("isExercisePlanner(#exerciseId)")
   public Inject duplicateInjectForExercise(
-      @PathVariable final String exerciseId, @PathVariable final String injectId) {
-    return injectDuplicateService.createInjectForExercise(exerciseId, injectId, true);
+      @PathVariable @NotBlank final String exerciseId,
+      @PathVariable @NotBlank final String injectId) {
+    return injectDuplicateService.duplicateInjectForExerciseWithDuplicateWordInTitle(
+        exerciseId, injectId);
   }
 
   @Transactional(rollbackFor = Exception.class)
@@ -606,8 +601,10 @@ public Inject createInjectForScenario(
   @PostMapping(SCENARIO_URI + "/{scenarioId}/injects/{injectId}")
   @PreAuthorize("isScenarioPlanner(#scenarioId)")
   public Inject duplicateInjectForScenario(
-      @PathVariable final String scenarioId, @PathVariable final String injectId) {
-    return injectDuplicateService.createInjectForScenario(scenarioId, injectId, true);
+      @PathVariable @NotBlank final String scenarioId,
+      @PathVariable @NotBlank final String injectId) {
+    return injectDuplicateService.duplicateInjectForScenarioWithDuplicateWordInTitle(
+        scenarioId, injectId);
   }
 
   @GetMapping(SCENARIO_URI + "/{scenarioId}/injects")

openbas-api/src/main/java/io/openbas/rest/inject/service/InjectDuplicateService.java

@@ -1,5 +1,7 @@
 package io.openbas.rest.inject.service;
 
+import static io.openbas.utils.StringUtils.duplicateString;
+
 import io.openbas.database.model.Exercise;
 import io.openbas.database.model.Inject;
 import io.openbas.database.model.Scenario;
@@ -8,11 +10,9 @@
 import io.openbas.database.repository.InjectRepository;
 import io.openbas.database.repository.ScenarioRepository;
 import io.openbas.rest.exception.ElementNotFoundException;
-import io.openbas.service.AtomicTestingService;
+import io.openbas.utils.InjectUtils;
 import jakarta.transaction.Transactional;
-import jakarta.validation.constraints.NotBlank;
 import lombok.RequiredArgsConstructor;
-import org.jetbrains.annotations.NotNull;
 import org.springframework.stereotype.Service;
 import org.springframework.validation.annotation.Validated;
 
@@ -25,43 +25,69 @@ public class InjectDuplicateService {
   private final ScenarioRepository scenarioRepository;
   private final InjectRepository injectRepository;
   private final InjectDocumentRepository injectDocumentRepository;
-  private final AtomicTestingService atomicTestingService;
 
   @Transactional
-  public Inject createInjectForScenario(
-      @NotBlank final String scenarioId, @NotBlank final String injectId, boolean isChild) {
-    Scenario scenario = scenarioRepository.findById(scenarioId).orElseThrow();
-    Inject injectOrigin = injectRepository.findById(injectId).orElseThrow();
-    Inject injectDuplicate = atomicTestingService.copyInject(injectOrigin, isChild);
-    injectDuplicate.setScenario(scenario);
-    Inject saved = injectRepository.save(injectDuplicate);
-    getDocumentList(saved, injectId);
-    return saved;
+  public Inject duplicateInjectForScenario(Scenario scenario, Inject inject) {
+    Inject duplicatedInject = getDuplicatedInjectWithScenario(scenario, inject);
+    return saveInject(inject, duplicatedInject);
+  }
+
+  @Transactional
+  public Inject duplicateInjectForScenarioWithDuplicateWordInTitle(
+      final String scenarioId, final String injectId) {
+    Scenario scenario =
+        scenarioRepository.findById(scenarioId).orElseThrow(ElementNotFoundException::new);
+    Inject inject = injectRepository.findById(injectId).orElseThrow(ElementNotFoundException::new);
+    Inject duplicatedInject = getDuplicatedInjectWithScenario(scenario, inject);
+    duplicatedInject.setTitle(duplicateString(duplicatedInject.getTitle()));
+    return saveInject(inject, duplicatedInject);
+  }
+
+  @Transactional
+  public Inject duplicateInjectForExercise(Exercise exercise, Inject inject) {
+    Inject duplicatedInject = getDuplicatedInjectWithExercise(exercise, inject);
+    return saveInject(inject, duplicatedInject);
   }
 
   @Transactional
-  public Inject createInjectForExercise(
-      @NotBlank final String exerciseId, @NotBlank final String injectId, boolean isChild) {
+  public Inject duplicateInjectForExerciseWithDuplicateWordInTitle(
+      final String exerciseId, final String injectId) {
     Exercise exercise =
         exerciseRepository.findById(exerciseId).orElseThrow(ElementNotFoundException::new);
-    Inject injectOrigin = injectRepository.findById(injectId).orElseThrow();
-    Inject inject = atomicTestingService.copyInject(injectOrigin, isChild);
-    inject.setExercise(exercise);
-    Inject saved = injectRepository.save(inject);
-    getDocumentList(saved, injectId);
-    return saved;
+    Inject inject = injectRepository.findById(injectId).orElseThrow(ElementNotFoundException::new);
+    Inject duplicatedInject = getDuplicatedInjectWithExercise(exercise, inject);
+    duplicatedInject.setTitle(duplicateString(duplicatedInject.getTitle()));
+    return saveInject(inject, duplicatedInject);
+  }
+
+  private Inject getDuplicatedInjectWithScenario(Scenario scenario, Inject inject) {
+    Inject duplicatedInject = InjectUtils.duplicateInject(inject);
+    duplicatedInject.setScenario(scenario);
+    duplicatedInject.setExercise(null);
+    return duplicatedInject;
+  }
+
+  private Inject getDuplicatedInjectWithExercise(Exercise exercise, Inject inject) {
+    Inject duplicatedInject = InjectUtils.duplicateInject(inject);
+    duplicatedInject.setExercise(exercise);
+    duplicatedInject.setScenario(null);
+    return duplicatedInject;
+  }
+
+  private Inject saveInject(Inject inject, Inject duplicatedInject) {
+    Inject savedInject = injectRepository.save(duplicatedInject);
+    addInjectDocumentsToDuplicatedInject(inject, savedInject);
+    return savedInject;
   }
 
-  private void getDocumentList(
-      @NotNull final Inject injectDuplicate, @NotNull final String injectId) {
-    Inject injectOrigin = injectRepository.findById(injectId).orElseThrow();
+  private void addInjectDocumentsToDuplicatedInject(Inject injectOrigin, Inject duplicatedInject) {
     injectOrigin
         .getDocuments()
         .forEach(
             injectDocument -> {
               String documentId = injectDocument.getDocument().getId();
               injectDocumentRepository.addInjectDoc(
-                  injectDuplicate.getId(), documentId, injectDocument.isAttached());
+                  duplicatedInject.getId(), documentId, injectDocument.isAttached());
             });
   }
 }

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

@@ -3,7 +3,6 @@
 import static io.openbas.config.SessionHelper.currentUser;
 import static io.openbas.helper.StreamHelper.fromIterable;
 import static io.openbas.helper.StreamHelper.iterableToSet;
-import static io.openbas.utils.StringUtils.duplicateString;
 import static io.openbas.utils.pagination.PaginationUtils.buildPaginationCriteriaBuilder;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
@@ -26,8 +25,6 @@
 import jakarta.persistence.criteria.Join;
 import jakarta.persistence.criteria.Predicate;
 import jakarta.transaction.Transactional;
-import jakarta.validation.constraints.NotBlank;
-import java.time.Instant;
 import java.util.*;
 import java.util.stream.StreamSupport;
 import lombok.RequiredArgsConstructor;
@@ -37,7 +34,6 @@
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;
-import org.springframework.validation.annotation.Validated;
 
 @Service
 @Log
@@ -59,6 +55,7 @@ public class AtomicTestingService {
   private final AssetGroupService assetGroupService;
   private final InjectMapper injectMapper;
   private final InjectSearchService injectSearchService;
+  private final InjectService injectService;
 
   private static final String PRE_DEFINE_EXPECTATIONS = "predefinedExpectations";
   private static final String EXPECTATIONS = "expectations";
@@ -196,78 +193,22 @@ public InjectResultOverviewOutput updateAtomicTestingTags(
     return injectMapper.toInjectResultOverviewOutput(saved);
   }
 
-  @Transactional
   public void deleteAtomicTesting(String injectId) {
-    injectDocumentRepository.deleteDocumentsFromInject(injectId);
-    injectRepository.deleteById(injectId);
+    injectService.delete(injectId);
   }
 
   // -- ACTIONS --
 
-  @Transactional
-  @Validated
-  public InjectResultOverviewOutput getDuplicateAtomicTesting(@NotBlank String id) {
-    Inject injectOrigin = injectRepository.findById(id).orElseThrow(ElementNotFoundException::new);
-    Inject injectDuplicate = copyInject(injectOrigin, true);
-    injectDuplicate.setExercise(injectOrigin.getExercise());
-    injectDuplicate.setScenario(injectOrigin.getScenario());
-    Inject inject = injectRepository.save(injectDuplicate);
-    return injectMapper.toInjectResultOverviewOutput(inject);
+  public InjectResultOverviewOutput duplicate(String id) {
+    return injectService.duplicate(id);
   }
 
-  public Inject copyInject(@NotNull Inject injectOrigin, boolean isAtomic) {
-    ObjectMapper objectMapper = new ObjectMapper();
-    Inject injectDuplicate = new Inject();
-    injectDuplicate.setUser(injectOrigin.getUser());
-    if (isAtomic) {
-      injectDuplicate.setTitle(duplicateString(injectOrigin.getTitle()));
-    } else {
-      injectDuplicate.setTitle(injectOrigin.getTitle());
-    }
-    injectDuplicate.setDescription(injectOrigin.getDescription());
-    try {
-      ObjectNode content =
-          objectMapper.readValue(
-              objectMapper.writeValueAsString(injectOrigin.getContent()), ObjectNode.class);
-      injectDuplicate.setContent(content);
-    } catch (JsonProcessingException e) {
-      throw new RuntimeException(e);
-    }
-    injectDuplicate.setAllTeams(injectOrigin.isAllTeams());
-    injectDuplicate.setTeams(injectOrigin.getTeams().stream().toList());
-    injectDuplicate.setEnabled(injectOrigin.isEnabled());
-    injectDuplicate.setDependsDuration(injectOrigin.getDependsDuration());
-    if (injectOrigin.getDependsOn() != null) {
-      injectDuplicate.setDependsOn(injectOrigin.getDependsOn().stream().toList());
-    }
-    injectDuplicate.setCountry(injectOrigin.getCountry());
-    injectDuplicate.setCity(injectOrigin.getCity());
-    injectDuplicate.setInjectorContract(injectOrigin.getInjectorContract().orElse(null));
-    injectDuplicate.setAssetGroups(injectOrigin.getAssetGroups().stream().toList());
-    injectDuplicate.setAssets(injectOrigin.getAssets().stream().toList());
-    injectDuplicate.setCommunications(injectOrigin.getCommunications().stream().toList());
-    injectDuplicate.setPayloads(injectOrigin.getPayloads().stream().toList());
-    injectDuplicate.setTags(new HashSet<>(injectOrigin.getTags()));
-    return injectDuplicate;
+  public InjectResultOverviewOutput launch(String id) {
+    return injectService.launch(id);
   }
 
-  @Transactional
-  public Inject tryInject(String injectId) {
-    Inject inject = injectRepository.findById(injectId).orElseThrow();
-
-    // Reset injects outcome, communications and expectations
-    inject.clean();
-    inject.setUpdatedAt(Instant.now());
-
-    // New inject status
-    InjectStatus injectStatus = new InjectStatus();
-    injectStatus.setInject(inject);
-    injectStatus.setTrackingSentDate(Instant.now());
-    injectStatus.setName(ExecutionStatus.QUEUING);
-    this.injectStatusRepository.save(injectStatus);
-
-    // Return inject
-    return this.injectRepository.save(inject);
+  public InjectResultOverviewOutput relaunch(String id) {
+    return injectService.relaunch(id);
   }
 
   // -- PAGINATION --