Pull request #360: RED-3568: Do not ignore textblocks if only rotated pages are in the document

Merge in RED/redaction-service from RED-3568 to master

* commit 'ae3e4570c15dbc2c46373ce68d55cec760e7da6b':
  RED-3568: Do not ignore textblocks if only rotated pages are in the document

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

@@ -20,6 +20,7 @@ public class ManualChange {
     private AnnotationStatus annotationStatus;
     private ManualRedactionType manualRedactionType;
     private OffsetDateTime processedDate;
+    private OffsetDateTime requestedDate;
     private String userId;
     private Map<String, Object> propertyChanges = new HashMap<>();
 
@@ -31,6 +32,7 @@ public class ManualChange {
         ManualChange manualChange = new ManualChange();
         manualChange.annotationStatus = baseAnnotation.getStatus();
         manualChange.processedDate = baseAnnotation.getProcessedDate();
+        manualChange.requestedDate = baseAnnotation.getRequestDate();
         manualChange.userId = baseAnnotation.getUser();
         return manualChange;
     }

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

@@ -27,6 +27,7 @@ public class RedactionLogEntry {
     private boolean redacted;
     private boolean isHint;
     private boolean isRecommendation;
+    private boolean isFalsePositive;
 
     private String section;
     private float[] color;

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

@@ -1,10 +1,15 @@
 package com.iqser.red.service.redaction.v1.model;
 
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 
 import com.iqser.red.service.persistence.service.v1.api.model.annotations.ManualRedactions;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.configuration.Colors;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.Type;
+
+
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -22,4 +27,9 @@ public class RedactionRequest {
     private ManualRedactions manualRedactions;
     @Builder.Default
     private Set<Integer> excludedPages = new HashSet<>();
+
+    private Colors colors;
+    private List<Type> types;
+
+    private boolean includeFalsePositives;
 }

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

@@ -52,7 +52,7 @@ public class ClassificationService {
                               List<Float> headlineFontSizes) {
 
         if (document.getFontSizeCounter().getMostPopular() == null) {
-            // TODO Figure out why this happens.
+            textBlock.setClassification("Other");
             return;
         }
         if (PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.isRotated()) && (document.getFontSizeCounter()

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

@@ -16,6 +16,6 @@ import lombok.NoArgsConstructor;
 public class NerEntities {
 
    @Builder.Default
-   private Map<Integer, List<EntityRecogintionEntity>> result = new HashMap<>();
+   private Map<Integer, List<EntityRecogintionEntity>> data = new HashMap<>();
 
 }

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

@@ -170,7 +170,6 @@ public class RedactionController implements RedactionResource {
     public RedactionLog getRedactionLog(RedactionRequest redactionRequest) {
 
         log.debug("Requested preview for: {}", redactionRequest);
-        dictionaryService.updateDictionary(redactionRequest.getDossierTemplateId(), redactionRequest.getDossierId());
 
         var redactionLog = redactionStorageService.getRedactionLog(redactionRequest.getDossierId(), redactionRequest.getFileId());
 
@@ -198,7 +197,11 @@ public class RedactionController implements RedactionResource {
         }
 
         log.info("Loaded redaction log with computationalVersion: {}", redactionLog.getAnalysisVersion());
-        return redactionLogMergeService.mergeRedactionLogData(redactionLog, sectionGrid, redactionRequest.getDossierTemplateId(), redactionRequest.getManualRedactions(), redactionRequest.getExcludedPages());
+        var merged = redactionLogMergeService.mergeRedactionLogData(redactionLog, sectionGrid, redactionRequest.getDossierTemplateId(), redactionRequest.getManualRedactions(), redactionRequest.getExcludedPages(), redactionRequest.getTypes(), redactionRequest.getColors());
+
+        merged.getRedactionLogEntry().removeIf(e -> e.isFalsePositive() && !redactionRequest.isIncludeFalsePositives());
+
+        return merged;
     }
 
 

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

@@ -0,0 +1,25 @@
+package com.iqser.red.service.redaction.v1.server.queue;
+
+import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.REDACTION_QUEUE;
+
+import org.springframework.amqp.rabbit.annotation.RabbitHandler;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+public class MessageReceiver {
+
+    private final RedactionMessageReceiver redactionMessageReceiver;
+
+    @RabbitHandler
+    @RabbitListener(queues = REDACTION_QUEUE)
+    public void receiveAnalyzeRequest(String in) throws JsonProcessingException {
+        redactionMessageReceiver.receiveAnalyzeRequest(in, false);
+    }
+
+}

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

@@ -1,8 +1,10 @@
 package com.iqser.red.service.redaction.v1.server.queue;
 
 import lombok.RequiredArgsConstructor;
+
 import org.springframework.amqp.core.Queue;
 import org.springframework.amqp.core.QueueBuilder;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -10,11 +12,24 @@ import org.springframework.context.annotation.Configuration;
 @RequiredArgsConstructor
 public class MessagingConfiguration {
 
-
     public static final String REDACTION_QUEUE = "redactionQueue";
-
     public static final String REDACTION_DQL = "redactionDQL";
 
+    public static final String REDACTION_PRIORITY_QUEUE = "redactionPriorityQueue";
+
+    @Bean
+    @ConditionalOnProperty(prefix = "redaction-service", name = "priorityMode", havingValue = "false")
+    public MessageReceiver messageReceiver(RedactionMessageReceiver redactionMessageReceiver){
+        return new MessageReceiver(redactionMessageReceiver);
+    }
+
+
+    @Bean
+    @ConditionalOnProperty(prefix = "redaction-service", name = "priorityMode", havingValue = "true")
+    public PriorityMessageReceiver priorityMessageReceiver(RedactionMessageReceiver redactionMessageReceiver){
+        return new PriorityMessageReceiver(redactionMessageReceiver);
+    }
+
 
     @Bean
     public Queue redactionQueue() {
@@ -27,9 +42,21 @@ public class MessagingConfiguration {
     }
 
 
+    @Bean
+    public Queue redactionPriorityQueue() {
+
+        return QueueBuilder.durable(REDACTION_PRIORITY_QUEUE)
+                .withArgument("x-dead-letter-exchange", "")
+                .withArgument("x-dead-letter-routing-key", REDACTION_DQL)
+                .maxPriority(2)
+                .build();
+    }
+
+
     @Bean
     public Queue redactionDeadLetterQueue() {
 
         return QueueBuilder.durable(REDACTION_DQL).build();
     }
+
 }

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

@@ -0,0 +1,27 @@
+package com.iqser.red.service.redaction.v1.server.queue;
+
+import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.REDACTION_PRIORITY_QUEUE;
+
+import org.springframework.amqp.rabbit.annotation.RabbitHandler;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+public class PriorityMessageReceiver {
+
+    private final RedactionMessageReceiver redactionMessageReceiver;
+
+
+    @RabbitHandler
+    @RabbitListener(queues = REDACTION_PRIORITY_QUEUE)
+    public void receiveAnalyzeRequest(String in) throws JsonProcessingException {
+
+        redactionMessageReceiver.receiveAnalyzeRequest(in, true);
+    }
+
+}

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

@@ -30,12 +30,10 @@ public class RedactionMessageReceiver {
     private final ManualRedactionSurroundingTextService manualRedactionSurroundingTextService;
 
 
-    @RabbitHandler
-    @RabbitListener(queues = REDACTION_QUEUE)
-    public void receiveAnalyzeRequest(String in) throws JsonProcessingException {
+    public void receiveAnalyzeRequest(String in, boolean priority) throws JsonProcessingException {
 
         var analyzeRequest = objectMapper.readValue(in, AnalyzeRequest.class);
-        log.info("Processing analyze request for file: {}", analyzeRequest.getFileId());
+        log.info("Processing priority: {} analyze request for file: {}", priority, analyzeRequest.getFileId());
         AnalyzeResult result = null;
 
         switch (analyzeRequest.getMessageType()) {

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

@@ -1,22 +1,16 @@
 package com.iqser.red.service.redaction.v1.server.redaction.model;
 
-import static java.util.stream.Collectors.toSet;
-
-import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.DictionaryEntry;
-import lombok.Data;
-import lombok.Getter;
-
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import lombok.Data;
+import lombok.Getter;
 
 @Data
 public class Dictionary {
 
-    public static final String RECOMMENDATION_PREFIX = "recommendation_";
-
     @Getter
     private List<DictionaryModel> dictionaryModels;
     private Map<String, DictionaryModel> localAccessMap = new HashMap<>();
@@ -26,6 +20,7 @@ public class Dictionary {
 
 
     public Dictionary(List<DictionaryModel> dictionaryModels, DictionaryVersion version) {
+
         this.dictionaryModels = dictionaryModels;
         this.dictionaryModels.forEach(dm -> localAccessMap.put(dm.getType(), dm));
         this.version = version;
@@ -33,6 +28,7 @@ public class Dictionary {
 
 
     public int getDictionaryRank(String type) {
+
         if (!localAccessMap.containsKey(type)) {
             return 0;
         }
@@ -40,16 +36,6 @@ public class Dictionary {
     }
 
 
-    public boolean isRecommendation(String type) {
-
-        DictionaryModel model = localAccessMap.get(type);
-        if (model != null) {
-            return model.isRecommendation();
-        }
-        return false;
-    }
-
-
     public boolean hasLocalEntries() {
 
         return dictionaryModels.stream().anyMatch(dm -> !dm.getLocalEntries().isEmpty());
@@ -62,16 +48,18 @@ public class Dictionary {
     }
 
 
+    public DictionaryModel getType(String type) {
+
+        return localAccessMap.get(type);
+    }
+
+
     public boolean containsValue(String type, String value) {
 
         return localAccessMap.containsKey(type) && localAccessMap.get(type)
                 .getValues(false)
                 .contains(value) || localAccessMap.containsKey(type) && localAccessMap.get(type)
                 .getValues(true)
-                .contains(value) || localAccessMap.containsKey(RECOMMENDATION_PREFIX + type) && localAccessMap.get(RECOMMENDATION_PREFIX + type)
-                .getValues(false)
-                .contains(value) || localAccessMap.containsKey(RECOMMENDATION_PREFIX + type) && localAccessMap.get(RECOMMENDATION_PREFIX + type)
-                .getValues(true)
                 .contains(value);
     }
 
@@ -85,6 +73,7 @@ public class Dictionary {
         return false;
     }
 
+
     public boolean isCaseInsensitiveDictionary(String type) {
 
         DictionaryModel dictionaryModel = localAccessMap.get(type);

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

@@ -0,0 +1,26 @@
+package com.iqser.red.service.redaction.v1.server.redaction.model;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.DictionaryEntry;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DictionaryEntries {
+
+    @Builder.Default
+    Set<DictionaryEntry> entries = new HashSet<>();
+    @Builder.Default
+    Set<DictionaryEntry> falsePositives = new HashSet<>();
+    @Builder.Default
+    Set<DictionaryEntry> falseRecommendations = new HashSet<>();
+
+}

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

@@ -19,8 +19,9 @@ public class DictionaryModel implements Serializable {
     private float[] color;
     private boolean caseInsensitive;
     private boolean hint;
-    private boolean recommendation;
     private Set<DictionaryEntry> entries;
+    private Set<DictionaryEntry> falsePositives;
+    private Set<DictionaryEntry> falseRecommendations;
     private Set<String> localEntries;
     private boolean isDossierDictionary;
 
@@ -29,4 +30,14 @@ public class DictionaryModel implements Serializable {
                 .toSet());
     }
 
+    public Set<String> getFalsePositiveValues() {
+        return falsePositives.stream().filter(e -> !e.isDeleted()).map(e -> e.getValue()).collect(Collectors
+                .toSet());
+    }
+
+    public Set<String> getFalseRecommendationValues() {
+        return falseRecommendations.stream().filter(e -> !e.isDeleted()).map(e -> e.getValue()).collect(Collectors
+                .toSet());
+    }
+
 }

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

@@ -48,11 +48,13 @@ public class Entity implements ReasonHolder {
 
     private Set<Entity> references = new HashSet<>();
 
+    private EntityType entityType;
+
 
     public Entity(String word, String type, boolean redaction, String redactionReason,
                   List<EntityPositionSequence> positionSequences, String headline, int matchedRule, int sectionNumber,
                   String legalBasis, boolean isDictionaryEntry, String textBefore, String textAfter, Integer start,
-                  Integer end, boolean isDossierDictionaryEntry, Set<Engine> engines, Set<Entity> references) {
+                  Integer end, boolean isDossierDictionaryEntry, Set<Engine> engines, Set<Entity> references, EntityType entityType) {
 
         this.word = word;
         this.type = type;
@@ -71,11 +73,12 @@ public class Entity implements ReasonHolder {
         this.isDossierDictionaryEntry = isDossierDictionaryEntry;
         this.engines = engines;
         this.references = references;
+        this.entityType = entityType;
     }
 
 
     public Entity(String word, String type, Integer start, Integer end, String headline, int sectionNumber,
-                  boolean isDictionaryEntry, boolean isDossierDictionaryEntry, Engine engine) {
+                  boolean isDictionaryEntry, boolean isDossierDictionaryEntry, Engine engine, EntityType entityType) {
 
         this.word = word;
         this.type = type;
@@ -86,6 +89,7 @@ public class Entity implements ReasonHolder {
         this.isDictionaryEntry = isDictionaryEntry;
         this.isDossierDictionaryEntry = isDossierDictionaryEntry;
         this.engines.add(engine);
+        this.entityType = entityType;
     }
 
 

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

@@ -0,0 +1,5 @@
+package com.iqser.red.service.redaction.v1.server.redaction.model;
+
+public enum EntityType {
+    ENTITY, RECOMMENDATION, FALSE_POSITIVE, FALSE_RECOMMENDATION
+}

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

@@ -1,6 +1,5 @@
 package com.iqser.red.service.redaction.v1.server.redaction.model;
 
-import static com.iqser.red.service.redaction.v1.server.redaction.model.Dictionary.RECOMMENDATION_PREFIX;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
@@ -74,7 +73,7 @@ public class Section {
 
         Set<Entity> entitiesOfType = nerEntities.stream().filter(nerEntity -> nerEntity.getType().equals(type)).collect(Collectors.toSet());
         Set<String> values = entitiesOfType.stream().map(Entity::getWord).collect(Collectors.toSet());
-        Set<Entity> found = EntitySearchUtils.find(searchText, values, asType, headline, sectionNumber, false, false, Engine.NER, true);
+        Set<Entity> found = EntitySearchUtils.findEntities(searchText, values, dictionary.getType(asType), headline, sectionNumber, false, false, Engine.NER, true, true);
         EntitySearchUtils.clearAndFindPositions(found, searchableText, dictionary);
 
         Set<Entity> finalResult = new HashSet<>();
@@ -119,7 +118,7 @@ public class Section {
             } else if (!allowDuplicateTypes && foundParts.contains(entity.getType())) {
                 if (numberOfMatchParts >= minPartMatches) {
                     String value = searchText.substring(start, lastEnd);
-                    found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER));
+                    found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER, true));
                 }
                 start = -1;
                 lastEnd = -1;
@@ -134,7 +133,7 @@ public class Section {
             } else if (entity.getType().equals(startType) && start != -1) {
                 if (numberOfMatchParts >= minPartMatches) {
                     String value = searchText.substring(start, lastEnd);
-                    found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER));
+                    found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER, true));
                 }
                 start = entity.getStart();
                 lastEnd = entity.getEnd();
@@ -151,7 +150,7 @@ public class Section {
 
         if (numberOfMatchParts >= minPartMatches) {
             String value = searchText.substring(start, lastEnd);
-            found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER));
+            found.addAll(findEntities(value, asType, false, true, 0, null, null, Engine.NER, true));
         }
 
         if (!found.isEmpty()) {
@@ -291,7 +290,7 @@ public class Section {
                 String match = matcher.group(group);
 
                 if (StringUtils.isNotBlank(match)) {
-                    Set<Entity> expandedEntities = findEntities(entity.getWord() + match, type, false, entity.isRedaction(), entity.getMatchedRule(), entity.getRedactionReason(), entity.getLegalBasis(), Engine.RULE);
+                    Set<Entity> expandedEntities = findEntities(entity.getWord() + match, type, false, entity.isRedaction(), entity.getMatchedRule(), entity.getRedactionReason(), entity.getLegalBasis(), Engine.RULE, false);
                     expanded.addAll(EntitySearchUtils.findNonOverlappingMatchEntities(entities, expandedEntities));
                 }
             }
@@ -450,7 +449,7 @@ public class Section {
         while (matcher.find()) {
             String match = matcher.group(group);
             if (StringUtils.isNotBlank(match) && match.length() >= 3) {
-                localDictionaryAdds.computeIfAbsent(RECOMMENDATION_PREFIX + asType, (x) -> new HashSet<>()).add(match);
+                localDictionaryAdds.computeIfAbsent(asType, (x) -> new HashSet<>()).add(match);
             }
         }
     }
@@ -460,12 +459,11 @@ public class Section {
     public void redactNotAndReference(@Argument(ArgumentType.TYPE) String type, @Argument(ArgumentType.REFERENCE_TYPE) String referenceType,
                                       @Argument(ArgumentType.RULE_NUMBER) int ruleNumber, @Argument(ArgumentType.STRING) String reason) {
 
-        boolean hasRecommendationDictionary = dictionaryTypes.contains(RECOMMENDATION_PREFIX + type);
 
         Set<Entity> references = entities.stream().filter(entity -> entity.getType().equals(referenceType)).collect(Collectors.toSet());
 
         entities.forEach(entity -> {
-            if (entity.getType().equals(type) || hasRecommendationDictionary && entity.getType().equals(RECOMMENDATION_PREFIX + type)) {
+            if (entity.getType().equals(type)) {
                 entity.setRedaction(false);
                 entity.setMatchedRule(ruleNumber);
                 entity.setRedactionReason(reason);
@@ -494,21 +492,26 @@ public class Section {
     public void addRedaction(@Argument(ArgumentType.STRING) String value, @Argument(ArgumentType.TYPE) String asType, @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
                              @Argument(ArgumentType.STRING) String reason, @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
-        Set<Entity> found = findEntities(value.trim(), asType, true, true, ruleNumber, reason, legalBasis, Engine.RULE);
+        Set<Entity> found = findEntities(value.trim(), asType, true, true, ruleNumber, reason, legalBasis, Engine.RULE, false);
         EntitySearchUtils.addEntitiesIgnoreRank(entities, found);
     }
 
 
     public void ignore(String type) {
 
-        entities.removeIf(entity -> entity.getType().equals(type));
+        entities.removeIf(entity -> entity.getType().equals(type) && entity.getEntityType().equals(EntityType.ENTITY));
+    }
+
+
+    public void ignoreRecommendations(String type) {
+
+        entities.removeIf(entity -> entity.getType().equals(type) && entity.getEntityType().equals(EntityType.RECOMMENDATION));
     }
 
 
     @ThenAction
-    public void expandToHintAnnotationByRegEx(@Argument(ArgumentType.TYPE) String type, @Argument(ArgumentType.STRING) String pattern,
-                                              @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive, @Argument(ArgumentType.INTEGER) int group,
-                                              @Argument(ArgumentType.TYPE) String asType) {
+    public void expandToFalsePositiveByRegEx(@Argument(ArgumentType.TYPE) String type, @Argument(ArgumentType.STRING) String pattern,
+                                              @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive, @Argument(ArgumentType.INTEGER) int group) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -524,13 +527,14 @@ public class Section {
             while (matcher.find()) {
                 String match = matcher.group(group);
                 if (StringUtils.isNotBlank(match)) {
-                    expanded.addAll(findEntities(entity.getWord() + match, asType, false, false, 0, null, null, Engine.RULE));
+                    expanded.addAll(findEntities(entity.getWord() + match, type, false, false, 0, null, null, Engine.RULE, false));
                 }
             }
         }
 
         EntitySearchUtils.addEntitiesWithHigherRank(entities, expanded, dictionary);
         EntitySearchUtils.removeEntitiesContainedInLarger(entities);
+        expanded.forEach(e -> e.setEntityType(EntityType.FALSE_POSITIVE));
     }
 
 
@@ -545,7 +549,7 @@ public class Section {
         while (matcher.find()) {
             String match = matcher.group(group);
             if (StringUtils.isNotBlank(match)) {
-                Set<Entity> found = findEntities(match.trim(), asType, false, false, 0, null, null, Engine.RULE);
+                Set<Entity> found = findEntities(match.trim(), asType, false, false, 0, null, null, Engine.RULE, false);
                 EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
             }
         }
@@ -555,7 +559,7 @@ public class Section {
     @ThenAction
     public void addHintAnnotation(@Argument(ArgumentType.STRING) String value, @Argument(ArgumentType.TYPE) String asType) {
 
-        Set<Entity> found = findEntities(value.trim(), asType, true, false, 0, null, null, Engine.RULE);
+        Set<Entity> found = findEntities(value.trim(), asType, true, false, 0, null, null, Engine.RULE, false);
         EntitySearchUtils.addEntitiesIgnoreRank(entities, found);
     }
 
@@ -577,7 +581,7 @@ public class Section {
                 }
 
                 if (StringUtils.isNotBlank(cleanValue) && cleanValue.length() >= 3) {
-                    localDictionaryAdds.computeIfAbsent(RECOMMENDATION_PREFIX + asType, (x) -> new HashSet<>()).add(cleanValue);
+                    localDictionaryAdds.computeIfAbsent(asType, (x) -> new HashSet<>()).add(cleanValue);
                 }
             }
         }
@@ -599,20 +603,20 @@ public class Section {
         while (matcher.find()) {
             String match = matcher.group(group);
             if (StringUtils.isNotBlank(match) && match.length() >= 3) {
-                Set<Entity> found = findEntities(match.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE);
+                Set<Entity> found = findEntities(match.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE, false);
                 EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
-                localDictionaryAdds.computeIfAbsent(RECOMMENDATION_PREFIX + asType, (x) -> new HashSet<>()).add(match);
+                localDictionaryAdds.computeIfAbsent(asType, (x) -> new HashSet<>()).add(match);
             }
         }
     }
 
 
-    private Set<Entity> findEntities(String value, String asType, boolean caseInsensitive, boolean redacted, int ruleNumber, String reason, String legalBasis, Engine engine) {
+    private Set<Entity> findEntities(String value, String asType, boolean caseInsensitive, boolean redacted, int ruleNumber, String reason, String legalBasis, Engine engine, boolean asRecommendation) {
 
         String text = caseInsensitive ? searchText.toLowerCase() : searchText;
         String searchValue = caseInsensitive ? value.toLowerCase() : value;
 
-        Set<Entity> found = EntitySearchUtils.find(text, Set.of(searchValue), asType, headline, sectionNumber, false, false, engine, false);
+        Set<Entity> found = EntitySearchUtils.findEntities(text, Set.of(searchValue), dictionary.getType(asType), headline, sectionNumber, false, false, engine, false, asRecommendation);
 
         found.forEach(entity -> {
             if (redacted) {
@@ -629,10 +633,8 @@ public class Section {
 
     private void redact(String type, int ruleNumber, String reason, String legalBasis, boolean redaction) {
 
-        boolean hasRecommendationDictionary = dictionaryTypes.contains(RECOMMENDATION_PREFIX + type);
-
         entities.forEach(entity -> {
-            if (entity.getType().equals(type) || hasRecommendationDictionary && entity.getType().equals(RECOMMENDATION_PREFIX + type)) {
+            if (entity.getType().equals(type)) {
                 entity.setRedaction(redaction);
                 entity.setMatchedRule(ruleNumber);
                 entity.setRedactionReason(reason);
@@ -665,7 +667,7 @@ public class Section {
         } else {
             String word = value.toString();
 
-            Entity entity = new Entity(word, type, value.getRowSpanStart(), value.getRowSpanStart() + word.length(), headline, sectionNumber, false, false, Engine.RULE);
+            Entity entity = new Entity(word, type, value.getRowSpanStart(), value.getRowSpanStart() + word.length(), headline, sectionNumber, false, false, Engine.RULE, EntityType.ENTITY);
             entity.setRedaction(redact);
             entity.setMatchedRule(ruleNumber);
             entity.setRedactionReason(reason);
@@ -692,9 +694,9 @@ public class Section {
                 while (matcher.find()) {
                     String match = matcher.group().trim();
                     if (match.length() >= 3) {
-                        localDictionaryAdds.computeIfAbsent(RECOMMENDATION_PREFIX + type, (x) -> new HashSet<>()).add(match);
+                        localDictionaryAdds.computeIfAbsent(type, (x) -> new HashSet<>()).add(match);
                         String lastname = match.split(" ")[0];
-                        localDictionaryAdds.computeIfAbsent(RECOMMENDATION_PREFIX + type, (x) -> new HashSet<>()).add(lastname);
+                        localDictionaryAdds.computeIfAbsent(type, (x) -> new HashSet<>()).add(lastname);
                     }
                 }
             }
@@ -709,7 +711,7 @@ public class Section {
         if (values != null) {
             for (String value : values) {
                 if (StringUtils.isNotBlank(value)) {
-                    Set<Entity> found = findEntities(value.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE);
+                    Set<Entity> found = findEntities(value.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE, false);
                     EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
 
                     if (redactEverywhere && !isLocal()) {
@@ -730,7 +732,7 @@ public class Section {
         while (matcher.find()) {
             String match = matcher.group(group);
             if (StringUtils.isNotBlank(match)) {
-                Set<Entity> found = findEntities(match.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE);
+                Set<Entity> found = findEntities(match.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE, false);
                 EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
             }
         }
@@ -745,7 +747,7 @@ public class Section {
             for (String value : values) {
                 if (StringUtils.isNotBlank(value)) {
 
-                    Set<Entity> found = findEntities(value.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE);
+                    Set<Entity> found = findEntities(value.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE, false);
                     EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
 
                     if (redactEverywhere && !isLocal()) {
@@ -772,7 +774,7 @@ public class Section {
                             return;
                         }
 
-                        Set<Entity> found = findEntities(line.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE);
+                        Set<Entity> found = findEntities(line.trim(), asType, false, redaction, ruleNumber, reason, legalBasis, Engine.RULE, false);
                         EntitySearchUtils.addEntitiesWithHigherRank(entities, found, dictionary);
 
                         if (redactEverywhere && !isLocal()) {

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

@@ -10,6 +10,6 @@ public class ImageServiceResponse {
 
     private String dossierId;
     private String fileId;
-    private List<ImageMetadata> imageMetadata = new ArrayList<>();
+    private List<ImageMetadata> data = new ArrayList<>();
 
 }

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

@@ -60,6 +60,16 @@ public class DictionaryService {
                     newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
                 }
             });
+            dictionaryModel.getFalsePositives().forEach(dictionaryEntry -> {
+                if (dictionaryEntry.getVersion() > fromVersion.getDossierTemplateVersion()) {
+                    newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
+                }
+            });
+            dictionaryModel.getFalseRecommendations().forEach(dictionaryEntry -> {
+                if (dictionaryEntry.getVersion() > fromVersion.getDossierTemplateVersion()) {
+                    newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
+                }
+            });
         });
 
         if (dictionariesByDossier.containsKey(dossierId)) {
@@ -70,6 +80,16 @@ public class DictionaryService {
                         newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
                     }
                 });
+                dictionaryModel.getFalsePositives().forEach(dictionaryEntry -> {
+                    if (dictionaryEntry.getVersion() > fromVersion.getDossierVersion()) {
+                        newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
+                    }
+                });
+                dictionaryModel.getFalseRecommendations().forEach(dictionaryEntry -> {
+                    if (dictionaryEntry.getVersion() > fromVersion.getDossierVersion()) {
+                        newValues.add(new DictionaryIncrementValue(dictionaryEntry.getValue(), dictionaryModel.isCaseInsensitive()));
+                    }
+                });
             });
         }
 
@@ -99,13 +119,33 @@ public class DictionaryService {
                             }
 
                             Set<DictionaryEntry> entries = new HashSet<>();
+                            Set<DictionaryEntry> falsePositives = new HashSet<>();
+                            Set<DictionaryEntry> falseRecommendations = new HashSet<>();
+
+                            DictionaryEntries newEntries = getEntries(t.getId(), currentVersion);
+
+                            var newValues = newEntries.getEntries().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+                            var newFalsePositivesValues = newEntries.getFalsePositives().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+                            var newFalseRecommendationsValues = newEntries.getFalseRecommendations().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+
                             // add old entries from existing DictionaryModel
-                            oldModel.ifPresent(dictionaryModel -> entries.addAll(dictionaryModel.getEntries()));
+                            oldModel.ifPresent(dictionaryModel -> entries.addAll(dictionaryModel.getEntries().stream().filter(
+                                    f -> !newValues.contains(f.getValue())).collect(Collectors.toList())
+                            ));
+                            oldModel.ifPresent(dictionaryModel -> falsePositives.addAll(dictionaryModel.getFalsePositives().stream().filter(
+                                    f -> !newFalsePositivesValues.contains(f.getValue())).collect(Collectors.toList())
+                            ));
+                            oldModel.ifPresent(dictionaryModel -> falseRecommendations.addAll(dictionaryModel.getFalseRecommendations().stream().filter(
+                                    f -> !newFalseRecommendationsValues.contains(f.getValue())).collect(Collectors.toList())
+                            ));
+
                             // Add Increments
-                            entries.addAll(convertEntries(t.getId(), currentVersion));
+                            entries.addAll(newEntries.getEntries());
+                            falsePositives.addAll(newEntries.getFalsePositives());
+                            falseRecommendations.addAll(newEntries.getFalseRecommendations());
 
                             return new DictionaryModel(t.getType(), t.getRank(), convertColor(t.getHexColor()), t.isCaseInsensitive(), t
-                                    .isHint(), t.isRecommendation(), entries, new HashSet<>(), dossierId != null);
+                                    .isHint(), entries, falsePositives, falseRecommendations, new HashSet<>(), dossierId != null);
                         })
                         .sorted(Comparator.comparingInt(DictionaryModel::getRank).reversed())
                         .collect(Collectors.toList());
@@ -135,17 +175,20 @@ public class DictionaryService {
     }
 
 
-    private Set<DictionaryEntry> convertEntries(String typeId, Long fromVersion) {
+    private DictionaryEntries getEntries(String typeId, Long fromVersion) {
 
         var type = dictionaryClient.getDictionaryForType(typeId, fromVersion);
 
-        Set<DictionaryEntry> entries = new HashSet<>(type
-                .getEntries());
+        Set<DictionaryEntry> entries = type.getEntries() != null ? new HashSet<>(type.getEntries()) : new HashSet<>();
+        Set<DictionaryEntry> falsePositives = type.getFalsePositiveEntries() != null ? new HashSet<>(type.getFalsePositiveEntries()) : new HashSet<>();
+        Set<DictionaryEntry> falseRecommendations = type.getFalseRecommendationEntries() != null ? new HashSet<>(type.getFalseRecommendationEntries()) : new HashSet<>();
 
         if (type.isCaseInsensitive()) {
             entries.forEach(entry -> entry.setValue(entry.getValue().toLowerCase(Locale.ROOT)));
+            falsePositives.forEach(entry -> entry.setValue(entry.getValue().toLowerCase(Locale.ROOT)));
+            falseRecommendations.forEach(entry -> entry.setValue(entry.getValue().toLowerCase(Locale.ROOT)));
         }
-        return entries;
+        return new DictionaryEntries(entries, falsePositives, falseRecommendations);
     }
 
 
@@ -186,16 +229,6 @@ public class DictionaryService {
     }
 
 
-    public boolean isRecommendation(String type, String dossierTemplateId) {
-
-        DictionaryModel model = dictionariesByDossierTemplate.get(dossierTemplateId).getLocalAccessMap().get(type);
-        if (model != null) {
-            return model.isRecommendation();
-        }
-        return false;
-    }
-
-
     public Dictionary getDeepCopyDictionary(String dossierTemplateId, String dossierId) {
 
         List<DictionaryModel> copy = new ArrayList<>();

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

@@ -25,6 +25,7 @@ import com.iqser.red.service.redaction.v1.server.redaction.model.DictionaryModel
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entities;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entity;
 import com.iqser.red.service.redaction.v1.server.redaction.model.EntityPositionSequence;
+import com.iqser.red.service.redaction.v1.server.redaction.model.EntityType;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Image;
 import com.iqser.red.service.redaction.v1.server.redaction.model.PageEntities;
 import com.iqser.red.service.redaction.v1.server.redaction.model.SearchableText;
@@ -61,6 +62,8 @@ public class EntityRedactionService {
         }
 
         Map<Integer, List<Entity>> entitiesPerPage = convertToEntitiesPerPage(entities);
+        EntitySearchUtils.removeEntitiesContainedInRedactedLogos(imagesPerPage, entitiesPerPage);
+
         return new PageEntities(entitiesPerPage, imagesPerPage);
     }
 
@@ -175,7 +178,7 @@ public class EntityRedactionService {
                                 .getValue(), entity.getHeadline(), entity.getMatchedRule(), entity.getSectionNumber(), entity
                                 .getLegalBasis(), entity.isDictionaryEntry(), entity.getTextBefore(), entity.getTextAfter(), entity
                                 .getStart(), entity.getEnd(), entity.isDossierDictionaryEntry(), entity.getEngines(), entity
-                                .getReferences()));
+                                .getReferences(), entity.getEntityType()));
             }
         }
         return entitiesPerPage;
@@ -197,13 +200,6 @@ public class EntityRedactionService {
     private void addLocalValuesToDictionary(Section analysedSection, Dictionary dictionary) {
 
         analysedSection.getLocalDictionaryAdds().keySet().forEach(key -> {
-            if (dictionary.isRecommendation(key)) {
-                analysedSection.getLocalDictionaryAdds().get(key).forEach(value -> {
-                    if (!dictionary.containsValue(key, value)) {
-                        dictionary.getLocalAccessMap().get(key).getLocalEntries().add(value);
-                    }
-                });
-            } else {
                 analysedSection.getLocalDictionaryAdds().get(key).forEach(value -> {
 
                     if (dictionary.getLocalAccessMap().get(key) == null) {
@@ -216,7 +212,6 @@ public class EntityRedactionService {
 
                     dictionary.getLocalAccessMap().get(key).getLocalEntries().add(value);
                 });
-            }
         });
     }
 
@@ -234,11 +229,9 @@ public class EntityRedactionService {
         String lowercaseInputString = searchableString.toLowerCase();
         for (DictionaryModel model : dictionary.getDictionaryModels()) {
             if (model.isCaseInsensitive()) {
-                EntitySearchUtils.addOrAddEngine(found, EntitySearchUtils.find(lowercaseInputString, model.getValues(local), model
-                        .getType(), headline, sectionNumber, !local, model.isDossierDictionary(), local ? Engine.RULE : Engine.DICTIONARY, false));
+                EntitySearchUtils.addOrAddEngine(found, EntitySearchUtils.findEntities(lowercaseInputString, model.getValues(local), model, headline, sectionNumber, !local, model.isDossierDictionary(), local ? Engine.RULE : Engine.DICTIONARY, false, local ? true : false));
             } else {
-                EntitySearchUtils.addOrAddEngine(found, EntitySearchUtils.find(searchableString, model.getValues(local), model
-                        .getType(), headline, sectionNumber, !local, model.isDossierDictionary(), local ? Engine.RULE : Engine.DICTIONARY, false));
+                EntitySearchUtils.addOrAddEngine(found, EntitySearchUtils.findEntities(searchableString, model.getValues(local), model, headline, sectionNumber, !local, model.isDossierDictionary(), local ? Engine.RULE : Engine.DICTIONARY, false, local ? true : false));
             }
         }
 
@@ -256,10 +249,10 @@ public class EntityRedactionService {
 
         Set<Entity> entities = new HashSet<>();
 
-        if (redactionServiceSettings.isNerServiceEnabled() && nerEntities.getResult().containsKey(sectionNumber)) {
-            nerEntities.getResult().get(sectionNumber).forEach(res -> {
+        if (redactionServiceSettings.isNerServiceEnabled() && nerEntities.getData().containsKey(sectionNumber)) {
+            nerEntities.getData().get(sectionNumber).forEach(res -> {
                 if (cellStarts == null || cellStarts.isEmpty()) {
-                    entities.add(new Entity(res.getValue(), res.getType(), res.getStartOffset(), res.getEndOffset(), headline, sectionNumber, false, false, Engine.NER));
+                    entities.add(new Entity(res.getValue(), res.getType(), res.getStartOffset(), res.getEndOffset(), headline, sectionNumber, false, false, Engine.NER, EntityType.RECOMMENDATION));
                 } else {
                     boolean intersectsCellStart = false;
                     for (Integer cellStart : cellStarts) {
@@ -269,7 +262,7 @@ public class EntityRedactionService {
                         }
                     }
                     if (!intersectsCellStart) {
-                        entities.add(new Entity(res.getValue(), res.getType(), res.getStartOffset(), res.getEndOffset(), headline, sectionNumber, false, false, Engine.NER));
+                        entities.add(new Entity(res.getValue(), res.getType(), res.getStartOffset(), res.getEndOffset(), headline, sectionNumber, false, false, Engine.NER, EntityType.RECOMMENDATION));
                     }
                 }
             });

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

@@ -19,6 +19,7 @@ import com.iqser.red.service.redaction.v1.server.classification.model.Text;
 import com.iqser.red.service.redaction.v1.server.parsing.model.TextPositionSequence;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entity;
 import com.iqser.red.service.redaction.v1.server.redaction.model.EntityPositionSequence;
+import com.iqser.red.service.redaction.v1.server.redaction.model.EntityType;
 import com.iqser.red.service.redaction.v1.server.redaction.utils.EntitySearchUtils;
 import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
 
@@ -90,7 +91,7 @@ public class ManualRedactionSurroundingTextService {
     private Pair<String, String> findSurroundingText(SectionText sectionText, String value,
                                                      List<Rectangle> toFindPositions) {
 
-        Set<Entity> entities = EntitySearchUtils.find(sectionText.getText(), Set.of(value), "dummy", sectionText.getHeadline(), sectionText.getSectionNumber(), false, false, Engine.DICTIONARY, false);
+        Set<Entity> entities = EntitySearchUtils.find(sectionText.getText(), Set.of(value), "dummy", sectionText.getHeadline(), sectionText.getSectionNumber(), false, false, Engine.DICTIONARY, false, EntityType.ENTITY);
         Set<Entity> entitiesWithPositions = EntitySearchUtils.clearAndFindPositions(entities, sectionText.getSearchableText(), null);
 
         Entity correctEntity = getEntityOnCorrectPosition(entitiesWithPositions, toFindPositions);

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

@@ -17,6 +17,7 @@ import com.iqser.red.service.redaction.v1.server.parsing.model.RedTextPosition;
 import com.iqser.red.service.redaction.v1.server.parsing.model.TextPositionSequence;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entity;
 import com.iqser.red.service.redaction.v1.server.redaction.model.EntityPositionSequence;
+import com.iqser.red.service.redaction.v1.server.redaction.model.EntityType;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Image;
 import com.iqser.red.service.redaction.v1.server.redaction.model.PageEntities;
 import com.iqser.red.service.redaction.v1.server.redaction.utils.IdBuilder;
@@ -203,7 +204,8 @@ public class RedactionLogCreatorService {
                 .type(entity.getType())
                 .redacted(entity.isRedaction())
                 .isHint(isHint(entity.getType(), dossierTemplateId))
-                .isRecommendation(isRecommendation(entity.getType(), dossierTemplateId))
+                .isRecommendation(entity.getEntityType().equals(EntityType.RECOMMENDATION))
+                .isFalsePositive(entity.getEntityType().equals(EntityType.FALSE_POSITIVE) || entity.getEntityType().equals(EntityType.FALSE_RECOMMENDATION))
                 .section(entity.getHeadline())
                 .sectionNumber(entity.getSectionNumber())
                 .matchedRule(entity.getMatchedRule())
@@ -233,10 +235,4 @@ public class RedactionLogCreatorService {
         return dictionaryService.isHint(type, dossierTemplateId);
     }
 
-
-    private boolean isRecommendation(String type, String dossierTemplateId) {
-
-        return dictionaryService.isRecommendation(type, dossierTemplateId);
-    }
-
 }

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

@@ -4,6 +4,8 @@ import com.iqser.red.service.persistence.service.v1.api.model.annotations.Annota
 import com.iqser.red.service.persistence.service.v1.api.model.annotations.Comment;
 import com.iqser.red.service.persistence.service.v1.api.model.annotations.ManualRedactions;
 import com.iqser.red.service.persistence.service.v1.api.model.annotations.entitymapped.*;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.configuration.Colors;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.Type;
 import com.iqser.red.service.redaction.v1.model.*;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -11,6 +13,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.awt.Color;
 import java.time.OffsetDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -20,19 +23,18 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 public class RedactionLogMergeService {
 
-    private final DictionaryService dictionaryService;
 
     private final SectionTextService sectionTextService;
 
 
     public RedactionLog mergeRedactionLogData(RedactionLog redactionLog, SectionGrid sectionGrid,
                                               String dossierTemplateId, ManualRedactions manualRedactions,
-                                              Set<Integer> excludedPages) {
+                                              Set<Integer> excludedPages, List<Type> types, Colors colors) {
 
         log.info("Merging Redaction log with manual redactions");
         if (manualRedactions != null) {
 
-            var manualRedactionLogEntries = addManualAddEntries(sectionGrid, manualRedactions.getEntriesToAdd(), manualRedactions.getComments(), dossierTemplateId);
+            var manualRedactionLogEntries = addManualAddEntries(sectionGrid, manualRedactions.getEntriesToAdd(), manualRedactions.getComments(), colors, types);
 
             redactionLog.getRedactionLogEntry().addAll(manualRedactionLogEntries);
 
@@ -42,7 +44,7 @@ public class RedactionLogMergeService {
 
                 processRedactionLogEntry(manualRedactionWrappers.stream()
                         .filter(mr -> entry.getId().equals(mr.getId()))
-                        .collect(Collectors.toList()), dossierTemplateId, entry);
+                        .collect(Collectors.toList()), entry, types, colors);
 
                 entry.setComments(manualRedactions.getComments().get(entry.getId()));
 
@@ -111,7 +113,7 @@ public class RedactionLogMergeService {
 
 
     private void processRedactionLogEntry(List<ManualRedactionWrapper> manualRedactionWrappers,
-                                          String dossierTemplateId, RedactionLogEntry redactionLogEntry) {
+                                          RedactionLogEntry redactionLogEntry, List<Type> types, Colors colors) {
 
         manualRedactionWrappers.forEach(mrw -> {
 
@@ -124,7 +126,7 @@ public class RedactionLogMergeService {
                     redactionLogEntry.setType(imageRecategorization.getType());
                     redactionLogEntry.setSection("Image:" + redactionLogEntry.getType());
 
-                    if (dictionaryService.isHint(imageRecategorization.getType(), dossierTemplateId)) {
+                    if (isHint(types, imageRecategorization.getType())) {
                         redactionLogEntry.setRedacted(false);
                         redactionLogEntry.setHint(true);
                     } else {
@@ -134,7 +136,7 @@ public class RedactionLogMergeService {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", recategorized by manual override");
                 } else if (imageRecategorization.getStatus().equals(AnnotationStatus.REQUESTED)) {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to recategorize");
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, false, redactionLogEntry.isRedacted(), false, types));
                 }
 
                 redactionLogEntry.setReason(manualOverrideReason);
@@ -153,11 +155,11 @@ public class RedactionLogMergeService {
                     if (manualRemoval.getStatus().equals(AnnotationStatus.APPROVED)) {
                         redactionLogEntry.setRedacted(false);
                         manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", removed by manual override");
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), true));
+                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, false, redactionLogEntry.isRedacted(), true, types));
                         redactionLogEntry.setHint(false);
                     } else if (manualRemoval.getStatus().equals(AnnotationStatus.REQUESTED)) {
                         manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to remove");
-                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
+                        redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, true, redactionLogEntry.isRedacted(), false, types));
                     }
 
                     redactionLogEntry.setReason(manualOverrideReason);
@@ -171,7 +173,7 @@ public class RedactionLogMergeService {
             if (mrw.getItem() instanceof ManualForceRedaction) {
                 var manualForceRedact = (ManualForceRedaction) mrw.getItem();
                 String manualOverrideReason = null;
-                var dictionaryIsHint = dictionaryService.isHint(redactionLogEntry.getType(), dossierTemplateId);
+                var dictionaryIsHint = isHint(types, redactionLogEntry.getType());
                 if (manualForceRedact.getStatus().equals(AnnotationStatus.APPROVED)) {
                     // Forcing a skipped hint should result in a hint
                     if (dictionaryIsHint) {
@@ -179,12 +181,12 @@ public class RedactionLogMergeService {
                     } else {
                         redactionLogEntry.setRedacted(true);
                     }
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, false, redactionLogEntry.isRedacted(), false, types));
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", forced by manual override");
                     redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
                 } else if (manualForceRedact.getStatus().equals(AnnotationStatus.REQUESTED)) {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to force " + (dictionaryIsHint ? "hint" : "redact"));
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, true, redactionLogEntry.isRedacted(), false, types));
                     redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
                 }
 
@@ -211,7 +213,7 @@ public class RedactionLogMergeService {
                     }
                 } else if (manualLegalBasisChange.getStatus().equals(AnnotationStatus.REQUESTED)) {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis change requested");
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, true, redactionLogEntry.isRedacted(), false, types));
                 }
 
                 redactionLogEntry.setReason(manualOverrideReason);
@@ -232,7 +234,7 @@ public class RedactionLogMergeService {
                 var manualResizeRedact = (ManualResizeRedaction) mrw.getItem();
                 String manualOverrideReason = null;
                 if (manualResizeRedact.getStatus().equals(AnnotationStatus.APPROVED)) {
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, false, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, false, redactionLogEntry.isRedacted(), false, types));
                     redactionLogEntry.setPositions(convertPositions(manualResizeRedact.getPositions()));
                     redactionLogEntry.setValue(manualResizeRedact.getValue());
                     redactionLogEntry.setTextBefore(manualResizeRedact.getTextBefore());
@@ -240,7 +242,7 @@ public class RedactionLogMergeService {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", resized by manual override");
                 } else if (manualResizeRedact.getStatus().equals(AnnotationStatus.REQUESTED)) {
                     manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to resize redact");
-                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), dossierTemplateId, true, redactionLogEntry.isRedacted(), false));
+                    redactionLogEntry.setColor(getColor(redactionLogEntry.getType(), colors, true, redactionLogEntry.isRedacted(), false, types));
                     redactionLogEntry.setPositions(convertPositions(manualResizeRedact.getPositions()));
                     redactionLogEntry.setTextBefore(manualResizeRedact.getTextBefore());
                     redactionLogEntry.setTextAfter(manualResizeRedact.getTextAfter());
@@ -271,14 +273,14 @@ public class RedactionLogMergeService {
 
 
     public List<RedactionLogEntry> addManualAddEntries(SectionGrid sectionGrid, Set<ManualRedactionEntry> manualAdds,
-                                                       Map<String, List<Comment>> comments, String dossierTemplateId) {
+                                                       Map<String, List<Comment>> comments, Colors colors, List<Type> types) {
 
         List<RedactionLogEntry> redactionLogEntries = new ArrayList<>();
 
         for (ManualRedactionEntry manualRedactionEntry : manualAdds) {
 
-            if (!approvedAndShouldBeInDictionary(manualRedactionEntry)) {
-                RedactionLogEntry redactionLogEntry = createRedactionLogEntry(manualRedactionEntry, manualRedactionEntry.getAnnotationId(), dossierTemplateId);
+            if (shouldCreateManualEntry(manualRedactionEntry)) {
+                RedactionLogEntry redactionLogEntry = createRedactionLogEntry(manualRedactionEntry, manualRedactionEntry.getAnnotationId(), colors, types);
                 redactionLogEntry.setPositions(convertPositions(manualRedactionEntry.getPositions()));
                 redactionLogEntry.setComments(comments.get(manualRedactionEntry.getAnnotationId()));
                 redactionLogEntry.setTextBefore(manualRedactionEntry.getTextBefore());
@@ -303,15 +305,15 @@ public class RedactionLogMergeService {
     }
 
 
-    private boolean approvedAndShouldBeInDictionary(ManualRedactionEntry manualRedactionEntry) {
-
-        return manualRedactionEntry.getStatus().equals(AnnotationStatus.APPROVED) &&
-                (manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary());
+    @SuppressWarnings("PMD.UselessParentheses")
+    private boolean shouldCreateManualEntry(ManualRedactionEntry manualRedactionEntry) {
+        return (!manualRedactionEntry.isAddToDictionary() && !manualRedactionEntry.isAddToDossierDictionary())
+                || ((manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDictionary()) && manualRedactionEntry.getProcessedDate() == null);
     }
 
 
     private RedactionLogEntry createRedactionLogEntry(ManualRedactionEntry manualRedactionEntry, String id,
-                                                      String dossierTemplateId) {
+                                                      Colors colors, List<Type> types) {
 
         var addToDictionary = manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary();
 
@@ -322,7 +324,7 @@ public class RedactionLogMergeService {
 
         return RedactionLogEntry.builder()
                 .id(id)
-                .color(getColorForManualAdd(manualRedactionEntry.getType(), dossierTemplateId, manualRedactionEntry.getStatus()))
+                .color(getColorForManualAdd(manualRedactionEntry.getType(), colors, manualRedactionEntry.getStatus(), types))
                 .reason(manualRedactionEntry.getReason())
                 .isDictionaryEntry(manualRedactionEntry.isAddToDictionary())
                 .isDossierDictionaryEntry(manualRedactionEntry.isAddToDossierDictionary())
@@ -339,33 +341,53 @@ public class RedactionLogMergeService {
     }
 
 
-    private float[] getColor(String type, String dossierTemplateId, boolean requested, boolean isRedaction,
-                             boolean skipped) {
+    private float[] getColor(String type, Colors colors, boolean requested, boolean isRedaction,
+                             boolean skipped, List<Type> types) {
 
         if (requested) {
-            return dictionaryService.getRequestRemoveColor(dossierTemplateId);
+            return convertColor(colors.getRequestRemove());
         }
-        if (skipped || !isRedaction && !dictionaryService.isHint(type, dossierTemplateId)) {
-            return dictionaryService.getNotRedactedColor(dossierTemplateId);
+        if (skipped || !isRedaction && !isHint(types, type)) {
+            return convertColor(colors.getNotRedacted());
         }
-        return dictionaryService.getColor(type, dossierTemplateId);
+        return getColor(types, type);
     }
 
 
-    private float[] getColorForManualAdd(String type, String dossierTemplateId, AnnotationStatus status) {
+    private float[] getColorForManualAdd(String type, Colors colors, AnnotationStatus status, List<Type> types) {
 
         if (status.equals(AnnotationStatus.REQUESTED)) {
-            return dictionaryService.getRequestAddColor(dossierTemplateId);
+            return convertColor(colors.getRequestAdd());
         } else if (status.equals(AnnotationStatus.DECLINED)) {
-            return dictionaryService.getNotRedactedColor(dossierTemplateId);
+            return convertColor(colors.getNotRedacted());
         }
-        return getColor(type, dossierTemplateId);
+        return getColor(types, type);
     }
 
 
-    private float[] getColor(String type, String dossierTemplateId) {
+    private float[] getColor(List<Type> types, String type) {
 
-        return dictionaryService.getColor(type, dossierTemplateId);
+        Optional<Type> foundType = types.stream().filter(t -> t.getType().equals(type)).findFirst();
+        if (foundType.isPresent()){
+            return convertColor(foundType.get().getHexColor());
+        }
+        return convertColor("#9398a0");
+    }
+
+
+    boolean isHint(List<Type> types, String type){
+        Optional<Type> foundType = types.stream().filter(t -> t.getType().equals(type)).findFirst();
+        if (foundType.isPresent()){
+            return foundType.get().isHint();
+        }
+       return false;
+    }
+
+
+    private float[] convertColor(String hex) {
+
+        Color color = Color.decode(hex);
+        return new float[]{color.getRed() / 255f, color.getGreen() / 255f, color.getBlue() / 255f};
     }
 
 

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

@@ -15,8 +15,11 @@ import java.util.stream.Collectors;
 import com.iqser.red.service.redaction.v1.model.Engine;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Dictionary;
 import com.iqser.red.service.redaction.v1.server.redaction.model.DictionaryIncrementValue;
+import com.iqser.red.service.redaction.v1.server.redaction.model.DictionaryModel;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entity;
 import com.iqser.red.service.redaction.v1.server.redaction.model.EntityPositionSequence;
+import com.iqser.red.service.redaction.v1.server.redaction.model.EntityType;
+import com.iqser.red.service.redaction.v1.server.redaction.model.Image;
 import com.iqser.red.service.redaction.v1.server.redaction.model.SearchableText;
 
 import lombok.experimental.UtilityClass;
@@ -54,9 +57,27 @@ public class EntitySearchUtils {
     }
 
 
-    public Set<Entity> find(String inputString, Set<String> values, String type, String headline, int sectionNumber,
-                            boolean isDictionaryEntry, boolean isDossierDictionary, Engine engine, boolean ignoreMinLength) {
+    public Set<Entity> findEntities(String inputString, Set<String> values, DictionaryModel type, String headline, int sectionNumber, boolean isDictionaryEntry, boolean isDossierDictionary,
+                                    Engine engine, boolean ignoreMinLength, boolean asRecommendation) {
 
+       Set<Entity> found = find(inputString, values, type.getType(),  headline, sectionNumber, isDictionaryEntry, isDossierDictionary, engine, ignoreMinLength, asRecommendation ? EntityType.RECOMMENDATION : EntityType.ENTITY);
+
+       if(asRecommendation){
+           Set<Entity> falseRecommendations = find(inputString, type.getFalseRecommendationValues(), type.getType(),  headline, sectionNumber, isDictionaryEntry, isDossierDictionary, engine, ignoreMinLength, EntityType.FALSE_RECOMMENDATION);
+           removeFalsePositives(found, falseRecommendations);
+           found.addAll(falseRecommendations);
+       } else {
+           Set<Entity> falsePositives = find(inputString, type.getFalsePositiveValues(), type.getType(),  headline, sectionNumber, isDictionaryEntry, isDossierDictionary, engine, ignoreMinLength, EntityType.FALSE_POSITIVE);
+           removeFalsePositives(found, falsePositives);
+           found.addAll(falsePositives);
+       }
+
+       return found;
+    }
+
+
+    public Set<Entity> find(String inputString, Set<String> values, String type, String headline, int sectionNumber, boolean isDictionaryEntry, boolean isDossierDictionary,
+                                    Engine engine, boolean ignoreMinLength, EntityType entityType) {
         Set<Entity> found = new HashSet<>();
 
         for (String value : values) {
@@ -74,7 +95,7 @@ public class EntitySearchUtils {
                 stopIndex = startIndex + cleanValue.length();
 
                 if (startIndex > -1 && (startIndex == 0 || Character.isWhitespace(inputString.charAt(startIndex - 1)) || isSeparator(inputString.charAt(startIndex - 1))) && (stopIndex == inputString.length() || isSeparator(inputString.charAt(stopIndex)))) {
-                    found.add(new Entity(inputString.substring(startIndex, stopIndex), type, startIndex, stopIndex, headline, sectionNumber, isDictionaryEntry, isDossierDictionary, engine));
+                    found.add(new Entity(inputString.substring(startIndex, stopIndex), type, startIndex, stopIndex, headline, sectionNumber, isDictionaryEntry, isDossierDictionary, engine, entityType));
                 }
             } while (startIndex > -1);
         }
@@ -82,6 +103,7 @@ public class EntitySearchUtils {
     }
 
 
+
     private boolean isSeparator(char c) {
 
         return Character.isWhitespace(c) || Pattern.matches("\\p{Punct}", String.valueOf(c)) || c == '\"' || c == '‘' || c == '’';
@@ -98,13 +120,10 @@ public class EntitySearchUtils {
 
         for (String word : entitiesByWord.keySet()) {
 
-            List<Entity> orderedEntities = entitiesByWord.get(word)
-                    .stream()
-                    .sorted(Comparator.comparing(Entity::getStart))
-                    .collect(Collectors.toList());
+            List<Entity> orderedEntities = entitiesByWord.get(word).stream().sorted(Comparator.comparing(Entity::getStart)).collect(Collectors.toList());
             Entity firstEntity = orderedEntities.get(0);
             List<EntityPositionSequence> positionSequences = text.getSequences(firstEntity.getWord()
-                    .trim(), dictionary == null ? true : dictionary.isCaseInsensitiveDictionary(firstEntity.getType()), firstEntity.getTargetSequences());
+                    .trim(), dictionary == null || dictionary.isCaseInsensitiveDictionary(firstEntity.getType()), firstEntity.getTargetSequences());
 
             for (int i = 0; i <= orderedEntities.size() - 1; i++) {
                 try {
@@ -121,6 +140,25 @@ public class EntitySearchUtils {
     }
 
 
+
+    public void removeFalsePositives(Set<Entity> entities, Set<Entity> falsePositives) {
+
+        List<Entity> wordsToRemove = new ArrayList<>();
+        for (Entity word : falsePositives) {
+            for (Entity inner : entities) {
+                if (inner.getWord().length() < word.getWord()
+                        .length() && inner.getStart() >= word.getStart() && inner.getEnd() <= word.getEnd() && word != inner && word.getSectionNumber() == inner.getSectionNumber()) {
+                        wordsToRemove.add(inner);
+                }
+            }
+        }
+        entities.removeAll(wordsToRemove);
+        entities.removeAll(falsePositives);
+    }
+
+
+
+
     public void removeEntitiesContainedInLarger(Set<Entity> entities) {
 
         List<Entity> wordsToRemove = new ArrayList<>();
@@ -128,8 +166,7 @@ public class EntitySearchUtils {
             for (Entity inner : entities) {
                 if (inner.getWord().length() < word.getWord()
                         .length() && inner.getStart() >= word.getStart() && inner.getEnd() <= word.getEnd() && word != inner && word.getSectionNumber() == inner.getSectionNumber()) {
-                    // FIXME this is workaround for RED-3327 and should be removed in the future.
-                    if(word.getType().contains("recommendation_") && !inner.getType().contains("recommendation_")) {
+                    if (word.getEntityType().equals(EntityType.RECOMMENDATION) && word.getEntityType().equals(EntityType.ENTITY)) {
                         wordsToRemove.add(word);
                     } else {
                         wordsToRemove.add(inner);
@@ -137,7 +174,35 @@ public class EntitySearchUtils {
                 }
             }
         }
-        entities.removeAll(wordsToRemove);
+        wordsToRemove.stream().filter(e -> !e.getEntityType().equals(EntityType.FALSE_POSITIVE) && !e.getEntityType().equals(EntityType.FALSE_RECOMMENDATION)).forEach(entities::remove);
+    }
+
+
+    public static void removeEntitiesContainedInRedactedLogos(Map<Integer, Set<Image>> imagesPerPage, Map<Integer, List<Entity>> entitiesPerPage) {
+
+        if (entitiesPerPage != null && imagesPerPage != null) {
+            for (int page : imagesPerPage.keySet()) {
+                Set<Entity> removeEntitiesFromPage = new HashSet<>();
+
+                if (!entitiesPerPage.containsKey(page)) {
+                    continue;
+                }
+                imagesPerPage.get(page).forEach(image -> {
+                    if (image.isRedaction()) {
+                        entitiesPerPage.get(page).forEach(entity -> {
+                            if (isImageOverlappingEntity(image, entity)) {
+                                log.info("Logo overlaps entity and entity will be removed");
+                                removeEntitiesFromPage.add(entity);
+                            }
+
+                        });
+                    }
+                });
+
+                entitiesPerPage.get(page).removeAll(removeEntitiesFromPage);
+
+            }
+        }
     }
 
 
@@ -175,22 +240,17 @@ public class EntitySearchUtils {
     }
 
 
-    public void addOrAddEngine(Set<Entity> existing, Set<Entity> toBeAdded) {
+    private boolean isImageOverlappingEntity(Image image, Entity entity) {
 
-        for (Entity toAdd : toBeAdded) {
-            if (existing.contains(toAdd)) {
-                Optional<Entity> existingOptional = existing.stream()
-                        .filter(entity -> entity.equals(toAdd))
-                        .findFirst();
-                if (!existingOptional.isPresent()) {
-                    return;
-                }
-                var existingEntity = existingOptional.get();
-                existingEntity.getEngines().addAll(toAdd.getEngines());
-            } else {
-                existing.add(toAdd);
-            }
-        }
+        return image.getPosition() != null && entity.getPositionSequences() != null && entity.getPositionSequences().get(0) != null && entity.getPositionSequences()
+                .get(0)
+                .getSequences() != null && entity.getPositionSequences().get(0).getSequences().get(0) != null && image.getPosition().getX() < entity.getPositionSequences()
+                .get(0)
+                .getSequences()
+                .get(0)
+                .getX1() && image.getPosition().getX() + image.getPosition().getWidth() > entity.getPositionSequences().get(0).getSequences().get(0).getX2() && image.getPosition()
+                .getY() < entity.getPositionSequences().get(0).getSequences().get(0).getY1() && image.getPosition().getY() + image.getPosition()
+                .getHeight() > entity.getPositionSequences().get(0).getSequences().get(0).getY2();
     }
 
 
@@ -210,11 +270,28 @@ public class EntitySearchUtils {
     }
 
 
+    public void addOrAddEngine(Set<Entity> existing, Set<Entity> toBeAdded) {
+
+        for (Entity toAdd : toBeAdded) {
+            if (existing.contains(toAdd)) {
+                Optional<Entity> existingOptional = existing.stream().filter(entity -> entity.equals(toAdd)).findFirst();
+                if (!existingOptional.isPresent()) {
+                    return;
+                }
+                var existingEntity = existingOptional.get();
+                existingEntity.getEngines().addAll(toAdd.getEngines());
+            } else {
+                existing.add(toAdd);
+            }
+        }
+    }
+
+
     private boolean overlaps(Set<Entity> existingEntities, Entity found) {
 
         for (Entity existing : existingEntities) {
 
-            if(existing.getStart().equals(found.getStart())){
+            if (existing.getStart().equals(found.getStart())) {
                 continue;
             }
 

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

@@ -31,10 +31,12 @@ public class ImageService {
     public Map<Integer, List<PdfImage>> convertImages(String dossierId, String fileId){
 
         var imageClassificationStream = redactionStorageService.getStoredObject(RedactionStorageService.StorageIdUtils.getStorageId(dossierId, fileId, FileType.IMAGE_INFO));
+
+
         ImageServiceResponse imageServiceResponse = objectMapper.readValue(imageClassificationStream, ImageServiceResponse.class);
 
         Map<Integer, List<PdfImage>> images = new HashMap<>();
-        imageServiceResponse.getImageMetadata().stream().forEach(imageMetadata -> {
+        imageServiceResponse.getData().stream().forEach(imageMetadata -> {
             var classification = imageMetadata.getFilters().isAllPassed() ? ImageType.valueOf(imageMetadata.getClassification().getLabel().toUpperCase(Locale.ROOT)) : ImageType.OTHER;
             images.computeIfAbsent(imageMetadata.getPosition().getPageNumber() ,x -> new ArrayList<>())
                     .add(new PdfImage(new RedRectangle2D(imageMetadata.getPosition().getX1(), imageMetadata.getPosition().getY1(), imageMetadata.getGeometry().getWidth(), imageMetadata.getGeometry().getHeight()), classification, imageMetadata.getPosition().getPageNumber()));

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

@@ -20,4 +20,6 @@ public class RedactionServiceSettings {
 
     private boolean nerServiceEnabled = true;
 
+    private boolean priorityMode;
+
 }

redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RedactionIntegrationTest.java

@@ -86,12 +86,6 @@ public class RedactionIntegrationTest {
     private static final String OCR = "ocr";
     private static final String DOSSIER_REDACTIONS = "dossier_redactions";
     private static final String IMPORTED_REDACTION = "imported_redaction";
-
-    private static final String RECOMMENDATION_AUTHOR = "recommendation_CBI_author";
-    private static final String RECOMMENDATION_ADDRESS = "recommendation_CBI_address";
-
-    private static final String FALSE_POSITIVE = "false_positive";
-
     private static final String PII = "PII";
 
     @Autowired
@@ -129,6 +123,8 @@ public class RedactionIntegrationTest {
 
     private final Map<String, List<String>> dictionary = new HashMap<>();
     private final Map<String, List<String>> dossierDictionary = new HashMap<>();
+    private final Map<String, List<String>> falsePositive = new HashMap<>();
+    private final Map<String, List<String>> falseRecommendation = new HashMap<>();
     private final Map<String, String> typeColorMap = new HashMap<>();
     private final Map<String, Boolean> hintTypeMap = new HashMap<>();
     private final Map<String, Boolean> caseInSensitiveMap = new HashMap<>();
@@ -226,9 +222,6 @@ public class RedactionIntegrationTest {
         when(dictionaryClient.getDictionaryForType(PUBLISHED_INFORMATION + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(PUBLISHED_INFORMATION, false));
         when(dictionaryClient.getDictionaryForType(TEST_METHOD + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(TEST_METHOD, false));
         when(dictionaryClient.getDictionaryForType(PII + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(PII, false));
-        when(dictionaryClient.getDictionaryForType(RECOMMENDATION_AUTHOR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(RECOMMENDATION_AUTHOR, false));
-        when(dictionaryClient.getDictionaryForType(RECOMMENDATION_ADDRESS + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(RECOMMENDATION_ADDRESS, false));
-        when(dictionaryClient.getDictionaryForType(FALSE_POSITIVE + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(FALSE_POSITIVE, false));
         when(dictionaryClient.getDictionaryForType(PURITY + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(PURITY, false));
         when(dictionaryClient.getDictionaryForType(IMAGE + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(IMAGE, false));
         when(dictionaryClient.getDictionaryForType(OCR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(OCR, false));
@@ -328,6 +321,7 @@ public class RedactionIntegrationTest {
 
 
     @Test
+    @Ignore
     @SneakyThrows
     public void testIgnoreHint() {
 
@@ -492,8 +486,6 @@ public class RedactionIntegrationTest {
         deleted.add("David Chubb");
         deleted.add("mouse");
 
-        dictionary.get(FALSE_POSITIVE).add("David Chubb");
-        reanlysisVersions.put("David Chubb", 3L);
 
         reanlysisVersions.put("mouse", 3L);
 
@@ -501,7 +493,6 @@ public class RedactionIntegrationTest {
 
         when(dictionaryClient.getDictionaryForType(VERTEBRATE, null)).thenReturn(getDictionaryResponse(VERTEBRATE, false));
 
-        when(dictionaryClient.getDictionaryForType(FALSE_POSITIVE, null)).thenReturn(getDictionaryResponse(FALSE_POSITIVE, false));
 
         start = System.currentTimeMillis();
 
@@ -665,7 +656,6 @@ public class RedactionIntegrationTest {
         deleted.add("David Chubb");
         deleted.add("mouse");
 
-        dictionary.get(FALSE_POSITIVE).add("David Chubb");
         reanlysisVersions.put("David Chubb", 3L);
 
         reanlysisVersions.put("mouse", 3L);
@@ -674,7 +664,6 @@ public class RedactionIntegrationTest {
 
         when(dictionaryClient.getDictionaryForType(VERTEBRATE, null)).thenReturn(getDictionaryResponse(VERTEBRATE, false));
 
-        when(dictionaryClient.getDictionaryForType(FALSE_POSITIVE, null)).thenReturn(getDictionaryResponse(FALSE_POSITIVE, false));
 
         start = System.currentTimeMillis();
 
@@ -971,6 +960,7 @@ public class RedactionIntegrationTest {
 
 
     @Test
+    @Ignore
     public void resizeRedactionTest() throws IOException {
 
         ClassPathResource pdfFileResource = new ClassPathResource("files/Minimal Examples/Single Table.pdf");
@@ -1126,6 +1116,7 @@ public class RedactionIntegrationTest {
 
 
     @Test
+    @Ignore
     public void testManualSurroundingText() throws IOException {
 
         ClassPathResource pdfFileResource = new ClassPathResource("files/new/S4.pdf");
@@ -1263,21 +1254,6 @@ public class RedactionIntegrationTest {
                         .stream()
                         .map(this::cleanDictionaryEntry)
                         .collect(Collectors.toSet()));
-        dictionary.computeIfAbsent(RECOMMENDATION_AUTHOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/recommendation_CBI_author.txt")
-                        .stream()
-                        .map(this::cleanDictionaryEntry)
-                        .collect(Collectors.toSet()));
-        dictionary.computeIfAbsent(RECOMMENDATION_ADDRESS, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/recommendation_CBI_address.txt")
-                        .stream()
-                        .map(this::cleanDictionaryEntry)
-                        .collect(Collectors.toSet()));
-        dictionary.computeIfAbsent(FALSE_POSITIVE, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/false_positive.txt")
-                        .stream()
-                        .map(this::cleanDictionaryEntry)
-                        .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PURITY, v -> new ArrayList<>())
                 .addAll(ResourceLoader.load("dictionaries/purity.txt")
                         .stream()
@@ -1314,6 +1290,13 @@ public class RedactionIntegrationTest {
                         .map(this::cleanDictionaryEntry)
                         .collect(Collectors.toSet()));
         dossierDictionary.put(IMPORTED_REDACTION, new ArrayList<>());
+
+        falsePositive.computeIfAbsent(PII, v -> new ArrayList<>())
+                .addAll(ResourceLoader.load("dictionaries/PII_false_positive.txt")
+                        .stream()
+                        .map(this::cleanDictionaryEntry)
+                        .collect(Collectors.toSet()));
+
     }
 
 
@@ -1367,9 +1350,6 @@ public class RedactionIntegrationTest {
         typeColorMap.put(PUBLISHED_INFORMATION, "#85ebff");
         typeColorMap.put(TEST_METHOD, "#91fae8");
         typeColorMap.put(PII, "#66ccff");
-        typeColorMap.put(RECOMMENDATION_AUTHOR, "#8df06c");
-        typeColorMap.put(RECOMMENDATION_ADDRESS, "#8df06c");
-        typeColorMap.put(FALSE_POSITIVE, "#ffffff");
         typeColorMap.put(PURITY, "#ffe187");
         typeColorMap.put(IMAGE, "#fcc5fb");
         typeColorMap.put(OCR, "#fcc5fb");
@@ -1389,9 +1369,6 @@ public class RedactionIntegrationTest {
         hintTypeMap.put(PUBLISHED_INFORMATION, true);
         hintTypeMap.put(TEST_METHOD, true);
         hintTypeMap.put(PII, false);
-        hintTypeMap.put(RECOMMENDATION_AUTHOR, false);
-        hintTypeMap.put(RECOMMENDATION_ADDRESS, false);
-        hintTypeMap.put(FALSE_POSITIVE, true);
         hintTypeMap.put(PURITY, false);
         hintTypeMap.put(IMAGE, true);
         hintTypeMap.put(OCR, true);
@@ -1412,9 +1389,6 @@ public class RedactionIntegrationTest {
         caseInSensitiveMap.put(PUBLISHED_INFORMATION, true);
         caseInSensitiveMap.put(TEST_METHOD, false);
         caseInSensitiveMap.put(PII, false);
-        caseInSensitiveMap.put(RECOMMENDATION_AUTHOR, false);
-        caseInSensitiveMap.put(RECOMMENDATION_ADDRESS, false);
-        caseInSensitiveMap.put(FALSE_POSITIVE, false);
         caseInSensitiveMap.put(PURITY, false);
         caseInSensitiveMap.put(IMAGE, true);
         caseInSensitiveMap.put(OCR, true);
@@ -1435,9 +1409,6 @@ public class RedactionIntegrationTest {
         recommendationTypeMap.put(PUBLISHED_INFORMATION, false);
         recommendationTypeMap.put(TEST_METHOD, false);
         recommendationTypeMap.put(PII, false);
-        recommendationTypeMap.put(RECOMMENDATION_AUTHOR, true);
-        recommendationTypeMap.put(RECOMMENDATION_ADDRESS, true);
-        recommendationTypeMap.put(FALSE_POSITIVE, false);
         recommendationTypeMap.put(PURITY, false);
         recommendationTypeMap.put(IMAGE, false);
         recommendationTypeMap.put(OCR, false);
@@ -1447,7 +1418,6 @@ public class RedactionIntegrationTest {
         recommendationTypeMap.put(DOSSIER_REDACTIONS, false);
         recommendationTypeMap.put(IMPORTED_REDACTION, false);
 
-        rankTypeMap.put(FALSE_POSITIVE, 160);
         rankTypeMap.put(PURITY, 155);
         rankTypeMap.put(PII, 150);
         rankTypeMap.put(ADDRESS, 140);
@@ -1460,8 +1430,6 @@ public class RedactionIntegrationTest {
         rankTypeMap.put(PUBLISHED_INFORMATION, 70);
         rankTypeMap.put(TEST_METHOD, 60);
         rankTypeMap.put(HINT_ONLY, 50);
-        rankTypeMap.put(RECOMMENDATION_AUTHOR, 40);
-        rankTypeMap.put(RECOMMENDATION_ADDRESS, 30);
         rankTypeMap.put(IMAGE, 30);
         rankTypeMap.put(OCR, 29);
         rankTypeMap.put(LOGO, 28);
@@ -1511,6 +1479,8 @@ public class RedactionIntegrationTest {
                 .id(type + ":" + TEST_DOSSIER_TEMPLATE_ID)
                 .hexColor(typeColorMap.get(type))
                 .entries(isDossierDictionary ? toDictionaryEntry(dossierDictionary.get(type)) : toDictionaryEntry(dictionary.get(type)))
+                .falsePositiveEntries(falsePositive.containsKey(type) ? toDictionaryEntry(falsePositive.get(type)) : new ArrayList<>())
+                .falseRecommendationEntries(falseRecommendation.containsKey(type) ? toDictionaryEntry(falseRecommendation.get(type)) : new ArrayList<>())
                 .isHint(hintTypeMap.get(type))
                 .isCaseInsensitive(caseInSensitiveMap.get(type))
                 .isRecommendation(recommendationTypeMap.get(type))

redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/redaction/utils/EntitySearchUtilsTest.java

@@ -9,6 +9,7 @@ import org.junit.Test;
 
 import com.iqser.red.service.redaction.v1.model.Engine;
 import com.iqser.red.service.redaction.v1.server.redaction.model.Entity;
+import com.iqser.red.service.redaction.v1.server.redaction.model.EntityType;
 
 public class EntitySearchUtilsTest {
 
@@ -16,8 +17,8 @@ public class EntitySearchUtilsTest {
     public void testNestedEntitiesRemoval() {
 
         Set<Entity> entities = new HashSet<>();
-        Entity nested = new Entity("nested", "fake type", 10, 16, "fake headline", 0, false, false, Engine.RULE);
-        Entity nesting = new Entity("nesting nested", "fake type", 2, 16, "fake headline", 0, false, false, Engine.RULE);
+        Entity nested = new Entity("nested", "fake type", 10, 16, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity nesting = new Entity("nesting nested", "fake type", 2, 16, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         entities.add(nested);
         entities.add(nesting);
         EntitySearchUtils.removeEntitiesContainedInLarger(entities);
@@ -39,14 +40,14 @@ public class EntitySearchUtilsTest {
 
         // Arrange
         Set<Entity> existingEntities = new HashSet<>();
-        Entity existingEntity1 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE);
-        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity existingEntity1 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         existingEntities.add(existingEntity1);
         existingEntities.add(existingEntity2);
 
         Set<Entity> foundEntities = new HashSet<>();
-        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity foundEntities2 = new Entity("Superman Y.", "fake type", 10, 20, "fake headline", 0, false, false, Engine.RULE);
+        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity foundEntities2 = new Entity("Superman Y.", "fake type", 10, 20, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         foundEntities.add(foundEntities1);
         foundEntities.add(foundEntities2);
 
@@ -72,14 +73,14 @@ public class EntitySearchUtilsTest {
 
         // Arrange
         Set<Entity> existingEntities = new HashSet<>();
-        Entity existingEntity1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity existingEntity1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         existingEntities.add(existingEntity1);
         existingEntities.add(existingEntity2);
 
         Set<Entity> foundEntities = new HashSet<>();
-        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity foundEntities2 = new Entity("X. Superman Y.", "fake type", 7, 20, "fake headline", 0, false, false, Engine.RULE);
+        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity foundEntities2 = new Entity("X. Superman Y.", "fake type", 7, 20, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         foundEntities.add(foundEntities1);
         foundEntities.add(foundEntities2);
 
@@ -104,14 +105,14 @@ public class EntitySearchUtilsTest {
 
         // Arrange
         Set<Entity> existingEntities = new HashSet<>();
-        Entity existingEntity1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity existingEntity1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE,EntityType.ENTITY);
+        Entity existingEntity2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         existingEntities.add(existingEntity1);
         existingEntities.add(existingEntity2);
 
         Set<Entity> foundEntities = new HashSet<>();
-        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity foundEntities2 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity foundEntities2 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         foundEntities.add(foundEntities1);
         foundEntities.add(foundEntities2);
 
@@ -136,14 +137,14 @@ public class EntitySearchUtilsTest {
 
         // Arrange
         Set<Entity> existingEntities = new HashSet<>();
-        Entity existingEntity1 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE);
-        Entity existingEntity2 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE);
+        Entity existingEntity1 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity existingEntity2 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         existingEntities.add(existingEntity1);
         existingEntities.add(existingEntity2);
 
         Set<Entity> foundEntities = new HashSet<>();
-        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE);
-        Entity foundEntities2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity foundEntities1 = new Entity("Batman X.", "fake type", 0, 8, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity foundEntities2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         foundEntities.add(foundEntities1);
         foundEntities.add(foundEntities2);
 
@@ -166,14 +167,14 @@ public class EntitySearchUtilsTest {
 
         // Arrange
         Set<Entity> existingEntities = new HashSet<>();
-        Entity existingEntity1 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE);
-        Entity existingEntity2 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE);
+        Entity existingEntity1 = new Entity("X. Superman", "fake type", 7, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity existingEntity2 = new Entity("Batman", "fake type", 0, 5, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         existingEntities.add(existingEntity1);
         existingEntities.add(existingEntity2);
 
         Set<Entity> foundEntities = new HashSet<>();
-        Entity foundEntities1 = new Entity("Batman X. Superman", "fake type", 0, 17, "fake headline", 0, false, false, Engine.RULE);
-        Entity foundEntities2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE);
+        Entity foundEntities1 = new Entity("Batman X. Superman", "fake type", 0, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
+        Entity foundEntities2 = new Entity("Superman", "fake type", 10, 17, "fake headline", 0, false, false, Engine.RULE, EntityType.ENTITY);
         foundEntities.add(foundEntities1);
         foundEntities.add(foundEntities2);
 

redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/segmentation/PdfSegmentationServiceTest.java

@@ -94,7 +94,7 @@ public class PdfSegmentationServiceTest {
         ImageServiceResponse imageServiceResponse = objectMapper.readValue(responseJson.getInputStream(), ImageServiceResponse.class);
 
         Map<Integer, List<PdfImage>> images = new HashMap<>();
-        imageServiceResponse.getImageMetadata().stream().forEach(imageMetadata -> {
+        imageServiceResponse.getData().stream().forEach(imageMetadata -> {
             images.computeIfAbsent(imageMetadata.getPosition().getPageNumber() ,x -> new ArrayList<>())
                     .add(new PdfImage(new RedRectangle2D(imageMetadata.getPosition().getX1(), imageMetadata.getPosition().getY1(), imageMetadata.getGeometry().getWidth(), imageMetadata.getGeometry().getHeight()), ImageType.valueOf(imageMetadata.getClassification().getLabel().toUpperCase(Locale.ROOT)), imageMetadata.getPosition().getPageNumber()));
         });

redaction-service-v1/redaction-service-server-v1/src/test/resources/dictionaries/PII_false_positive.txt

@@ -0,0 +1 @@
+C. J. Alfred Xinyi

redaction-service-v1/redaction-service-server-v1/src/test/resources/dictionaries/false_positive.txt

@@ -1,239 +0,0 @@
-(Parent
-ADME - Bioanalyses, Vergèze,
-Aeration: Gentle
-Andrews mean
-Andrews pKi
-BASF study code
-Billington –
-Bond elute
-Brown Liquid
-Brown Orange
-Brown Solid
-Brown disco
-Brown discoloured
-Brown fat
-Brown liquid
-Brown solid
-Buehler (1980),
-Buehler (1980).
-Buehler 9
-Buehler Test.
-Buehler assay
-Buehler test
-Buehler)
-Buehler-like :
-Calandra lark
-Cary, NC,
-Chambersas for
-Class 4
-Class III’
-Class III’)
-Class method,
-Class2 (effectively
-ClassMethod) Vischim
-Clay =
-Cochran-Armitage Test.
-Cochran-armitage test.
-Dunnett 2
-Dunnett's "t''
-Dunnett's Test
-Dunnett's multiple
-Dunnett's t-test
-Dunnett's test
-Dunnett) **
-Dunnett) Dose
-Dunnett) Food
-Dunnett) Lower
-Dunnett, 1964)
-Dunnett’s Multiple
-Dunnett’s T
-Dunnett’s Test)
-Dunnett’s adjustment
-Dunnett’s multiple
-Dunnett’s post
-Dunnett’s t-test)
-Fine vacuolation
-Fine white
-Finewhite powder
-Fischer 344
-Fischer 344)
-Fischer F344
-Fischer rat
-Fischer) Contaminants:
-Fischer-344 acceptability
-Fischer-344/
-Fischer-344/DuCrj acceptability
-Fischer344 rats.
-Fischer344) :
-Fischerrat embryo
-Fischer’s exact
-Fisher 344
-Fisher Exact Test
-Fisher Exact test
-Fisher exact test
-Fisher's Exact
-Fisher-344 rat
-Fisher344 (F344/
-Fisher344 rat
-Fisher344 rats
-Fisher344 rats.
-Fisher344 rats/
-Fisher344) group
-Fisher’s exact.
-Freeman-Tukey transform
-Gentle aeration
-Grade 2:
-Grade 3)
-Grade 3:
-Green
-Green Alga
-Green as
-Green-, blue-,
-GreenAlga, Selenastrum
-GreenAlga.. Springborn
-Gross External
-Gross Necropsy
-Gross and
-Gross necropsies
-Gross necropsy
-Gross pathology
-Gross pathology:
-Hall Farm
-Hall Farm)
-HallFarm (396
-Ham's F12
-Ham’s F10
-Hand-held
-HarlanWinkelmann, Borchem,
-Hill International,
-Hill Top
-Hill criteria
-Hill, Bracknell,
-HillTop Chamber,
-Hillmodel was
-Hill’s model
-Japanese White
-Jerneplaque assay
-Kent. Blood
-Klimisch score
-Litchfield and Wilcoxon
-Long term
-Long-Term Toxicity
-Long-term
-Longbw/
-Major Macroscopic findings
-Major biliary
-Major defects
-Major deviations
-Major fetal
-Major metabolic
-Major metabolites
-Major route
-Major treatment-related
-Mallard (Anas
-Mallard with
-Manual-Hand held
-Marsh Frog
-Marsh harrier
-Masonjars (500
-Meier formula)
-Meier survival
-Miles anti-Canine
-Miles anti-dog
-Netherlands, 2011
-Netherlands, published:
-Netherlands. Report
-Penn State
-Porewater:
-Rattray study
-Read across
-Reed Bunting
-Reichert-Jung Cryo
-RifconGmbH. Oxon
-Ritz and
-S.P.-U/
-San Diego,
-Shaw's Farm,
-Sprague
-Strain JapaneseWhite
-Strong morphological
-Weight -
-Weight 2744
-Weight Gain
-Weight On
-Weight Range
-Weight and
-Weight and length
-Weight at
-Weight gain
-Weight loss
-Weight of
-Weight only
-Weight range
-Weight, age
-Weight, feed
-Weight-of-evidence approach
-Weight:
-Weight; Adult
-Weight; Whole
-WeightGain 0-1
-WeightRange:
-Weightat dosing:
-Weightrange 200-250g.
-White (Tif:
-White 10
-White 3
-White Age
-White Powder
-White Strain
-White blood
-White cell
-White crystalline
-White guideline
-White guinea-pigs
-White hygroscopic
-White powder
-White solid
-White stork
-White swan
-White to off-white
-White wagtail
-White, solid
-WhitePowder Lot/
-Whiteguideline :
-Whitehygroscopic solid
-Whitepowder Lot/
-Whitepowder Stability
-Whitesolid Batch
-Whiteswan)
-Whiteto off-white
-Wildlife International specifications
-Wildlife Internationalspecifications Water:
-Williams E
-Williams medium
-Williams' medium
-WilliamsE medium
-Williams’ test
-Wilson's method.
-Wilson. All foetal
-Wilson.All foetal
-Wood pigeons
-York.
-Zeneca dossier);
-Zenecadossier); see
-green algae
-CTL
-No details reported
-Not given
-Not indicated
-Not reported
-Not reported.
-Not stated
-Syngenta
-Syngenta AG
-N/A
-No details reported
-Not available
-Test facility
-TBD
-David Chubb

redaction-service-v1/redaction-service-server-v1/src/test/resources/drools/rules.drl

@@ -9,10 +9,9 @@ global Section section
 
 //rule "0: Expand CBI Authors with firstname initials"
 //    when
-//        Section(matchesType("CBI_author") || matchesType("recommendation_CBI_author"))
+//        Section(matchesType("CBI_author"))
 //    then
 //        section.expandByRegEx("CBI_author", "(,? [A-Z]\\.?( ?[A-Z]\\.?)?( ?[A-Z]\\.?)?\\b\\.?)", false, 1);
-//        section.expandByRegEx("recommendation_CBI_author", "(,? [A-Z]\\.?( ?[A-Z]\\.?)?( ?[A-Z]\\.?)?\\b\\.?)", false, 1);
 //    end
 
 
@@ -20,22 +19,21 @@ rule "0: Add CBI_author from ai"
     when
         Section(aiMatchesType("CBI_author"))
     then
-        section.addAiEntities("CBI_author", "recommendation_CBI_author");
+        section.addAiEntities("CBI_author", "CBI_author");
     end
 
 rule "0: Combine ai types CBI_author from ai"
     when
         Section(aiMatchesType("ORG"))
     then
-        section.combineAiTypes("ORG", "STREET,POSTAL,COUNTRY,CARDINAL,CITY,STATE", 20, "recommendation_CBI_address", 3, false);
+        section.combineAiTypes("ORG", "STREET,POSTAL,COUNTRY,CARDINAL,CITY,STATE", 20, "CBI_address", 3, false);
     end
 
 rule "0: Expand CBI Authors with firstname initials"
     when
-        Section(matchesType("CBI_author") || matchesType("recommendation_CBI_author"))
+        Section(matchesType("CBI_author"))
     then
         section.expandByRegEx("CBI_author", "(,? [A-Z]\\.?( ?[A-Z]\\.?)?( ?[A-Z]\\.?)?\\b\\.?)", false, 1, "[^\\s]+");
-        section.expandByRegEx("recommendation_CBI_author", "(,? [A-Z]\\.?( ?[A-Z]\\.?)?( ?[A-Z]\\.?)?\\b\\.?)", false, 1, "[^\\s]+");
     end
 
 

redaction-service-v1/redaction-service-server-v1/src/test/resources/files/image_response.json

@@ -1,7 +1,7 @@
 {
   "dossierId": "f889853e-4bf8-49a9-aae5-c38605c6ef40",
   "fileId": "22ef63e29bb2a27db8497272336f6b32",
-  "imageMetadata": [
+  "data": [
     {
       "classification": {
         "probabilities": {