Merge branch 'RED-8114' into 'master'

RED-8114 - Allow editing of unprocessed manual changes

Closes RED-8114

See merge request redactmanager/persistence-service!282

persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java

@@ -74,11 +74,14 @@ public class ManualRedactionController implements ManualRedactionResource {
 
     @Override
     @PreAuthorize("hasAuthority('" + DELETE_MANUAL_REDACTION + "')")
-    public void undo(@PathVariable(DOSSIER_ID) String dossierId, @PathVariable(FILE_ID) String fileId, @RequestBody Set<String> annotationIds) {
+    public void undo(@PathVariable(DOSSIER_ID) String dossierId,
+                     @PathVariable(FILE_ID) String fileId,
+                     @RequestBody Set<String> annotationIds,
+                     @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed) {
 
         accessControlService.verifyFileIsNotApproved(dossierId, fileId);
         accessControlService.verifyUserIsApprover(dossierId);
-        manualRedactionUndoService.undo(dossierId, fileId, annotationIds);
+        manualRedactionUndoService.undo(dossierId, fileId, annotationIds, includeUnprocessed);
 
     }
 
@@ -184,7 +187,8 @@ public class ManualRedactionController implements ManualRedactionResource {
     @PreAuthorize("hasAuthority('" + DO_MANUAL_REDACTION + "')")
     public List<ManualAddResponse> removeRedactionBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                                        @PathVariable(FILE_ID) String fileId,
-                                                       @RequestBody Set<RemoveRedactionRequestModel> removeRedactionRequests) {
+                                                       @RequestBody Set<RemoveRedactionRequestModel> removeRedactionRequests,
+                                                       @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed) {
 
         var dossier = dossierManagementService.getDossierById(dossierId, false, false);
         accessControlService.verifyFileIsNotApproved(dossierId, fileId);
@@ -194,7 +198,7 @@ public class ManualRedactionController implements ManualRedactionResource {
             accessControlService.verifyUserIsMemberOrApprover(dossierId);
         }
 
-        List<RemoveRedactionRequest> requests = manualRedactionMapper.toRemoveRedactionRequestList(dossierId, fileId, dossier.getDossierTemplateId(), removeRedactionRequests);
+        List<RemoveRedactionRequest> requests = manualRedactionMapper.toRemoveRedactionRequestList(dossierId, fileId, dossier.getDossierTemplateId(), removeRedactionRequests, includeUnprocessed);
         List<ManualAddResponse> responseList = manualRedactionService.addRemoveRedaction(dossierId, fileId, requests);
 
         responseList.forEach(response -> auditPersistenceService.audit(AuditRequest.builder()
@@ -259,13 +263,14 @@ public class ManualRedactionController implements ManualRedactionResource {
     @PreAuthorize("hasAuthority('" + DO_MANUAL_REDACTION + "')")
     public List<ManualAddResponse> recategorizeBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                                     @PathVariable(FILE_ID) String fileId,
-                                                    @RequestBody Set<RecategorizationRequestModel> recategorizationRequests) {
+                                                    @RequestBody Set<RecategorizationRequestModel> recategorizationRequests,
+                                                    @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed) {
 
         var dossier = dossierManagementService.getDossierById(dossierId, false, false);
         accessControlService.verifyFileIsNotApproved(dossierId, fileId);
         accessControlService.verifyUserIsMemberOrApprover(dossierId);
 
-        List<RecategorizationRequest> requests = manualRedactionMapper.toRecategorizationRequestList(dossierId, fileId, dossier.getDossierTemplateId(), recategorizationRequests);
+        List<RecategorizationRequest> requests = manualRedactionMapper.toRecategorizationRequestList(dossierId, fileId, dossier.getDossierTemplateId(), recategorizationRequests, includeUnprocessed);
 
         List<ManualAddResponse> responseList = manualRedactionService.addRecategorization(dossierId, fileId, requests);
 
@@ -284,13 +289,14 @@ public class ManualRedactionController implements ManualRedactionResource {
     @PreAuthorize("hasAuthority('" + DO_MANUAL_REDACTION + "')")
     public List<ManualAddResponse> resizeRedactionBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                                        @PathVariable(FILE_ID) String fileId,
-                                                       @RequestBody Set<ResizeRedactionRequestModel> resizeRedactionRequests) {
+                                                       @RequestBody Set<ResizeRedactionRequestModel> resizeRedactionRequests,
+                                                       @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed) {
 
         accessControlService.verifyFileIsNotApproved(dossierId, fileId);
         accessControlService.verifyUserIsMemberOrApprover(dossierId);
 
         List<ResizeRedactionRequest> requests = manualRedactionMapper.toResizeRedactionRequestList(resizeRedactionRequests);
-        List<ManualAddResponse> responseList = manualRedactionService.addResizeRedaction(dossierId, fileId, requests);
+        List<ManualAddResponse> responseList = manualRedactionService.addResizeRedaction(dossierId, fileId, requests, includeUnprocessed);
 
         responseList.forEach(response -> auditPersistenceService.audit(AuditRequest.builder()
                 .userId(KeycloakSecurity.getUserId())

persistence-service-v1/persistence-service-external-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/external/resource/ManualRedactionResource.java

@@ -52,7 +52,10 @@ public interface ManualRedactionResource {
     @DeleteMapping(MANUAL_REDACTION_REST_PATH + "/bulk/undo" + DOSSIER_ID_PATH_PARAM + FILE_ID_PATH_VARIABLE)
     @Operation(summary = "Undo a list of manual requests or redactions", description = "Can only be done be the " + "user who added the request/redaction.")
     @ApiResponses(value = {@ApiResponse(responseCode = "204", description = "OK")})
-    void undo(@PathVariable(DOSSIER_ID) String dossierId, @PathVariable(FILE_ID) String fileId, @RequestBody Set<String> annotationIds);
+    void undo(@PathVariable(DOSSIER_ID) String dossierId,
+              @PathVariable(FILE_ID) String fileId,
+              @RequestBody Set<String> annotationIds,
+              @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed);
 
 
     @ResponseStatus(value = HttpStatus.OK)
@@ -90,7 +93,8 @@ public interface ManualRedactionResource {
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK")})
     List<ManualAddResponse> removeRedactionBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                                 @PathVariable(FILE_ID) String fileId,
-                                                @RequestBody Set<RemoveRedactionRequestModel> removeRedactionRequests);
+                                                @RequestBody Set<RemoveRedactionRequestModel> removeRedactionRequests,
+                                                @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed);
 
 
     @ResponseStatus(value = HttpStatus.OK)
@@ -117,7 +121,8 @@ public interface ManualRedactionResource {
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK")})
     List<ManualAddResponse> recategorizeBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                              @PathVariable(FILE_ID) String fileId,
-                                             @RequestBody Set<RecategorizationRequestModel> recategorizationRequests);
+                                             @RequestBody Set<RecategorizationRequestModel> recategorizationRequests,
+                                             @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed);
 
 
     @ResponseStatus(value = HttpStatus.OK)
@@ -126,7 +131,8 @@ public interface ManualRedactionResource {
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK")})
     List<ManualAddResponse> resizeRedactionBulk(@PathVariable(DOSSIER_ID) String dossierId,
                                                 @PathVariable(FILE_ID) String fileId,
-                                                @RequestBody Set<ResizeRedactionRequestModel> resizeRedactionRequests);
+                                                @RequestBody Set<ResizeRedactionRequestModel> resizeRedactionRequests,
+                                                @RequestParam(value = "includeUnprocessed", required = false, defaultValue = FALSE) boolean includeUnprocessed);
 
 
     @ResponseStatus(value = HttpStatus.OK)

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/EntityLogMergeService.java

@@ -103,16 +103,6 @@ public class EntityLogMergeService {
             return Optional.empty();
         }
 
-        List<Change> changes = new ArrayList<>();
-
-        changes.add(Change.builder()
-                .analysisNumber(entityLog.getAnalysisNumber())
-                .dateTime(manualRedactionEntry.getRequestDate())
-                .type(ChangeType.ADDED)
-                .build());
-
-        boolean isHint = isHint(manualRedactionEntry.getType(), dossier);
-
         if (isFalsePositive(manualRedactionEntry)) {
             var matchingEntities = entityLog.getEntityLogEntry().stream()
                     .filter(entityLogEntry -> equalPosition(manualRedactionEntry.getPositions().get(0), entityLogEntry.getPositions().get(0)))
@@ -121,6 +111,24 @@ public class EntityLogMergeService {
             return Optional.empty();
         }
 
+        List<ManualChange> manualChanges = new ArrayList<>();
+        manualChanges.add(ManualChange.builder()
+                .manualRedactionType(calculateManualRedactionType(manualRedactionEntry))
+                .requestedDate(manualRedactionEntry.getRequestDate())
+                .processedDate(null)
+                .userId(manualRedactionEntry.getUser())
+                .propertyChanges(Map.of("value", manualRedactionEntry.getValue()))
+                .build());
+
+        List<Change> changes = new ArrayList<>();
+        changes.add(Change.builder()
+                .analysisNumber(entityLog.getAnalysisNumber())
+                .dateTime(manualRedactionEntry.getRequestDate())
+                .type(ChangeType.ADDED)
+                .build());
+
+        boolean isHint = isHint(manualRedactionEntry.getType(), dossier);
+
         EntityLogEntry entityLogEntry = EntityLogEntry.builder()
                 .id(manualRedactionEntry.getAnnotationId())
                 .type(manualRedactionEntry.getType())
@@ -140,13 +148,7 @@ public class EntityLogMergeService {
                 .dossierDictionaryEntry(manualRedactionEntry.isAddToDossierDictionary())
                 .excluded(false)
                 .changes(changes)
-                .manualChanges(List.of(ManualChange.builder()
+                .manualChanges(manualChanges)
-                        .manualRedactionType(calculateManualRedactionType(manualRedactionEntry))
-                        .requestedDate(manualRedactionEntry.getRequestDate())
-                        .processedDate(null)
-                        .userId(manualRedactionEntry.getUser())
-                        .propertyChanges(Map.of("value", manualRedactionEntry.getValue()))
-                        .build()))
                 .engines(new HashSet<>())
                 .reference(new HashSet<>())
                 .importedRedactionIntersections(new HashSet<>())

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionMapper.java

@@ -3,11 +3,11 @@ package com.iqser.red.service.persistence.management.v1.processor.service.manual
 import static com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils.toTypeId;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 
 import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
@@ -78,10 +78,10 @@ public class ManualRedactionMapper {
     public List<RemoveRedactionRequest> toRemoveRedactionRequestList(String dossierId,
                                                                      String fileId,
                                                                      String dossierTemplateId,
-                                                                     Set<RemoveRedactionRequestModel> removeRedactionRequests) {
+                                                                     Set<RemoveRedactionRequestModel> removeRedactionRequests, boolean includeUnprocessed) {
 
         List<RemoveRedactionRequest> requests = new ArrayList<>();
-        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId);
+        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, Collections.emptyList(), includeUnprocessed);
         for (var removeRedactionRequest : removeRedactionRequests) {
             EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, removeRedactionRequest.getAnnotationId());
             var removeRedactionRequestBuilder = RemoveRedactionRequest.builder()
@@ -139,9 +139,10 @@ public class ManualRedactionMapper {
     public List<RecategorizationRequest> toRecategorizationRequestList(String dossierId,
                                                                        String fileId,
                                                                        String dossierTemplateId,
-                                                                       Set<RecategorizationRequestModel> recategorizationRequests) {
+                                                                       Set<RecategorizationRequestModel> recategorizationRequests,
+                                                                       boolean includeUnprocessed) {
 
-        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId);
+        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, Collections.emptyList(), includeUnprocessed);
         List<RecategorizationRequest> requests = new ArrayList<>();
         for (RecategorizationRequestModel recategorizationRequest : recategorizationRequests) {
             EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, recategorizationRequest.getAnnotationId());

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java

@@ -2,6 +2,7 @@ package com.iqser.red.service.persistence.management.v1.processor.service.manual
 
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -249,11 +250,11 @@ public class ManualRedactionService {
 
 
     @Transactional
-    public List<ManualAddResponse> addResizeRedaction(String dossierId, String fileId, List<ResizeRedactionRequest> resizeRedactionRequests) {
+    public List<ManualAddResponse> addResizeRedaction(String dossierId, String fileId, List<ResizeRedactionRequest> resizeRedactionRequests, boolean includeUnprocessed) {
 
         List<ManualAddResponse> response = new ArrayList<>();
         Set<ManualResizeRedactionEntity> manualResizeRedactionEntities = new HashSet<>();
-        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId);
+        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, Collections.emptyList(), includeUnprocessed);
 
         for (ResizeRedactionRequest resizeRedactionRequest : resizeRedactionRequests) {
 

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionUndoService.java

@@ -73,7 +73,7 @@ public class ManualRedactionUndoService {
 
 
     @Transactional
-    public void undo(String dossierId, String fileId, Set<String> annotationIds) {
+    public void undo(String dossierId, String fileId, Set<String> annotationIds, boolean includeUnprocessed) {
 
         // undo the latest manual redaction for each annotationId
         ManualRedactions manualRedactions = getManualRedactions(fileId);
@@ -87,7 +87,7 @@ public class ManualRedactionUndoService {
         undoManualRedactionEntries(dossierId, fileId, manualRedactionWrappers);
         undoIdRemovals(dossierId, fileId, manualRedactionWrappers);
         undoForceRedactions(dossierId, fileId, manualRedactionWrappers);
-        undoRecategorization(dossierId, fileId, manualRedactionWrappers);
+        undoRecategorization(dossierId, fileId, manualRedactionWrappers, includeUnprocessed);
         undoLegalBasisChange(dossierId, fileId, manualRedactionWrappers);
         undoResize(dossierId, fileId, manualRedactionWrappers);
         reprocess(dossierId, fileId);
@@ -167,7 +167,7 @@ public class ManualRedactionUndoService {
     }
 
 
-    private void undoRecategorization(String dossierId, String fileId, Map<String, ManualRedactionWrapperModel> manualRedactionWrappers) {
+    private void undoRecategorization(String dossierId, String fileId, Map<String, ManualRedactionWrapperModel> manualRedactionWrappers, boolean includeUnprocessed) {
 
         List<String> manualImageRecategorizations = manualRedactionWrappers.values()
                 .stream()
@@ -176,7 +176,7 @@ public class ManualRedactionUndoService {
                 .collect(Collectors.toList());
         if (!manualImageRecategorizations.isEmpty()) {
 
-            deleteRecategorization(dossierId, fileId, manualImageRecategorizations);
+            deleteRecategorization(dossierId, fileId, manualImageRecategorizations, includeUnprocessed);
             manualImageRecategorizations.forEach(annotationId -> auditPersistenceService.audit(AuditRequest.builder()
                     .userId(KeycloakSecurity.getUserId())
                     .objectId(fileId)
@@ -188,10 +188,10 @@ public class ManualRedactionUndoService {
     }
 
 
-    private void deleteRecategorization(String dossierId, String fileId, List<String> annotationIds) {
+    private void deleteRecategorization(String dossierId, String fileId, List<String> annotationIds, boolean includeUnprocessed) {
 
         dossierPersistenceService.getAndValidateDossier(dossierId);
-        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId);
+        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, Collections.emptyList(), includeUnprocessed);
 
         for (var annotationId : annotationIds) {
             ManualRecategorizationEntity recategorizationEntity = recategorizationPersistenceService.findRecategorization(fileId, annotationId);
@@ -265,7 +265,7 @@ public class ManualRedactionUndoService {
     private void deleteRemoveRedaction(String dossierId, String fileId, List<String> annotationIds) {
 
         dossierPersistenceService.getAndValidateDossier(dossierId);
-        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId);
+        EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, Collections.emptyList(), true);
 
         for (String annotationId : annotationIds) {
 

persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/FileTest.java

@@ -1,6 +1,8 @@
 package com.iqser.red.service.peristence.v1.server.integration.tests;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.when;
 
 import java.io.ByteArrayInputStream;
@@ -361,7 +363,7 @@ public class FileTest extends AbstractPersistenceServerServiceTest {
         EntityLog entityLog = new EntityLog(1, 1,
                 List.of(EntityLogEntry.builder().id(annotationId).type(type.getType()).value("value entry").state(EntryState.APPLIED).entryType(EntryType.ENTITY).build()), null, 0, 0, 0, 0);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         assertThat(fileClient.getDossierStatus(dossier.getId()).size()).isEqualTo(1);
 
@@ -378,7 +380,8 @@ public class FileTest extends AbstractPersistenceServerServiceTest {
 
         manualRedactionClient.removeRedactionBulk(dossierId,
                 fileId,
-                Set.of(RemoveRedactionRequestModel.builder().annotationId(annotationId).comment("comment").removeFromDictionary(false).build()));
+                Set.of(RemoveRedactionRequestModel.builder().annotationId(annotationId).comment("comment").removeFromDictionary(false).build()),
+                false);
         manualRedactionClient.forceRedactionBulk(dossierId,
                 fileId,
                 Set.of(ForceRedactionRequestModel.builder().annotationId("forceRedactionAnnotation").comment("comment").legalBasis("1").build()));
@@ -387,7 +390,8 @@ public class FileTest extends AbstractPersistenceServerServiceTest {
                 Set.of(LegalBasisChangeRequestModel.builder().annotationId("legalBasisChangeAnnotation").comment("comment").legalBasis("1").build()));
         manualRedactionClient.recategorizeBulk(dossierId,
                 fileId,
-                Set.of(RecategorizationRequestModel.builder().annotationId(annotationId).comment("comment").type("new-type").build()));
+                Set.of(RecategorizationRequestModel.builder().annotationId(annotationId).comment("comment").type("new-type").build()),
+                false);
 
         var loadedFile = fileClient.getFileStatus(dossierId, fileId);
 

persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java

@@ -4,6 +4,9 @@ import static com.iqser.red.service.persistence.management.v1.processor.utils.Ty
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
@@ -12,6 +15,7 @@ import java.util.Set;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 
@@ -133,12 +137,12 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyBoolean())).thenReturn(entityLog);
 
         Assertions.assertThrows(FeignException.Forbidden.class,
                 () -> manualRedactionClient.removeRedactionBulk(dossier.getId(),
                         file.getId(),
-                        Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build())));//.get(0);
+                        Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false));//.get(0);
 
         var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null);
         assertThat(dossierTemplateDictionary.getEntries().size()).isZero();
@@ -289,18 +293,18 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.removeRedactionBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()));
+                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder("Darth Vader");
         dossierDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), dossier.getId());
         assertThat(dossierDictionary.getEntries()).isEmpty();
 
-        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of("AnnotationId"));
+        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of("AnnotationId"), false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder("Luke Skywalker", "Darth Vader");
@@ -344,11 +348,11 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.removeRedactionBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).build())).get(0);
+                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).build()), false).get(0);
 
         var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null);
 
@@ -392,11 +396,11 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.removeRedactionBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build())).get(0);
+                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false).get(0);
 
         var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null);
         assertThat(dossierDictionary.getEntries().size()).isEqualTo(1);
@@ -480,7 +484,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1);
         var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file1.getDossierId(), file1.getFileId())).thenReturn(entityLog1);
