Added equalsIgnoreCase fileattributes methods for rules

Merge in RED/redaction-service from RED-1755-2 to release/2.52.x

* commit 'dd585a13fd8d37319ce695eeb39a87ff197bec15':
  RED-1755: Calculate falgs in file-management-service async

redaction-service-v1/redaction-service-api-v1/src/main/java/com/iqser/red/service/redaction/v1/model/AnalyzeResult.java

@@ -15,10 +15,6 @@ public class AnalyzeResult {
     private String fileId;
     private long duration;
     private int numberOfPages;
-    private boolean hasHints;
-    private boolean hasRequests;
-    private boolean hasRedactions;
-    private boolean hasImages;
     private boolean hasUpdates;
     private long dictionaryVersion;
     private long dossierDictionaryVersion;

redaction-service-v1/redaction-service-api-v1/src/main/java/com/iqser/red/service/redaction/v1/model/RedactionRequest.java

@@ -1,5 +1,8 @@
 package com.iqser.red.service.redaction.v1.model;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -15,4 +18,6 @@ public class RedactionRequest {
     private String fileId;
     private String dossierTemplateId;
     private ManualRedactions manualRedactions;
+    @Builder.Default
+    private Set<Integer> excludedPages = new HashSet<>();
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/controller/RedactionController.java

@@ -159,7 +159,7 @@ public class RedactionController implements RedactionResource {
             // old redaction logs are returned directly
             return redactionLog;
         } else {
-            return redactionLogMergeService.mergeRedactionLogData(redactionLog, redactionRequest.getDossierTemplateId(), redactionRequest.getManualRedactions());
+            return redactionLogMergeService.mergeRedactionLogData(redactionLog, redactionRequest.getDossierTemplateId(), redactionRequest.getManualRedactions(), redactionRequest.getExcludedPages());
         }
     }
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/model/Section.java

@@ -72,6 +72,19 @@ public class Section {
     }
 
 
+    public boolean fileAttributeByIdEqualsIgnoreCase(String id, String value){
+        return fileAttributes != null && fileAttributes.stream().filter(attribute -> id.equals(attribute.getId()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
+    }
+
+    public boolean fileAttributeByPlaceholderEqualsIgnoreCase(String placeholder, String value){
+        return fileAttributes != null && fileAttributes.stream().filter(attribute -> placeholder.equals(attribute.getPlaceholder()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
+    }
+
+    public boolean fileAttributeByLabelEqualsIgnoreCase(String label, String value){
+        return fileAttributes != null && fileAttributes.stream().filter(attribute -> label.equals(attribute.getLabel()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
+    }
+
+
     public boolean rowEquals(String headerName, String value) {
 
         String cleanHeaderName = headerName.replaceAll("\n", "").replaceAll(" ", "").replaceAll("-", "");

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/service/AnalyzeResponseService.java

@@ -19,27 +19,6 @@ public class AnalyzeResponseService {
     public AnalyzeResult createAnalyzeResponse(String dossierId, String fileId, long duration, int pageCount,
                                                RedactionLog redactionLog, RedactionChangeLog redactionChangeLog) {
 
-        boolean hasHints = redactionLog.getRedactionLogEntry()
-                .stream()
-                .filter(entry -> !entry.isExcluded())
-                .anyMatch(entry -> entry.isHint() && !entry.getType().equals("false_positive"));
-
-        boolean hasRequests = redactionLog.getRedactionLogEntry()
-                .stream()
-                .filter(entry -> !entry.isExcluded())
-                .anyMatch(entry -> entry.isManual() && entry.getStatus()
-                        .equals(com.iqser.red.service.redaction.v1.model.Status.REQUESTED));
-
-        boolean hasRedactions = redactionLog.getRedactionLogEntry()
-                .stream()
-                .filter(entry -> !entry.isExcluded())
-                .anyMatch(entry -> entry.isRedacted() && !entry.isManual() || entry.isManual() && entry.getStatus()
-                        .equals(com.iqser.red.service.redaction.v1.model.Status.APPROVED));
-
-        boolean hasImages = redactionLog.getRedactionLogEntry()
-                .stream()
-                .filter(entry -> !entry.isExcluded())
-                .anyMatch(entry -> entry.isHint() && entry.getType().equals("image") || entry.isImage());
 
         boolean hasUpdates = redactionChangeLog != null && redactionChangeLog.getRedactionLogEntry() != null && !redactionChangeLog
                 .getRedactionLogEntry()
@@ -52,10 +31,6 @@ public class AnalyzeResponseService {
                 .fileId(fileId)
                 .duration(duration)
                 .numberOfPages(pageCount)
-                .hasHints(hasHints)
-                .hasRedactions(hasRedactions)
-                .hasRequests(hasRequests)
-                .hasImages(hasImages)
                 .hasUpdates(hasUpdates)
                 .analysisVersion(redactionServiceSettings.getAnalysisVersion())
                 .rulesVersion(redactionLog.getRulesVersion())

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/service/ReanalyzeService.java

@@ -311,9 +311,11 @@ public class ReanalyzeService {
 
     private void excludeExcludedPages(RedactionLog redactionLog, Set<Integer> excludedPages) {
 
-        redactionLog.getRedactionLogEntry()
-                .forEach(entry -> entry.getPositions()
-                        .forEach(pos -> entry.setExcluded(excludedPages != null && excludedPages.contains(pos.getPage()))));
+        if(excludedPages != null && !excludedPages.isEmpty()) {
+            redactionLog.getRedactionLogEntry().forEach(entry -> entry.getPositions().forEach(pos -> { if (excludedPages.contains(pos.getPage())) {
+                entry.setExcluded(true);
+            }}));
+        }
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/service/RedactionLogMergeService.java

@@ -1,14 +1,31 @@
 package com.iqser.red.service.redaction.v1.server.redaction.service;
 
-import com.iqser.red.service.redaction.v1.model.*;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
+import java.time.OffsetDateTime;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.redaction.v1.model.Comment;
+import com.iqser.red.service.redaction.v1.model.IdRemoval;
+import com.iqser.red.service.redaction.v1.model.ManualForceRedact;
+import com.iqser.red.service.redaction.v1.model.ManualImageRecategorization;
+import com.iqser.red.service.redaction.v1.model.ManualLegalBasisChange;
+import com.iqser.red.service.redaction.v1.model.ManualRedactionEntry;
+import com.iqser.red.service.redaction.v1.model.ManualRedactionType;
+import com.iqser.red.service.redaction.v1.model.ManualRedactions;
+import com.iqser.red.service.redaction.v1.model.RedactionLog;
+import com.iqser.red.service.redaction.v1.model.RedactionLogEntry;
+import com.iqser.red.service.redaction.v1.model.Status;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 @Service
@@ -18,7 +35,8 @@ public class RedactionLogMergeService {
     private final DictionaryService dictionaryService;
 
 
-    public RedactionLog mergeRedactionLogData(RedactionLog redactionLog, String dossierTemplateId, ManualRedactions manualRedactions) {
+    public RedactionLog mergeRedactionLogData(RedactionLog redactionLog, String dossierTemplateId,
+                                              ManualRedactions manualRedactions, Set<Integer> excludedPages) {
 
         log.info("Merging Redaction log with manual redactions {}", manualRedactions);
         if (manualRedactions != null) {
@@ -27,10 +45,23 @@ public class RedactionLogMergeService {
 
             redactionLog.getRedactionLogEntry().addAll(manualRedactionLogEntries);
 
-            log.info("Adding {}", manualRedactionLogEntries);
+            var manualRedactionWrappers = createManualRedactionWrappers(manualRedactions);
+
             for (RedactionLogEntry entry : redactionLog.getRedactionLogEntry()) {
-                processRedactionLogEntry(manualRedactions, dossierTemplateId, entry);
+
+                processRedactionLogEntry(manualRedactionWrappers.stream()
+                        .filter(mr -> entry.getId().equals(mr.getId()))
+                        .collect(Collectors.toList()), dossierTemplateId, entry);
+
                 entry.setComments(manualRedactions.getComments().get(entry.getId()));
+
+                if (excludedPages != null && !excludedPages.isEmpty()) {
+                    entry.getPositions().forEach(pos -> {
+                        if (excludedPages.contains(pos.getPage())) {
+                            entry.setExcluded(true);
+                        }
+                    });
+                }
             }
 
         }
@@ -39,126 +70,151 @@ public class RedactionLogMergeService {
     }
 
 
-    private void processRedactionLogEntry(ManualRedactions manualRedactions, String dossierTemplateId, RedactionLogEntry redactionLogEntry) {
+    private List<ManualRedactionWrapper> createManualRedactionWrappers(ManualRedactions manualRedactions) {
 
-        List<Comment> comments = null;
+        List<ManualRedactionWrapper> manualRedactionWrappers = new ArrayList<>();
 
-
-        if (manualRedactions != null && !manualRedactions.getImageRecategorizations().isEmpty()) {
-            for (ManualImageRecategorization recategorization : manualRedactions.getImageRecategorizations()) {
-                if (recategorization.getId().equals(redactionLogEntry.getId())) {
-                    String manualOverrideReason = null;
-                    if (recategorization.getStatus().equals(Status.APPROVED)) {
-                        redactionLogEntry.setStatus(Status.APPROVED);
-                        redactionLogEntry.setType(recategorization.getType());
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", recategorized by manual override");
-                    } else if (recategorization.getStatus().equals(Status.REQUESTED)) {
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to recategorize");
-                        redactionLogEntry.setStatus(Status.REQUESTED);
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), false));
-                        redactionLogEntry.setRecategorizationType(recategorization.getType());
-                    } else {
-                        redactionLogEntry.setStatus(Status.DECLINED);
-                    }
-
-                    redactionLogEntry.setManualRedactionUserId(recategorization.getUser());
-                    redactionLogEntry.setReason(manualOverrideReason);
-                    redactionLogEntry.setManual(true);
-                    redactionLogEntry.setManualRedactionType(ManualRedactionType.RECATEGORIZE);
-                }
+        manualRedactions.getImageRecategorizations().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getId(), item.getRequestDate(), item));
             }
-        }
+        });
 
-        if (manualRedactions != null && !manualRedactions.getIdsToRemove().isEmpty()) {
-            for (IdRemoval manualRemoval : manualRedactions.getIdsToRemove()) {
-                if (manualRemoval.getId().equals(redactionLogEntry.getId())) {
-                    comments = manualRedactions.getComments().get(manualRemoval.getId());
-                    String manualOverrideReason = null;
-                    if (manualRemoval.getStatus().equals(Status.APPROVED)) {
-                        redactionLogEntry.setRedacted(false);
-                        redactionLogEntry.setStatus(Status.APPROVED);
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", removed by manual override");
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), true));
-                    } else if (manualRemoval.getStatus().equals(Status.REQUESTED)) {
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to remove");
-                        redactionLogEntry.setStatus(Status.REQUESTED);
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
-                    } else {
-                        redactionLogEntry.setStatus(Status.DECLINED);
-                    }
-
-                    redactionLogEntry.setReason(manualOverrideReason);
-                    redactionLogEntry.setManual(true);
-                    redactionLogEntry.setManualRedactionUserId(manualRemoval.getUser());
-                    redactionLogEntry.setManualRedactionType(ManualRedactionType.REMOVE);
-                    redactionLogEntry.setDictionaryEntry(manualRemoval.isRemoveFromDictionary());
-                    redactionLogEntry.setDossierDictionaryEntry(manualRemoval.isRemoveFromDictionary());
-                }
+        manualRedactions.getIdsToRemove().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getId(), item.getRequestDate(), item));
             }
-        }
+        });
 
-        if (manualRedactions != null && !manualRedactions.getForceRedacts().isEmpty()) {
-            for (ManualForceRedact manualForceRedact : manualRedactions.getForceRedacts()) {
-                if (manualForceRedact.getId().equals(redactionLogEntry.getId())) {
-                    String manualOverrideReason = null;
-                    if (manualForceRedact.getStatus().equals(Status.APPROVED)) {
-                        redactionLogEntry.setRedacted(true);
-                        redactionLogEntry.setStatus(Status.APPROVED);
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), false));
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", forced by manual override");
-                        redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
-                    } else if (manualForceRedact.getStatus().equals(Status.REQUESTED)) {
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to force redact");
-                        redactionLogEntry.setStatus(Status.REQUESTED);
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
-                        redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
-                    } else {
-                        redactionLogEntry.setStatus(Status.DECLINED);
-                    }
-
-                    redactionLogEntry.setManualRedactionUserId(manualForceRedact.getUser());
-                    redactionLogEntry.setReason(manualOverrideReason);
-                    redactionLogEntry.setManual(true);
-                    redactionLogEntry.setManualRedactionType(ManualRedactionType.FORCE_REDACT);
-
-                }
+        manualRedactions.getForceRedacts().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getId(), item.getRequestDate(), item));
             }
