Merge branch 'RED-8589-4.0.0' into 'release/2.349.x'

RED-8589 - Add "MANUAL" engine to all annotations that has entries in manualChanges

See merge request redactmanager/persistence-service!362

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

@@ -11,6 +11,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -29,6 +30,7 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequ
 import com.iqser.red.service.persistence.service.v1.api.shared.model.MessageType;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ChangeType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
@@ -149,7 +151,7 @@ public class EntityLogMergeService {
                 .excluded(false)
                 .changes(changes)
                 .manualChanges(manualChanges)
-                .engines(new HashSet<>())
+                .engines(Set.of(Engine.MANUAL))
                 .reference(new HashSet<>())
                 .importedRedactionIntersections(new HashSet<>())
                 .build();
@@ -183,6 +185,7 @@ public class EntityLogMergeService {
         var entity = entityLogEntries.stream().filter(entityLogEntry -> entityLogEntry.getId().equals(idRemoval.getAnnotationId())).findAny();
         entity.ifPresent(entityLogEntry -> {
             entityLogEntry.setState(EntryState.IGNORED);
+            entityLogEntry.getEngines().add(Engine.MANUAL);
             addChanges(entityLogEntry.getChanges(), ChangeType.REMOVED, analysisNumber, idRemoval.getRequestDate());
             entityLogEntry.getManualChanges()
                     .add(ManualChange.builder()
@@ -203,6 +206,7 @@ public class EntityLogMergeService {
             entityLogEntry.setTextBefore(manualResizeRedaction.getTextBefore());
             entityLogEntry.setPositions(convertPositions(manualResizeRedaction.getPositions()));
             entityLogEntry.setValue(manualResizeRedaction.getValue());
+            entityLogEntry.getEngines().add(Engine.MANUAL);
             addChanges(entityLogEntry.getChanges(), ChangeType.CHANGED, analysisNumber, manualResizeRedaction.getRequestDate());
             ManualChange.ManualChangeBuilder manualChange = ManualChange.builder()
                     .manualRedactionType(manualResizeRedaction.getUpdateDictionary() ? ManualRedactionType.RESIZE_IN_DICTIONARY : ManualRedactionType.RESIZE)
@@ -224,6 +228,7 @@ public class EntityLogMergeService {
             entityLogEntry.setLegalBasis(manualLegalBasisChange.getLegalBasis());
             entityLogEntry.setSection(manualLegalBasisChange.getSection());
             entityLogEntry.setValue(manualLegalBasisChange.getValue());
+            entityLogEntry.getEngines().add(Engine.MANUAL);
             addChanges(entityLogEntry.getChanges(), ChangeType.CHANGED, analysisNumber, manualLegalBasisChange.getRequestDate());
             Map<String, String> propertyChanges = getPropertyChanges(manualLegalBasisChange);
             entityLogEntry.getManualChanges()
@@ -263,6 +268,7 @@ public class EntityLogMergeService {
             entityLogEntry.setType(recategorization.getType());
             entityLogEntry.setEntryType(getEntryType(isHint, recategorization.getType()));
             entityLogEntry.setState(isHint ? EntryState.SKIPPED : EntryState.APPLIED);
+            entityLogEntry.getEngines().add(Engine.MANUAL);
             addChanges(entityLogEntry.getChanges(), ChangeType.CHANGED, analysisNumber, recategorization.getRequestDate());
             entityLogEntry.getManualChanges()
                     .add(ManualChange.builder()
@@ -282,6 +288,7 @@ public class EntityLogMergeService {
         entity.ifPresent(entityLogEntry -> {
             entityLogEntry.setLegalBasis(forceRedaction.getLegalBasis());
             entityLogEntry.setState(entityLogEntry.getEntryType().equals(EntryType.HINT) ? EntryState.SKIPPED : EntryState.APPLIED);
+            entityLogEntry.getEngines().add(Engine.MANUAL);
             addChanges(entityLogEntry.getChanges(), ChangeType.CHANGED, analysisNumber, forceRedaction.getRequestDate());
             var forceRedactManualChange = ManualChange.builder()
                     .manualRedactionType(entityLogEntry.getEntryType().equals(EntryType.HINT) ? ManualRedactionType.FORCE_HINT : ManualRedactionType.FORCE_REDACT)

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

@@ -40,6 +40,7 @@ import com.iqser.red.service.persistence.management.v1.processor.service.persist
 import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ChangeType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
@@ -145,7 +146,9 @@ public class EntityLogMergeTest {
         assertEquals(entityLogEntry.getState(), EntryState.APPLIED);
         assertEquals(entityLogEntry.getValue(), "Test");
         assertEquals(entityLogEntry.getReason(), "Reason");
-        assertEquals(entityLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.ADD_LOCALLY);
+        assertTrue(entityLogEntry.getEngines().contains(Engine.MANUAL));
+        assertEquals(entityLogEntry.getManualChanges()
+                             .get(0).getManualRedactionType(), ManualRedactionType.ADD_LOCALLY);
 
         var optionalRemoveEntryLogEntry = response.getEntityLogEntry().stream().filter(entityLogEntry1 -> entityLogEntry1.getId().equals(entryToRemoveId)).findFirst();
         assertTrue(optionalRemoveEntryLogEntry.isPresent());
@@ -153,7 +156,9 @@ public class EntityLogMergeTest {
         assertEquals(removeEntryLogEntry.getEntryType(), EntryType.ENTITY);
         assertEquals(removeEntryLogEntry.getState(), EntryState.IGNORED);
         assertEquals(removeEntryLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.REMOVE_LOCALLY);
-        assertEquals(removeEntryLogEntry.getChanges().get(0).getType(), ChangeType.REMOVED);
+        assertEquals(removeEntryLogEntry.getChanges()
+                             .get(0).getType(), ChangeType.REMOVED);
+        assertTrue(removeEntryLogEntry.getEngines().contains(Engine.MANUAL));
 
         var optionalResizeEntryLogEntry = response.getEntityLogEntry().stream().filter(entityLogEntry1 -> entityLogEntry1.getId().equals(entryToResizeId)).findFirst();
         assertTrue(optionalResizeEntryLogEntry.isPresent());
@@ -166,7 +171,9 @@ public class EntityLogMergeTest {
         assertEquals(resizeEntryLogEntry.getEntryType(), EntryType.ENTITY);
         assertEquals(resizeEntryLogEntry.getState(), EntryState.APPLIED);
         assertEquals(resizeEntryLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.RESIZE);
-        assertEquals(resizeEntryLogEntry.getChanges().get(0).getType(), ChangeType.CHANGED);
+        assertEquals(resizeEntryLogEntry.getChanges()
+                             .get(0).getType(), ChangeType.CHANGED);
+        assertTrue(resizeEntryLogEntry.getEngines().contains(Engine.MANUAL));
 
         var optionalLegalBasisEntryLogEntry = response.getEntityLogEntry().stream().filter(entityLogEntry1 -> entityLogEntry1.getId().equals(entryLegalBasisId)).findFirst();
         assertTrue(optionalLegalBasisEntryLogEntry.isPresent());
@@ -175,7 +182,9 @@ public class EntityLogMergeTest {
         assertEquals(legalBasisEntryLogEntry.getEntryType(), EntryType.ENTITY);
         assertEquals(legalBasisEntryLogEntry.getState(), EntryState.APPLIED);
         assertEquals(legalBasisEntryLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.LEGAL_BASIS_CHANGE);
-        assertEquals(legalBasisEntryLogEntry.getChanges().get(0).getType(), ChangeType.CHANGED);
+        assertEquals(legalBasisEntryLogEntry.getChanges()
+                             .get(0).getType(), ChangeType.CHANGED);
+        assertTrue(legalBasisEntryLogEntry.getEngines().contains(Engine.MANUAL));
 
         var optionalForceRedactionEntryLogEntry = response.getEntityLogEntry().stream().filter(entityLogEntry1 -> entityLogEntry1.getId().equals(forceRedactionId)).findFirst();
         assertTrue(optionalForceRedactionEntryLogEntry.isPresent());
@@ -184,7 +193,9 @@ public class EntityLogMergeTest {
         assertEquals(forceRedactionEntryLogEntry.getEntryType(), EntryType.ENTITY);
         assertEquals(forceRedactionEntryLogEntry.getState(), EntryState.APPLIED);
         assertEquals(forceRedactionEntryLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.FORCE_REDACT);
-        assertEquals(forceRedactionEntryLogEntry.getChanges().get(0).getType(), ChangeType.CHANGED);
+        assertEquals(forceRedactionEntryLogEntry.getChanges()
+                             .get(0).getType(), ChangeType.CHANGED);
+        assertTrue(forceRedactionEntryLogEntry.getEngines().contains(Engine.MANUAL));
 
         var optionalRectangleEntryLogEntry = response.getEntityLogEntry().stream().filter(entityLogEntry1 -> entityLogEntry1.getId().equals(rectangleToAddId)).findFirst();
         assertTrue(optionalRectangleEntryLogEntry.isPresent());
@@ -194,7 +205,9 @@ public class EntityLogMergeTest {
         assertEquals(rectangleEntryLogEntry.getState(), EntryState.APPLIED);
         assertEquals(rectangleEntryLogEntry.getValue(), "Test2");
         assertEquals(rectangleEntryLogEntry.getReason(), "Rectangle");
-        assertEquals(rectangleEntryLogEntry.getManualChanges().get(0).getManualRedactionType(), ManualRedactionType.ADD_LOCALLY);
+        assertEquals(rectangleEntryLogEntry.getManualChanges()
+                             .get(0).getManualRedactionType(), ManualRedactionType.ADD_LOCALLY);
+        assertTrue(rectangleEntryLogEntry.getEngines().contains(Engine.MANUAL));
 
     }