+        when(entityLogService.getEntityLog(eq(file1.getDossierId()), eq(file1.getFileId()), any(), anyBoolean())).thenReturn(entityLog1);
 
         var entityLog2 = new EntityLog(1,
                 1,
@@ -499,7 +503,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2);
         var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file2.getDossierId(), file2.getFileId())).thenReturn(entityLog2);
+        when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2);
 
         // resize redaction in dossier 1
         var resizeRedactionDosAndAddToAllDos = ResizeRedactionRequestModel.builder()
@@ -510,7 +514,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 .addToAllDossiers(true)
                 .build();
 
-        manualRedactionClient.resizeRedactionBulk(dossier1.getId(), file1.getFileId(), Set.of(resizeRedactionDosAndAddToAllDos));
+        manualRedactionClient.resizeRedactionBulk(dossier1.getId(), file1.getFileId(), Set.of(resizeRedactionDosAndAddToAllDos), false);
 
         loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false);
 
@@ -633,7 +637,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1);
         var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file1.getDossierId(), file1.getFileId())).thenReturn(entityLog1);
+        when(entityLogService.getEntityLog(eq(file1.getDossierId()), eq(file1.getFileId()), any(), anyBoolean())).thenReturn(entityLog1);
 
         var entityLog2 = new EntityLog(1,
                 1,
@@ -652,7 +656,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2);
         var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file2.getDossierId(), file2.getFileId())).thenReturn(entityLog2);