-        }
+        });
 
-        if (manualRedactions != null && !manualRedactions.getManualLegalBasisChanges().isEmpty()) {
-            for (ManualLegalBasisChange manualLegalBasisChange : manualRedactions.getManualLegalBasisChanges()) {
-                if (manualLegalBasisChange.getId().equals(redactionLogEntry.getId())) {
-                    String manualOverrideReason = null;
-                    if (manualLegalBasisChange.getStatus().equals(Status.APPROVED)) {
-                        redactionLogEntry.setStatus(Status.APPROVED);
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis was manually changed");
-                        redactionLogEntry.setLegalBasis(manualLegalBasisChange.getLegalBasis());
-                    } else if (manualLegalBasisChange.getStatus().equals(Status.REQUESTED)) {
-                        manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis change requested");
-                        redactionLogEntry.setStatus(Status.REQUESTED);
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
-                        redactionLogEntry.setLegalBasisChangeValue(manualLegalBasisChange.getLegalBasis());
-                    } else {
-                        redactionLogEntry.setStatus(Status.DECLINED);
-                    }
-
-                    redactionLogEntry.setManualRedactionUserId(manualLegalBasisChange.getUser());
-                    redactionLogEntry.setReason(manualOverrideReason);
-                    redactionLogEntry.setManual(true);
-                    redactionLogEntry.setManualRedactionType(ManualRedactionType.LEGAL_BASIS_CHANGE);
-                }
+        manualRedactions.getManualLegalBasisChanges().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getId(), item.getRequestDate(), item));
             }
