[NAE-2199] Force delete of processes

application-engine/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java

@@ -524,19 +524,25 @@ private void addValueCriteria(Query query, Query queryTotal, Criteria criteria)
     @Override
     @Transactional
     public void deletePetriNet(String processId, LoggedUser loggedUser) {
+        deletePetriNet(processId, loggedUser, false);
+    }
+
+    @Override
+    @Transactional
+    public void deletePetriNet(String processId, LoggedUser loggedUser, boolean force) {
         Optional<PetriNet> petriNetOptional = repository.findById(processId);
-        if (!petriNetOptional.isPresent()) {
+        if (petriNetOptional.isEmpty()) {
             throw new IllegalArgumentException("Could not find process with id [" + processId + "]");
         }
 
         PetriNet petriNet = petriNetOptional.get();
-        log.info("[" + processId + "]: Initiating deletion of Petri net " + petriNet.getIdentifier() + " version " + petriNet.getVersion().toString());
+        log.info("[{}]: Initiating deletion of Petri net {} version {}", processId, petriNet.getIdentifier(), petriNet.getVersion().toString());
 
         userService.removeRoleOfDeletedPetriNet(petriNet, null);
-        workflowService.deleteInstancesOfPetriNet(petriNet);
+        workflowService.deleteInstancesOfPetriNet(petriNet, force);
         processRoleService.deleteRolesOfNet(petriNet, loggedUser);
 
-        log.info("[" + processId + "]: User [" + userService.getLoggedOrSystem().getStringId() + "] is deleting Petri net " + petriNet.getIdentifier() + " version " + petriNet.getVersion().toString());
+        log.info("[{}]: User [{}] is deleting Petri net {} version {}", processId, userService.getLoggedOrSystem().getStringId(), petriNet.getIdentifier(), petriNet.getVersion().toString());
         publisher.publishEvent(new ProcessDeleteEvent(petriNet, EventPhase.PRE));
         repository.deleteBy_id(petriNet.getObjectId());
         evictCache(petriNet);

application-engine/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java

@@ -311,6 +311,15 @@ static DataFieldReference transformToReference(PetriNet net, Transition transiti
      */
     void deletePetriNet(String id, LoggedUser loggedUser);
 
+    /**
+     * Deletes a PetriNet by its ID.
+     *
+     * @param id the ID of the PetriNet to delete
+     * @param loggedUser the user requesting the deletion
+     * @param force whether to force the deletion without running events
+     */
+    void deletePetriNet(String id, LoggedUser loggedUser, boolean force);
+
     /**
      * Runs the specified set of actions on a PetriNet.
      *

application-engine/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java

@@ -223,14 +223,14 @@ PagedModel<PetriNetReferenceResource> searchElasticPetriNets(@RequestBody PetriN
             @ApiResponse(responseCode = "403", description = "Caller doesn't fulfill the authorisation requirements")
     })
     @DeleteMapping(value = "/{id}", produces = MediaTypes.HAL_JSON_VALUE)
-    public MessageResource deletePetriNet(@PathVariable("id") String processId, Authentication auth) {
+    public MessageResource deletePetriNet(@PathVariable("id") String processId, @RequestParam(required = false) boolean force, Authentication auth) {
         String decodedProcessId = decodeUrl(processId);
         if (Objects.equals(decodedProcessId, "")) {
             log.error("Deleting Petri net [" + processId + "] failed: could not decode process ID from URL");
             return MessageResource.errorMessage("Deleting Petri net " + processId + " failed!");
         }
         LoggedUser user = (LoggedUser) auth.getPrincipal();
-        asyncRunner.execute(() -> this.service.deletePetriNet(decodedProcessId, user));
+        asyncRunner.execute(() -> this.service.deletePetriNet(decodedProcessId, user, force));
         return MessageResource.successMessage("Petri net " + decodedProcessId + " is being deleted");
     }
 

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java

@@ -924,15 +924,27 @@ public void delete(List<Task> tasks, Case useCase) {
 
     @Override
     public void delete(List<Task> tasks, String caseId) {
-        workflowService.removeTasksFromCase(tasks, caseId);
-        log.info("[" + caseId + "]: Tasks of case are being deleted");
+        delete(tasks, caseId, false);
+    }
+
+    @Override
+    public void delete(List<Task> tasks, String caseId, boolean force) {
+        if (!force) {
+            workflowService.removeTasksFromCase(tasks, caseId);
+        }
+        log.info("[{}]: Tasks of case are being deleted", caseId);
         taskRepository.deleteAll(tasks);
         tasks.forEach(t -> elasticTaskService.remove(t.getStringId()));
     }
 
     @Override
     public void deleteTasksByCase(String caseId) {
-        delete(taskRepository.findAllByCaseId(caseId), caseId);
+        deleteTasksByCase(caseId, false);
+    }
+
+    @Override
+    public void deleteTasksByCase(String caseId, boolean force) {
+        delete(taskRepository.findAllByCaseId(caseId), caseId, force);
     }
 
     @Override

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java

@@ -392,33 +392,51 @@ public DeleteCaseEventOutcome deleteCase(String caseId) {
 
     @Override
     public DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params) {
+        return deleteCase(useCase, params, false);
+    }
 
-        DeleteCaseEventOutcome outcome = new DeleteCaseEventOutcome(useCase, eventService.runActions(useCase.getPetriNet().getPreDeleteActions(), useCase, Optional.empty(), params));
-        publisher.publishEvent(new DeleteCaseEvent(outcome, EventPhase.PRE));
-        useCase = ((Evaluator<DeleteCaseEvent, Case>) evaluationService.getEvaluator("default")).apply(new DeleteCaseEvent(outcome, EventPhase.PRE));;
+    @Override
+    public DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params, boolean force) {
+        DeleteCaseEventOutcome outcome = null;
+        if (!force) {
+            outcome = new DeleteCaseEventOutcome(useCase, eventService.runActions(useCase.getPetriNet().getPreDeleteActions(), useCase, Optional.empty(), params));
+            publisher.publishEvent(new DeleteCaseEvent(outcome, EventPhase.PRE));
+            useCase = ((Evaluator<DeleteCaseEvent, Case>) evaluationService.getEvaluator("default")).apply(new DeleteCaseEvent(outcome, EventPhase.PRE));
+        }
         log.info("[" + useCase.getStringId() + "]: User [" + userService.getLoggedOrSystem().getStringId() + "] is deleting case " + useCase.getTitle());
 
         taskService.deleteTasksByCase(useCase.getStringId());
         repository.delete(useCase);
-
-        outcome.addOutcomes(eventService.runActions(useCase.getPetriNet().getPostDeleteActions(), null, Optional.empty(), params));
-        addMessageToOutcome(useCase.getPetriNet(), CaseEventType.DELETE, outcome);
-        ((Evaluator<DeleteCaseEvent, Case>) evaluationService.getEvaluator("noContext")).apply(new DeleteCaseEvent(outcome, EventPhase.POST));
-        publisher.publishEvent(new DeleteCaseEvent(outcome, EventPhase.POST));
+        if (!force) {
+            outcome.addOutcomes(eventService.runActions(useCase.getPetriNet().getPostDeleteActions(), null, Optional.empty(), params));
+            addMessageToOutcome(useCase.getPetriNet(), CaseEventType.DELETE, outcome);
+            ((Evaluator<DeleteCaseEvent, Case>) evaluationService.getEvaluator("noContext")).apply(new DeleteCaseEvent(outcome, EventPhase.POST));
+            publisher.publishEvent(new DeleteCaseEvent(outcome, EventPhase.POST));
+        }
         return outcome;
     }
 
     @Override
     public DeleteCaseEventOutcome deleteCase(Case useCase) {
-        return deleteCase(useCase, new HashMap<>());
+        return deleteCase(useCase, false);
+    }
+
+    @Override
+    public DeleteCaseEventOutcome deleteCase(Case useCase, boolean force) {
+        return deleteCase(useCase, new HashMap<>(), force);
     }
 
     @Override
     public void deleteInstancesOfPetriNet(PetriNet net) {
+        deleteInstancesOfPetriNet(net, false);
+    }
+
+    @Override
+    public void deleteInstancesOfPetriNet(PetriNet net, boolean force) {
         log.info("[" + net.getStringId() + "]: User " + userService.getLoggedOrSystem().getStringId() + " is deleting all cases and tasks of Petri net " + net.getIdentifier() + " version " + net.getVersion().toString());
         List<Case> cases = this.searchAll(QCase.case$.petriNetObjectId.eq(net.getObjectId())).getContent();
         if (!cases.isEmpty()) {
-            cases.forEach(this::deleteCase);
+            cases.forEach(aCase -> deleteCase(aCase, new HashMap<>(), force));
         }
     }
 

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java

@@ -112,8 +112,12 @@ public interface ITaskService {
 
     void delete(List<Task> tasks, String caseId);
 
+    void delete(List<Task> tasks, String caseId, boolean force);
+
     void deleteTasksByCase(String caseId);
 
+    void deleteTasksByCase(String caseId, boolean force);
+
     void deleteTasksByPetriNetId(String petriNetId);
 
     List<TaskReference> findAllByCase(String caseId, Locale locale);

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java

@@ -55,10 +55,16 @@ public interface IWorkflowService {
 
     DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params);
 
+    DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params, boolean force);
+
     DeleteCaseEventOutcome deleteCase(Case useCase);
 
+    DeleteCaseEventOutcome deleteCase(Case useCase, boolean force);
+
     void deleteInstancesOfPetriNet(PetriNet net);
 
+    void deleteInstancesOfPetriNet(PetriNet net, boolean force);
+
     void updateMarking(Case useCase);
 
     Page<Case> searchAll(Predicate predicate);