+        when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2);
 
         // resize redaction in dossier 1
         var resizeRedactionDosAndAddToAllDos = ResizeRedactionRequestModel.builder()
@@ -663,7 +667,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 .addToAllDossiers(true)
                 .build();
 
-        manualRedactionClient.resizeRedactionBulk(dossier1.getId(), file1.getFileId(), Set.of(resizeRedactionDosAndAddToAllDos));
+        manualRedactionClient.resizeRedactionBulk(dossier1.getId(), file1.getFileId(), Set.of(resizeRedactionDosAndAddToAllDos), false);
 
         loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false);
 
@@ -809,7 +813,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2);
         var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file2.getDossierId(), file2.getFileId())).thenReturn(entityLog2);
+        when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2);
 
         // resize redaction in dossier dict
         var resizeRedactionDosTemp = ResizeRedactionRequestModel.builder()
@@ -820,7 +824,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 .addToAllDossiers(true)
                 .build();
 
-        var resizeRedactions = manualRedactionClient.resizeRedactionBulk(dossier2.getId(), file2.getFileId(), Set.of(resizeRedactionDosTemp));
+        var resizeRedactions = manualRedactionClient.resizeRedactionBulk(dossier2.getId(), file2.getFileId(), Set.of(resizeRedactionDosTemp), false);
 
         var loadedRedactionsFile2 = manualRedactionClient.getManualRedactions(file2.getDossierId(), file2.getFileId(), false);
 