-        }
+        });
 
+        Collections.sort(manualRedactionWrappers);
 
-        if (manualRedactions != null) {
-            comments = manualRedactions.getComments().get(redactionLogEntry.getId());
-        }
-
-        redactionLogEntry.setComments(comments);
+        return manualRedactionWrappers;
     }
 
+
+    private void processRedactionLogEntry(List<ManualRedactionWrapper> manualRedactionWrappers,
+                                          String dossierTemplateId, RedactionLogEntry redactionLogEntry) {
+
+        manualRedactionWrappers.forEach(mrw -> {
+
+            if (mrw.getItem() instanceof ManualImageRecategorization) {
+                var imageRecategorization = (ManualImageRecategorization) mrw.getItem();
+                String manualOverrideReason = null;
+                if (imageRecategorization.getStatus().equals(Status.APPROVED)) {
+                    redactionLogEntry.setStatus(Status.APPROVED);
+                    redactionLogEntry.setType(imageRecategorization.getType());
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", recategorized by manual override");
+                } else if (imageRecategorization.getStatus().equals(Status.REQUESTED)) {
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to recategorize");
+                    redactionLogEntry.setStatus(Status.REQUESTED);
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry
+                            .isRedacted(), false));
+                    redactionLogEntry.setRecategorizationType(imageRecategorization.getType());
+                } else {
+                    redactionLogEntry.setStatus(Status.DECLINED);
+                }
+
+                redactionLogEntry.setManualRedactionUserId(imageRecategorization.getUser());
+                redactionLogEntry.setReason(manualOverrideReason);
+                redactionLogEntry.setManual(true);
+                redactionLogEntry.setManualRedactionType(ManualRedactionType.RECATEGORIZE);
+            }
+
+            if (mrw.getItem() instanceof IdRemoval) {
+                var manualRemoval = (IdRemoval) mrw.getItem();
+                String manualOverrideReason = null;
+                if (manualRemoval.getStatus().equals(Status.APPROVED)) {
+                    redactionLogEntry.setRedacted(false);
+                    redactionLogEntry.setStatus(Status.APPROVED);
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", removed by manual override");
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry
+                            .isRedacted(), true));
+                } else if (manualRemoval.getStatus().equals(Status.REQUESTED)) {
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to remove");
+                    redactionLogEntry.setStatus(Status.REQUESTED);
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry
+                            .isRedacted(), false));
+                } else {
+                    redactionLogEntry.setStatus(Status.DECLINED);
+                }
+
+                redactionLogEntry.setReason(manualOverrideReason);
+                redactionLogEntry.setManual(true);
+                redactionLogEntry.setManualRedactionUserId(manualRemoval.getUser());
+                redactionLogEntry.setManualRedactionType(ManualRedactionType.REMOVE);
+                redactionLogEntry.setDictionaryEntry(manualRemoval.isRemoveFromDictionary());
+                redactionLogEntry.setDossierDictionaryEntry(manualRemoval.isRemoveFromDictionary());
+            }
+
+            if (mrw.getItem() instanceof ManualForceRedact) {
+                var manualForceRedact = (ManualForceRedact) mrw.getItem();
+                String manualOverrideReason = null;
+                if (manualForceRedact.getStatus().equals(Status.APPROVED)) {
+                    redactionLogEntry.setRedacted(true);
+                    redactionLogEntry.setStatus(Status.APPROVED);
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry
+                            .isRedacted(), false));
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", forced by manual override");
+                    redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
+                } else if (manualForceRedact.getStatus().equals(Status.REQUESTED)) {
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to force redact");
+                    redactionLogEntry.setStatus(Status.REQUESTED);
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry
+                            .isRedacted(), false));
+                    redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
+                } else {
+                    redactionLogEntry.setStatus(Status.DECLINED);
+                }
+
+                redactionLogEntry.setManualRedactionUserId(manualForceRedact.getUser());
+                redactionLogEntry.setReason(manualOverrideReason);
+                redactionLogEntry.setManual(true);
+                redactionLogEntry.setManualRedactionType(ManualRedactionType.FORCE_REDACT);
+
+            }
+
+            if (mrw.getItem() instanceof ManualLegalBasisChange) {
+                var manualLegalBasisChange = (ManualLegalBasisChange) mrw.getItem();
+                String manualOverrideReason = null;
+                if (manualLegalBasisChange.getStatus().equals(Status.APPROVED)) {
+                    redactionLogEntry.setStatus(Status.APPROVED);
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis was manually changed");
+                    redactionLogEntry.setLegalBasis(manualLegalBasisChange.getLegalBasis());
+                } else if (manualLegalBasisChange.getStatus().equals(Status.REQUESTED)) {
+                    manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis change requested");
+                    redactionLogEntry.setStatus(Status.REQUESTED);
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry
+                            .isRedacted(), false));
+                    redactionLogEntry.setLegalBasisChangeValue(manualLegalBasisChange.getLegalBasis());
+                } else {
+                    redactionLogEntry.setStatus(Status.DECLINED);
+                }
+
+                redactionLogEntry.setManualRedactionUserId(manualLegalBasisChange.getUser());
+                redactionLogEntry.setReason(manualOverrideReason);
+                redactionLogEntry.setManual(true);
+                redactionLogEntry.setManualRedactionType(ManualRedactionType.LEGAL_BASIS_CHANGE);
+            }
+
+        });
+
+    }
+
+
     private String mergeReasonIfNecessary(String currentReason, String addition) {
+
         if (currentReason != null) {
             if (!currentReason.contains(addition)) {
                 return currentReason + addition;
@@ -170,14 +226,16 @@ public class RedactionLogMergeService {
     }
 
 
-    public List<RedactionLogEntry> addManualAddEntries(Set<ManualRedactionEntry> manualAdds, Map<String, List<Comment>> comments, String dossierTemplateId) {
+    public List<RedactionLogEntry> addManualAddEntries(Set<ManualRedactionEntry> manualAdds,
+                                                       Map<String, List<Comment>> comments, String dossierTemplateId) {
 
         List<RedactionLogEntry> redactionLogEntries = new ArrayList<>();
 
         for (ManualRedactionEntry manualRedactionEntry : manualAdds) {
 
             if (!approvedAndShouldBeInDictionary(manualRedactionEntry)) {
-                RedactionLogEntry redactionLogEntry = createRedactionLogEntry(manualRedactionEntry, manualRedactionEntry.getId(), dossierTemplateId);
+                RedactionLogEntry redactionLogEntry = createRedactionLogEntry(manualRedactionEntry, manualRedactionEntry
+                        .getId(), dossierTemplateId);
                 redactionLogEntry.setPositions(manualRedactionEntry.getPositions());
                 redactionLogEntry.setComments(comments.get(manualRedactionEntry.getId()));
                 redactionLogEntries.add(redactionLogEntry);
@@ -190,7 +248,8 @@ public class RedactionLogMergeService {
 
     private boolean approvedAndShouldBeInDictionary(ManualRedactionEntry manualRedactionEntry) {
 
-        return manualRedactionEntry.getStatus().equals(Status.APPROVED) && (manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary());
+        return manualRedactionEntry.getStatus()
+                .equals(Status.APPROVED) && (manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary());
     }
 
 
@@ -218,7 +277,9 @@ public class RedactionLogMergeService {
     }
 
 
-    private float[] getColor(String type, String dossierTemplateId, boolean requested, boolean isRedaction, boolean skipped) {
+    private float[] getColor(String type, String dossierTemplateId, boolean requested, boolean isRedaction,
+                             boolean skipped) {
+
         if (requested) {
             return dictionaryService.getRequestRemoveColor(dossierTemplateId);
         }
@@ -246,4 +307,22 @@ public class RedactionLogMergeService {
     }
 
 
+    @Data
+    @AllArgsConstructor
+    private static class ManualRedactionWrapper implements Comparable<ManualRedactionWrapper> {
+
+        private String id;
+        private OffsetDateTime date;
+        private Object item;
+
+
+        @Override
+        public int compareTo(ManualRedactionWrapper o) {
+
+            return this.date.compareTo(o.date);
+        }
+
+    }
+
 }
+