@@ -963,7 +967,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2);
         var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build();
-        when(entityLogService.getEntityLog(file2.getDossierId(), file2.getFileId())).thenReturn(entityLog2);
+        when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2);
 
         // resize redaction in dossier dict
         var resizeRedactionDosTemp = ResizeRedactionRequestModel.builder()
@@ -974,7 +978,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 .addToAllDossiers(true)
                 .build();
 
-        var resizeRedactions = manualRedactionClient.resizeRedactionBulk(dossier2.getId(), file2.getFileId(), Set.of(resizeRedactionDosTemp));
+        var resizeRedactions = manualRedactionClient.resizeRedactionBulk(dossier2.getId(), file2.getFileId(), Set.of(resizeRedactionDosTemp), false);
 
         var loadedRedactionsFile2 = manualRedactionClient.getManualRedactions(file2.getDossierId(), file2.getFileId(), false);
 
@@ -1078,11 +1082,12 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.recategorizeBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(true).build()));
+                Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(true).build()),
+                false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder(darthVader);
@@ -1094,7 +1099,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
         dossierDictionary2 = dictionaryClient.getDictionaryForType(type2.getType(), type.getDossierTemplateId(), dossier.getId());
         assertThat(dossierDictionary2.getEntries()).isEmpty();
 
-        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of(annotationId));
+        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of(annotationId), false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder(lukeSkywalker, darthVader);
@@ -1155,11 +1160,12 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.recategorizeBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(false).build()));
+                Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(false).build()),
+                false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).isEmpty();
@@ -1171,7 +1177,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
         dossierDictionary2 = dictionaryClient.getDictionaryForType(type2.getType(), type.getDossierTemplateId(), dossier.getId());
         assertThat(dossierDictionary2.getEntries()).containsExactlyInAnyOrder(lukeSkywalker);
 
-        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of(annotationId));
+        manualRedactionClient.undo(dossier.getId(), file.getFileId(), Set.of(annotationId), false);
 
         dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null);
         assertThat(dossierTemplateDictionary.getEntries()).isEmpty();
@@ -1311,11 +1317,11 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
         manualRedactionClient.removeRedactionBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()));
+                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false);
 
         var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
         assertEquals(allManualRedactions.getIdsToRemove().size(), 1);
@@ -1337,7 +1343,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
 
         manualRedactionClient.removeRedactionBulk(dossier.getId(),
                 file.getId(),
-                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId2").removeFromDictionary(true).removeFromAllDossiers(true).build()));
+                Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId2").removeFromDictionary(true).removeFromAllDossiers(true).build()), false);
 
         allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
         assertEquals(allManualRedactions.getIdsToRemove().size(), 2);
@@ -1468,9 +1474,10 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                 0);
         fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
 
-        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
+        when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog);
 
-        manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv").build()));
+        manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv").build()),
+                false);
 
         var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
         assertEquals(allManualRedactions.getRecategorizations().size(), 1);
@@ -1490,7 +1497,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
                         .dossierId(dossier.getId())
                         .build());
 
-        manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv2").build()));
+        manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv2").build()),
+                false);
 
         allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
         assertEquals(allManualRedactions.getRecategorizations().size(), 2);