Merge branch 'RED-8645-more-fixes-4.1' into 'master'

RED-8645 - Fix some more rules

Closes RED-8645

See merge request redactmanager/redaction-service!318

.gitlab-ci.yml

@@ -1,5 +1,7 @@
 variables:
   SONAR_PROJECT_KEY: 'RED_redaction-service'
+  GIT_SUBMODULE_STRATEGY: recursive
+  GIT_SUBMODULE_FORCE_HTTPS: "true"
 include:
   - project: 'gitlab/gitlab'
     ref: 'main'
@@ -21,3 +23,18 @@ deploy:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
     - if: $CI_COMMIT_BRANCH =~ /^release/
     - if: $CI_COMMIT_TAG
+
+generateJavaDoc:
+  stage: build
+  tags:
+    - dind
+  script:
+    - echo "Generating Javadoc..."
+    - gradle generateJavaDoc -PjavadocDestinationDir="javadoc"
+  artifacts:
+    paths:
+      - redaction-service-v1/redaction-service-server-v1/javadoc/*
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_BRANCH =~ /^release/
+    - if: $CI_COMMIT_TAG

.gitmodules

@@ -0,0 +1,8 @@
+[submodule "redaction-service-v1/redaction-service-server-v1/src/test/resources/files/syngenta"]
+	path = redaction-service-v1/redaction-service-server-v1/src/test/resources/files/syngenta
+	url = ssh://git@git.knecon.com:22222/fforesight/documents/syngenta.git
+	update = merge
+[submodule "redaction-service-v1/redaction-service-server-v1/src/test/resources/files/basf"]
+	path = redaction-service-v1/redaction-service-server-v1/src/test/resources/files/basf
+	url = ssh://git@git.knecon.com:22222/fforesight/documents/basf.git
+	update = merge

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

@@ -15,4 +15,5 @@ public class AnalyzeResponse {
 
     private String fileId;
     private List<UnprocessedManualEntity> unprocessedManualEntities;
+
 }

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

@@ -0,0 +1,27 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import java.util.List;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(callSuper = true)
+public class DroolsBlacklistErrorMessage extends DroolsValidationMessage {
+
+    List<String> blacklistedKeywords;
+
+    public String getMessage() {
+        return String.format("Blacklisted keywords found in this rule: %s", String.join(", ", blacklistedKeywords));
+    }
+
+}

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

@@ -4,17 +4,19 @@ import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
 
 @Data
-@Builder
+@SuperBuilder
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DroolsSyntaxDeprecatedWarnings {
+@EqualsAndHashCode(callSuper = true)
+public class DroolsSyntaxDeprecatedWarnings extends DroolsValidationMessage {
 
-    Integer line;
-    Integer column;
     String message;
+
 }

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

@@ -4,17 +4,19 @@ import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
 
 @Data
-@Builder
+@SuperBuilder
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DroolsSyntaxErrorMessage {
+@EqualsAndHashCode(callSuper = true)
+public class DroolsSyntaxErrorMessage extends DroolsValidationMessage {
 
-    Integer line;
-    Integer column;
     String message;
+
 }

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

@@ -1,36 +0,0 @@
-package com.iqser.red.service.redaction.v1.model;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@FieldDefaults(level = AccessLevel.PRIVATE)
-public class DroolsSyntaxValidation {
-
-    @Builder.Default
-    List<DroolsSyntaxErrorMessage> droolsSyntaxErrorMessages = new LinkedList<>();
-    @Builder.Default
-    List<DroolsSyntaxDeprecatedWarnings> droolsSyntaxDeprecatedWarnings = new LinkedList<>();
-
-
-    public void addErrorMessage(int line, int column, String message) {
-
-        getDroolsSyntaxErrorMessages().add(DroolsSyntaxErrorMessage.builder().line(line).column(column).message(message).build());
-    }
-
-    public boolean isCompiled() {
-
-        return droolsSyntaxErrorMessages.isEmpty();
-    }
-
-}

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

@@ -0,0 +1,39 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class DroolsValidation {
+
+    @Builder.Default
+    List<DroolsSyntaxErrorMessage> syntaxErrorMessages = new ArrayList<>();
+    @Builder.Default
+    List<DroolsSyntaxDeprecatedWarnings> deprecatedWarnings = new ArrayList<>();
+    @Builder.Default
+    List<DroolsBlacklistErrorMessage> blacklistErrorMessages = new ArrayList<>();
+
+
+    public void addErrorMessage(int line, int column, String message) {
+
+        getSyntaxErrorMessages().add(DroolsSyntaxErrorMessage.builder().line(line).column(column).message(message).build());
+    }
+
+
+    public boolean isCompiled() {
+
+        return syntaxErrorMessages.isEmpty() && blacklistErrorMessages.isEmpty();
+    }
+
+}

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

@@ -0,0 +1,21 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+@AllArgsConstructor
+@NoArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode
+public class DroolsValidationMessage {
+
+    Integer line;
+    Integer column;
+}

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

@@ -24,4 +24,5 @@ public class UnprocessedManualEntity {
     private String section;
     @Builder.Default
     private List<Position> positions = new ArrayList<>();
+
 }

redaction-service-v1/redaction-service-api-v1/src/main/java/com/iqser/red/service/redaction/v1/resources/RedactionResource.java

@@ -4,12 +4,12 @@ import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+import com.iqser.red.service.redaction.v1.model.DroolsValidation;
 import com.iqser.red.service.redaction.v1.model.RuleValidationModel;
 
 public interface RedactionResource {
 
     @PostMapping(value = "/rules/test", consumes = MediaType.APPLICATION_JSON_VALUE)
-    DroolsSyntaxValidation testRules(@RequestBody RuleValidationModel rulesValidationModel);
+    DroolsValidation testRules(@RequestBody RuleValidationModel rulesValidationModel);
 
 }

redaction-service-v1/redaction-service-server-v1/build.gradle.kts

@@ -12,7 +12,7 @@ plugins {
 description = "redaction-service-server-v1"
 
 
-val layoutParserVersion = "0.94.0"
+val layoutParserVersion = "0.96.0"
 val jacksonVersion = "2.15.2"
 val droolsVersion = "9.44.0.Final"
 val pdfBoxVersion = "3.0.0"
@@ -113,3 +113,42 @@ tasks.named<BootBuildImage>("bootBuildImage") {
         tags.set(listOf(dockerTag))
     }
 }
+
+fun parseDroolsImports(droolsFilePath: String): List<String> {
+
+    val imports = mutableListOf<String>()
+    val importPattern = Regex("^import\\s+(com\\.iqser\\.red\\.service\\.redaction\\.v1\\.[\\w.]+);")
+    val desiredPrefix = "com.iqser.red.service.redaction.v1"
+
+    File(droolsFilePath).forEachLine { line ->
+        importPattern.find(line)?.let { matchResult ->
+            val importPath = matchResult.groupValues[1].trim()
+            if (importPath.startsWith(desiredPrefix)) {
+                val formattedPath = importPath.replace('.', '/')
+                imports.add("$formattedPath.java")
+            }
+        }
+    }
+
+    return imports
+}
+
+val droolsImports = parseDroolsImports("redaction-service-v1/redaction-service-server-v1/src/main/resources/drools/all_rules_documine.drl")
+
+tasks.register("generateJavaDoc", Javadoc::class) {
+
+    dependsOn("compileJava")
+    dependsOn("delombok")
+    classpath = project.sourceSets["main"].runtimeClasspath
+    source = fileTree("${buildDir}/generated/sources/delombok/java/main") {
+        include(droolsImports)
+    }
+    destinationDir = file(project.findProperty("javadocDestinationDir")?.toString() ?: "")
+
+    options.memberLevel = JavadocMemberLevel.PUBLIC
+    (options as StandardJavadocDocletOptions).apply {
+        header = "Redaction Service ${project.version}"
+        footer = "Redaction Service ${project.version}"
+        title = "API Documentation for Redaction Service ${project.version}"
+    }
+}

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

@@ -35,11 +35,14 @@ public class Application {
         SpringApplication.run(Application.class, args);
     }
 
+
     @Bean
     public ObservedAspect observedAspect(ObservationRegistry observationRegistry) {
+
         return new ObservedAspect(observationRegistry);
     }
 
+
     @Bean
     public TimedAspect timedAspect(MeterRegistry registry) {
 

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

@@ -95,6 +95,7 @@ public class DeprecatedElementsFinder {
         return this.deprecatedClasses;
     }
 
+
     private String getMethodSignature(Method method) {
 
         String methodName = method.getName();

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

@@ -30,4 +30,6 @@ public class RedactionServiceSettings {
 
     private int droolsExecutionTimeoutSecs = 300;
 
+    private boolean ruleExecutionSecured = true;
+
 }

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

@@ -16,7 +16,7 @@ public class RedisCachingConfiguration {
     public RedisCacheManagerBuilderCustomizer redisCacheManagerBuilderCustomizer() {
 
         return (builder) -> builder.withCacheConfiguration("documentDataCache",
-                RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).disableCachingNullValues());
+                                                           RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).disableCachingNullValues());
     }
 
 

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

@@ -1,6 +1,5 @@
 package com.iqser.red.service.redaction.v1.server.client.model;
 
-
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;

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

@@ -3,10 +3,10 @@ package com.iqser.red.service.redaction.v1.server.controller;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
 
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+import com.iqser.red.service.redaction.v1.model.DroolsValidation;
 import com.iqser.red.service.redaction.v1.model.RuleValidationModel;
 import com.iqser.red.service.redaction.v1.resources.RedactionResource;
-import com.iqser.red.service.redaction.v1.server.service.drools.DroolsSyntaxValidationService;
+import com.iqser.red.service.redaction.v1.server.service.drools.DroolsValidationService;
 import com.iqser.red.service.redaction.v1.server.utils.exception.RulesValidationException;
 
 import lombok.RequiredArgsConstructor;
@@ -17,14 +17,14 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class RedactionController implements RedactionResource {
 
-    private final DroolsSyntaxValidationService droolsSyntaxValidationService;
+    private final DroolsValidationService droolsValidationService;
 
 
     @Override
-    public DroolsSyntaxValidation testRules(@RequestBody RuleValidationModel rulesValidationModel) {
+    public DroolsValidation testRules(@RequestBody RuleValidationModel rulesValidationModel) {
 
         try {
-            return droolsSyntaxValidationService.testRules(rulesValidationModel);
+            return droolsValidationService.testRules(rulesValidationModel);
         } catch (Exception e) {
             throw new RulesValidationException("Could not test rules: " + e.getMessage(), e);
         }

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

@@ -13,7 +13,6 @@ import lombok.RequiredArgsConstructor;
 @RequiredArgsConstructor
 public class RuleBuilderController implements RuleBuilderResource {
 
-
     @Override
     public RuleBuilderModel getRuleBuilderModel() {
 

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

@@ -92,11 +92,16 @@ public class LegacyRedactionLogMergeService {
         return redactionLog;
     }
 
+
     public long getNumberOfAffectedAnnotations(ManualRedactions manualRedactions) {
 
-        return createManualRedactionWrappers(manualRedactions).stream().map(ManualRedactionWrapper::getId).distinct().count();
+        return createManualRedactionWrappers(manualRedactions).stream()
+                .map(ManualRedactionWrapper::getId)
+                .distinct()
+                .count();
     }
 
+
     private List<ManualRedactionWrapper> createManualRedactionWrappers(ManualRedactions manualRedactions) {
 
         List<ManualRedactionWrapper> manualRedactionWrappers = new ArrayList<>();

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

@@ -21,7 +21,9 @@ public class LegacyVersion0MigrationService {
     public RedactionLog mergeDuplicateAnnotationIds(RedactionLog redactionLog) {
 
         List<RedactionLogEntry> mergedEntries = new LinkedList<>();
-        Map<String, List<RedactionLogEntry>> entriesById = redactionLog.getRedactionLogEntry().stream().collect(Collectors.groupingBy(RedactionLogEntry::getId));
+        Map<String, List<RedactionLogEntry>> entriesById = redactionLog.getRedactionLogEntry()
+                .stream()
+                .collect(Collectors.groupingBy(RedactionLogEntry::getId));
         for (List<RedactionLogEntry> entries : entriesById.values()) {
 
             if (entries.isEmpty()) {
@@ -33,7 +35,10 @@ public class LegacyVersion0MigrationService {
                 continue;
             }
 
-            List<RedactionLogEntry> sortedEntries = entries.stream().sorted(Comparator.comparing(entry -> entry.getChanges().get(0).getDateTime())).toList();
+            List<RedactionLogEntry> sortedEntries = entries.stream()
+                    .sorted(Comparator.comparing(entry -> entry.getChanges()
+                            .get(0).getDateTime()))
+                    .toList();
 
             RedactionLogEntry initialEntry = sortedEntries.get(0);
             for (RedactionLogEntry entry : sortedEntries.subList(1, sortedEntries.size())) {

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

@@ -14,4 +14,5 @@ public record KieWrapper(KieContainer container, long rulesVersion) {
 
         return container != null && rulesVersion >= 0;
     }
+
 }

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

@@ -19,4 +19,5 @@ public class MigratedEntityLog {
 
     MigratedIds migratedIds;
     EntityLog entityLog;
+
 }

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

@@ -357,6 +357,7 @@ public final class MigrationEntity {
                         .annotationId(getNewId())
                         .updateDictionary(manualResizeRedaction.getUpdateDictionary())
                         .addToAllDossiers(manualResizeRedaction.isAddToAllDossiers())
+                        .requestDate(manualResizeRedaction.getRequestDate())
                         .textAfter(manualResizeRedaction.getTextAfter())
                         .textBefore(manualResizeRedaction.getTextBefore())
                         .build();
@@ -378,6 +379,12 @@ public final class MigrationEntity {
                 .findFirst()
                 .orElse(manualChanges.get(0)).getUser();
 
+        var requestDate = manualChanges.stream()
+                .filter(mc -> mc instanceof ManualResizeRedaction)
+                .findFirst()
+                .orElse(manualChanges.get(0)).getRequestDate();
+
+
         return ManualRedactionEntry.builder()
                 .annotationId(newId)
                 .fileId(fileId)
@@ -386,6 +393,7 @@ public final class MigrationEntity {
                 .reason(redactionLogEntry.getReason())
                 .legalBasis(redactionLogEntry.getLegalBasis())
                 .section(redactionLogEntry.getSection())
+                .requestDate(requestDate)
                 .addToDictionary(false)
                 .addToDossierDictionary(false)
                 .rectangle(false)

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

@@ -27,13 +27,15 @@ public class NerEntities {
 
     public boolean hasEntitiesOfType(String type) {
 
-        return nerEntityList.stream().anyMatch(nerEntity -> nerEntity.type.equals(type));
+        return nerEntityList.stream()
+                .anyMatch(nerEntity -> nerEntity.type.equals(type));
     }
 
 
     public Stream<NerEntity> streamEntitiesOfType(String type) {
 
-        return nerEntityList.stream().filter(nerEntity -> nerEntity.type().equals(type));
+        return nerEntityList.stream()
+                .filter(nerEntity -> nerEntity.type().equals(type));
     }
 
 

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

@@ -88,7 +88,8 @@ public class Entity {
                 .textAfter(e.getTextAfter())
                 .startOffset(e.getStartOffset())
                 .endOffset(e.getEndOffset())
-                .length(Optional.ofNullable(e.getValue()).orElse("").length())
+                .length(Optional.ofNullable(e.getValue())
+                                .orElse("").length())
                 .imageHasTransparency(e.isImageHasTransparency())
                 .isDictionaryEntry(e.isDictionaryEntry())
                 .isDossierDictionaryEntry(e.isDossierDictionaryEntry())

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

@@ -53,7 +53,8 @@ public class Dictionary {
 
     public boolean hasLocalEntries() {
 
-        return dictionaryModels.stream().anyMatch(dm -> !dm.getLocalEntriesWithMatchedRules().isEmpty());
+        return dictionaryModels.stream()
+                .anyMatch(dm -> !dm.getLocalEntriesWithMatchedRules().isEmpty());
     }
 
 
@@ -116,12 +117,18 @@ public class Dictionary {
         }
         localAccessMap.get(type)
                 .getLocalEntriesWithMatchedRules()
-                .merge(cleanedValue.trim(), matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
+                .merge(cleanedValue.trim(),
+                       matchedRulesSet,
+                       (set1, set2) -> Stream.concat(set1.stream(), set2.stream())
+                               .collect(Collectors.toSet()));
         if (alsoAddLastname) {
             String lastname = cleanedValue.split(" ")[0];
             localAccessMap.get(type)
                     .getLocalEntriesWithMatchedRules()
-                    .merge(lastname, matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
+                    .merge(lastname,
+                           matchedRulesSet,
+                           (set1, set2) -> Stream.concat(set1.stream(), set2.stream())
+                                   .collect(Collectors.toSet()));
         }
     }
 
@@ -153,7 +160,10 @@ public class Dictionary {
         } else {
             splitAuthorNames = Arrays.asList(textEntity.getValueWithLineBreaks().split("\n"));
         }
-        return splitAuthorNames.stream().map(String::trim).filter(authorName -> Patterns.AUTHOR_NAME_PATTERN.matcher(authorName).matches()).toList();
+        return splitAuthorNames.stream()
+                .map(String::trim)
+                .filter(authorName -> Patterns.AUTHOR_NAME_PATTERN.matcher(authorName).matches())
+                .toList();
     }
 
 }

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

@@ -57,14 +57,18 @@ public class DictionaryModel implements Serializable {
         this.falsePositives = falsePositives;
         this.falseRecommendations = falseRecommendations;
 
-        this.entriesSearch = new SearchImplementation(this.entries.stream().filter(e -> !e.isDeleted()).map(DictionaryEntryModel::getValue).collect(Collectors.toList()),
-                caseInsensitive);
-        this.falsePositiveSearch = new SearchImplementation(this.falsePositives.stream().filter(e -> !e.isDeleted()).map(DictionaryEntryModel::getValue).collect(Collectors.toList()),
-                caseInsensitive);
+        this.entriesSearch = new SearchImplementation(this.entries.stream()
+                                                              .filter(e -> !e.isDeleted())
+                                                              .map(DictionaryEntryModel::getValue)
+                                                              .collect(Collectors.toList()), caseInsensitive);
+        this.falsePositiveSearch = new SearchImplementation(this.falsePositives.stream()
+                                                                    .filter(e -> !e.isDeleted())
+                                                                    .map(DictionaryEntryModel::getValue)
+                                                                    .collect(Collectors.toList()), caseInsensitive);
         this.falseRecommendationsSearch = new SearchImplementation(this.falseRecommendations.stream()
-                .filter(e -> !e.isDeleted())
-                .map(DictionaryEntry::getValue)
-                .collect(Collectors.toList()), caseInsensitive);
+                                                                           .filter(e -> !e.isDeleted())
+                                                                           .map(DictionaryEntry::getValue)
+                                                                           .collect(Collectors.toList()), caseInsensitive);
 
     }
 
@@ -81,8 +85,10 @@ public class DictionaryModel implements Serializable {
     public SearchImplementation getEntriesSearch() {
 
         if (entriesSearch == null) {
-            this.entriesSearch = new SearchImplementation(this.entries.stream().filter(e -> !e.isDeleted()).map(DictionaryEntry::getValue).collect(Collectors.toList()),
-                    caseInsensitive);
+            this.entriesSearch = new SearchImplementation(this.entries.stream()
+                                                                  .filter(e -> !e.isDeleted())
+                                                                  .map(DictionaryEntry::getValue)
+                                                                  .collect(Collectors.toList()), caseInsensitive);
         }
         return entriesSearch;
     }
@@ -92,9 +98,9 @@ public class DictionaryModel implements Serializable {
 
         if (falsePositiveSearch == null) {
             this.falsePositiveSearch = new SearchImplementation(this.falsePositives.stream()
-                    .filter(e -> !e.isDeleted())
-                    .map(DictionaryEntry::getValue)
-                    .collect(Collectors.toList()), caseInsensitive);
+                                                                        .filter(e -> !e.isDeleted())
+                                                                        .map(DictionaryEntry::getValue)
+                                                                        .collect(Collectors.toList()), caseInsensitive);
         }
         return falsePositiveSearch;
     }
@@ -104,14 +110,16 @@ public class DictionaryModel implements Serializable {
 
         if (falseRecommendationsSearch == null) {
             this.falseRecommendationsSearch = new SearchImplementation(this.falseRecommendations.stream()
-                    .filter(e -> !e.isDeleted())
-                    .map(DictionaryEntry::getValue)
-                    .collect(Collectors.toList()), caseInsensitive);
+                                                                               .filter(e -> !e.isDeleted())
+                                                                               .map(DictionaryEntry::getValue)
+                                                                               .collect(Collectors.toList()), caseInsensitive);
         }
         return falseRecommendationsSearch;
     }
 
+
     public Set<MatchedRule> getMatchedRulesForLocalDictionaryEntry(String value) {
+
         var cleanedValue = isCaseInsensitive() ? value.toLowerCase(Locale.US) : value;
 
         return localEntriesWithMatchedRules.get(cleanedValue);

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

@@ -76,7 +76,9 @@ public class SearchImplementation {
             if (ignoreCase) {
                 textToCheck = textToCheck.toLowerCase(Locale.ROOT);
             }
-            return this.pattern.matcher(textToCheck).results().findAny().isPresent();
+            return this.pattern.matcher(textToCheck).results()
+                    .findAny()
+                    .isPresent();
         } else {
             return this.trie.containsMatch(textToCheck);
         }
@@ -89,9 +91,14 @@ public class SearchImplementation {
             return new ArrayList<>();
         }
         if (this.pattern != null) {
-            return this.pattern.matcher(text).results().map(r -> new TextRange(r.start(), r.end())).collect(Collectors.toList());
+            return this.pattern.matcher(text).results()
+                    .map(r -> new TextRange(r.start(), r.end()))
+                    .collect(Collectors.toList());
         } else {
-            return this.trie.parseText(text).stream().map(r -> new TextRange(r.getStart(), r.getEnd() + 1)).collect(Collectors.toList());
+            return this.trie.parseText(text)
+                    .stream()
+                    .map(r -> new TextRange(r.getStart(), r.getEnd() + 1))
+                    .collect(Collectors.toList());
         }
     }
 
@@ -103,9 +110,14 @@ public class SearchImplementation {
         }
         CharSequence subSequence = text.subSequence(region.start(), region.end());
         if (this.pattern != null) {
-            return this.pattern.matcher(subSequence).results().map(r -> new TextRange(r.start() + region.start(), r.end() + region.start())).collect(Collectors.toList());
+            return this.pattern.matcher(subSequence).results()
+                    .map(r -> new TextRange(r.start() + region.start(), r.end() + region.start()))
+                    .collect(Collectors.toList());
         } else {
-            return this.trie.parseText(subSequence).stream().map(r -> new TextRange(r.getStart() + region.start(), r.getEnd() + region.start() + 1)).collect(Collectors.toList());
+            return this.trie.parseText(subSequence)
+                    .stream()
+                    .map(r -> new TextRange(r.getStart() + region.start(), r.getEnd() + region.start() + 1))
+                    .collect(Collectors.toList());
         }
     }
 
@@ -120,9 +132,14 @@ public class SearchImplementation {
             if (ignoreCase) {
                 textToCheck = textToCheck.toLowerCase(Locale.ROOT);
             }
-            return this.pattern.matcher(textToCheck).results().map(r -> new MatchPosition(r.start(), r.end())).collect(Collectors.toList());
+            return this.pattern.matcher(textToCheck).results()
+                    .map(r -> new MatchPosition(r.start(), r.end()))
+                    .collect(Collectors.toList());
         } else {
-            return this.trie.parseText(textToCheck).stream().map(r -> new MatchPosition(r.getStart(), r.getEnd() + 1)).collect(Collectors.toList());
+            return this.trie.parseText(textToCheck)
+                    .stream()
+                    .map(r -> new MatchPosition(r.getStart(), r.getEnd() + 1))
+                    .collect(Collectors.toList());
         }
     }
 

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

@@ -40,7 +40,10 @@ public class DocumentTree {
 
     public TextBlock buildTextBlock() {
 
-        return allEntriesInOrder().map(Entry::getNode).filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+        return allEntriesInOrder().map(Entry::getNode)
+                .filter(SemanticNode::isLeaf)
+                .map(SemanticNode::getLeafTextBlock)
+                .collect(new TextBlockCollector());
     }
 
 
@@ -114,13 +117,16 @@ public class DocumentTree {
 
     public Stream<SemanticNode> childNodes(List<Integer> treeId) {
 
-        return getEntryById(treeId).children.stream().map(Entry::getNode);
+        return getEntryById(treeId).children.stream()
+                .map(Entry::getNode);
     }
 
 
     public Stream<SemanticNode> childNodesOfType(List<Integer> treeId, NodeType nodeType) {
 
-        return getEntryById(treeId).children.stream().filter(entry -> entry.node.getType().equals(nodeType)).map(Entry::getNode);
+        return getEntryById(treeId).children.stream()
+                .filter(entry -> entry.node.getType().equals(nodeType))
+                .map(Entry::getNode);
     }
 
 
@@ -199,26 +205,32 @@ public class DocumentTree {
 
     public Stream<Entry> allEntriesInOrder() {
 
-        return Stream.of(root).flatMap(DocumentTree::flatten);
+        return Stream.of(root)
+                .flatMap(DocumentTree::flatten);
     }
 
 
     public Stream<Entry> allSubEntriesInOrder(List<Integer> parentId) {
 
-        return getEntryById(parentId).children.stream().flatMap(DocumentTree::flatten);
+        return getEntryById(parentId).children.stream()
+                .flatMap(DocumentTree::flatten);
     }
 
 
     @Override
     public String toString() {
 
-        return String.join("\n", allEntriesInOrder().map(Entry::toString).toList());
+        return String.join("\n",
+                           allEntriesInOrder().map(Entry::toString)
+                                   .toList());
     }
 
 
     private static Stream<Entry> flatten(Entry entry) {
 
-        return Stream.concat(Stream.of(entry), entry.children.stream().flatMap(DocumentTree::flatten));
+        return Stream.concat(Stream.of(entry),
+                             entry.children.stream()
+                                     .flatMap(DocumentTree::flatten));
     }
 
 

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

@@ -92,8 +92,13 @@ public class TextRange implements Comparable<TextRange> {
 
     public List<TextRange> split(List<Integer> splitIndices) {
 
-        if (splitIndices.stream().anyMatch(idx -> !this.contains(idx))) {
-            throw new IndexOutOfBoundsException(format("%s splitting indices are out of range for %s", splitIndices.stream().filter(idx -> !this.contains(idx)).toList(), this));
+        if (splitIndices.stream()
+                .anyMatch(idx -> !this.contains(idx))) {
+            throw new IndexOutOfBoundsException(format("%s splitting indices are out of range for %s",
+                                                       splitIndices.stream()
+                                                               .filter(idx -> !this.contains(idx))
+                                                               .toList(),
+                                                       this));
         }
         List<TextRange> splitBoundaries = new LinkedList<>();
         int previousIndex = start;
@@ -113,8 +118,14 @@ public class TextRange implements Comparable<TextRange> {
 
     public static TextRange merge(Collection<TextRange> boundaries) {
 
-        int minStart = boundaries.stream().mapToInt(TextRange::start).min().orElseThrow(IllegalArgumentException::new);
-        int maxEnd = boundaries.stream().mapToInt(TextRange::end).max().orElseThrow(IllegalArgumentException::new);
+        int minStart = boundaries.stream()
+                .mapToInt(TextRange::start)
+                .min()
+                .orElseThrow(IllegalArgumentException::new);
+        int maxEnd = boundaries.stream()
+                .mapToInt(TextRange::end)
+                .max()
+                .orElseThrow(IllegalArgumentException::new);
         return new TextRange(minStart, maxEnd);
     }
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/entity/IEntity.java

@@ -35,14 +35,16 @@ public interface IEntity {
 
     default String value() {
 
-        return getManualOverwrite().getValue().orElse(getValue() == null ? "" : getValue());
+        return getManualOverwrite().getValue()
+                .orElse(getValue() == null ? "" : getValue());
     }
 
 
     // Don't use default accessor pattern (e.g. isApplied()), as it might lead to errors in drools due to property-specific optimization of the drools planner.
     default boolean applied() {
 
-        return getManualOverwrite().getApplied().orElse(getMatchedRule().isApplied());
+        return getManualOverwrite().getApplied()
+                .orElse(getMatchedRule().isApplied());
     }
 
 
@@ -54,19 +56,22 @@ public interface IEntity {
 
     default boolean ignored() {
 
-        return getManualOverwrite().getIgnored().orElse(getMatchedRule().isIgnored());
+        return getManualOverwrite().getIgnored()
+                .orElse(getMatchedRule().isIgnored());
     }
 
 
     default boolean removed() {
 
-        return getManualOverwrite().getRemoved().orElse(getMatchedRule().isRemoved());
+        return getManualOverwrite().getRemoved()
+                .orElse(getMatchedRule().isRemoved());
     }
 
 
     default boolean resized() {
 
-        return getManualOverwrite().getResized().orElse(false);
+        return getManualOverwrite().getResized()
+                .orElse(false);
     }
 
 
@@ -133,12 +138,12 @@ public interface IEntity {
             throw new IllegalArgumentException("legal basis cannot be empty when redacting an entity");
         }
         getMatchedRuleList().add(MatchedRule.builder()
-                .ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier))
-                .reason(reason)
-                .legalBasis(legalBasis)
-                .applied(true)
-                .writeValueWithLineBreaks(true)
-                .build());
+                                         .ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier))
+                                         .reason(reason)
+                                         .legalBasis(legalBasis)
+                                         .applied(true)
+                                         .writeValueWithLineBreaks(true)
+                                         .build());
     }
 
 
@@ -148,12 +153,12 @@ public interface IEntity {
             throw new IllegalArgumentException("legal basis cannot be empty when redacting an entity");
         }
         getMatchedRuleList().add(MatchedRule.builder()
-                .ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier))
-                .reason(reason)
-                .legalBasis(legalBasis)
-                .applied(true)
-                .references(new HashSet<>(references))
-                .build());
+                                         .ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier))
+                                         .reason(reason)
+                                         .legalBasis(legalBasis)
+                                         .applied(true)
+                                         .references(new HashSet<>(references))
+                                         .build());
     }
 
 
@@ -207,7 +212,8 @@ public interface IEntity {
 
     default String legalBasis() {
 
-        return getManualOverwrite().getLegalBasis().orElse(getMatchedRule().getLegalBasis());
+        return getManualOverwrite().getLegalBasis()
+                .orElse(getMatchedRule().getLegalBasis());
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/entity/MatchedRule.java

@@ -52,7 +52,8 @@ public final class MatchedRule implements Comparable<MatchedRule> {
         if (!this.isApplied()) {
             return this;
         }
-        return MatchedRule.builder().ruleIdentifier(getRuleIdentifier())
+        return MatchedRule.builder()
+                .ruleIdentifier(getRuleIdentifier())
                 .writeValueWithLineBreaks(this.isWriteValueWithLineBreaks())
                 .legalBasis(this.getLegalBasis())
                 .reason(this.getReason())
@@ -97,7 +98,19 @@ public final class MatchedRule implements Comparable<MatchedRule> {
     @Override
     public String toString() {
 
-        return "MatchedRule[ruleIdentifier=" + ruleIdentifier + ", reason=" + reason + ", legalBasis=" + legalBasis + ", applied=" + applied + ", writeValueWithLineBreaks=" + writeValueWithLineBreaks + ", references=" + references + ']';
+        return "MatchedRule[ruleIdentifier="
+               + ruleIdentifier
+               + ", reason="
+               + reason
+               + ", legalBasis="
+               + legalBasis
+               + ", applied="
+               + applied
+               + ", writeValueWithLineBreaks="
+               + writeValueWithLineBreaks
+               + ", references="
+               + references
+               + ']';
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/entity/TextEntity.java

@@ -67,7 +67,13 @@ public class TextEntity implements IEntity {
 
     public static TextEntity initialEntityNode(TextRange textRange, String type, EntityType entityType, SemanticNode node) {
 
-        return TextEntity.builder().id(buildId(node, textRange, type, entityType)).type(type).entityType(entityType).textRange(textRange).manualOverwrite(new ManualChangeOverwrite(entityType)).build();
+        return TextEntity.builder()
+                .id(buildId(node, textRange, type, entityType))
+                .type(type)
+                .entityType(entityType)
+                .textRange(textRange)
+                .manualOverwrite(new ManualChangeOverwrite(entityType))
+                .build();
     }
 
 
@@ -80,7 +86,13 @@ public class TextEntity implements IEntity {
     private static String buildId(SemanticNode node, TextRange textRange, String type, EntityType entityType) {
 
         Map<Page, List<Rectangle2D>> rectanglesPerLinePerPage = node.getPositionsPerPage(textRange);
-        return IdBuilder.buildId(rectanglesPerLinePerPage.keySet(), rectanglesPerLinePerPage.values().stream().flatMap(Collection::stream).toList(), type, entityType.name());
+        return IdBuilder.buildId(rectanglesPerLinePerPage.keySet(),
+                                 rectanglesPerLinePerPage.values()
+                                         .stream()
+                                         .flatMap(Collection::stream)
+                                         .toList(),
+                                 type,
+                                 entityType.name());
     }
 
 
@@ -89,15 +101,18 @@ public class TextEntity implements IEntity {
         duplicateTextRanges.add(textRange);
     }
 
+
     public boolean occursInNodeOfType(Class<? extends SemanticNode> clazz) {
 
-        return intersectingNodes.stream().anyMatch(clazz::isInstance);
+        return intersectingNodes.stream()
+                .anyMatch(clazz::isInstance);
     }
 
 
     public boolean occursInNode(SemanticNode semanticNode) {
 
-        return intersectingNodes.stream().anyMatch(node -> node.equals(semanticNode));
+        return intersectingNodes.stream()
+                .anyMatch(node -> node.equals(semanticNode));
     }
 
 
@@ -146,7 +161,10 @@ public class TextEntity implements IEntity {
                     .min(Comparator.comparingInt(Page::getNumber))
                     .orElseThrow(() -> new RuntimeException("No Positions found on any page!"));
 
-            positionsOnPagePerPage = rectanglesPerLinePerPage.entrySet().stream().map(entry -> buildPositionOnPage(firstPage, id, entry)).toList();
+            positionsOnPagePerPage = rectanglesPerLinePerPage.entrySet()
+                    .stream()
+                    .map(entry -> buildPositionOnPage(firstPage, id, entry))
+                    .toList();
         }
         return positionsOnPagePerPage;
     }
@@ -194,7 +212,8 @@ public class TextEntity implements IEntity {
 
     public boolean matchesAnnotationId(String manualRedactionId) {
 
-        return getPositionsOnPagePerPage().stream().anyMatch(entityPosition -> entityPosition.getId().equals(manualRedactionId));
+        return getPositionsOnPagePerPage().stream()
+                .anyMatch(entityPosition -> entityPosition.getId().equals(manualRedactionId));
     }
 
 
@@ -224,14 +243,16 @@ public class TextEntity implements IEntity {
     @Override
     public String type() {
 
-        return getManualOverwrite().getType().orElse(type);
+        return getManualOverwrite().getType()
+                .orElse(type);
     }
 
 
     @Override
     public String value() {
 
-        return getManualOverwrite().getValue().orElse(getMatchedRule().isWriteValueWithLineBreaks() ? getValueWithLineBreaks() : value);
+        return getManualOverwrite().getValue()
+                .orElse(getMatchedRule().isWriteValueWithLineBreaks() ? getValueWithLineBreaks() : value);
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Document.java

@@ -57,7 +57,7 @@ public class Document implements GenericSemanticNode {
     public TextBlock getTextBlock() {
 
         if (textBlock == null) {
-            textBlock = streamTerminalTextBlocksInOrder().collect(new TextBlockCollector());
+            textBlock = GenericSemanticNode.super.getTextBlock();
         }
         return textBlock;
     }
@@ -65,13 +65,14 @@ public class Document implements GenericSemanticNode {
 
     public List<Section> getMainSections() {
 
-        return streamChildrenOfType(NodeType.SECTION).map(node -> (Section) node).collect(Collectors.toList());
+        return streamChildrenOfType(NodeType.SECTION).map(node -> (Section) node)
+                .collect(Collectors.toList());
     }
 
 
     public Stream<TextBlock> streamTerminalTextBlocksInOrder() {
 
-        return streamAllNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock);
+        return streamAllNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getTextBlock);
     }
 
 
@@ -92,13 +93,16 @@ public class Document implements GenericSemanticNode {
     @Override
     public Headline getHeadline() {
 
-        return streamAllSubNodesOfType(NodeType.HEADLINE).map(node -> (Headline) node).findFirst().orElseGet(Headline::empty);
+        return streamAllSubNodesOfType(NodeType.HEADLINE).map(node -> (Headline) node)
+                .findFirst()
+                .orElseGet(Headline::empty);
     }
 
 
     private Stream<SemanticNode> streamAllNodes() {
 
-        return documentTree.allEntriesInOrder().map(DocumentTree.Entry::getNode);
+        return documentTree.allEntriesInOrder()
+                .map(DocumentTree.Entry::getNode);
     }
 
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/DuplicatedParagraph.java

@@ -0,0 +1,34 @@
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
+
+import java.util.stream.Stream;
+
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlockCollector;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@SuperBuilder
+public class DuplicatedParagraph extends Paragraph {
+
+    TextBlock unsortedLeafTextBlock;
+
+
+    @Override
+    public TextBlock getTextBlock() {
+
+        return Stream.of(leafTextBlock, unsortedLeafTextBlock).collect(new TextBlockCollector());
+
+    }
+
+
+    @Override
+    public String toString() {
+
+        return super.toString();
+    }
+
+}

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Headline.java

@@ -106,7 +106,9 @@ public class Headline implements GenericSemanticNode {
 
     public boolean hasParagraphs() {
 
-        return getParent().streamAllSubNodesOfType(NodeType.PARAGRAPH).findFirst().isPresent();
+        return getParent().streamAllSubNodesOfType(NodeType.PARAGRAPH)
+                .findFirst()
+                .isPresent();
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Image.java

@@ -98,14 +98,14 @@ public class Image implements GenericSemanticNode, IEntity {
     public String type() {
 
         return getManualOverwrite().getType()
-                .orElse(imageType.toString());
+                .orElse(imageType.toString().toLowerCase(Locale.ENGLISH));
     }
 
 
     @Override
     public String toString() {
 
-        return treeId + ": " + NodeType.IMAGE + ": " + imageType.toString() + " " + position;
+        return treeId + ": " + getValue() + " " + position;
     }
 
 
@@ -136,7 +136,7 @@ public class Image implements GenericSemanticNode, IEntity {
         Map<Page, Rectangle2D> bboxImage = image.getBBox();
         Map<Page, Rectangle2D> bbox = this.getBBox();
         //image needs to be on the same page
-        if(bboxImage.get(this.page) != null) {
+        if (bboxImage.get(this.page) != null) {
             Rectangle2D intersection = bboxImage.get(this.page).createIntersection(bbox.get(this.page));
             double calculatedIntersection = intersection.getWidth() * intersection.getHeight();
             double area = bbox.get(this.page).getWidth() * bbox.get(this.page).getHeight();

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/ImageType.java

@@ -6,22 +6,10 @@ public enum ImageType {
     LOGO,
     FORMULA,
     SIGNATURE,
-    OTHER {
-        @Override
-        public String toString() {
-
-            return "image";
-        }
-    },
+    OTHER,
     OCR;
 
 
-    public String toString() {
-
-        return name().toLowerCase(Locale.ENGLISH);
-    }
-
-
     public static ImageType fromString(String imageType) {
 
         return switch (imageType.toLowerCase(Locale.ROOT)) {

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Page.java

@@ -45,7 +45,10 @@ public class Page {
 
     public TextBlock getMainBodyTextBlock() {
 
-        return mainBody.stream().filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+        return mainBody.stream()
+                .filter(SemanticNode::isLeaf)
+                .map(SemanticNode::getLeafTextBlock)
+                .collect(new TextBlockCollector());
     }
 
 
@@ -54,4 +57,5 @@ public class Page {
 
         return String.valueOf(number);
     }
+
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Paragraph.java

@@ -17,11 +17,12 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
 
 @Data
-@Builder
+@SuperBuilder
 @AllArgsConstructor
-@FieldDefaults(level = AccessLevel.PRIVATE)
+@FieldDefaults(level = AccessLevel.PROTECTED)
 @EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Paragraph implements GenericSemanticNode {
 

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

@@ -53,7 +53,8 @@ public class Section implements GenericSemanticNode {
 
     public boolean hasTables() {
 
-        return streamAllSubNodesOfType(NodeType.TABLE).findAny().isPresent();
+        return streamAllSubNodesOfType(NodeType.TABLE).findAny()
+                .isPresent();
     }
 
 
@@ -68,7 +69,7 @@ public class Section implements GenericSemanticNode {
     public TextBlock getTextBlock() {
 
         if (textBlock == null) {
-            textBlock = streamAllSubNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+            textBlock = GenericSemanticNode.super.getTextBlock();
         }
         return textBlock;
     }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/SectionIdentifier.java

@@ -72,7 +72,11 @@ public class SectionIdentifier {
             }
             identifiers.add(Integer.parseInt(numericalIdentifier.trim()));
         }
-        return new SectionIdentifier(Format.NUMERICAL, identifierString, identifiers.stream().toList(), false);
+        return new SectionIdentifier(Format.NUMERICAL,
+                                     identifierString,
+                                     identifiers.stream()
+                                             .toList(),
+                                     false);
     }
 
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/SemanticNode.java

@@ -19,6 +19,7 @@ import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
 import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
 import com.iqser.red.service.redaction.v1.server.model.document.textblock.AtomicTextBlock;
 import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlockCollector;
 import com.iqser.red.service.redaction.v1.server.service.document.NodeVisitor;
 import com.iqser.red.service.redaction.v1.server.utils.RectangleTransformations;
 import com.iqser.red.service.redaction.v1.server.utils.RedactionSearchUtility;
@@ -41,7 +42,11 @@ public interface SemanticNode {
      *
      * @return TextBlock containing all AtomicTextBlocks that are located under this Node.
      */
-    TextBlock getTextBlock();
+    default TextBlock getTextBlock() {
+
+        return streamAllSubNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getTextBlock).collect(new TextBlockCollector());
+    }
+
 
 
     /**
@@ -71,7 +76,10 @@ public interface SemanticNode {
      */
     default Page getFirstPage() {
 
-        return getTextBlock().getPages().stream().min(Comparator.comparingInt(Page::getNumber)).orElseThrow();
+        return getTextBlock().getPages()
+                .stream()
+                .min(Comparator.comparingInt(Page::getNumber))
+                .orElseThrow();
     }
 
 
@@ -97,7 +105,8 @@ public interface SemanticNode {
      */
     default boolean onPage(int pageNumber) {
 
-        return getPages().stream().anyMatch(page -> page.getNumber() == pageNumber);
+        return getPages().stream()
+                .anyMatch(page -> page.getNumber() == pageNumber);
     }
 
 
@@ -249,7 +258,9 @@ public interface SemanticNode {
      */
     default boolean hasEntitiesOfType(String type) {
 
-        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> redactionEntity.type().equals(type));
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .anyMatch(redactionEntity -> redactionEntity.type().equals(type));
     }
 
 
@@ -262,7 +273,10 @@ public interface SemanticNode {
      */
     default boolean hasEntitiesOfAnyType(String... types) {
 
-        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> Arrays.stream(types).anyMatch(type -> redactionEntity.type().equals(type)));
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .anyMatch(redactionEntity -> Arrays.stream(types)
+                        .anyMatch(type -> redactionEntity.type().equals(type)));
     }
 
 
@@ -275,7 +289,12 @@ public interface SemanticNode {
      */
     default boolean hasEntitiesOfAllTypes(String... types) {
 
-        return getEntities().stream().filter(TextEntity::active).map(TextEntity::type).collect(Collectors.toUnmodifiableSet()).containsAll(Arrays.stream(types).toList());
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .map(TextEntity::type)
+                .collect(Collectors.toUnmodifiableSet())
+                .containsAll(Arrays.stream(types)
+                                     .toList());
     }
 
 
@@ -288,7 +307,10 @@ public interface SemanticNode {
      */
     default List<TextEntity> getEntitiesOfType(String type) {
 
-        return getEntities().stream().filter(TextEntity::active).filter(redactionEntity -> redactionEntity.type().equals(type)).toList();
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .filter(redactionEntity -> redactionEntity.type().equals(type))
+                .toList();
     }
 
 
@@ -301,7 +323,10 @@ public interface SemanticNode {
      */
     default List<TextEntity> getEntitiesOfType(List<String> types) {
 
-        return getEntities().stream().filter(TextEntity::active).filter(redactionEntity -> redactionEntity.isAnyType(types)).toList();
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .filter(redactionEntity -> redactionEntity.isAnyType(types))
+                .toList();
     }
 
 
@@ -314,7 +339,11 @@ public interface SemanticNode {
      */
     default List<TextEntity> getEntitiesOfType(String... types) {
 
-        return getEntities().stream().filter(TextEntity::active).filter(redactionEntity -> redactionEntity.isAnyType(Arrays.stream(types).toList())).toList();
+        return getEntities().stream()
+                .filter(TextEntity::active)
+                .filter(redactionEntity -> redactionEntity.isAnyType(Arrays.stream(types)
+                                                                             .toList()))
+                .toList();
     }
 
 
@@ -328,7 +357,8 @@ public interface SemanticNode {
 
         TextBlock textBlock = getTextBlock();
         if (!textBlock.getAtomicTextBlocks().isEmpty()) {
-            return getTextBlock().getAtomicTextBlocks().get(0).getNumberOnPage();
+            return getTextBlock().getAtomicTextBlocks()
+                    .get(0).getNumberOnPage();
         } else {
             return -1;
         }
@@ -357,14 +387,16 @@ public interface SemanticNode {
         return getTextBlock().getSearchText().contains(string);
     }
 
+
     Set<LayoutEngine> getEngines();
 
+
     default void addEngine(LayoutEngine engine) {
+
         getEngines().add(engine);
     }
 
 
-
     /**
      * Checks whether this SemanticNode contains all the provided Strings.
      *
@@ -373,7 +405,8 @@ public interface SemanticNode {
      */
     default boolean containsAllStrings(String... strings) {
 
-        return Arrays.stream(strings).allMatch(this::containsString);
+        return Arrays.stream(strings)
+                .allMatch(this::containsString);
     }
 
 
@@ -385,7 +418,8 @@ public interface SemanticNode {
      */
     default boolean containsAnyString(String... strings) {
 
-        return Arrays.stream(strings).anyMatch(this::containsString);
+        return Arrays.stream(strings)
+                .anyMatch(this::containsString);
     }
 
 
@@ -397,7 +431,8 @@ public interface SemanticNode {
      */
     default boolean containsAnyString(List<String> strings) {
 
-        return strings.stream().anyMatch(this::containsString);
+        return strings.stream()
+                .anyMatch(this::containsString);
     }
 
 
@@ -421,7 +456,8 @@ public interface SemanticNode {
      */
     default boolean containsAnyStringIgnoreCase(String... strings) {
 
-        return Arrays.stream(strings).anyMatch(this::containsStringIgnoreCase);
+        return Arrays.stream(strings)
+                .anyMatch(this::containsStringIgnoreCase);
     }
 
 
@@ -433,7 +469,8 @@ public interface SemanticNode {
      */
     default boolean containsAllStringsIgnoreCase(String... strings) {
 
-        return Arrays.stream(strings).allMatch(this::containsStringIgnoreCase);
+        return Arrays.stream(strings)
+                .allMatch(this::containsStringIgnoreCase);
     }
 
 
@@ -445,7 +482,9 @@ public interface SemanticNode {
      */
     default boolean containsWord(String word) {
 
-        return getTextBlock().getWords().stream().anyMatch(s -> s.equals(word));
+        return getTextBlock().getWords()
+                .stream()
+                .anyMatch(s -> s.equals(word));
     }
 
 
@@ -457,7 +496,10 @@ public interface SemanticNode {
      */
     default boolean containsWordIgnoreCase(String word) {
 
-        return getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(s -> s.equals(word.toLowerCase(Locale.ENGLISH)));
+        return getTextBlock().getWords()
+                .stream()
+                .map(String::toLowerCase)
+                .anyMatch(s -> s.equals(word.toLowerCase(Locale.ENGLISH)));
     }
 
 
@@ -469,7 +511,10 @@ public interface SemanticNode {
      */
     default boolean containsAnyWord(String... words) {
 
-        return Arrays.stream(words).anyMatch(word -> getTextBlock().getWords().stream().anyMatch(word::equals));
+        return Arrays.stream(words)
+                .anyMatch(word -> getTextBlock().getWords()
+                        .stream()
+                        .anyMatch(word::equals));
     }
 
 
@@ -481,7 +526,12 @@ public interface SemanticNode {
      */
     default boolean containsAnyWordIgnoreCase(String... words) {
 
-        return Arrays.stream(words).map(String::toLowerCase).anyMatch(word -> getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(word::equals));
+        return Arrays.stream(words)
+                .map(String::toLowerCase)
+                .anyMatch(word -> getTextBlock().getWords()
+                        .stream()
+                        .map(String::toLowerCase)
+                        .anyMatch(word::equals));
     }
 
 
@@ -493,7 +543,10 @@ public interface SemanticNode {
      */
     default boolean containsAllWords(String... words) {
 
-        return Arrays.stream(words).allMatch(word -> getTextBlock().getWords().stream().anyMatch(word::equals));
+        return Arrays.stream(words)
+                .allMatch(word -> getTextBlock().getWords()
+                        .stream()
+                        .anyMatch(word::equals));
     }
 
 
@@ -505,7 +558,12 @@ public interface SemanticNode {
      */
     default boolean containsAllWordsIgnoreCase(String... words) {
 
-        return Arrays.stream(words).map(String::toLowerCase).allMatch(word -> getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(word::equals));
+        return Arrays.stream(words)
+                .map(String::toLowerCase)
+                .allMatch(word -> getTextBlock().getWords()
+                        .stream()
+                        .map(String::toLowerCase)
+                        .anyMatch(word::equals));
     }
 
 
@@ -545,7 +603,11 @@ public interface SemanticNode {
      */
     default boolean intersectsRectangle(int x, int y, int w, int h, int pageNumber) {
 
-        return getBBox().entrySet().stream().filter(entry -> entry.getKey().getNumber() == pageNumber).map(Map.Entry::getValue).anyMatch(rect -> rect.intersects(x, y, w, h));
+        return getBBox().entrySet()
+                .stream()
+                .filter(entry -> entry.getKey().getNumber() == pageNumber)
+                .map(Map.Entry::getValue)
+                .anyMatch(rect -> rect.intersects(x, y, w, h));
     }
 
 
@@ -598,7 +660,8 @@ public interface SemanticNode {
      */
     default Stream<SemanticNode> streamAllSubNodes() {
 
-        return getDocumentTree().allSubEntriesInOrder(getTreeId()).map(DocumentTree.Entry::getNode);
+        return getDocumentTree().allSubEntriesInOrder(getTreeId())
+                .map(DocumentTree.Entry::getNode);
     }
 
 
@@ -609,7 +672,9 @@ public interface SemanticNode {
      */
     default Stream<SemanticNode> streamAllSubNodesOfType(NodeType nodeType) {
 
-        return getDocumentTree().allSubEntriesInOrder(getTreeId()).filter(entry -> entry.getType().equals(nodeType)).map(DocumentTree.Entry::getNode);
+        return getDocumentTree().allSubEntriesInOrder(getTreeId())
+                .filter(entry -> entry.getType().equals(nodeType))
+                .map(DocumentTree.Entry::getNode);
     }
 
 
@@ -648,7 +713,8 @@ public interface SemanticNode {
         if (isLeaf()) {
             return getTextBlock().getPositionsPerPage(textRange);
         }
-        Optional<SemanticNode> containingChildNode = streamChildren().filter(child -> child.getTextRange().contains(textRange)).findFirst();
+        Optional<SemanticNode> containingChildNode = streamChildren().filter(child -> child.getTextRange().contains(textRange))
+                .findFirst();
         if (containingChildNode.isEmpty()) {
             return getTextBlock().getPositionsPerPage(textRange);
         }
@@ -698,8 +764,12 @@ public interface SemanticNode {
     private Map<Page, Rectangle2D> getBBoxFromChildren() {
 
         Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
-        List<Map<Page, Rectangle2D>> childrenBBoxes = streamChildren().map(SemanticNode::getBBox).toList();
-        Set<Page> pages = childrenBBoxes.stream().flatMap(map -> map.keySet().stream()).collect(Collectors.toSet());
+        List<Map<Page, Rectangle2D>> childrenBBoxes = streamChildren().map(SemanticNode::getBBox)
+                .toList();
+        Set<Page> pages = childrenBBoxes.stream()
+                .flatMap(map -> map.keySet()
+                        .stream())
+                .collect(Collectors.toSet());
         for (Page page : pages) {
             Rectangle2D bBoxOnPage = childrenBBoxes.stream()
                     .filter(childBboxPerPage -> childBboxPerPage.containsKey(page))
@@ -717,7 +787,9 @@ public interface SemanticNode {
     private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock() {
 
         Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
-        Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks().stream().collect(Collectors.groupingBy(AtomicTextBlock::getPage));
+        Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks()
+                .stream()
+                .collect(Collectors.groupingBy(AtomicTextBlock::getPage));
         atomicTextBlockPerPage.forEach((page, atomicTextBlocks) -> bBoxPerPage.put(page, RectangleTransformations.atomicTextBlockBBox(atomicTextBlocks)));
         return bBoxPerPage;
     }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/Table.java

@@ -408,9 +408,7 @@ public class Table implements SemanticNode {
     public TextBlock getTextBlock() {
 
         if (textBlock == null) {
-            textBlock = streamAllSubNodes().filter(SemanticNode::isLeaf)
-                    .map(SemanticNode::getLeafTextBlock)
-                    .collect(new TextBlockCollector());
+            textBlock = SemanticNode.super.getTextBlock();
         }
         return textBlock;
     }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/nodes/TableCell.java

@@ -79,7 +79,9 @@ public class TableCell implements GenericSemanticNode {
         }
 
         if (textBlock == null) {
-            textBlock = streamAllSubNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+            textBlock = streamAllSubNodes().filter(SemanticNode::isLeaf)
+                    .map(SemanticNode::getLeafTextBlock)
+                    .collect(new TextBlockCollector());
         }
         return textBlock;
     }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/textblock/AtomicTextBlock.java

@@ -61,6 +61,7 @@ public class AtomicTextBlock implements TextBlock {
         return lineBreaks.size() + 1;
     }
 
+
     public static AtomicTextBlock empty(Long textBlockIdx, int stringOffset, Page page, int numberOnPage, SemanticNode parent) {
 
         return AtomicTextBlock.builder()
@@ -77,10 +78,7 @@ public class AtomicTextBlock implements TextBlock {
     }
 
 
-    public static AtomicTextBlock fromAtomicTextBlockData(DocumentTextData atomicTextBlockData,
-                                                          DocumentPositionData atomicPositionBlockData,
-                                                          SemanticNode parent,
-                                                          Page page) {
+    public static AtomicTextBlock fromAtomicTextBlockData(DocumentTextData atomicTextBlockData, DocumentPositionData atomicPositionBlockData, SemanticNode parent, Page page) {
 
         return AtomicTextBlock.builder()
                 .id(atomicTextBlockData.getId())
@@ -88,8 +86,10 @@ public class AtomicTextBlock implements TextBlock {
                 .page(page)
                 .textRange(new TextRange(atomicTextBlockData.getStart(), atomicTextBlockData.getEnd()))
                 .searchText(atomicTextBlockData.getSearchText())
-                .lineBreaks(Arrays.stream(atomicTextBlockData.getLineBreaks()).boxed().toList())
-                .stringIdxToPositionIdx(Arrays.stream(atomicPositionBlockData.getStringIdxToPositionIdx()).boxed().toList())
+                .lineBreaks(Arrays.stream(atomicTextBlockData.getLineBreaks()).boxed()
+                                    .toList())
+                .stringIdxToPositionIdx(Arrays.stream(atomicPositionBlockData.getStringIdxToPositionIdx()).boxed()
+                                                .toList())
                 .positions(toRectangle2DList(atomicPositionBlockData.getPositions()))
                 .parent(parent)
                 .build();
@@ -98,7 +98,9 @@ public class AtomicTextBlock implements TextBlock {
 
     private static List<Rectangle2D> toRectangle2DList(float[][] positions) {
 
-        return Arrays.stream(positions).map(floatArr -> (Rectangle2D) new Rectangle2D.Float(floatArr[0], floatArr[1], floatArr[2], floatArr[3])).toList();
+        return Arrays.stream(positions)
+                .map(floatArr -> (Rectangle2D) new Rectangle2D.Float(floatArr[0], floatArr[1], floatArr[2], floatArr[3]))
+                .toList();
     }
 
 
@@ -118,6 +120,7 @@ public class AtomicTextBlock implements TextBlock {
         return new TextRange(lineBreaks.get(lineNumber - 1) + textRange.start(), lineBreaks.get(lineNumber) + textRange.start());
     }
 
+
     public List<String> getWords() {
 
         if (words == null) {
@@ -144,9 +147,9 @@ public class AtomicTextBlock implements TextBlock {
     public int getNextLinebreak(int fromIndex) {
 
         return lineBreaks.stream()//
-                .filter(linebreak -> linebreak > fromIndex - textRange.start()) //
-                .findFirst() //
-                .orElse(searchText.length()) + textRange.start();
+                       .filter(linebreak -> linebreak > fromIndex - textRange.start()) //
+                       .findFirst() //
+                       .orElse(searchText.length()) + textRange.start();
     }
 
 
@@ -154,9 +157,9 @@ public class AtomicTextBlock implements TextBlock {
     public int getPreviousLinebreak(int fromIndex) {
 
         return lineBreaks.stream()//
-                .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
-                .reduce((a, b) -> b)//
-                .orElse(0) + textRange.start();
+                       .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
+                       .reduce((a, b) -> b)//
+                       .orElse(0) + textRange.start();
     }
 
 
@@ -209,7 +212,10 @@ public class AtomicTextBlock implements TextBlock {
             return "";
         }
 
-        Set<Integer> lbInBoundary = lineBreaks.stream().map(i -> i + textRange.start()).filter(textRange::contains).collect(Collectors.toSet());
+        Set<Integer> lbInBoundary = lineBreaks.stream()
+                .map(i -> i + textRange.start())
+                .filter(textRange::contains)
+                .collect(Collectors.toSet());
         if (textRange.end() == getTextRange().end()) {
             lbInBoundary.add(getTextRange().end());
         }
@@ -235,7 +241,10 @@ public class AtomicTextBlock implements TextBlock {
 
     private List<Integer> getAllLineBreaksInBoundary(TextRange textRange) {
 
-        return getLineBreaks().stream().map(linebreak -> linebreak + this.textRange.start()).filter(textRange::contains).toList();
+        return getLineBreaks().stream()
+                .map(linebreak -> linebreak + this.textRange.start())
+                .filter(textRange::contains)
+                .toList();
     }
 
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/textblock/ConcatenatedTextBlock.java

@@ -44,7 +44,8 @@ public class ConcatenatedTextBlock implements TextBlock {
         this.atomicTextBlocks.add(firstTextBlock);
         textRange = new TextRange(firstTextBlock.getTextRange().start(), firstTextBlock.getTextRange().end());
 
-        atomicTextBlocks.subList(1, atomicTextBlocks.size()).forEach(this::concat);
+        atomicTextBlocks.subList(1, atomicTextBlocks.size())
+                .forEach(this::concat);
     }
 
 
@@ -65,7 +66,10 @@ public class ConcatenatedTextBlock implements TextBlock {
 
     private AtomicTextBlock getAtomicTextBlockByStringIndex(int stringIdx) {
 
-        return atomicTextBlocks.stream().filter(textBlock -> textBlock.getTextRange().contains(stringIdx)).findAny().orElseThrow(IndexOutOfBoundsException::new);
+        return atomicTextBlocks.stream()
+                .filter(textBlock -> textBlock.getTextRange().contains(stringIdx))
+                .findAny()
+                .orElseThrow(IndexOutOfBoundsException::new);
     }
 
 
@@ -99,14 +103,18 @@ public class ConcatenatedTextBlock implements TextBlock {
     @Override
     public List<String> getWords() {
 
-        return atomicTextBlocks.stream().map(AtomicTextBlock::getWords).flatMap(Collection::stream).toList();
+        return atomicTextBlocks.stream()
+                .map(AtomicTextBlock::getWords)
+                .flatMap(Collection::stream)
+                .toList();
     }
 
 
     @Override
     public int numberOfLines() {
 
-        return atomicTextBlocks.stream().mapToInt(AtomicTextBlock::numberOfLines).sum();
+        return atomicTextBlocks.stream()
+                .mapToInt(AtomicTextBlock::numberOfLines).sum();
     }
 
 
@@ -127,7 +135,10 @@ public class ConcatenatedTextBlock implements TextBlock {
     @Override
     public List<Integer> getLineBreaks() {
 
-        return getAtomicTextBlocks().stream().flatMap(atomicTextBlock -> atomicTextBlock.getLineBreaks().stream()).toList();
+        return getAtomicTextBlocks().stream()
+                .flatMap(atomicTextBlock -> atomicTextBlock.getLineBreaks()
+                        .stream())
+                .toList();
     }
 
 
@@ -202,7 +213,8 @@ public class ConcatenatedTextBlock implements TextBlock {
 
         AtomicTextBlock lastTextBlock = textBlocks.get(textBlocks.size() - 1);
         rectanglesPerLinePerPage = mergeEntityPositionsWithSamePageNode(rectanglesPerLinePerPage,
-                lastTextBlock.getPositionsPerPage(new TextRange(lastTextBlock.getTextRange().start(), stringTextRange.end())));
+                                                                        lastTextBlock.getPositionsPerPage(new TextRange(lastTextBlock.getTextRange().start(),
+                                                                                                                        stringTextRange.end())));
 
         return rectanglesPerLinePerPage;
     }
@@ -239,7 +251,10 @@ public class ConcatenatedTextBlock implements TextBlock {
     private Map<Page, List<Rectangle2D>> mergeEntityPositionsWithSamePageNode(Map<Page, List<Rectangle2D>> map1, Map<Page, List<Rectangle2D>> map2) {
 
         Map<Page, List<Rectangle2D>> mergedMap = new HashMap<>(map1);
-        map2.forEach((pageNode, rectangles) -> mergedMap.merge(pageNode, rectangles, (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).toList()));
+        map2.forEach((pageNode, rectangles) -> mergedMap.merge(pageNode,
+                                                               rectangles,
+                                                               (l1, l2) -> Stream.concat(l1.stream(), l2.stream())
+                                                                       .toList()));
         return mergedMap;
     }
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/model/document/textblock/TextBlock.java

@@ -18,8 +18,10 @@ public interface TextBlock extends CharSequence {
 
     String getSearchText();
 
+
     List<String> getWords();
 
+
     List<AtomicTextBlock> getAtomicTextBlocks();
 
 
@@ -35,7 +37,6 @@ public interface TextBlock extends CharSequence {
     TextRange getLineTextRange(int lineNumber);
 
 
-
     List<Integer> getLineBreaks();
 
 
@@ -71,6 +72,7 @@ public interface TextBlock extends CharSequence {
         return RectangleTransformations.rectangle2DBBox(getLinePositions(lineNumber));
     }
 
+
     default String searchTextWithLineBreaks() {
 
         return subSequenceWithLineBreaks(getTextRange());
@@ -85,7 +87,9 @@ public interface TextBlock extends CharSequence {
 
     default Set<Page> getPages() {
 
-        return getAtomicTextBlocks().stream().map(AtomicTextBlock::getPage).collect(Collectors.toUnmodifiableSet());
+        return getAtomicTextBlocks().stream()
+                .map(AtomicTextBlock::getPage)
+                .collect(Collectors.toUnmodifiableSet());
     }
 
 

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

@@ -9,7 +9,8 @@ public record RuleClass(RuleType ruleType, List<RuleUnit> ruleUnits) {
     public Optional<RuleUnit> findRuleUnitByInteger(Integer unit) {
 
         return ruleUnits.stream()
-                .filter(ruleUnit -> Objects.equals(ruleUnit.unit(), unit)).findFirst();
+                .filter(ruleUnit -> Objects.equals(ruleUnit.unit(), unit))
+                .findFirst();
     }
 
 }

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

@@ -10,7 +10,7 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+import com.iqser.red.service.redaction.v1.model.DroolsValidation;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -32,18 +32,22 @@ public final class RuleFileBluePrint {
     int globalsLine;
     List<BasicQuery> queries;
     List<RuleClass> ruleClasses;
-    DroolsSyntaxValidation droolsSyntaxValidation;
+    DroolsValidation droolsValidation;
 
 
     public Optional<RuleClass> findRuleClassByType(RuleType ruleType) {
 
-        return ruleClasses.stream().filter(ruleClass -> Objects.equals(ruleClass.ruleType(), ruleType)).findFirst();
+        return ruleClasses.stream()
+                .filter(ruleClass -> Objects.equals(ruleClass.ruleType(), ruleType))
+                .findFirst();
     }
 
 
     public Set<String> getImportSplitByKeyword() {
 
-        return Arrays.stream(imports.replaceAll("\n", "").split("import")).map(String::trim).collect(Collectors.toSet());
+        return Arrays.stream(imports.replaceAll("\n", "").split("import"))
+                .map(String::trim)
+                .collect(Collectors.toSet());
     }
 
 
@@ -53,11 +57,15 @@ public final class RuleFileBluePrint {
             return findRuleClassByType(ruleIdentifier.type()).map(RuleClass::ruleUnits)
                     .orElse(Collections.emptyList())
                     .stream()
-                    .flatMap(ruleUnit -> ruleUnit.rules().stream().filter(rule -> rule.getIdentifier().matches(ruleIdentifier)))
+                    .flatMap(ruleUnit -> ruleUnit.rules()
+                            .stream()
+                            .filter(rule -> rule.getIdentifier().matches(ruleIdentifier)))
                     .toList();
         }
         return findRuleClassByType(ruleIdentifier.type()).flatMap(ruleClass -> ruleClass.findRuleUnitByInteger(ruleIdentifier.unit()))
-                .map(ruleUnit -> ruleUnit.rules().stream().filter(rule -> rule.getIdentifier().matches(ruleIdentifier)))
+                .map(ruleUnit -> ruleUnit.rules()
+                        .stream()
+                        .filter(rule -> rule.getIdentifier().matches(ruleIdentifier)))
                 .orElse(Stream.empty())
                 .toList();
     }
@@ -65,13 +73,18 @@ public final class RuleFileBluePrint {
 
     public List<RuleIdentifier> getAllRuleIdentifiers() {
 
-        return streamAllRules().map(BasicRule::getIdentifier).collect(Collectors.toList());
+        return streamAllRules().map(BasicRule::getIdentifier)
+                .collect(Collectors.toList());
     }
 
 
     public Stream<BasicRule> streamAllRules() {
 
-        return getRuleClasses().stream().map(RuleClass::ruleUnits).flatMap(Collection::stream).map(RuleUnit::rules).flatMap(Collection::stream);
+        return getRuleClasses().stream()
+                .map(RuleClass::ruleUnits)
+                .flatMap(Collection::stream)
+                .map(RuleUnit::rules)
+                .flatMap(Collection::stream);
     }
 
 

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

@@ -42,8 +42,8 @@ public record RuleIdentifier(@NonNull RuleType type, Integer unit, Integer id) {
     public boolean matches(RuleIdentifier ruleIdentifier) {
 
         return ruleIdentifier.type().equals(this.type()) && //
-                (Objects.isNull(ruleIdentifier.unit()) || Objects.isNull(this.unit()) || Objects.equals(this.unit(), ruleIdentifier.unit())) && //
-                (Objects.isNull(ruleIdentifier.id()) || Objects.isNull(this.id()) || Objects.equals(this.id(), ruleIdentifier.id()));
+               (Objects.isNull(ruleIdentifier.unit()) || Objects.isNull(this.unit()) || Objects.equals(this.unit(), ruleIdentifier.unit())) && //
+               (Objects.isNull(ruleIdentifier.id()) || Objects.isNull(this.id()) || Objects.equals(this.id(), ruleIdentifier.id()));
 
     }
 

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

@@ -70,6 +70,7 @@ public class MessagingConfiguration {
                 .build();
     }
 
+
     @Bean
     public Queue redactionAnalysisResponseQueue() {
 

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

@@ -51,14 +51,14 @@ public class RedactionMessageReceiver {
         // This prevents from endless retries oom errors.
         if (message.getMessageProperties().isRedelivered()) {
             var errorMessage = format("Error during last processing of request with dossierId: %s and fileId: %s, do not retry.",
-                    analyzeRequest.getDossierId(),
-                    analyzeRequest.getFileId());
+                                      analyzeRequest.getDossierId(),
+                                      analyzeRequest.getFileId());
             fileStatusProcessingUpdateClient.analysisFailed(analyzeRequest.getDossierId(),
-                    analyzeRequest.getFileId(),
-                    new FileErrorInfo(errorMessage,
-                            priority ? REDACTION_PRIORITY_QUEUE : REDACTION_QUEUE,
-                            "redaction-service",
-                            OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS)));
+                                                            analyzeRequest.getFileId(),
+                                                            new FileErrorInfo(errorMessage,
+                                                                              priority ? REDACTION_PRIORITY_QUEUE : REDACTION_QUEUE,
+                                                                              "redaction-service",
+                                                                              OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS)));
             throw new AmqpRejectAndDontRequeueException(errorMessage);
         }
 
@@ -84,9 +84,9 @@ public class RedactionMessageReceiver {
                     log.debug(analyzeRequest.getManualRedactions().toString());
                     result = analyzeService.analyze(analyzeRequest);
                     log.info("Successfully analyzed dossier {} file {} took: {} s",
-                            analyzeRequest.getDossierId(),
-                            analyzeRequest.getFileId(),
-                            format("%.2f", result.getDuration() / 1000.0));
+                             analyzeRequest.getDossierId(),
+                             analyzeRequest.getFileId(),
+                             format("%.2f", result.getDuration() / 1000.0));
                     log.info("----------------------------------------------------------------------------------");
                     break;
 
@@ -96,9 +96,9 @@ public class RedactionMessageReceiver {
                     log.debug(analyzeRequest.getManualRedactions().toString());
                     result = analyzeService.reanalyze(analyzeRequest);
                     log.info("Successfully reanalyzed dossier {} file {} took: {} s",
-                            analyzeRequest.getDossierId(),
-                            analyzeRequest.getFileId(),
-                            format("%.2f", result.getDuration() / 1000.0));
+                             analyzeRequest.getDossierId(),
+                             analyzeRequest.getFileId(),
+                             format("%.2f", result.getDuration() / 1000.0));
                     log.info("----------------------------------------------------------------------------------");
                     break;
                 case SURROUNDING_TEXT_ANALYSIS:
@@ -106,9 +106,7 @@ public class RedactionMessageReceiver {
                     log.info("Starting Surrounding Text Analysis for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
                     log.debug(analyzeRequest.getManualRedactions().toString());
                     unprocessedChangesService.analyseSurroundingText(analyzeRequest);
-                    log.info("Successful Surrounding Text Analysis dossier {} file {} ",
-                            analyzeRequest.getDossierId(),
-                            analyzeRequest.getFileId());
+                    log.info("Successful Surrounding Text Analysis dossier {} file {} ", analyzeRequest.getDossierId(), analyzeRequest.getFileId());
                     log.info("-------------------------------------------------------------------------------------------------");
                     shouldRespond = false;
                     break;
@@ -137,8 +135,8 @@ public class RedactionMessageReceiver {
         log.warn("Failed to process analyze request: {}", analyzeRequest, e);
         var timestamp = OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS);
         fileStatusProcessingUpdateClient.analysisFailed(analyzeRequest.getDossierId(),
-                analyzeRequest.getFileId(),
-                new FileErrorInfo(e.getMessage(), priority ? REDACTION_PRIORITY_QUEUE : REDACTION_QUEUE, "redaction-service", timestamp));
+                                                        analyzeRequest.getFileId(),
+                                                        new FileErrorInfo(e.getMessage(), priority ? REDACTION_PRIORITY_QUEUE : REDACTION_QUEUE, "redaction-service", timestamp));
     }
 
 
@@ -153,8 +151,8 @@ public class RedactionMessageReceiver {
         timestamp = timestamp != null ? timestamp : OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS);
         log.info("Failed to process analyze request, errorCause: {}, timestamp: {}", errorCause, timestamp);
         fileStatusProcessingUpdateClient.analysisFailed(analyzeRequest.getDossierId(),
-                analyzeRequest.getFileId(),
-                new FileErrorInfo(errorCause, REDACTION_DQL, "redaction-service", timestamp));
+                                                        analyzeRequest.getFileId(),
+                                                        new FileErrorInfo(errorCause, REDACTION_DQL, "redaction-service", timestamp));
     }
 
 }

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

@@ -23,13 +23,15 @@ public class ComponentLogCreatorService {
     public ComponentLog buildComponentLog(int analysisNumber, List<Component> components, long componentRulesVersion) {
 
         Map<String, List<ComponentLogEntryValue>> map = new HashMap<>();
-        components.stream().sorted(ComponentComparator.first()).forEach(component -> {
-            ComponentLogEntryValue componentLogEntryValue = buildComponentLogEntry(component);
-            map.computeIfAbsent(component.getName(), k -> new ArrayList<>()).add(componentLogEntryValue);
-        });
-        List<ComponentLogEntry> componentLogComponents = map
-                .entrySet()
-                .stream().map(entry -> new ComponentLogEntry(entry.getKey(), entry.getValue()))
+        components.stream()
+                .sorted(ComponentComparator.first())
+                .forEach(component -> {
+                    ComponentLogEntryValue componentLogEntryValue = buildComponentLogEntry(component);
+                    map.computeIfAbsent(component.getName(), k -> new ArrayList<>()).add(componentLogEntryValue);
+                });
+        List<ComponentLogEntry> componentLogComponents = map.entrySet()
+                .stream()
+                .map(entry -> new ComponentLogEntry(entry.getKey(), entry.getValue()))
                 .toList();
         return new ComponentLog(analysisNumber, componentRulesVersion, componentLogComponents);
     }
@@ -38,24 +40,36 @@ public class ComponentLogCreatorService {
     private ComponentLogEntryValue buildComponentLogEntry(Component component) {
 
         return ComponentLogEntryValue.builder()
-                .value(component.getValue()).originalValue(component.getValue())
+                .value(component.getValue())
+                .originalValue(component.getValue())
                 .componentRuleId(component.getMatchedRule().toString())
                 .valueDescription(component.getValueDescription())
-                .componentLogEntityReferences(toComponentEntityReferences(component.getReferences().stream().sorted(EntityComparators.first()).toList()))
+                .componentLogEntityReferences(toComponentEntityReferences(component.getReferences()
+                                                                                  .stream()
+                                                                                  .sorted(EntityComparators.first())
+                                                                                  .toList()))
                 .build();
     }
 
 
     private List<ComponentLogEntityReference> toComponentEntityReferences(List<Entity> references) {
 
-        return references.stream().map(this::toComponentEntityReference).toList();
+        return references.stream()
+                .map(this::toComponentEntityReference)
+                .toList();
     }
 
 
     private ComponentLogEntityReference toComponentEntityReference(Entity entity) {
 
-        return ComponentLogEntityReference.builder().id(entity.getId())
-                .page(entity.getPositions().stream().findFirst().map(Position::getPageNumber).orElse(0)).entityRuleId(entity.getMatchedRule())
+        return ComponentLogEntityReference.builder()
+                .id(entity.getId())
+                .page(entity.getPositions()
+                              .stream()
+                              .findFirst()
+                              .map(Position::getPageNumber)
+                              .orElse(0))
+                .entityRuleId(entity.getMatchedRule())
                 .type(entity.getType())
                 .build();
     }

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

@@ -56,10 +56,11 @@ public class DictionarySearchService {
         searchImplementation.getBoundaries(node.getTextBlock(), node.getTextRange())
                 .stream()
                 .filter(boundary -> entityCreationService.isValidEntityTextRange(node.getTextBlock(), boundary))
-                .forEach(bounds -> entityCreationService.byTextRangeWithEngine(bounds, type, entityType, node, Set.of(Engine.DICTIONARY)).ifPresent(entity -> {
-                    entity.setDictionaryEntry(true);
-                    entity.setDossierDictionaryEntry(isDossierDictionaryEntry);
-                }));
+                .forEach(bounds -> entityCreationService.byTextRangeWithEngine(bounds, type, entityType, node, Set.of(Engine.DICTIONARY))
+                        .ifPresent(entity -> {
+                            entity.setDictionaryEntry(true);
+                            entity.setDossierDictionaryEntry(isDossierDictionaryEntry);
+                        }));
     }
 
 }

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

@@ -106,41 +106,47 @@ public class DictionaryService {
         List<DictionaryModel> dictionaryModels = getDossierTemplateDictionary(dossierTemplateId).getDictionary();
 
         dictionaryModels.forEach(dictionaryModel -> {
-            dictionaryModel.getEntries().forEach(dictionaryEntry -> {
-                if (dictionaryEntry.getVersion() > fromVersion.getDossierTemplateVersion()) {
-                    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()));
-                }
-            });
+            dictionaryModel.getEntries()
+                    .forEach(dictionaryEntry -> {
+                        if (dictionaryEntry.getVersion() > fromVersion.getDossierTemplateVersion()) {
+                            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 (dossierDictionaryExists(dossierId)) {
             dictionaryModels = getDossierDictionary(dossierId).getDictionary();
             dictionaryModels.forEach(dictionaryModel -> {
-                dictionaryModel.getEntries().forEach(dictionaryEntry -> {
-                    if (dictionaryEntry.getVersion() > fromVersion.getDossierVersion()) {
-                        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()));
-                    }
-                });
+                dictionaryModel.getEntries()
+                        .forEach(dictionaryEntry -> {
+                            if (dictionaryEntry.getVersion() > fromVersion.getDossierVersion()) {
+                                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()));
+                            }
+                        });
             });
         }
 
@@ -155,84 +161,120 @@ public class DictionaryService {
             DictionaryRepresentation dictionaryRepresentation = new DictionaryRepresentation();
 
             var typeResponse = dossierId == null ? dictionaryClient.getAllTypesForDossierTemplate(dossierTemplateId, true) : dictionaryClient.getAllTypesForDossier(dossierId,
-                    true);
+                                                                                                                                                                    true);
             if (CollectionUtils.isNotEmpty(typeResponse)) {
 
-                List<DictionaryModel> dictionary = typeResponse.stream().map(t -> {
+                List<DictionaryModel> dictionary = typeResponse.stream()
+                        .map(t -> {
 
-                    Optional<DictionaryModel> optionalOldModel;
-                    if (dossierId == null) {
-                        var representation = getDossierTemplateDictionary(dossierTemplateId);
-                        optionalOldModel = representation != null ? representation.getDictionary()
-                                .stream()
-                                .filter(f -> f.getType().equals(t.getType()))
-                                .findAny() : Optional.empty();
-                    } else {
-                        var representation = getDossierDictionary(dossierId);
-                        optionalOldModel = representation != null ? representation.getDictionary()
-                                .stream()
-                                .filter(f -> f.getType().equals(t.getType()))
-                                .findAny() : Optional.empty();
-                    }
+                            Optional<DictionaryModel> optionalOldModel;
+                            if (dossierId == null) {
+                                var representation = getDossierTemplateDictionary(dossierTemplateId);
+                                optionalOldModel = representation != null ? representation.getDictionary()
+                                        .stream()
+                                        .filter(f -> f.getType().equals(t.getType()))
+                                        .findAny() : Optional.empty();
+                            } else {
+                                var representation = getDossierDictionary(dossierId);
+                                optionalOldModel = representation != null ? representation.getDictionary()
+                                        .stream()
+                                        .filter(f -> f.getType().equals(t.getType()))
+                                        .findAny() : Optional.empty();
+                            }
 
-                    Set<DictionaryEntryModel> entries = new HashSet<>();
-                    Set<DictionaryEntryModel> falsePositives = new HashSet<>();
-                    Set<DictionaryEntryModel> falseRecommendations = new HashSet<>();
+                            Set<DictionaryEntryModel> entries = new HashSet<>();
+                            Set<DictionaryEntryModel> falsePositives = new HashSet<>();
+                            Set<DictionaryEntryModel> falseRecommendations = new HashSet<>();
 
-                    DictionaryEntries newEntries = getEntries(t.getId(), currentVersion);
+                            DictionaryEntries newEntries = getEntries(t.getId(), currentVersion);
 
-                    var newValues = newEntries.getEntries().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
-                    var newFalsePositivesValues = newEntries.getFalsePositives().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
-                    var newFalseRecommendationsValues = newEntries.getFalseRecommendations().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
-
-                    optionalOldModel.ifPresent(oldDictionaryModel -> {
-
-                    });
-                    if (optionalOldModel.isPresent()) {
-                        var oldModel = optionalOldModel.get();
-                        if (oldModel.isCaseInsensitive() && !t.isCaseInsensitive()) {
-                            // add old entries from existing DictionaryModel but exclude lower case representation
-                            entries.addAll(oldModel.getEntries().stream().filter(f -> !newValues.stream().map(s -> s.toLowerCase(Locale.ROOT)).toList().contains(f.getValue())).toList());
-                            falsePositives.addAll(oldModel.getFalsePositives()
+                            var newValues = newEntries.getEntries()
                                     .stream()
-                                    .filter(f -> !newFalsePositivesValues.stream().map(s -> s.toLowerCase(Locale.ROOT)).toList().contains(f.getValue()))
-                                    .toList());
-                            falseRecommendations.addAll(oldModel.getFalseRecommendations()
+                                    .map(DictionaryEntry::getValue)
+                                    .collect(Collectors.toSet());
+                            var newFalsePositivesValues = newEntries.getFalsePositives()
                                     .stream()
-                                    .filter(f -> !newFalseRecommendationsValues.stream().map(s -> s.toLowerCase(Locale.ROOT)).toList().contains(f.getValue()))
-                                    .toList());
-                        } else if (!oldModel.isCaseInsensitive() && t.isCaseInsensitive()) {
-                            // add old entries from existing DictionaryModel but exclude upper case representation
-                            entries.addAll(oldModel.getEntries().stream().filter(f -> !newValues.contains(f.getValue().toLowerCase(Locale.ROOT))).toList());
-                            falsePositives.addAll(oldModel.getFalsePositives().stream().filter(f -> !newFalsePositivesValues.contains(f.getValue().toLowerCase(Locale.ROOT))).toList());
-                            falseRecommendations.addAll(oldModel.getFalseRecommendations()
+                                    .map(DictionaryEntry::getValue)
+                                    .collect(Collectors.toSet());
+                            var newFalseRecommendationsValues = newEntries.getFalseRecommendations()
                                     .stream()
-                                    .filter(f -> !newFalseRecommendationsValues.contains(f.getValue().toLowerCase(Locale.ROOT)))
-                                    .toList());
+                                    .map(DictionaryEntry::getValue)
+                                    .collect(Collectors.toSet());
 
-                        } else {
-                            // add old entries from existing DictionaryModel
-                            entries.addAll(oldModel.getEntries().stream().filter(f -> !newValues.contains(f.getValue())).toList());
-                            falsePositives.addAll(oldModel.getFalsePositives().stream().filter(f -> !newFalsePositivesValues.contains(f.getValue())).toList());
-                            falseRecommendations.addAll(oldModel.getFalseRecommendations().stream().filter(f -> !newFalseRecommendationsValues.contains(f.getValue())).toList());
-                        }
-                    }
+                            optionalOldModel.ifPresent(oldDictionaryModel -> {
 
-                    // Add Increments
-                    entries.addAll(newEntries.getEntries());
-                    falsePositives.addAll(newEntries.getFalsePositives());
-                    falseRecommendations.addAll(newEntries.getFalseRecommendations());
+                            });
+                            if (optionalOldModel.isPresent()) {
+                                var oldModel = optionalOldModel.get();
+                                if (oldModel.isCaseInsensitive() && !t.isCaseInsensitive()) {
+                                    // add old entries from existing DictionaryModel but exclude lower case representation
+                                    entries.addAll(oldModel.getEntries()
+                                                           .stream()
+                                                           .filter(f -> !newValues.stream()
+                                                                   .map(s -> s.toLowerCase(Locale.ROOT))
+                                                                   .toList().contains(f.getValue()))
+                                                           .toList());
+                                    falsePositives.addAll(oldModel.getFalsePositives()
+                                                                  .stream()
+                                                                  .filter(f -> !newFalsePositivesValues.stream()
+                                                                          .map(s -> s.toLowerCase(Locale.ROOT))
+                                                                          .toList().contains(f.getValue()))
+                                                                  .toList());
+                                    falseRecommendations.addAll(oldModel.getFalseRecommendations()
+                                                                        .stream()
+                                                                        .filter(f -> !newFalseRecommendationsValues.stream()
+                                                                                .map(s -> s.toLowerCase(Locale.ROOT))
+                                                                                .toList().contains(f.getValue()))
+                                                                        .toList());
+                                } else if (!oldModel.isCaseInsensitive() && t.isCaseInsensitive()) {
+                                    // add old entries from existing DictionaryModel but exclude upper case representation
+                                    entries.addAll(oldModel.getEntries()
+                                                           .stream()
+                                                           .filter(f -> !newValues.contains(f.getValue().toLowerCase(Locale.ROOT)))
+                                                           .toList());
+                                    falsePositives.addAll(oldModel.getFalsePositives()
+                                                                  .stream()
+                                                                  .filter(f -> !newFalsePositivesValues.contains(f.getValue().toLowerCase(Locale.ROOT)))
+                                                                  .toList());
+                                    falseRecommendations.addAll(oldModel.getFalseRecommendations()
+                                                                        .stream()
+                                                                        .filter(f -> !newFalseRecommendationsValues.contains(f.getValue().toLowerCase(Locale.ROOT)))
+                                                                        .toList());
 
-                    return new DictionaryModel(t.getType(),
-                            t.getRank(),
-                            convertColor(t.getHexColor()),
-                            t.isCaseInsensitive(),
-                            t.isHint(),
-                            entries,
-                            falsePositives,
-                            falseRecommendations,
-                            dossierId != null);
-                }).sorted(Comparator.comparingInt(DictionaryModel::getRank).reversed()).collect(Collectors.toList());
+                                } else {
+                                    // add old entries from existing DictionaryModel
+                                    entries.addAll(oldModel.getEntries()
+                                                           .stream()
+                                                           .filter(f -> !newValues.contains(f.getValue()))
+                                                           .toList());
+                                    falsePositives.addAll(oldModel.getFalsePositives()
+                                                                  .stream()
+                                                                  .filter(f -> !newFalsePositivesValues.contains(f.getValue()))
+                                                                  .toList());
+                                    falseRecommendations.addAll(oldModel.getFalseRecommendations()
+                                                                        .stream()
+                                                                        .filter(f -> !newFalseRecommendationsValues.contains(f.getValue()))
+                                                                        .toList());
+                                }
+                            }
+
+                            // Add Increments
+                            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(),
+                                                       entries,
+                                                       falsePositives,
+                                                       falseRecommendations,
+                                                       dossierId != null);
+                        })
+                        .sorted(Comparator.comparingInt(DictionaryModel::getRank).reversed())
+                        .collect(Collectors.toList());
 
                 dictionary.forEach(dm -> dictionaryRepresentation.getLocalAccessMap().put(dm.getType(), dm));
 
@@ -264,17 +306,17 @@ public class DictionaryService {
         var type = dictionaryClient.getDictionaryForType(typeId, fromVersion);
 
         Set<DictionaryEntryModel> entries = type.getEntries() != null ? new HashSet<>(type.getEntries()
-                .stream()
-                .map(DictionaryEntryModel::new)
-                .collect(Collectors.toSet())) : new HashSet<>();
+                                                                                              .stream()
+                                                                                              .map(DictionaryEntryModel::new)
+                                                                                              .collect(Collectors.toSet())) : new HashSet<>();
         Set<DictionaryEntryModel> falsePositives = type.getFalsePositiveEntries() != null ? new HashSet<>(type.getFalsePositiveEntries()
-                .stream()
-                .map(DictionaryEntryModel::new)
-                .collect(Collectors.toSet())) : new HashSet<>();
+                                                                                                                  .stream()
+                                                                                                                  .map(DictionaryEntryModel::new)
+                                                                                                                  .collect(Collectors.toSet())) : new HashSet<>();
         Set<DictionaryEntryModel> falseRecommendations = type.getFalseRecommendationEntries() != null ? new HashSet<>(type.getFalseRecommendationEntries()
-                .stream()
-                .map(DictionaryEntryModel::new)
-                .collect(Collectors.toSet())) : new HashSet<>();
+                                                                                                                              .stream()
+                                                                                                                              .map(DictionaryEntryModel::new)
+                                                                                                                              .collect(Collectors.toSet())) : new HashSet<>();
 
         if (type.isCaseInsensitive()) {
             entries.forEach(entry -> entry.setValue(entry.getValue().toLowerCase(Locale.ROOT)));
@@ -282,10 +324,10 @@ public class DictionaryService {
             falseRecommendations.forEach(entry -> entry.setValue(entry.getValue().toLowerCase(Locale.ROOT)));
         }
         log.debug("Dictionary update returned {} entries {} falsePositives and {} falseRecommendations for type {}",
-                entries.size(),
-                falsePositives.size(),
-                falseRecommendations.size(),
-                typeId);
+                  entries.size(),
+                  falsePositives.size(),
+                  falseRecommendations.size(),
+                  typeId);
         return new DictionaryEntries(entries, falsePositives, falseRecommendations);
     }
 
@@ -300,7 +342,8 @@ public class DictionaryService {
     @SneakyThrows
     public float[] getColor(String type, String dossierTemplateId) {
 
-        DictionaryModel model = getDossierTemplateDictionary(dossierTemplateId).getLocalAccessMap().get(type);
+        DictionaryModel model = getDossierTemplateDictionary(dossierTemplateId).getLocalAccessMap()
+                .get(type);
         if (model != null) {
             return model.getColor();
         }
@@ -311,7 +354,8 @@ public class DictionaryService {
     @SneakyThrows
     public boolean isHint(String type, String dossierTemplateId) {
 
-        DictionaryModel model = getDossierTemplateDictionary(dossierTemplateId).getLocalAccessMap().get(type);
+        DictionaryModel model = getDossierTemplateDictionary(dossierTemplateId).getLocalAccessMap()
+                .get(type);
         if (model != null) {
             return model.isHint();
         }
@@ -335,15 +379,20 @@ public class DictionaryService {
             var dossierRepresentation = getDossierDictionary(dossierId);
             var dossierDictionaries = dossierRepresentation.getDictionary();
             mergedDictionaries = convertCommonsDictionaryModel(dictionaryMergeService.getMergedDictionary(convertDictionaryModel(dossierTemplateDictionaries),
-                    convertDictionaryModel(dossierDictionaries)));
+                                                                                                          convertDictionaryModel(dossierDictionaries)));
             dossierDictionaryVersion = dossierRepresentation.getDictionaryVersion();
         } else {
             mergedDictionaries = new ArrayList<>();
             dossierTemplateDictionaries.forEach(dm -> mergedDictionaries.add(SerializationUtils.clone(dm)));
         }
 
-        return new Dictionary(mergedDictionaries.stream().sorted(Comparator.comparingInt(DictionaryModel::getRank).reversed()).collect(Collectors.toList()),
-                DictionaryVersion.builder().dossierTemplateVersion(dossierTemplateRepresentation.getDictionaryVersion()).dossierVersion(dossierDictionaryVersion).build());
+        return new Dictionary(mergedDictionaries.stream()
+                                      .sorted(Comparator.comparingInt(DictionaryModel::getRank).reversed())
+                                      .collect(Collectors.toList()),
+                              DictionaryVersion.builder()
+                                      .dossierTemplateVersion(dossierTemplateRepresentation.getDictionaryVersion())
+                                      .dossierVersion(dossierDictionaryVersion)
+                                      .build());
     }
 
 
@@ -371,14 +420,16 @@ public class DictionaryService {
     @SneakyThrows
     private DictionaryRepresentation getDossierTemplateDictionary(String dossierTemplateId) {
 
-        return tenantDictionaryCache.get(TenantContext.getTenantId()).getDictionariesByDossierTemplate().get(dossierTemplateId);
+        return tenantDictionaryCache.get(TenantContext.getTenantId()).getDictionariesByDossierTemplate()
+                .get(dossierTemplateId);
     }
 
 
     @SneakyThrows
     private DictionaryRepresentation getDossierDictionary(String dossierId) {
 
-        return tenantDictionaryCache.get(TenantContext.getTenantId()).getDictionariesByDossier().get(dossierId);
+        return tenantDictionaryCache.get(TenantContext.getTenantId()).getDictionariesByDossier()
+                .get(dossierId);
     }
 
 
@@ -421,14 +472,14 @@ public class DictionaryService {
 
         return commonsDictionaries.stream()
                 .map(cd -> new DictionaryModel(cd.getType(),
-                        cd.getRank(),
-                        cd.getColor(),
-                        cd.isCaseInsensitive(),
-                        cd.isHint(),
-                        cd.getEntries(),
-                        cd.getFalsePositives(),
-                        cd.getFalseRecommendations(),
-                        cd.isDossierDictionary()))
+                                               cd.getRank(),
+                                               cd.getColor(),
+                                               cd.isCaseInsensitive(),
+                                               cd.isHint(),
+                                               cd.getEntries(),
+                                               cd.getFalsePositives(),
+                                               cd.getFalseRecommendations(),
+                                               cd.isDossierDictionary()))
                 .collect(Collectors.toList());
     }
 

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

@@ -30,7 +30,7 @@ import lombok.extern.slf4j.Slf4j;
 public class EntityChangeLogService {
 
     @Timed("redactmanager_computeChanges")
-    public boolean computeChanges(List<EntityLogEntry> previousEntityLogEntries, List<EntityLogEntry> newEntityLogEntries, ManualRedactions manualRedactions, int analysisNumber) {
+    public boolean computeChanges(List<EntityLogEntry> previousEntityLogEntries, List<EntityLogEntry> newEntityLogEntries, int analysisNumber) {
 
         var now = OffsetDateTime.now();
         if (previousEntityLogEntries.isEmpty()) {
@@ -58,50 +58,25 @@ public class EntityChangeLogService {
                 entityLogEntry.getChanges().add(new Change(analysisNumber, changeType, now));
             }
         }
-        addRemovedEntriesAsRemoved(previousEntityLogEntries, newEntityLogEntries, manualRedactions, analysisNumber, now);
+        addRemovedEntriesAsRemoved(previousEntityLogEntries, newEntityLogEntries, analysisNumber, now);
         return hasChanges;
     }
 
 
-    private void addRemovedEntriesAsRemoved(List<EntityLogEntry> previousEntityLogEntries,
-                                            List<EntityLogEntry> newEntityLogEntries,
-                                            ManualRedactions manualRedactions,
-                                            int analysisNumber,
-                                            OffsetDateTime now) {
+    private void addRemovedEntriesAsRemoved(List<EntityLogEntry> previousEntityLogEntries, List<EntityLogEntry> newEntityLogEntries, int analysisNumber, OffsetDateTime now) {
 
         Set<String> existingIds = newEntityLogEntries.stream()
                 .map(EntityLogEntry::getId)
                 .collect(Collectors.toSet());
         List<EntityLogEntry> removedEntries = previousEntityLogEntries.stream()
                 .filter(entry -> !existingIds.contains(entry.getId()))
-                .collect(Collectors.toList());
-        List<EntityLogEntry> removedDossierRedaction = removedEntries.stream()
-                .filter(e -> e.getState() == EntryState.REMOVED && e.getType().equals("dossier_redaction"))
                 .toList();
-        previousEntityLogEntries.removeAll(removedDossierRedaction);
-        removedEntries.removeAll(removedDossierRedaction);
         removedEntries.forEach(entry -> entry.getChanges().add(new Change(analysisNumber, ChangeType.REMOVED, now)));
         removedEntries.forEach(entry -> entry.setState(EntryState.REMOVED));
-        removedEntries.forEach(entry -> addManualChangeForDictionaryRemovals(entry, manualRedactions));
         newEntityLogEntries.addAll(removedEntries);
     }
 
 
-    private void addManualChangeForDictionaryRemovals(EntityLogEntry entry, ManualRedactions manualRedactions) {
-
-        if (manualRedactions == null || manualRedactions.getIdsToRemove().isEmpty()) {
-            return;
-        }
-
-        manualRedactions.getIdsToRemove()
-                .stream()
-                .filter(IdRemoval::isRemoveFromDictionary)//
-                .filter(removed -> removed.getAnnotationId().equals(entry.getId()))//
-                .findFirst()//
-                .ifPresent(idRemove -> entry.getManualChanges().add(ManualChangeFactory.toManualChange(idRemove, false)));
-    }
-
-
     private ChangeType calculateChangeType(EntryState state, EntryState previousState) {
 
         if (state.equals(previousState)) {

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

@@ -70,7 +70,7 @@ public class EntityLogCreatorService {
 
         List<EntityLogEntry> previousExistingEntityLogEntries = getPreviousEntityLogEntries(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
 
-        entityChangeLogService.computeChanges(previousExistingEntityLogEntries, entityLogEntries, analyzeRequest.getManualRedactions(), analyzeRequest.getAnalysisNumber());
+        entityChangeLogService.computeChanges(previousExistingEntityLogEntries, entityLogEntries, analyzeRequest.getAnalysisNumber());
 
         return new EntityLog(redactionServiceSettings.getAnalysisVersion(),
                              analyzeRequest.getAnalysisNumber(),
@@ -128,10 +128,8 @@ public class EntityLogCreatorService {
                 .collect(Collectors.toList());
         previousEntityLog.getEntityLogEntry().removeAll(previousEntriesFromReAnalyzedSections);
 
-        boolean hasChanges = entityChangeLogService.computeChanges(previousEntriesFromReAnalyzedSections,
-                                                                   newEntityLogEntries,
-                                                                   analyzeRequest.getManualRedactions(),
-                                                                   analyzeRequest.getAnalysisNumber());
+        boolean hasChanges = entityChangeLogService.computeChanges(previousEntriesFromReAnalyzedSections, newEntityLogEntries, analyzeRequest.getAnalysisNumber());
+
         previousEntityLog.getEntityLogEntry().addAll(newEntityLogEntries);
 
         return updateVersionsAndReturnChanges(previousEntityLog, dictionaryVersion, analyzeRequest, hasChanges);

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

@@ -74,9 +74,9 @@ public class ManualChangesApplicationService {
                 .orElseThrow(() -> new NoSuchElementException("No redaction position with matching annotation id found!"));
 
         positionOnPageToBeResized.setRectanglePerLine(manualResizeRedaction.getPositions()
-                .stream()
-                .map(ManualChangesApplicationService::toRectangle2D)
-                .collect(Collectors.toList()));
+                                                              .stream()
+                                                              .map(ManualChangesApplicationService::toRectangle2D)
+                                                              .collect(Collectors.toList()));
 
         entityToBeResized.getManualOverwrite().addChange(manualResizeRedaction);
 
@@ -90,11 +90,17 @@ public class ManualChangesApplicationService {
 
             if (closestEntity.isPresent()) {
                 copyValuesFromClosestEntity(entityToBeResized, manualResizeRedaction, closestEntity.get());
-                possibleEntities.values().stream().flatMap(Collection::stream).forEach(TextEntity::removeFromGraph);
+                possibleEntities.values()
+                        .stream()
+                        .flatMap(Collection::stream)
+                        .forEach(TextEntity::removeFromGraph);
                 return;
             }
 
-            possibleEntities.values().stream().flatMap(Collection::stream).forEach(TextEntity::removeFromGraph);
+            possibleEntities.values()
+                    .stream()
+                    .flatMap(Collection::stream)
+                    .forEach(TextEntity::removeFromGraph);
 
             if (node.hasParent()) {
                 node = node.getParent();
@@ -110,14 +116,18 @@ public class ManualChangesApplicationService {
         Set<SemanticNode> currentIntersectingNodes = new HashSet<>(entityToBeResized.getIntersectingNodes());
         Set<SemanticNode> newIntersectingNodes = new HashSet<>(closestEntity.getIntersectingNodes());
 
-        Sets.difference(currentIntersectingNodes, newIntersectingNodes).forEach(removedNode -> removedNode.getEntities().remove(entityToBeResized));
-        Sets.difference(newIntersectingNodes, currentIntersectingNodes).forEach(addedNode -> addedNode.getEntities().add(entityToBeResized));
+        Sets.difference(currentIntersectingNodes, newIntersectingNodes)
+                .forEach(removedNode -> removedNode.getEntities().remove(entityToBeResized));
+        Sets.difference(newIntersectingNodes, currentIntersectingNodes)
+                .forEach(addedNode -> addedNode.getEntities().add(entityToBeResized));
 
         Set<Page> currentIntersectingPages = new HashSet<>(entityToBeResized.getPages());
         Set<Page> newIntersectingPages = new HashSet<>(closestEntity.getPages());
 
-        Sets.difference(currentIntersectingPages, newIntersectingPages).forEach(removedPage -> removedPage.getEntities().remove(entityToBeResized));
-        Sets.difference(newIntersectingPages, currentIntersectingPages).forEach(addedPage -> addedPage.getEntities().add(entityToBeResized));
+        Sets.difference(currentIntersectingPages, newIntersectingPages)
+                .forEach(removedPage -> removedPage.getEntities().remove(entityToBeResized));
+        Sets.difference(newIntersectingPages, currentIntersectingPages)
+                .forEach(addedPage -> addedPage.getEntities().add(entityToBeResized));
 
         entityToBeResized.setDeepestFullyContainingNode(closestEntity.getDeepestFullyContainingNode());
         entityToBeResized.setIntersectingNodes(new ArrayList<>(newIntersectingNodes));
@@ -135,7 +145,10 @@ public class ManualChangesApplicationService {
         if (manualResizeRedaction.getPositions().isEmpty() || manualResizeRedaction.getPositions() == null) {
             return;
         }
-        var bBox = RectangleTransformations.rectangle2DBBox(manualResizeRedaction.getPositions().stream().map(ManualChangesApplicationService::toRectangle2D).toList());
+        var bBox = RectangleTransformations.rectangle2DBBox(manualResizeRedaction.getPositions()
+                                                                    .stream()
+                                                                    .map(ManualChangesApplicationService::toRectangle2D)
+                                                                    .toList());
         image.setPosition(bBox);
         image.getManualOverwrite().addChange(manualResizeRedaction);
     }

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

@@ -53,10 +53,13 @@ public class NotFoundImportedEntitiesService {
         if (!notFoundEntities.isEmpty()) {
             // imported redactions present, intersections must be added with merged imported redactions
             Map<Integer, List<PrecursorEntity>> importedRedactionsMap = mapImportedRedactionsOnPage(notFoundEntities);
-            entityLog.getEntityLogEntry().stream().filter(entry -> !entry.getEngines().contains(Engine.IMPORTED)).forEach(redactionLogEntry -> {
-                redactionLogEntry.setImportedRedactionIntersections(new HashSet<>());
-                addIntersections(redactionLogEntry, importedRedactionsMap, analysisNumber);
-            });
+            entityLog.getEntityLogEntry()
+                    .stream()
+                    .filter(entry -> !entry.getEngines().contains(Engine.IMPORTED))
+                    .forEach(redactionLogEntry -> {
+                        redactionLogEntry.setImportedRedactionIntersections(new HashSet<>());
+                        addIntersections(redactionLogEntry, importedRedactionsMap, analysisNumber);
+                    });
         }
     }
 
@@ -70,7 +73,10 @@ public class NotFoundImportedEntitiesService {
                 .map(RectangleWithPage::pageNumber)
                 .collect(Collectors.toSet());
         pageNumbers.forEach(pageNumber -> importedRedactionsMap.put(pageNumber,
-                importedEntities.stream().filter(i -> pageNumber == i.getEntityPosition().get(0).pageNumber()).collect(Collectors.toList())));
+                                                                    importedEntities.stream()
+                                                                            .filter(i -> pageNumber == i.getEntityPosition()
+                                                                                    .get(0).pageNumber())
+                                                                            .collect(Collectors.toList())));
         return importedRedactionsMap;
     }
 

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

@@ -15,8 +15,12 @@ public class ComponentComparator implements Comparator<Component> {
     @Override
     public int compare(Component component1, Component component2) {
 
-        var firstEntity1 = component1.getReferences().stream().min(EntityComparators.first());
-        var firstEntity2 = component2.getReferences().stream().min(EntityComparators.first());
+        var firstEntity1 = component1.getReferences()
+                .stream()
+                .min(EntityComparators.first());
+        var firstEntity2 = component2.getReferences()
+                .stream()
+                .min(EntityComparators.first());
         if (firstEntity1.isEmpty() && firstEntity2.isEmpty()) {
             return 0;
         }

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

@@ -40,7 +40,8 @@ public class ComponentCreationService {
 
     private static List<Entity> findEntitiesFromLongestSection(Collection<Entity> entities) {
 
-        var entitiesBySection = entities.stream().collect(Collectors.groupingBy(entity -> entity.getContainingNode().getHighestParent()));
+        var entitiesBySection = entities.stream()
+                .collect(Collectors.groupingBy(entity -> entity.getContainingNode().getHighestParent()));
         Optional<SemanticNode> longestSection = entitiesBySection.entrySet()
                 .stream()
                 .sorted(Comparator.comparingInt(ComponentCreationService::getTotalLengthOfEntities).reversed())
@@ -79,14 +80,20 @@ public class ComponentCreationService {
     public void firstOrElse(String ruleIdentifier, String name, Collection<Entity> entities, String fallback) {
 
         String valueDescription = String.format("First found value of type %s or else '%s'", joinTypes(entities), fallback);
-        String value = entities.stream().min(EntityComparators.first()).map(Entity::getValue).orElse(fallback);
+        String value = entities.stream()
+                .min(EntityComparators.first())
+                .map(Entity::getValue)
+                .orElse(fallback);
         create(ruleIdentifier, name, value, valueDescription, entities);
     }
 
 
     private static String joinTypes(Collection<Entity> entities) {
 
-        return entities.stream().map(Entity::getType).distinct().collect(Collectors.joining(", "));
+        return entities.stream()
+                .map(Entity::getType)
+                .distinct()
+                .collect(Collectors.joining(", "));
     }
 
 
@@ -104,12 +111,12 @@ public class ComponentCreationService {
         referencedEntities.addAll(references);
 
         kieSession.insert(Component.builder()
-                .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
-                .name(name)
-                .value(value)
-                .valueDescription(valueDescription)
-                .references(new LinkedList<>(references))
-                .build());
+                                  .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
+                                  .name(name)
+                                  .value(value)
+                                  .valueDescription(valueDescription)
+                                  .references(new LinkedList<>(references))
+                                  .build());
     }
 
 
@@ -142,8 +149,11 @@ public class ComponentCreationService {
 
     private static List<Entity> findEntitiesFromFirstSection(Collection<Entity> entities) {
 
-        var entitiesBySection = entities.stream().collect(Collectors.groupingBy(entity -> entity.getContainingNode().getHighestParent()));
-        Optional<SemanticNode> firstSection = entitiesBySection.keySet().stream().min(SemanticNodeComparators.first());
+        var entitiesBySection = entities.stream()
+                .collect(Collectors.groupingBy(entity -> entity.getContainingNode().getHighestParent()));
+        Optional<SemanticNode> firstSection = entitiesBySection.keySet()
+                .stream()
+                .min(SemanticNodeComparators.first());
         if (firstSection.isEmpty()) {
             return Collections.emptyList();
         }
@@ -188,7 +198,10 @@ public class ComponentCreationService {
     public void joining(String ruleIdentifier, String name, Collection<Entity> entities, String delimiter) {
 
         String valueDescription = String.format("Joining all values of type %s with '%s'", joinTypes(entities), delimiter);
-        String value = entities.stream().sorted(EntityComparators.first()).map(Entity::getValue).collect(Collectors.joining(delimiter));
+        String value = entities.stream()
+                .sorted(EntityComparators.first())
+                .map(Entity::getValue)
+                .collect(Collectors.joining(delimiter));
         create(ruleIdentifier, name, value, valueDescription, entities);
     }
 
@@ -231,14 +244,20 @@ public class ComponentCreationService {
     public void joiningUnique(String ruleIdentifier, String name, Collection<Entity> entities, String delimiter) {
 
         String valueDescription = String.format("Joining all unique values of type %s with '%s'", joinTypes(entities), delimiter);
-        String value = entities.stream().sorted(EntityComparators.first()).map(Entity::getValue).distinct().collect(Collectors.joining(delimiter));
+        String value = entities.stream()
+                .sorted(EntityComparators.first())
+                .map(Entity::getValue)
+                .distinct()
+                .collect(Collectors.joining(delimiter));
         create(ruleIdentifier, name, value, valueDescription, entities);
     }
 
 
     private static int getTotalLengthOfEntities(Map.Entry<SemanticNode, List<Entity>> entry) {
 
-        return entry.getValue().stream().mapToInt(Entity::getLength).sum();
+        return entry.getValue()
+                .stream()
+                .mapToInt(Entity::getLength).sum();
     }
 
 
@@ -293,7 +312,10 @@ public class ComponentCreationService {
      */
     public void uniqueValueCount(String ruleIdentifier, String name, Collection<Entity> entities) {
 
-        long count = entities.stream().map(Entity::getValue).distinct().count();
+        long count = entities.stream()
+                .map(Entity::getValue)
+                .distinct()
+                .count();
         create(ruleIdentifier, name, String.valueOf(count), "Number of unique values in the entity references", entities);
     }
 
@@ -307,18 +329,20 @@ public class ComponentCreationService {
      */
     public void rowValueCount(String ruleIdentifier, String name, Collection<Entity> entities) {
 
-        entities.stream().collect(Collectors.groupingBy(this::getFirstTable)).forEach((optionalTable, groupedEntities) -> {
+        entities.stream()
+                .collect(Collectors.groupingBy(this::getFirstTable))
+                .forEach((optionalTable, groupedEntities) -> {
 
-            if (optionalTable.isEmpty()) {
-                return;
-            }
+                    if (optionalTable.isEmpty()) {
+                        return;
+                    }
 
-            long count = groupedEntities.stream()
-                    .collect(Collectors.groupingBy(entity -> getFirstTableCell(entity).map(TableCell::getRow).orElse(-1)))
-                    .size();
+                    long count = groupedEntities.stream()
+                            .collect(Collectors.groupingBy(entity -> getFirstTableCell(entity).map(TableCell::getRow)
+                                    .orElse(-1))).size();
 
-            create(ruleIdentifier, name, String.valueOf(count), "Count rows with values in the entity references in same table", entities);
-        });
+                    create(ruleIdentifier, name, String.valueOf(count), "Count rows with values in the entity references in same table", entities);
+                });
     }
 
 
@@ -334,18 +358,20 @@ public class ComponentCreationService {
         if (entities.isEmpty()) {
             return;
         }
-        entities.stream().sorted(EntityComparators.first()).forEach(entity -> {
-            BreakIterator iterator = BreakIterator.getSentenceInstance(Locale.ENGLISH);
-            iterator.setText(entity.getValue());
-            int start = iterator.first();
-            for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
-                create(ruleIdentifier,
-                        name,
-                        entity.getValue().substring(start, end).replaceAll("\\n", "").trim(),
-                        String.format("Values of type '%s' as sentences", entity.getType()),
-                        entity);
-            }
-        });
+        entities.stream()
+                .sorted(EntityComparators.first())
+                .forEach(entity -> {
+                    BreakIterator iterator = BreakIterator.getSentenceInstance(Locale.ENGLISH);
+                    iterator.setText(entity.getValue());
+                    int start = iterator.first();
+                    for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
+                        create(ruleIdentifier,
+                               name,
+                               entity.getValue().substring(start, end).replaceAll("\\n", "").trim(),
+                               String.format("Values of type '%s' as sentences", entity.getType()),
+                               entity);
+                    }
+                });
     }
 
 
@@ -366,12 +392,12 @@ public class ComponentCreationService {
         List<Entity> referenceList = new LinkedList<>();
         referenceList.add(reference);
         kieSession.insert(Component.builder()
-                .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
-                .name(name)
-                .value(value)
-                .valueDescription(valueDescription)
-                .references(referenceList)
-                .build());
+                                  .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
+                                  .name(name)
+                                  .value(value)
+                                  .valueDescription(valueDescription)
+                                  .references(referenceList)
+                                  .build());
     }
 
 
@@ -428,8 +454,10 @@ public class ComponentCreationService {
         }
 
         String formattedDateStrings = Stream.concat(//
-                        dates.stream().sorted().map(date -> DateConverter.convertDate(date, resultFormat)), //
-                        unparsedDates.stream())//
+                                                    dates.stream()
+                                                            .sorted()
+                                                            .map(date -> DateConverter.convertDate(date, resultFormat)), //
+                                                    unparsedDates.stream())//
                 .collect(Collectors.joining(", "));
 
         create(ruleIdentifier, name, formattedDateStrings, valueDescription, entities);
@@ -445,26 +473,34 @@ public class ComponentCreationService {
      */
     public void joiningFromSameTableRow(String ruleIdentifier, String name, Collection<Entity> entities) {
 
-        String types = entities.stream().map(Entity::getType).sorted(Comparator.reverseOrder()).distinct().collect(Collectors.joining(", "));
+        String types = entities.stream()
+                .map(Entity::getType)
+                .sorted(Comparator.reverseOrder())
+                .distinct()
+                .collect(Collectors.joining(", "));
         String valueDescription = String.format("Combine values of %s that are in same table row", types);
-        entities.stream().collect(Collectors.groupingBy(this::getFirstTable)).forEach((optionalTable, groupedEntities) -> {
-            if (optionalTable.isEmpty()) {
-                groupedEntities.forEach(entity -> create(ruleIdentifier, name, entity.getValue(), valueDescription, entity));
-            }
+        entities.stream()
+                .collect(Collectors.groupingBy(this::getFirstTable))
+                .forEach((optionalTable, groupedEntities) -> {
+                    if (optionalTable.isEmpty()) {
+                        groupedEntities.forEach(entity -> create(ruleIdentifier, name, entity.getValue(), valueDescription, entity));
+                    }
 
-            groupedEntities.stream()
-                    .filter(entity -> entity.getContainingNode() instanceof TableCell)
-                    .collect(Collectors.groupingBy(entity -> ((TableCell) entity.getContainingNode()).getRow()))
-                    .entrySet()
-                    .stream()
-                    .sorted(Comparator.comparingInt(Map.Entry::getKey))
-                    .map(Map.Entry::getValue)
-                    .forEach(entitiesInSameRow -> create(ruleIdentifier,
-                            name,
-                            entitiesInSameRow.stream().sorted(EntityComparators.first()).map(Entity::getValue).collect(Collectors.joining(", ")),
-                            valueDescription,
-                            entitiesInSameRow));
-        });
+                    groupedEntities.stream()
+                            .filter(entity -> entity.getContainingNode() instanceof TableCell)
+                            .collect(Collectors.groupingBy(entity -> ((TableCell) entity.getContainingNode()).getRow())).entrySet()
+                            .stream()
+                            .sorted(Comparator.comparingInt(Map.Entry::getKey))
+                            .map(Map.Entry::getValue)
+                            .forEach(entitiesInSameRow -> create(ruleIdentifier,
+                                                                 name,
+                                                                 entitiesInSameRow.stream()
+                                                                         .sorted(EntityComparators.first())
+                                                                         .map(Entity::getValue)
+                                                                         .collect(Collectors.joining(", ")),
+                                                                 valueDescription,
+                                                                 entitiesInSameRow));
+                });
     }
 
 
@@ -521,12 +557,12 @@ public class ComponentCreationService {
     public void create(String ruleIdentifier, String name, String value) {
 
         kieSession.insert(Component.builder()
-                .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
-                .name(name)
-                .value(value)
-                .valueDescription("")
-                .references(Collections.emptyList())
-                .build());
+                                  .matchedRule(RuleIdentifier.fromString(ruleIdentifier))
+                                  .name(name)
+                                  .value(value)
+                                  .valueDescription("")
+                                  .references(Collections.emptyList())
+                                  .build());
     }
 
 }

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

@@ -9,6 +9,7 @@ import java.util.NoSuchElementException;
 import java.util.Set;
 
 import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.DuplicatedParagraph;
 import com.iqser.red.service.redaction.v1.server.model.document.nodes.Footer;
 import com.iqser.red.service.redaction.v1.server.model.document.nodes.Header;
 import com.iqser.red.service.redaction.v1.server.model.document.nodes.Image;
@@ -40,7 +41,9 @@ public class DocumentGraphMapper {
         DocumentTree documentTree = new DocumentTree(document);
         Context context = new Context(documentData, documentTree);
 
-        context.pageData.addAll(Arrays.stream(documentData.getDocumentPages()).map(DocumentGraphMapper::buildPage).toList());
+        context.pageData.addAll(Arrays.stream(documentData.getDocumentPages())
+                                        .map(DocumentGraphMapper::buildPage)
+                                        .toList());
 
         context.documentTree.getRoot().getChildren().addAll(buildEntries(documentData.getDocumentStructure().getRoot().getChildren(), context));
 
@@ -58,11 +61,13 @@ public class DocumentGraphMapper {
         List<DocumentTree.Entry> newEntries = new LinkedList<>();
         for (DocumentStructure.EntryData entryData : entries) {
 
-            List<Page> pages = Arrays.stream(entryData.getPageNumbers()).map(pageNumber -> getPage(pageNumber, context)).toList();
+            List<Page> pages = Arrays.stream(entryData.getPageNumbers())
+                    .map(pageNumber -> getPage(pageNumber, context))
+                    .toList();
 
             SemanticNode node = switch (entryData.getType()) {
                 case SECTION -> buildSection(context);
-                case PARAGRAPH -> buildParagraph(context);
+                case PARAGRAPH -> buildParagraph(context, entryData.getProperties());
                 case HEADLINE -> buildHeadline(context);
                 case HEADER -> buildHeader(context);
                 case FOOTER -> buildFooter(context);
@@ -76,8 +81,10 @@ public class DocumentGraphMapper {
                 TextBlock textBlock = toTextBlock(entryData.getAtomicBlockIds(), context, node);
                 node.setLeafTextBlock(textBlock);
             }
-            List<Integer> treeId = Arrays.stream(entryData.getTreeId()).boxed().toList();
-            entryData.getEngines().forEach(engine -> node.addEngine(engine));
+            List<Integer> treeId = Arrays.stream(entryData.getTreeId()).boxed()
+                    .toList();
+            entryData.getEngines()
+                    .forEach(engine -> node.addEngine(engine));
             node.setTreeId(treeId);
 
             switch (entryData.getType()) {
@@ -142,24 +149,35 @@ public class DocumentGraphMapper {
     }
 
 
-    private Paragraph buildParagraph(Context context) {
+    private Paragraph buildParagraph(Context context, Map<String, String> properties) {
+
+        if (PropertiesMapper.isDuplicateParagraph(properties)) {
+
+            DuplicatedParagraph duplicatedParagraph = DuplicatedParagraph.builder().documentTree(context.documentTree).build();
+
+            Long[] unsortedTextblockIds = PropertiesMapper.getUnsortedTextblockIds(properties);
+            duplicatedParagraph.setUnsortedLeafTextBlock(toTextBlock(unsortedTextblockIds, context, duplicatedParagraph));
+            return duplicatedParagraph;
+        }
 
         return Paragraph.builder().documentTree(context.documentTree).build();
     }
 
 
-    private TextBlock toTextBlock(Long[] atomicTextBlockIds, Context context, SemanticNode parent) {
+        private TextBlock toTextBlock(Long[] atomicTextBlockIds, Context context, SemanticNode parent) {
 
-        return Arrays.stream(atomicTextBlockIds).map(atomicTextBlockId -> getAtomicTextBlock(context, parent, atomicTextBlockId)).collect(new TextBlockCollector());
+        return Arrays.stream(atomicTextBlockIds)
+                .map(atomicTextBlockId -> getAtomicTextBlock(context, parent, atomicTextBlockId))
+                .collect(new TextBlockCollector());
     }
 
 
     private AtomicTextBlock getAtomicTextBlock(Context context, SemanticNode parent, Long atomicTextBlockId) {
 
         return AtomicTextBlock.fromAtomicTextBlockData(context.documentTextData.get(Math.toIntExact(atomicTextBlockId)),
-                context.documentPositionData.get(Math.toIntExact(atomicTextBlockId)),
-                parent,
-                getPage(context.documentTextData.get(Math.toIntExact(atomicTextBlockId)).getPage(), context));
+                                                       context.documentPositionData.get(Math.toIntExact(atomicTextBlockId)),
+                                                       parent,
+                                                       getPage(context.documentTextData.get(Math.toIntExact(atomicTextBlockId)).getPage(), context));
     }
 
 
@@ -190,8 +208,10 @@ public class DocumentGraphMapper {
 
             this.documentTree = documentTree;
             this.pageData = new LinkedList<>();
-            this.documentTextData = Arrays.stream(documentData.getDocumentTextData()).toList();
-            this.documentPositionData = Arrays.stream(documentData.getDocumentPositionData()).toList();
+            this.documentTextData = Arrays.stream(documentData.getDocumentTextData())
+                    .toList();
+            this.documentPositionData = Arrays.stream(documentData.getDocumentPositionData())
+                    .toList();
 
         }
 

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

@@ -11,6 +11,7 @@ public abstract class EntityComparators implements Comparator<Entity> {
         return new FirstEntity();
     }
 
+
     public static class LongestEntity implements Comparator<Entity> {
 
         @Override
@@ -27,6 +28,7 @@ public abstract class EntityComparators implements Comparator<Entity> {
         return new LongestEntity();
     }
 
+
     public static class FirstEntity implements Comparator<Entity> {
 
         @Override

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

@@ -276,7 +276,8 @@ public class EntityCreationService {
         "this is some text. a here is more text" and "here is more text". We only want to keep the latter.
          */
         return entityTextRanges.stream()
-                .filter(boundary -> entityTextRanges.stream().noneMatch(innerBoundary -> !innerBoundary.equals(boundary) && innerBoundary.containedBy(boundary)))
+                .filter(boundary -> entityTextRanges.stream()
+                        .noneMatch(innerBoundary -> !innerBoundary.equals(boundary) && innerBoundary.containedBy(boundary)))
                 .toList();
 
     }
@@ -351,10 +352,10 @@ public class EntityCreationService {
 
         return tableNode.streamTableCells()
                 .flatMap(tableCell -> lineAfterBoundariesAcrossColumns(RedactionSearchUtility.findTextRangesByString(string, tableCell.getTextBlock()),
-                        tableCell,
-                        type,
-                        entityType,
-                        tableNode));
+                                                                       tableCell,
+                                                                       type,
+                                                                       entityType,
+                                                                       tableNode));
     }
 
 
@@ -362,10 +363,10 @@ public class EntityCreationService {
 
         return tableNode.streamTableCells()
                 .flatMap(tableCell -> lineAfterBoundariesAcrossColumns(RedactionSearchUtility.findTextRangesByStringIgnoreCase(string, tableCell.getTextBlock()),
-                        tableCell,
-                        type,
-                        entityType,
-                        tableNode));
+                                                                       tableCell,
+                                                                       type,
+                                                                       entityType,
+                                                                       tableNode));
     }
 
 
@@ -500,7 +501,10 @@ public class EntityCreationService {
 
     public Stream<TextEntity> bySemanticNodeParagraphsOnly(SemanticNode node, String type, EntityType entityType) {
 
-        return node.streamAllSubNodesOfType(NodeType.PARAGRAPH).map(semanticNode -> bySemanticNode(semanticNode, type, entityType)).filter(Optional::isPresent).map(Optional::get);
+        return node.streamAllSubNodesOfType(NodeType.PARAGRAPH)
+                .map(semanticNode -> bySemanticNode(semanticNode, type, entityType))
+                .filter(Optional::isPresent)
+                .map(Optional::get);
     }
 
 
@@ -592,7 +596,11 @@ public class EntityCreationService {
         TextRange trimmedTextRange = textRange.trim(node.getTextBlock());
         TextEntity entity = TextEntity.initialEntityNode(trimmedTextRange, type, entityType, node);
         if (node.getEntities().contains(entity)) {
-            Optional<TextEntity> optionalTextEntity = node.getEntities().stream().filter(e -> e.equals(entity) && e.type().equals(type)).peek(e -> e.addEngines(engines)).findAny();
+            Optional<TextEntity> optionalTextEntity = node.getEntities()
+                    .stream()
+                    .filter(e -> e.equals(entity) && e.type().equals(type))
+                    .peek(e -> e.addEngines(engines))
+                    .findAny();
             if (optionalTextEntity.isEmpty()) {
                 return optionalTextEntity; // Entity has been recategorized and should not be created at all.
             }
@@ -647,17 +655,27 @@ public class EntityCreationService {
             return entitiesToMerge.get(0);
         }
 
-        TextEntity mergedEntity = TextEntity.initialEntityNode(TextRange.merge(entitiesToMerge.stream().map(TextEntity::getTextRange).toList()), type, entityType, node);
-        mergedEntity.addEngines(entitiesToMerge.stream().flatMap(entityNode -> entityNode.getEngines().stream()).collect(Collectors.toSet()));
-        entitiesToMerge.stream().map(TextEntity::getMatchedRuleList).flatMap(Collection::stream).forEach(matchedRule -> mergedEntity.getMatchedRuleList().add(matchedRule));
+        TextEntity mergedEntity = TextEntity.initialEntityNode(TextRange.merge(entitiesToMerge.stream()
+                                                                                       .map(TextEntity::getTextRange)
+                                                                                       .toList()), type, entityType, node);
+        mergedEntity.addEngines(entitiesToMerge.stream()
+                                        .flatMap(entityNode -> entityNode.getEngines()
+                                                .stream())
+                                        .collect(Collectors.toSet()));
+        entitiesToMerge.stream()
+                .map(TextEntity::getMatchedRuleList)
+                .flatMap(Collection::stream)
+                .forEach(matchedRule -> mergedEntity.getMatchedRuleList().add(matchedRule));
         entitiesToMerge.stream()
                 .map(TextEntity::getManualOverwrite)
                 .map(ManualChangeOverwrite::getManualChangeLog)
                 .flatMap(Collection::stream)
                 .forEach(manualChange -> mergedEntity.getManualOverwrite().addChange(manualChange));
 
-        mergedEntity.setDictionaryEntry(entitiesToMerge.stream().anyMatch(TextEntity::isDictionaryEntry));
-        mergedEntity.setDossierDictionaryEntry(entitiesToMerge.stream().anyMatch(TextEntity::isDossierDictionaryEntry));
+        mergedEntity.setDictionaryEntry(entitiesToMerge.stream()
+                                                .anyMatch(TextEntity::isDictionaryEntry));
+        mergedEntity.setDossierDictionaryEntry(entitiesToMerge.stream()
+                                                       .anyMatch(TextEntity::isDossierDictionaryEntry));
 
         addEntityToGraph(mergedEntity, node);
         insertToKieSession(mergedEntity);
@@ -667,7 +685,8 @@ public class EntityCreationService {
 
     public Stream<TextEntity> copyEntities(List<TextEntity> entities, String type, EntityType entityType, SemanticNode node) {
 
-        return entities.stream().map(entity -> copyEntity(entity, type, entityType, node));
+        return entities.stream()
+                .map(entity -> copyEntity(entity, type, entityType, node));
     }
 
 
@@ -744,7 +763,8 @@ public class EntityCreationService {
         try {
             if (node.getEntities().contains(entity)) {
                 // If entity already exists and it has a different text range, we add the text range to the list of duplicated text ranges
-                node.getEntities().stream()//
+                node.getEntities()
+                        .stream()//
                         .filter(e -> e.equals(entity))//
                         .filter(e -> !e.getTextRange().equals(entity.getTextRange()))//
                         .findAny()//
@@ -770,8 +790,10 @@ public class EntityCreationService {
         SemanticNode deepestSharedNode = entityToDuplicate.getIntersectingNodes()
                 .stream()
                 .sorted(Comparator.comparingInt(n -> -n.getTreeId().size()))
-                .filter(intersectingNode -> entityToDuplicate.getDuplicateTextRanges().stream().allMatch(tr -> intersectingNode.getTextRange().contains(tr)) && //
-                        intersectingNode.getTextRange().contains(entityToDuplicate.getTextRange()))
+                .filter(intersectingNode -> entityToDuplicate.getDuplicateTextRanges()
+                                                    .stream()
+                                                    .allMatch(tr -> intersectingNode.getTextRange().contains(tr)) && //
+                                            intersectingNode.getTextRange().contains(entityToDuplicate.getTextRange()))
                 .findFirst()
                 .orElse(node.getDocumentTree().getRoot().getNode());
 
@@ -784,7 +806,8 @@ public class EntityCreationService {
                 return;
             }
             additionalIntersectingNode.getEntities().add(entityToDuplicate);
-            additionalIntersectingNode.getPages(newTextRange).forEach(page -> page.getEntities().add(entityToDuplicate));
+            additionalIntersectingNode.getPages(newTextRange)
+                    .forEach(page -> page.getEntities().add(entityToDuplicate));
             entityToDuplicate.addIntersectingNode(additionalIntersectingNode);
         });
     }
@@ -806,5 +829,4 @@ public class EntityCreationService {
         addEntityToNodeEntitySets(entity);
     }
 
-
 }

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

@@ -11,7 +11,6 @@ import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBl
 
 public class EntityCreationUtility {
 
-
     public static void checkIfBothStartAndEndAreEmpty(String start, String end) {
 
         checkIfBothStartAndEndAreEmpty(List.of(start), List.of(end));
@@ -57,7 +56,8 @@ public class EntityCreationUtility {
 
     public static void addEntityToNodeEntitySets(TextEntity entity) {
 
-        entity.getIntersectingNodes().forEach(node -> node.getEntities().add(entity));
+        entity.getIntersectingNodes()
+                .forEach(node -> node.getEntities().add(entity));
     }
 
 

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

@@ -59,7 +59,9 @@ public class EntityEnrichmentService {
 
     private static List<String> splitToWordsAndRemoveEmptyWords(String textAfter) {
 
-        return Arrays.stream(textAfter.split(" ")).filter(word -> !Objects.equals("", word)).toList();
+        return Arrays.stream(textAfter.split(" "))
+                .filter(word -> !Objects.equals("", word))
+                .toList();
     }
 
 

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

@@ -47,7 +47,9 @@ public class EntityFindingUtility {
     }
 
 
-    public Optional<TextEntity> findClosestEntityAndReturnEmptyIfNotFound(PrecursorEntity precursorEntity, Map<String, List<TextEntity>> entitiesWithSameValue, double matchThreshold) {
+    public Optional<TextEntity> findClosestEntityAndReturnEmptyIfNotFound(PrecursorEntity precursorEntity,
+                                                                          Map<String, List<TextEntity>> entitiesWithSameValue,
+                                                                          double matchThreshold) {
 
         if (precursorEntity.getValue() == null) {
             return Optional.empty();
@@ -73,11 +75,15 @@ public class EntityFindingUtility {
         ClosestEntity closestEntity = optionalClosestEntity.get();
         if (closestEntity.getDistance() > matchThreshold) {
             log.warn("For entity {} on page {} with positions {} distance to closest found entity is {} and therefore higher than the threshold of {}",
-                    precursorEntity.getValue(),
-                    precursorEntity.getEntityPosition().get(0).pageNumber(),
-                    precursorEntity.getEntityPosition().stream().map(RectangleWithPage::rectangle2D).toList(),
-                    closestEntity.getDistance(),
-                    matchThreshold);
+                     precursorEntity.getValue(),
+                     precursorEntity.getEntityPosition()
+                             .get(0).pageNumber(),
+                     precursorEntity.getEntityPosition()
+                             .stream()
+                             .map(RectangleWithPage::rectangle2D)
+                             .toList(),
+                     closestEntity.getDistance(),
+                     matchThreshold);
             return Optional.empty();
         }
 
@@ -93,8 +99,14 @@ public class EntityFindingUtility {
 
     private static boolean pagesMatch(TextEntity entity, List<RectangleWithPage> originalPositions) {
 
-        Set<Integer> entityPageNumbers = entity.getPositionsOnPagePerPage().stream().map(PositionOnPage::getPage).map(Page::getNumber).collect(Collectors.toSet());
-        Set<Integer> originalPageNumbers = originalPositions.stream().map(RectangleWithPage::pageNumber).collect(Collectors.toSet());
+        Set<Integer> entityPageNumbers = entity.getPositionsOnPagePerPage()
+                .stream()
+                .map(PositionOnPage::getPage)
+                .map(Page::getNumber)
+                .collect(Collectors.toSet());
+        Set<Integer> originalPageNumbers = originalPositions.stream()
+                .map(RectangleWithPage::pageNumber)
+                .collect(Collectors.toSet());
         return entityPageNumbers.containsAll(originalPageNumbers);
     }
 
@@ -105,15 +117,16 @@ public class EntityFindingUtility {
             return Double.MAX_VALUE;
         }
         return originalPositions.stream()
-                .mapToDouble(rectangleWithPage -> calculateMinDistancePerRectangle(entity, rectangleWithPage.pageNumber(), rectangleWithPage.rectangle2D()))
-                .average()
+                .mapToDouble(rectangleWithPage -> calculateMinDistancePerRectangle(entity, rectangleWithPage.pageNumber(), rectangleWithPage.rectangle2D())).average()
                 .orElse(Double.MAX_VALUE);
     }
 
 
     private static long countRectangles(TextEntity entity) {
 
-        return entity.getPositionsOnPagePerPage().stream().mapToLong(redactionPosition -> redactionPosition.getRectanglePerLine().size()).sum();
+        return entity.getPositionsOnPagePerPage()
+                .stream()
+                .mapToLong(redactionPosition -> redactionPosition.getRectanglePerLine().size()).sum();
     }
 
 
@@ -144,24 +157,36 @@ public class EntityFindingUtility {
         double maxY2 = Math.max(rectangle2.getMinY(), rectangle2.getMaxY());
 
         return Math.abs(minX1 - minX2) //
-                + Math.abs(minY1 - minY2) //
-                + Math.abs(maxX1 - maxX2) //
-                + Math.abs(maxY1 - maxY2);
+               + Math.abs(minY1 - minY2) //
+               + Math.abs(maxX1 - maxX2) //
+               + Math.abs(maxY1 - maxY2);
     }
 
 
     public Map<String, List<TextEntity>> findAllPossibleEntitiesAndGroupByValue(SemanticNode node, List<PrecursorEntity> manualEntities) {
 
-        Set<Integer> pageNumbers = manualEntities.stream().flatMap(entry -> entry.getEntityPosition().stream().map(RectangleWithPage::pageNumber)).collect(Collectors.toSet());
-        Set<String> entryValues = manualEntities.stream().map(PrecursorEntity::getValue).filter(Objects::nonNull).map(String::toLowerCase).collect(Collectors.toSet());
+        Set<Integer> pageNumbers = manualEntities.stream()
+                .flatMap(entry -> entry.getEntityPosition()
+                        .stream()
+                        .map(RectangleWithPage::pageNumber))
+                .collect(Collectors.toSet());
+        Set<String> entryValues = manualEntities.stream()
+                .map(PrecursorEntity::getValue)
+                .filter(Objects::nonNull)
+                .map(String::toLowerCase)
+                .collect(Collectors.toSet());
 
-        if (!pageNumbers.stream().allMatch(node::onPage)) {
+        if (!pageNumbers.stream()
+                .allMatch(node::onPage)) {
             throw new IllegalArgumentException(format("SemanticNode \"%s\" does not contain these pages %s, it has pages: %s",
-                    node,
-                    pageNumbers.stream().filter(pageNumber -> !node.onPage(pageNumber)).toList(),
-                    node.getPages()));
+                                                      node,
+                                                      pageNumbers.stream()
+                                                              .filter(pageNumber -> !node.onPage(pageNumber))
+                                                              .toList(),
+                                                      node.getPages()));
         }
-        SearchImplementation searchImplementation = new SearchImplementation(entryValues, true);
+
+        SearchImplementation searchImplementation = new SearchImplementation(entryValues.stream().map(String::trim).collect(Collectors.toSet()), true);
 
         return searchImplementation.getBoundaries(node.getTextBlock(), node.getTextRange())
                 .stream()

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

@@ -52,9 +52,13 @@ public class ImportedRedactionEntryService {
     private List<BaseAnnotation> allManualChangesExceptAdd(ManualRedactions manualRedactions) {
 
         return Stream.of(manualRedactions.getForceRedactions(),
-                manualRedactions.getResizeRedactions(),
-                manualRedactions.getRecategorizations(),
-                manualRedactions.getIdsToRemove(),
-                manualRedactions.getLegalBasisChanges()).flatMap(Collection::stream).map(baseAnnotation -> (BaseAnnotation) baseAnnotation).toList();
+                         manualRedactions.getResizeRedactions(),
+                         manualRedactions.getRecategorizations(),
+                         manualRedactions.getIdsToRemove(),
+                         manualRedactions.getLegalBasisChanges())
+                .flatMap(Collection::stream)
+                .map(baseAnnotation -> (BaseAnnotation) baseAnnotation)
+                .toList();
     }
+
 }

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

@@ -14,12 +14,14 @@ public class IntersectingNodeVisitor implements NodeVisitor {
     private Set<SemanticNode> intersectingNodes;
     private final TextRange textRange;
 
+
     public IntersectingNodeVisitor(TextRange textRange) {
 
         this.textRange = textRange;
         this.intersectingNodes = new HashSet<>();
     }
 
+
     @Override
     public void visit(SemanticNode node) {
 

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

@@ -31,7 +31,8 @@ public class ManualRedactionEntryService {
         List<PrecursorEntity> notFoundManualRedactionEntries = Collections.emptyList();
         if (analyzeRequest.getManualRedactions() != null) {
             notFoundManualRedactionEntries = entityFromPrecursorCreationService.createEntitiesIfFoundAndReturnNotFoundEntries(analyzeRequest.getManualRedactions(),
-                    document, dossierTemplateId);
+                                                                                                                              document,
+                                                                                                                              dossierTemplateId);
             log.info("Added Manual redaction entries for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
         }
 
@@ -51,10 +52,13 @@ public class ManualRedactionEntryService {
     private List<BaseAnnotation> allManualChangesExceptAdd(ManualRedactions manualRedactions) {
 
         return Stream.of(manualRedactions.getForceRedactions(),
-                manualRedactions.getResizeRedactions(),
-                manualRedactions.getRecategorizations(),
-                manualRedactions.getIdsToRemove(),
-                manualRedactions.getLegalBasisChanges()).flatMap(Collection::stream).map(baseAnnotation -> (BaseAnnotation) baseAnnotation).toList();
+                         manualRedactions.getResizeRedactions(),
+                         manualRedactions.getRecategorizations(),
+                         manualRedactions.getIdsToRemove(),
+                         manualRedactions.getLegalBasisChanges())
+                .flatMap(Collection::stream)
+                .map(baseAnnotation -> (BaseAnnotation) baseAnnotation)
+                .toList();
     }
 
 }

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

@@ -44,9 +44,11 @@ public class NerEntitiesAdapter {
     public NerEntities toNerEntities(NerEntitiesModel nerEntitiesModel, Document document) {
 
         return new NerEntities(addOffsetsAndFlatten(getStringStartOffsetsForMainSections(document),
-                nerEntitiesModel).map(nerEntityModel -> new NerEntities.NerEntity(nerEntityModel.getValue(),
-                new TextRange(nerEntityModel.getStartOffset(), nerEntityModel.getEndOffset()),
-                nerEntityModel.getType())).toList());
+                                                    nerEntitiesModel).map(nerEntityModel -> new NerEntities.NerEntity(nerEntityModel.getValue(),
+                                                                                                                      new TextRange(nerEntityModel.getStartOffset(),
+                                                                                                                                    nerEntityModel.getEndOffset()),
+                                                                                                                      nerEntityModel.getType()))
+                                       .toList());
     }
 
 
@@ -83,7 +85,9 @@ public class NerEntitiesAdapter {
 
         List<List<NerEntities.NerEntity>> entityClusters = new LinkedList<>();
 
-        List<NerEntities.NerEntity> startEntitiesOfEssentialType = sortedEntities.stream().filter(e -> essentialTypes.contains(e.type())).toList();
+        List<NerEntities.NerEntity> startEntitiesOfEssentialType = sortedEntities.stream()
+                .filter(e -> essentialTypes.contains(e.type()))
+                .toList();
         for (NerEntities.NerEntity startEntity : startEntitiesOfEssentialType) {
             List<NerEntities.NerEntity> currentCluster = new LinkedList<>();
             entityClusters.add(currentCluster);
@@ -105,7 +109,10 @@ public class NerEntitiesAdapter {
             }
         }
 
-        return entityClusters.stream().filter(cluster -> cluster.size() >= minPartsToCombine).map(NerEntitiesAdapter::toContainingBoundary).distinct();
+        return entityClusters.stream()
+                .filter(cluster -> cluster.size() >= minPartsToCombine)
+                .map(NerEntitiesAdapter::toContainingBoundary)
+                .distinct();
     }
 
 
@@ -124,17 +131,18 @@ public class NerEntitiesAdapter {
     public Stream<TextRange> combineNerEntitiesToCbiAddressDefaults(NerEntities entityRecognitionEntities) {
 
         return combineNerEntities(entityRecognitionEntities,
-                CBI_ADDRESS_ESSENTIAL_TYPES,
-                CBI_ADDRESS_TYPES_TO_COMBINE,
-                MAX_DISTANCE_BETWEEN_PARTS,
-                MIN_PARTS_TO_COMBINE,
-                ALLOW_DUPLICATES);
+                                  CBI_ADDRESS_ESSENTIAL_TYPES,
+                                  CBI_ADDRESS_TYPES_TO_COMBINE,
+                                  MAX_DISTANCE_BETWEEN_PARTS,
+                                  MIN_PARTS_TO_COMBINE,
+                                  ALLOW_DUPLICATES);
     }
 
 
     private static boolean isDuplicate(List<NerEntities.NerEntity> currentCluster, NerEntities.NerEntity entity, boolean allowDuplicates) {
 
-        return allowDuplicates || currentCluster.stream().anyMatch(e -> e.type().equals(entity.type()));
+        return allowDuplicates || currentCluster.stream()
+                .anyMatch(e -> e.type().equals(entity.type()));
     }
 
 
@@ -146,24 +154,34 @@ public class NerEntitiesAdapter {
 
     private static TextRange toContainingBoundary(List<NerEntities.NerEntity> nerEntities) {
 
-        return TextRange.merge(nerEntities.stream().map(NerEntities.NerEntity::textRange).toList());
+        return TextRange.merge(nerEntities.stream()
+                                       .map(NerEntities.NerEntity::textRange)
+                                       .toList());
     }
 
 
     private static Stream<EntityRecognitionEntity> addOffsetsAndFlatten(List<Integer> stringOffsetsForMainSections, NerEntitiesModel nerEntitiesModel) {
 
-        nerEntitiesModel.getData().forEach((sectionNumber, listOfNerEntities) -> listOfNerEntities.forEach(entityRecognitionEntity -> {
-            int newStartOffset = entityRecognitionEntity.getStartOffset() + stringOffsetsForMainSections.get(sectionNumber);
-            entityRecognitionEntity.setStartOffset(newStartOffset);
-            entityRecognitionEntity.setEndOffset(newStartOffset + entityRecognitionEntity.getValue().length());
-        }));
-        return nerEntitiesModel.getData().values().stream().flatMap(Collection::stream);
+        nerEntitiesModel.getData()
+                .forEach((sectionNumber, listOfNerEntities) -> listOfNerEntities.forEach(entityRecognitionEntity -> {
+                    int newStartOffset = entityRecognitionEntity.getStartOffset() + stringOffsetsForMainSections.get(sectionNumber);
+                    entityRecognitionEntity.setStartOffset(newStartOffset);
+                    entityRecognitionEntity.setEndOffset(newStartOffset + entityRecognitionEntity.getValue().length());
+                }));
+        return nerEntitiesModel.getData().values()
+                .stream()
+                .flatMap(Collection::stream);
     }
 
 
     private static List<Integer> getStringStartOffsetsForMainSections(Document document) {
 
-        return document.getMainSections().stream().map(Section::getTextBlock).map(TextBlock::getTextRange).map(TextRange::start).toList();
+        return document.getMainSections()
+                .stream()
+                .map(Section::getTextBlock)
+                .map(TextBlock::getTextRange)
+                .map(TextRange::start)
+                .toList();
     }
 
 }

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

@@ -5,4 +5,5 @@ import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNo
 public interface NodeVisitor {
 
     void visit(SemanticNode node);
+
 }

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

@@ -43,8 +43,29 @@ public class PropertiesMapper {
 
     private Rectangle2D parseRectangle2D(String bBox) {
 
-        List<Float> floats = Arrays.stream(bBox.split(DocumentStructure.RECTANGLE_DELIMITER)).map(Float::parseFloat).toList();
+        List<Float> floats = Arrays.stream(bBox.split(DocumentStructure.RECTANGLE_DELIMITER))
+                .map(Float::parseFloat)
+                .toList();
         return new Rectangle2D.Float(floats.get(0), floats.get(1), floats.get(2), floats.get(3));
     }
 
+
+    public static boolean isDuplicateParagraph(Map<String, String> properties) {
+
+        return properties.containsKey(DocumentStructure.DuplicateParagraphProperties.UNSORTED_TEXTBLOCK_ID);
+    }
+
+
+    public static Long[] getUnsortedTextblockIds(Map<String, String> properties) {
+
+        return toLongArray(properties.get(DocumentStructure.DuplicateParagraphProperties.UNSORTED_TEXTBLOCK_ID));
+    }
+
+
+    public static Long[] toLongArray(String ids) {
+
+        return Arrays.stream(ids.substring(1, ids.length() - 1).trim().split(",")).map(Long::valueOf).toArray(Long[]::new);
+    }
+
+
 }

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

@@ -12,6 +12,7 @@ public abstract class SemanticNodeComparators implements Comparator<SemanticNode
         return new FirstSemanticNode();
     }
 
+
     public static class FirstSemanticNode extends SemanticNodeComparators {
 
         @Override

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

@@ -50,7 +50,9 @@ public class ComponentDroolsExecutionService {
                 .filter(entityLogEntry -> entityLogEntry.getState().equals(EntryState.APPLIED))
                 .map(entry -> Entity.fromEntityLogEntry(entry, document))
                 .forEach(kieSession::insert);
-        fileAttributes.stream().filter(f -> f.getValue() != null).forEach(kieSession::insert);
+        fileAttributes.stream()
+                .filter(f -> f.getValue() != null)
+                .forEach(kieSession::insert);
 
         CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
             kieSession.fireAllRules();
@@ -58,7 +60,8 @@ public class ComponentDroolsExecutionService {
         });
 
         try {
-            completableFuture.orTimeout(settings.getDroolsExecutionTimeoutSecs(), TimeUnit.SECONDS).get();
+            completableFuture.orTimeout(settings.getDroolsExecutionTimeoutSecs(), TimeUnit.SECONDS)
+                    .get();
         } catch (ExecutionException e) {
             kieSession.dispose();
             if (e.getCause() instanceof TimeoutException) {
@@ -71,7 +74,9 @@ public class ComponentDroolsExecutionService {
         }
 
         List<FileAttribute> resultingFileAttributes = getFileAttributes(kieSession);
-        List<Component> components = getComponents(kieSession).stream().sorted(ComponentComparator.first()).toList();
+        List<Component> components = getComponents(kieSession).stream()
+                .sorted(ComponentComparator.first())
+                .toList();
         kieSession.dispose();
         return components;
     }

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

@@ -7,6 +7,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.drools.drl.parser.DroolsParserException;
 import org.kie.api.builder.KieBuilder;
@@ -15,11 +16,13 @@ import org.springframework.stereotype.Service;
 
 import com.google.common.collect.Sets;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType;
+import com.iqser.red.service.redaction.v1.model.DroolsBlacklistErrorMessage;
 import com.iqser.red.service.redaction.v1.model.DroolsSyntaxDeprecatedWarnings;
 import com.iqser.red.service.redaction.v1.model.DroolsSyntaxErrorMessage;
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+import com.iqser.red.service.redaction.v1.model.DroolsValidation;
 import com.iqser.red.service.redaction.v1.model.RuleValidationModel;
 import com.iqser.red.service.redaction.v1.server.DeprecatedElementsFinder;
+import com.iqser.red.service.redaction.v1.server.RedactionServiceSettings;
 import com.iqser.red.service.redaction.v1.server.model.dictionary.SearchImplementation;
 import com.iqser.red.service.redaction.v1.server.model.drools.BasicQuery;
 import com.iqser.red.service.redaction.v1.server.model.drools.BasicRule;
@@ -35,31 +38,61 @@ import lombok.extern.slf4j.Slf4j;
 @Service
 @RequiredArgsConstructor
 @Slf4j
-public class DroolsSyntaxValidationService {
-
-    private static final Pattern allowedImportsPattern = Pattern.compile("^(?:import\\s+static\\s+)?(?:import\\s+)?(?:com\\.knecon\\.fforesight|com\\.iqser\\.red)\\..*;$");
+public class DroolsValidationService {
 
+    private final RedactionServiceSettings redactionServiceSettings;
     private final KieContainerCreationService kieContainerCreationService;
-
     private final DeprecatedElementsFinder deprecatedElementsFinder;
+    private static final Pattern allowedImportsPattern = Pattern.compile("^(?:import\\s+static\\s+)?(?:import\\s+)?(?:com\\.knecon\\.fforesight|com\\.iqser\\.red)\\..*;$");
+    public static final String LINEBREAK_MATCHER = "\\R";
 
 
     @SneakyThrows
-    public DroolsSyntaxValidation testRules(RuleValidationModel rules) {
+    public DroolsValidation testRules(RuleValidationModel rules) {
 
-        DroolsSyntaxValidation customDroolsSyntaxValidation;
+        DroolsValidation customDroolsValidation;
         try {
-            customDroolsSyntaxValidation = buildCustomDroolsSyntaxValidation(rules.getRulesString(), RuleFileType.valueOf(rules.getRuleFileType()));
+            customDroolsValidation = buildCustomDroolsValidation(rules.getRulesString(), RuleFileType.valueOf(rules.getRuleFileType()));
         } catch (DroolsParserException e) {
             // this means the parser could not parse the file at all. In this case use drools compiler only as it will return useful error messages.
-            customDroolsSyntaxValidation = new DroolsSyntaxValidation();
+            customDroolsValidation = new DroolsValidation();
         }
-        DroolsSyntaxValidation droolsCompilerSyntaxValidation = buildDroolsCompilerSyntaxValidation(rules);
-        droolsCompilerSyntaxValidation.getDroolsSyntaxErrorMessages().addAll(customDroolsSyntaxValidation.getDroolsSyntaxErrorMessages());
-        droolsCompilerSyntaxValidation.getDroolsSyntaxDeprecatedWarnings().addAll(customDroolsSyntaxValidation.getDroolsSyntaxDeprecatedWarnings());
-        return droolsCompilerSyntaxValidation;
+        DroolsValidation droolsCompilerValidation = buildDroolsCompilerValidation(rules);
+        droolsCompilerValidation.getSyntaxErrorMessages().addAll(customDroolsValidation.getSyntaxErrorMessages());
+        droolsCompilerValidation.getDeprecatedWarnings().addAll(customDroolsValidation.getDeprecatedWarnings());
+        droolsCompilerValidation.getBlacklistErrorMessages().addAll(customDroolsValidation.getBlacklistErrorMessages());
+        return droolsCompilerValidation;
     }
 
+
+    private DroolsValidation buildCustomDroolsValidation(String ruleString, RuleFileType ruleFileType) throws DroolsParserException {
+
+        RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(ruleString);
+
+        DroolsValidation customValidation = ruleFileBluePrint.getDroolsValidation();
+
+        addSyntaxDeprecatedWarnings(ruleFileBluePrint, customValidation);
+
+        addSyntaxErrorMessages(ruleFileType, ruleFileBluePrint, customValidation);
+
+        if (redactionServiceSettings.isRuleExecutionSecured()) {
+            addBlacklistErrorMessages(ruleFileBluePrint, customValidation);
+        }
+
+        return customValidation;
+    }
+
+
+    private void addSyntaxDeprecatedWarnings(RuleFileBluePrint ruleFileBluePrint, DroolsValidation customValidation) {
+        // find deprecated elements in the ruleFileBluePrint
+        DroolsSyntaxDeprecatedWarnings warningMessageForImports = getWarningsForDeprecatedImports(ruleFileBluePrint);
+        if (warningMessageForImports != null) {
+            customValidation.getDeprecatedWarnings().add(warningMessageForImports);
+        }
+        customValidation.getDeprecatedWarnings().addAll(getWarningsForDeprecatedRules(ruleFileBluePrint));
+    }
+
+
     private DroolsSyntaxDeprecatedWarnings getWarningsForDeprecatedImports(RuleFileBluePrint ruleFileBluePrint) {
 
         if (!deprecatedElementsFinder.getDeprecatedClasses().isEmpty()) {
@@ -70,13 +103,13 @@ public class DroolsSyntaxValidationService {
                 String sb = "Following imports are deprecated: \n" + matches.stream()
                         .map(m -> imports.substring(m.startIndex(), m.endIndex()))
                         .collect(Collectors.joining("\n"));
-                return DroolsSyntaxDeprecatedWarnings.builder().line(ruleFileBluePrint.getImportLine()).column(0).message(sb)
-                                            .build();
+                return DroolsSyntaxDeprecatedWarnings.builder().line(ruleFileBluePrint.getImportLine()).column(0).message(sb).build();
             }
         }
         return null;
     }
 
+
     private List<DroolsSyntaxDeprecatedWarnings> getWarningsForDeprecatedRules(RuleFileBluePrint ruleFileBluePrint) {
 
         List<DroolsSyntaxDeprecatedWarnings> warningMessages = new ArrayList<>();
@@ -96,8 +129,7 @@ public class DroolsSyntaxValidationService {
                                     .distinct()
                                     .map(dm -> String.format("Method %s might be deprecated because of \n %s \n", dm, deprecatedMethodsSignatureMap.get(dm)))
                                     .collect(Collectors.joining("\n"));
-                            warningMessages.add(DroolsSyntaxDeprecatedWarnings.builder().line(basicRule.getLine()).column(0).message(warningMessage)
-                                                        .build());
+                            warningMessages.add(DroolsSyntaxDeprecatedWarnings.builder().line(basicRule.getLine()).column(0).message(warningMessage).build());
                         }
                     }
                 }
@@ -111,18 +143,7 @@ public class DroolsSyntaxValidationService {
     }
 
 
-    private DroolsSyntaxValidation buildCustomDroolsSyntaxValidation(String ruleString, RuleFileType ruleFileType) throws DroolsParserException {
-
-        RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(ruleString);
-
-        DroolsSyntaxValidation customSyntaxValidation = ruleFileBluePrint.getDroolsSyntaxValidation();
-
-        // find deprecated elements in the ruleFileBluePrint
-        DroolsSyntaxDeprecatedWarnings warningMessageForImports = getWarningsForDeprecatedImports(ruleFileBluePrint);
-        if (warningMessageForImports != null) {
-            customSyntaxValidation.getDroolsSyntaxDeprecatedWarnings().add(warningMessageForImports);
-        }
-        customSyntaxValidation.getDroolsSyntaxDeprecatedWarnings().addAll(getWarningsForDeprecatedRules(ruleFileBluePrint));
+    private void addSyntaxErrorMessages(RuleFileType ruleFileType, RuleFileBluePrint ruleFileBluePrint, DroolsValidation customValidation) {
 
         RuleFileBluePrint baseRuleFileBluePrint = switch (ruleFileType) {
             case ENTITY -> RuleFileParser.buildBluePrintFromRulesString(RuleManagementResources.getBaseRuleFileString());
@@ -130,7 +151,7 @@ public class DroolsSyntaxValidationService {
         };
 
         if (!importsAreValid(baseRuleFileBluePrint, ruleFileBluePrint)) {
-            customSyntaxValidation.getDroolsSyntaxErrorMessages()
+            customValidation.getSyntaxErrorMessages()
                     .add(DroolsSyntaxErrorMessage.builder()
                                  .line(ruleFileBluePrint.getImportLine())
                                  .column(0)
@@ -138,7 +159,7 @@ public class DroolsSyntaxValidationService {
                                  .build());
         }
         if (!ruleFileBluePrint.getGlobals().equals(baseRuleFileBluePrint.getGlobals())) {
-            customSyntaxValidation.getDroolsSyntaxErrorMessages()
+            customValidation.getSyntaxErrorMessages()
                     .add(DroolsSyntaxErrorMessage.builder()
                                  .line(ruleFileBluePrint.getGlobalsLine())
                                  .column(0)
@@ -148,7 +169,7 @@ public class DroolsSyntaxValidationService {
         baseRuleFileBluePrint.getQueries()
                 .forEach(basicQuery -> {
                     if (!validateQueryIsPresent(basicQuery, ruleFileBluePrint)) {
-                        customSyntaxValidation.getDroolsSyntaxErrorMessages()
+                        customValidation.getSyntaxErrorMessages()
                                 .add(DroolsSyntaxErrorMessage.builder()
                                              .line(basicQuery.getLine())
                                              .column(0)
@@ -159,12 +180,14 @@ public class DroolsSyntaxValidationService {
         if (ruleFileType.equals(RuleFileType.ENTITY)) {
             String requiredAgendaGroup = "LOCAL_DICTIONARY_ADDS";
             if (!validateAgendaGroupIsPresent(ruleFileBluePrint, requiredAgendaGroup)) {
-                customSyntaxValidation.getDroolsSyntaxErrorMessages()
-                        .add(DroolsSyntaxErrorMessage.builder().line(0).column(0).message(String.format("At least one rule with Agenda-Group '%s' required!", requiredAgendaGroup))
+                customValidation.getSyntaxErrorMessages()
+                        .add(DroolsSyntaxErrorMessage.builder()
+                                     .line(0)
+                                     .column(0)
+                                     .message(String.format("At least one rule with Agenda-Group '%s' required!", requiredAgendaGroup))
                                      .build());
             }
         }
-        return customSyntaxValidation;
     }
 
 
@@ -196,7 +219,54 @@ public class DroolsSyntaxValidationService {
     }
 
 
-    private DroolsSyntaxValidation buildDroolsCompilerSyntaxValidation(RuleValidationModel rules) {
+    private void addBlacklistErrorMessages(RuleFileBluePrint ruleFileBluePrint, DroolsValidation customValidation) {
+
+        List<DroolsBlacklistErrorMessage> blacklistErrorMessages = new ArrayList<>();
+
+        List<String> blacklistedKeywords = parseBlacklistFile(RuleManagementResources.getBlacklistFileString());
+
+        // checks the rules for occurrence of blacklisted keyword
+        if (!blacklistedKeywords.isEmpty()) {
+            SearchImplementation blacklistedKeywordSearchImplementation = new SearchImplementation(blacklistedKeywords, false);
+
+            for (RuleClass ruleClass : ruleFileBluePrint.getRuleClasses()) {
+                for (RuleUnit ruleUnit : ruleClass.ruleUnits()) {
+                    for (BasicRule basicRule : ruleUnit.rules()) {
+                        List<SearchImplementation.MatchPosition> matches = blacklistedKeywordSearchImplementation.getMatches(basicRule.getCode());
+
+                        if (!matches.isEmpty()) {
+                            List<String> foundBlacklistedKeywords = matches.stream()
+                                    .map(m -> basicRule.getCode().substring(m.startIndex(), m.endIndex()))
+                                    .distinct()
+                                    .toList();
+                            blacklistErrorMessages.add(DroolsBlacklistErrorMessage.builder()
+                                                               .line(basicRule.getLine())
+                                                               .column(0)
+                                                               .blacklistedKeywords(foundBlacklistedKeywords)
+                                                               .build());
+                        }
+                    }
+                }
+            }
+        }
+
+        customValidation.getBlacklistErrorMessages()
+                .addAll(blacklistErrorMessages.stream()
+                                .sorted(Comparator.comparingInt(DroolsBlacklistErrorMessage::getLine))
+                                .toList());
+    }
+
+
+    private List<String> parseBlacklistFile(String blacklistFileString) {
+
+        return Stream.of(blacklistFileString.split(LINEBREAK_MATCHER))
+                .distinct()
+                .filter(s -> !s.isBlank())
+                .toList();
+    }
+
+
+    private DroolsValidation buildDroolsCompilerValidation(RuleValidationModel rules) {
 
         var versionId = System.currentTimeMillis();
         var testRules = "test-rules";
@@ -204,25 +274,23 @@ public class DroolsSyntaxValidationService {
                                                                                            versionId,
                                                                                            rules.getRulesString(),
                                                                                            RuleFileType.valueOf(rules.getRuleFileType()));
-        return buildDroolsCompilerSyntaxValidation(kieBuilder);
+        return buildDroolsCompilerValidation(kieBuilder);
     }
 
 
-    private DroolsSyntaxValidation buildDroolsCompilerSyntaxValidation(KieBuilder kieBuilder) {
+    private DroolsValidation buildDroolsCompilerValidation(KieBuilder kieBuilder) {
 
         List<Message> errorMessages = kieBuilder.getResults().getMessages(Message.Level.ERROR);
         List<DroolsSyntaxErrorMessage> droolsSyntaxErrorMessages = errorMessages.stream()
                 .map(this::buildDroolsSyntaxErrorMessage)
                 .collect(Collectors.toList());
-        return DroolsSyntaxValidation.builder().droolsSyntaxErrorMessages(droolsSyntaxErrorMessages)
-                .build();
+        return DroolsValidation.builder().syntaxErrorMessages(droolsSyntaxErrorMessages).build();
     }
 
 
     private DroolsSyntaxErrorMessage buildDroolsSyntaxErrorMessage(Message message) {
 
-        return DroolsSyntaxErrorMessage.builder().line(message.getLine()).column(message.getColumn()).message(message.getText())
-                .build();
+        return DroolsSyntaxErrorMessage.builder().line(message.getLine()).column(message.getColumn()).message(message.getText()).build();
     }
 
 }

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

@@ -30,8 +30,7 @@ public class KieContainerCreationService {
     private final RulesClient rulesClient;
 
 
-    @Observed(name = "KieContainerCreationService",
-            contextualName = "get-kie-container")
+    @Observed(name = "KieContainerCreationService", contextualName = "get-kie-container")
     public KieWrapper getLatestKieContainer(String dossierTemplateId, RuleFileType ruleFileType) {
 
         try {

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

@@ -16,7 +16,7 @@ import org.drools.drl.ast.descr.RuleDescr;
 import org.drools.drl.parser.DrlParser;
 import org.kie.internal.builder.conf.LanguageLevelOption;
 
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+import com.iqser.red.service.redaction.v1.model.DroolsValidation;
 import com.iqser.red.service.redaction.v1.server.model.drools.BasicQuery;
 import com.iqser.red.service.redaction.v1.server.model.drools.BasicRule;
 import com.iqser.red.service.redaction.v1.server.model.drools.RuleClass;
@@ -38,7 +38,7 @@ public class RuleFileParser {
     @SneakyThrows
     public RuleFileBluePrint buildBluePrintFromRulesString(String ruleString) {
 
-        DroolsSyntaxValidation customDroolsSyntaxValidation = DroolsSyntaxValidation.builder().build();
+        DroolsValidation customDroolsValidation = DroolsValidation.builder().build();
         DrlParser parser = new DrlParser(LanguageLevelOption.DRL6);
         PackageDescr packageDescr = parser.parse(false, ruleString);
         List<BasicRule> allRules = new LinkedList<>();
@@ -48,11 +48,16 @@ public class RuleFileParser {
             if (rule.isQuery()) {
                 allQueries.add(new BasicQuery(rule.getName(), rule.getLine(), ruleString.substring(rule.getStartCharacter(), rule.getEndCharacter())));
             } else {
-                validateRule(ruleString, rule, customDroolsSyntaxValidation, allRules);
+                validateRule(ruleString, rule, customDroolsValidation, allRules);
             }
         }
 
-        String imports = ruleString.substring(0, packageDescr.getImports().stream().mapToInt(ImportDescr::getEndCharacter).max().orElseThrow() + 1);
+        String imports = ruleString.substring(0,
+                                              packageDescr.getImports()
+                                                      .stream()
+                                                      .mapToInt(ImportDescr::getEndCharacter)
+                                                      .max()
+                                                      .orElseThrow() + 1);
         String globals = packageDescr.getGlobals()
                 .stream()
                 .map(globalDescr -> ruleString.substring(globalDescr.getStartCharacter(), globalDescr.getEndCharacter()))
@@ -61,66 +66,87 @@ public class RuleFileParser {
         List<RuleClass> ruleClasses = buildRuleClasses(allRules);
 
         return new RuleFileBluePrint(imports.trim(),
-                packageDescr.getImports().stream().findFirst().map(ImportDescr::getLine).orElse(0),
-                globals.trim(),
-                packageDescr.getGlobals().stream().findFirst().map(GlobalDescr::getLine).orElse(0), allQueries,
-                ruleClasses,
-                customDroolsSyntaxValidation);
+                                     packageDescr.getImports()
+                                             .stream()
+                                             .findFirst()
+                                             .map(ImportDescr::getLine)
+                                             .orElse(0),
+                                     globals.trim(),
+                                     packageDescr.getGlobals()
+                                             .stream()
+                                             .findFirst()
+                                             .map(GlobalDescr::getLine)
+                                             .orElse(0),
+                                     allQueries,
+                                     ruleClasses, customDroolsValidation);
     }
 
 
-    private static void validateRule(String ruleString, RuleDescr rule, DroolsSyntaxValidation customDroolsSyntaxValidation, List<BasicRule> allRules) {
+    private static void validateRule(String ruleString, RuleDescr rule, DroolsValidation customDroolsValidation, List<BasicRule> allRules) {
 
         BasicRule basicRule;
         try {
             basicRule = BasicRule.fromRuleDescr(rule, ruleString);
         } catch (Exception e) {
-            customDroolsSyntaxValidation.addErrorMessage(rule.getLine(), rule.getColumn(), "Malformed rule name, correct format is \"\\w+.\\d+.\\d+: <rule description>\"");
+            customDroolsValidation.addErrorMessage(rule.getLine(), rule.getColumn(), "Malformed rule name, correct format is \"\\w+.\\d+.\\d+: <rule description>\"");
             return;
         }
         if (allRules.contains(basicRule)) {
-            addDuplicateRuleIdentifierErrorMessage(rule, basicRule, customDroolsSyntaxValidation);
+            addDuplicateRuleIdentifierErrorMessage(rule, basicRule, customDroolsValidation);
         }
-        validateRuleIdentifierInCodeIsSame(basicRule.getCode(), basicRule.getIdentifier().toString(), rule.getLine(), customDroolsSyntaxValidation);
+        validateRuleIdentifierInCodeIsSame(basicRule.getCode(), basicRule.getIdentifier().toString(), rule.getLine(), customDroolsValidation);
         allRules.add(BasicRule.fromRuleDescr(rule, ruleString));
     }
 
 
-    private static void validateRuleIdentifierInCodeIsSame(String code, String identifier, int lineOffset, DroolsSyntaxValidation customDroolsSyntaxValidation) {
+    private static void validateRuleIdentifierInCodeIsSame(String code, String identifier, int lineOffset, DroolsValidation customDroolsValidation) {
 
         Matcher matcher = ruleIdentifierInCodeFinder.matcher(code);
         while (matcher.find()) {
             String identifierInCode = code.substring(matcher.start(1), matcher.end(1));
-            long line = code.substring(0, matcher.start(1)).lines().count() + lineOffset - 1;
+            long line = code.substring(0, matcher.start(1)).lines()
+                                .count() + lineOffset - 1;
             if (!identifier.equals(identifierInCode)) {
-                customDroolsSyntaxValidation.addErrorMessage((int) line,
-                        0,
-                        String.format("Rule identifier %s is not equal to rule identifier %s in rule name!", identifierInCode, identifier));
+                customDroolsValidation.addErrorMessage((int) line,
+                                                       0,
+                                                       String.format("Rule identifier %s is not equal to rule identifier %s in rule name!", identifierInCode, identifier));
             }
         }
     }
 
 
-    private void addDuplicateRuleIdentifierErrorMessage(RuleDescr rule, BasicRule basicRule, DroolsSyntaxValidation customDroolsSyntaxValidation) {
+    private void addDuplicateRuleIdentifierErrorMessage(RuleDescr rule, BasicRule basicRule, DroolsValidation customDroolsValidation) {
 
-        customDroolsSyntaxValidation.addErrorMessage(rule.getLine(),
-                rule.getColumn(),
-                String.format("RuleIdentifier: %s is a duplicate, duplicates are not allowed!", basicRule.getIdentifier()));
+        customDroolsValidation.addErrorMessage(rule.getLine(),
+                                               rule.getColumn(),
+                                               String.format("RuleIdentifier: %s is a duplicate, duplicates are not allowed!", basicRule.getIdentifier()));
     }
 
 
     private List<RuleClass> buildRuleClasses(List<BasicRule> allRules) {
 
-        List<RuleType> ruleTypeOrder = allRules.stream().map(BasicRule::getIdentifier).map(RuleIdentifier::type).distinct().toList();
-        Map<RuleType, List<BasicRule>> rulesPerType = allRules.stream().collect(groupingBy(rule -> rule.getIdentifier().type()));
-        return ruleTypeOrder.stream().map(type -> new RuleClass(type, groupingByGroup(rulesPerType.get(type)))).collect(Collectors.toList());
+        List<RuleType> ruleTypeOrder = allRules.stream()
+                .map(BasicRule::getIdentifier)
+                .map(RuleIdentifier::type)
+                .distinct()
+                .toList();
+        Map<RuleType, List<BasicRule>> rulesPerType = allRules.stream()
+                .collect(groupingBy(rule -> rule.getIdentifier().type()));
+        return ruleTypeOrder.stream()
+                .map(type -> new RuleClass(type, groupingByGroup(rulesPerType.get(type))))
+                .collect(Collectors.toList());
     }
 
 
     private List<RuleUnit> groupingByGroup(List<BasicRule> rules) {
 
-        Map<Integer, List<BasicRule>> rulesPerUnit = rules.stream().collect(groupingBy(rule -> rule.getIdentifier().unit()));
-        return rulesPerUnit.keySet().stream().sorted().map(unit -> new RuleUnit(unit, rulesPerUnit.get(unit))).collect(Collectors.toList());
+        Map<Integer, List<BasicRule>> rulesPerUnit = rules.stream()
+                .collect(groupingBy(rule -> rule.getIdentifier().unit()));
+        return rulesPerUnit.keySet()
+                .stream()
+                .sorted()
+                .map(unit -> new RuleUnit(unit, rulesPerUnit.get(unit)))
+                .collect(Collectors.toList());
     }
 
 }

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

@@ -16,6 +16,7 @@ public class ObservedStorageService {
 
     @Observed(name = "RedactionStorageService", contextualName = "get-document-data")
     public DocumentData getDocumentData(String dossierId, String fileId) {
+
         return redactionStorageService.getDocumentData(dossierId, fileId);
     }
 

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

@@ -80,9 +80,12 @@ public class RedactionStorageService {
 
         try {
             ImportedRedactionsPerPage importedRedactionsPerPage = storageService.readJSONObject(TenantContext.getTenantId(),
-                    StorageIdUtils.getStorageId(dossierId, fileId, FileType.IMPORTED_REDACTIONS),
-                    ImportedRedactionsPerPage.class);
-            return new ImportedRedactions(importedRedactionsPerPage.getImportedRedactions().values().stream().flatMap(List::stream).collect(Collectors.toList()));
+                                                                                                StorageIdUtils.getStorageId(dossierId, fileId, FileType.IMPORTED_REDACTIONS),
+                                                                                                ImportedRedactionsPerPage.class);
+            return new ImportedRedactions(importedRedactionsPerPage.getImportedRedactions().values()
+                                                  .stream()
+                                                  .flatMap(List::stream)
+                                                  .collect(Collectors.toList()));
         } catch (StorageObjectDoesNotExist e) {
             log.debug("Imported redactions not available.");
             return new ImportedRedactions();
@@ -90,14 +93,13 @@ public class RedactionStorageService {
     }
 
 
-
     @Timed("redactmanager_getImportedRedactions")
     public ImportedRedactionsPerPage getImportedRedactionsPerPage(String dossierId, String fileId) {
 
         try {
             return storageService.readJSONObject(TenantContext.getTenantId(),
-                    StorageIdUtils.getStorageId(dossierId, fileId, FileType.IMPORTED_REDACTIONS),
-                    ImportedRedactionsPerPage.class);
+                                                 StorageIdUtils.getStorageId(dossierId, fileId, FileType.IMPORTED_REDACTIONS),
+                                                 ImportedRedactionsPerPage.class);
         } catch (StorageObjectDoesNotExist e) {
             log.debug("Imported redactions not available.");
             return null;
@@ -111,12 +113,12 @@ public class RedactionStorageService {
 
         try {
             RedactionLog redactionLog = storageService.readJSONObject(TenantContext.getTenantId(),
-                    StorageIdUtils.getStorageId(dossierId, fileId, FileType.REDACTION_LOG),
-                    RedactionLog.class);
+                                                                      StorageIdUtils.getStorageId(dossierId, fileId, FileType.REDACTION_LOG),
+                                                                      RedactionLog.class);
             redactionLog.setRedactionLogEntry(redactionLog.getRedactionLogEntry()
-                    .stream()
-                    .filter(entry -> !(entry.getPositions() == null || entry.getPositions().isEmpty()))
-                    .collect(Collectors.toList()));
+                                                      .stream()
+                                                      .filter(entry -> !(entry.getPositions() == null || entry.getPositions().isEmpty()))
+                                                      .collect(Collectors.toList()));
             return redactionLog;
         } catch (StorageObjectDoesNotExist e) {
             log.debug("RedactionLog not available.");
@@ -132,9 +134,9 @@ public class RedactionStorageService {
         try {
             EntityLog entityLog = storageService.readJSONObject(TenantContext.getTenantId(), StorageIdUtils.getStorageId(dossierId, fileId, FileType.ENTITY_LOG), EntityLog.class);
             entityLog.setEntityLogEntry(entityLog.getEntityLogEntry()
-                    .stream()
-                    .filter(entry -> !(entry.getPositions() == null || entry.getPositions().isEmpty()))
-                    .collect(Collectors.toList()));
+                                                .stream()
+                                                .filter(entry -> !(entry.getPositions() == null || entry.getPositions().isEmpty()))
+                                                .collect(Collectors.toList()));
             return entityLog;
         } catch (StorageObjectDoesNotExist e) {
             log.debug("EntityLog not available.");
@@ -156,17 +158,17 @@ public class RedactionStorageService {
         try {
             return DocumentData.builder()
                     .documentStructure(storageService.readJSONObject(TenantContext.getTenantId(),
-                            StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_STRUCTURE),
-                            DocumentStructure.class))
+                                                                     StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_STRUCTURE),
+                                                                     DocumentStructure.class))
                     .documentTextData(storageService.readJSONObject(TenantContext.getTenantId(),
-                            StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_TEXT),
-                            DocumentTextData[].class))
+                                                                    StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_TEXT),
+                                                                    DocumentTextData[].class))
                     .documentPositionData(storageService.readJSONObject(TenantContext.getTenantId(),
-                            StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_POSITION),
-                            DocumentPositionData[].class))
+                                                                        StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_POSITION),
+                                                                        DocumentPositionData[].class))
                     .documentPages(storageService.readJSONObject(TenantContext.getTenantId(),
-                            StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_PAGES),
-                            DocumentPage[].class))
+                                                                 StorageIdUtils.getStorageId(dossierId, fileId, FileType.DOCUMENT_PAGES),
+                                                                 DocumentPage[].class))
                     .build();
         } catch (StorageObjectDoesNotExist e) {
             log.debug("DocumentData not available.");

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

@@ -11,6 +11,7 @@ public class RuleManagementResources {
 
     private static final String folderPrefix = "drools";
 
+
     @SneakyThrows
     public static InputStream getBaseRuleFileInputStream() {
 
@@ -26,6 +27,7 @@ public class RuleManagementResources {
         }
     }
 
+
     @SneakyThrows
     public static InputStream getBaseComponentRuleFileInputStream() {
 
@@ -41,4 +43,20 @@ public class RuleManagementResources {
         }
     }
 
+
+    @SneakyThrows
+    public static InputStream getBlacklistFileInputStream() {
+
+        return new ClassPathResource(Path.of(folderPrefix, "blacklist.txt").toString()).getInputStream();
+    }
+
+
+    @SneakyThrows
+    public static String getBlacklistFileString() {
+
+        try (var in = getBlacklistFileInputStream()) {
+            return new String(in.readAllBytes());
+        }
+    }
+
 }

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

@@ -18,11 +18,11 @@ import lombok.extern.slf4j.Slf4j;
 public class DateConverter {
 
     static List<SimpleDateFormat> formats = List.of(new SimpleDateFormat("dd MMM yy", Locale.ENGLISH),
-            new SimpleDateFormat("dd MM yyyy", Locale.ENGLISH),
-            new SimpleDateFormat("dd MM yyyy.", Locale.ENGLISH),
-            new SimpleDateFormat("dd MMMM yyyy", Locale.ENGLISH),
-            new SimpleDateFormat("MMMM dd, yyyy", Locale.ENGLISH),
-            new SimpleDateFormat("dd-MMM-yyyy", Locale.ENGLISH));
+                                                    new SimpleDateFormat("dd MM yyyy", Locale.ENGLISH),
+                                                    new SimpleDateFormat("dd MM yyyy.", Locale.ENGLISH),
+                                                    new SimpleDateFormat("dd MMMM yyyy", Locale.ENGLISH),
+                                                    new SimpleDateFormat("MMMM dd, yyyy", Locale.ENGLISH),
+                                                    new SimpleDateFormat("dd-MMM-yyyy", Locale.ENGLISH));
 
 
     public Optional<Date> parseDate(String dateAsString) {

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

@@ -21,7 +21,9 @@ public final class IdBuilder {
 
     public String buildId(Set<Page> pages, List<Rectangle2D> rectanglesPerLine, String type, String entityType) {
 
-        return buildId(pages.stream().map(Page::getNumber).collect(Collectors.toList()), rectanglesPerLine, type, entityType);
+        return buildId(pages.stream()
+                               .map(Page::getNumber)
+                               .collect(Collectors.toList()), rectanglesPerLine, type, entityType);
     }
 
 
@@ -29,7 +31,9 @@ public final class IdBuilder {
 
         StringBuilder sb = new StringBuilder();
         sb.append(type).append(entityType);
-        List<Integer> sortedPageNumbers = pageNumbers.stream().sorted(Comparator.comparingInt(Integer::intValue)).toList();
+        List<Integer> sortedPageNumbers = pageNumbers.stream()
+                .sorted(Comparator.comparingInt(Integer::intValue))
+                .toList();
         sortedPageNumbers.forEach(sb::append);
         rectanglesPerLine.forEach(rectangle2D -> sb.append(Math.round(rectangle2D.getX()))
                 .append(Math.round(rectangle2D.getY()))

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

@@ -22,19 +22,25 @@ public class RectangleTransformations {
 
     public static Rectangle2D atomicTextBlockBBox(List<AtomicTextBlock> atomicTextBlocks) {
 
-        return atomicTextBlocks.stream().flatMap(atomicTextBlock -> atomicTextBlock.getPositions().stream()).collect(new Rectangle2DBBoxCollector());
+        return atomicTextBlocks.stream()
+                .flatMap(atomicTextBlock -> atomicTextBlock.getPositions()
+                        .stream())
+                .collect(new Rectangle2DBBoxCollector());
     }
 
 
     public static Rectangle2D rectangleBBox(List<Position> positions) {
 
-        return positions.stream().map(Position::toRectangle2D).collect(new Rectangle2DBBoxCollector());
+        return positions.stream()
+                .map(Position::toRectangle2D)
+                .collect(new Rectangle2DBBoxCollector());
     }
 
 
     public static Rectangle2D rectangle2DBBox(List<Rectangle2D> rectangle2DList) {
 
-        return rectangle2DList.stream().collect(new Rectangle2DBBoxCollector());
+        return rectangle2DList.stream()
+                .collect(new Rectangle2DBBoxCollector());
     }
 
 
@@ -49,7 +55,9 @@ public class RectangleTransformations {
         if (rectangle2DList.isEmpty()) {
             return Collections.emptyList();
         }
-        double splitThreshold = rectangle2DList.stream().mapToDouble(RectangularShape::getWidth).average().orElse(5) * 5.0;
+        double splitThreshold = rectangle2DList.stream()
+                                        .mapToDouble(RectangularShape::getWidth).average()
+                                        .orElse(5) * 5.0;
 
         List<List<Rectangle2D>> rectangleListsWithGaps = new LinkedList<>();
         List<Rectangle2D> rectangleListWithoutGaps = new LinkedList<>();
@@ -66,7 +74,9 @@ public class RectangleTransformations {
                 previousRectangle = currentRectangle;
             }
         }
-        return rectangleListsWithGaps.stream().map(RectangleTransformations::rectangle2DBBox).toList();
+        return rectangleListsWithGaps.stream()
+                .map(RectangleTransformations::rectangle2DBBox)
+                .toList();
     }
 
 
@@ -96,9 +106,9 @@ public class RectangleTransformations {
         public BinaryOperator<BBox> combiner() {
 
             return (b1, b2) -> new BBox(Math.min(b1.lowerLeftX, b2.lowerLeftX),
-                    Math.min(b1.lowerLeftY, b2.lowerLeftY),
-                    Math.max(b1.upperRightX, b2.upperRightX),
-                    Math.max(b1.upperRightY, b2.upperRightY));
+                                        Math.min(b1.lowerLeftY, b2.lowerLeftY),
+                                        Math.max(b1.upperRightX, b2.upperRightX),
+                                        Math.max(b1.upperRightY, b2.upperRightY));
         }
 
 

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

@@ -89,7 +89,10 @@ public class RedactionSearchUtility {
 
     public static TextRange findTextRangesOfAllLinesInYRange(double maxY, double minY, TextBlock textBlock) {
 
-        List<TextRange> lineBoundaries = IntStream.range(0, textBlock.numberOfLines()).boxed().map(textBlock::getLineTextRange).filter(lineBoundary -> isWithinYRange(maxY, minY, textBlock, lineBoundary)).toList();
+        List<TextRange> lineBoundaries = IntStream.range(0, textBlock.numberOfLines()).boxed()
+                .map(textBlock::getLineTextRange)
+                .filter(lineBoundary -> isWithinYRange(maxY, minY, textBlock, lineBoundary))
+                .toList();
         if (lineBoundaries.isEmpty()) {
             return new TextRange(textBlock.getTextRange().start(), textBlock.getTextRange().start());
         }
@@ -132,6 +135,7 @@ public class RedactionSearchUtility {
         return getTextRangesByPatternWithLineBreaks(textBlock, group, pattern);
     }
 
+
     public static List<TextRange> findTextRangesByRegexIgnoreCase(String regexPattern, TextBlock textBlock) {
 
         Pattern pattern = Patterns.getCompiledPattern(regexPattern, true);
@@ -185,19 +189,21 @@ public class RedactionSearchUtility {
         return getTextRangesByPattern(textBlock, 0, pattern);
     }
 
+
     public static List<TextRange> findTextRangesByList(List<String> searchList, TextBlock textBlock) {
 
         List<TextRange> boundaries = new LinkedList<>();
-        for (var searchString: searchList) {
+        for (var searchString : searchList) {
             boundaries.addAll(findTextRangesByString(searchString, textBlock));
         }
         return boundaries;
     }
 
+
     public static List<TextRange> findTextRangesByListIgnoreCase(List<String> searchList, TextBlock textBlock) {
 
         List<TextRange> boundaries = new LinkedList<>();
-        for (var searchString: searchList) {
+        for (var searchString : searchList) {
             boundaries.addAll(findTextRangesByStringIgnoreCase(searchString, textBlock));
         }
         return boundaries;

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

@@ -20,7 +20,8 @@ public final class ResourceLoader {
             throw new IllegalArgumentException("could not load classpath resource: " + classpathPath);
         }
         try (BufferedReader br = new BufferedReader(new InputStreamReader(resource.openStream(), StandardCharsets.UTF_8))) {
-            return br.lines().collect(Collectors.toSet());
+            return br.lines()
+                    .collect(Collectors.toSet());
         } catch (IOException e) {
             throw new IllegalArgumentException("could not load classpath resource: " + classpathPath, e);
         }

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

@@ -54,16 +54,16 @@ public final class SeparatorUtils {
     private static boolean validateEnd(TextBlock textBlock, TextRange textRange) {
 
         return textRange.end() == textBlock.getTextRange().end() ||//
-                SeparatorUtils.isSeparator(textBlock.charAt(textRange.end())) ||//
-                SeparatorUtils.isJapaneseSeparator(textBlock.charAt(textRange.end() - 1));
+               SeparatorUtils.isSeparator(textBlock.charAt(textRange.end())) ||//
+               SeparatorUtils.isJapaneseSeparator(textBlock.charAt(textRange.end() - 1));
     }
 
 
     private static boolean validateStart(TextBlock textBlock, TextRange textRange) {
 
         return textRange.start() == textBlock.getTextRange().start() ||//
-                SeparatorUtils.isSeparator(textBlock.charAt(textRange.start() - 1)) ||//
-                SeparatorUtils.isJapaneseSeparator(textBlock.charAt(textRange.start()));
+               SeparatorUtils.isSeparator(textBlock.charAt(textRange.start() - 1)) ||//
+               SeparatorUtils.isJapaneseSeparator(textBlock.charAt(textRange.start()));
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/resources/application-dev.yaml

@@ -16,6 +16,7 @@ redaction-service:
   cvTableParsingEnabled: false
   nerServiceEnabled: false
   priorityMode: false
+  ruleExecutionSecured: false
 
 application:
   type: "RedactManager"

redaction-service-v1/redaction-service-server-v1/src/main/resources/drools/blacklist.txt

@@ -0,0 +1,17 @@
+System.
+Runtime.
+Thread.
+ProcessBuilder.
+SecurityManager.
+ClassLoader.
+Class.
+
+java.io.File
+java.nio.file
+java.io.Object
+
+java.net
+
+java.lang
+
+java.util.zip

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

@@ -172,7 +172,7 @@ public abstract class AbstractRedactionIntegrationTest {
         when(dictionaryClient.getDictionaryForType(HINT_ONLY_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(HINT_ONLY_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(MUST_REDACT_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(MUST_REDACT_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(PUBLISHED_INFORMATION_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(PUBLISHED_INFORMATION_INDICATOR,
-                false));
+                                                                                                                                                    false));
         when(dictionaryClient.getDictionaryForType(TEST_METHOD_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(TEST_METHOD_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(PII_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(DICTIONARY_PII, false));
         when(dictionaryClient.getDictionaryForType(PURITY_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(PURITY_INDICATOR, false));
@@ -183,9 +183,9 @@ public abstract class AbstractRedactionIntegrationTest {
         when(dictionaryClient.getDictionaryForType(FORMULA_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(FORMULA_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(ROTATE_SIMPLE_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(ROTATE_SIMPLE_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(DOSSIER_REDACTIONS_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(DOSSIER_REDACTIONS_INDICATOR,
-                true));
+                                                                                                                                                 true));
         when(dictionaryClient.getDictionaryForType(IMPORTED_REDACTION_TYPE_ID, version)).then((Answer<Type>) invocation -> getDictionaryResponse(IMPORTED_REDACTION_INDICATOR,
-                true));
+                                                                                                                                                 true));
 
     }
 
@@ -193,45 +193,102 @@ public abstract class AbstractRedactionIntegrationTest {
     protected void loadDictionaryForTest() {
 
         dictionary.computeIfAbsent(DICTIONARY_AUTHOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_author.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_author.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(DICTIONARY_SPONSOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_sponsor.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_sponsor.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(VERTEBRATE_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/vertebrate.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/vertebrate.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(DICTIONARY_ADDRESS, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_address.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_address.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(NO_REDACTION_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/no_redaction_indicator.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/no_redaction_indicator.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(REDACTION_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/redaction_indicator.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/redaction_indicator.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(HINT_ONLY_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/hint_only.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/hint_only.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(MUST_REDACT_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/must_redact.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/must_redact.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PUBLISHED_INFORMATION_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/published_information.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/published_information.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(TEST_METHOD_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/test_method.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/test_method.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(DICTIONARY_PII, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/PII.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/PII.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PURITY_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/purity.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/purity.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(IMAGE_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(OCR_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(LOGO_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(SIGNATURE_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(FORMULA_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dossierDictionary.computeIfAbsent(DOSSIER_REDACTIONS_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/dossier_redactions.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/dossier_redactions.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dossierDictionary.put(IMPORTED_REDACTION_INDICATOR, new ArrayList<>());
 
         falsePositive.computeIfAbsent(DICTIONARY_PII, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/PII_false_positive.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/PII_false_positive.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
 
     }
 
@@ -240,7 +297,10 @@ public abstract class AbstractRedactionIntegrationTest {
 
         dictionary.clear();
         dictionary.computeIfAbsent(ROTATE_SIMPLE_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/RotateTestFileSimple.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/RotateTestFileSimple.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
     }
 
 
@@ -373,8 +433,8 @@ public abstract class AbstractRedactionIntegrationTest {
 
         ClassPathResource responseJson = new ClassPathResource("files/ner_response.json");
         storageService.storeObject(TenantContext.getTenantId(),
-                RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.NER_ENTITIES),
-                responseJson.getInputStream());
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.NER_ENTITIES),
+                                   responseJson.getInputStream());
     }
 
 
@@ -424,7 +484,9 @@ public abstract class AbstractRedactionIntegrationTest {
         if (entries == null) {
             return Collections.emptyList();
         }
-        return entries.stream().map(this::toDictionaryEntry).collect(Collectors.toList());
+        return entries.stream()
+                .map(this::toDictionaryEntry)
+                .collect(Collectors.toList());
 
     }
 
@@ -480,11 +542,11 @@ public abstract class AbstractRedactionIntegrationTest {
 
         storageService.storeObject(TenantContext.getTenantId(), RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.ORIGIN), fileStream);
         storageService.storeObject(TenantContext.getTenantId(),
-                RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.TABLES),
-                cvServiceResponseFileStream);
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.TABLES),
+                                   cvServiceResponseFileStream);
         storageService.storeObject(TenantContext.getTenantId(),
-                RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.IMAGE_INFO),
-                imageServiceResponseStream);
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.IMAGE_INFO),
+                                   imageServiceResponseStream);
 
         return request;
 

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

@@ -104,15 +104,15 @@ public class AnalysisTest extends AbstractRedactionIntegrationTest {
 
         when(dictionaryClient.getVersion(TEST_DOSSIER_TEMPLATE_ID)).thenReturn(0L);
         when(dictionaryClient.getAllTypesForDossier(TEST_DOSSIER_ID, false)).thenReturn(List.of(Type.builder()
-                .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
-                .type(DOSSIER_REDACTIONS_INDICATOR)
-                .dossierTemplateId(TEST_DOSSIER_ID)
-                .hexColor("#ffe187")
-                .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .build()));
+                                                                                                        .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
+                                                                                                        .type(DOSSIER_REDACTIONS_INDICATOR)
+                                                                                                        .dossierTemplateId(TEST_DOSSIER_ID)
+                                                                                                        .hexColor("#ffe187")
+                                                                                                        .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .build()));
 
         mockDictionaryCalls(null);
 

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

@@ -82,18 +82,18 @@ public class DictionaryServiceTest {
 
         when(dictionaryClient.getVersion(anyString())).thenReturn(0L);
         when(dictionaryClient.getColors(anyString())).thenReturn(new Colors("dossierTemplateId",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc"));
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc"));
 
         var type1 = new Type();
         type1.setType("type1");
@@ -101,7 +101,9 @@ public class DictionaryServiceTest {
         type1.setVersion(1L);
         type1.setHexColor("#cccccc");
         type1.setHasDictionary(true);
-        type1.setEntries(Stream.of("a", "b", "c").map(t -> new DictionaryEntry(1, t, 1L, false, "type1")).collect(Collectors.toList()));
+        type1.setEntries(Stream.of("a", "b", "c")
+                                 .map(t -> new DictionaryEntry(1, t, 1L, false, "type1"))
+                                 .collect(Collectors.toList()));
 
         var type2 = new Type();
         type2.setType("type2");
@@ -109,7 +111,9 @@ public class DictionaryServiceTest {
         type2.setVersion(1L);
         type2.setHexColor("#cccccc");
         type2.setHasDictionary(true);
-        type2.setEntries(Stream.of("d", "e", "f").map(t -> new DictionaryEntry(1, t, 1L, false, "type2")).collect(Collectors.toList()));
+        type2.setEntries(Stream.of("d", "e", "f")
+                                 .map(t -> new DictionaryEntry(1, t, 1L, false, "type2"))
+                                 .collect(Collectors.toList()));
 
         var type1Updated = new Type();
         type1Updated.setType("type1");
@@ -117,7 +121,9 @@ public class DictionaryServiceTest {
         type1Updated.setVersion(2L);
         type1Updated.setHexColor("#cccccc");
         type1Updated.setHasDictionary(true);
-        type1Updated.setEntries(Stream.of("z", "q", "x").map(t -> new DictionaryEntry(1, t, 2L, false, "type1")).collect(Collectors.toList()));
+        type1Updated.setEntries(Stream.of("z", "q", "x")
+                                        .map(t -> new DictionaryEntry(1, t, 2L, false, "type1"))
+                                        .collect(Collectors.toList()));
 
         when(dictionaryClient.getAllTypesForDossierTemplate(anyString(), anyBoolean())).thenReturn(List.of(type1, type2));
         when(dictionaryClient.getDictionaryForType("type1", null)).thenReturn(type1);
@@ -174,18 +180,18 @@ public class DictionaryServiceTest {
 
         when(dictionaryClient.getVersion(anyString())).thenReturn(0L);
         when(dictionaryClient.getColors(anyString())).thenReturn(new Colors("dtId",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc",
-                "#cccccc"));
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc",
+                                                                            "#cccccc"));
 
         var type = "type";
         var dtType = new Type();
@@ -195,7 +201,9 @@ public class DictionaryServiceTest {
         dtType.setHexColor("#cccccc");
         dtType.setHasDictionary(true);
         dtType.setDossierTemplateId("dtId");
-        List<DictionaryEntry> dossierTemplateEntries = Stream.of("aa", "bb").map(t -> new DictionaryEntry(1, t, 1L, false, "type1")).collect(Collectors.toList());
+        List<DictionaryEntry> dossierTemplateEntries = Stream.of("aa", "bb")
+                .map(t -> new DictionaryEntry(1, t, 1L, false, "type1"))
+                .collect(Collectors.toList());
         dossierTemplateEntries.add(new DictionaryEntry(1, "cc", 2L, false, "type1"));
         assertThat(dossierTemplateEntries.size()).isEqualTo(3);
         dtType.setEntries(dossierTemplateEntries);
@@ -208,7 +216,9 @@ public class DictionaryServiceTest {
         dossierType.setHasDictionary(true);
         dossierType.setDossierTemplateId("dtId");
         dossierType.setDossierId("dossierId");
-        List<DictionaryEntry> dossierEntries = Stream.of("aa", "bb").map(t -> new DictionaryEntry(1, t, 2L, true, "dossierType")).collect(Collectors.toList());
+        List<DictionaryEntry> dossierEntries = Stream.of("aa", "bb")
+                .map(t -> new DictionaryEntry(1, t, 2L, true, "dossierType"))
+                .collect(Collectors.toList());
         dossierEntries.add(new DictionaryEntry(1, "dd", 1L, false, "dossierType"));
         assertThat(dossierEntries.size()).isEqualTo(3);
         dossierType.setEntries(dossierEntries);
@@ -224,15 +234,17 @@ public class DictionaryServiceTest {
         dictionaryService.updateDictionary("dtId", "dossierId");
         var dict = dictionaryService.getDeepCopyDictionary("dtId", "dossierId");
         assertThat(dict.getDictionaryModels().size()).isEqualTo(1);
-        var dictModel = dict.getDictionaryModels().get(0);
+        var dictModel = dict.getDictionaryModels()
+                .get(0);
         assertThat(dictModel.getType()).isEqualTo(type);
         assertThat(dictModel.getEntries().size()).isEqualTo(4);
-        dictModel.getEntries().forEach(entry -> {
-            switch (entry.getValue()) {
-                case "aa", "dd", "bb" -> assertThat(entry.getTypeId()).isEqualTo(dossierType.getTypeId());
-                case "cc" -> assertThat(entry.getTypeId()).isEqualTo(dtType.getTypeId());
-            }
-        });
+        dictModel.getEntries()
+                .forEach(entry -> {
+                    switch (entry.getValue()) {
+                        case "aa", "dd", "bb" -> assertThat(entry.getTypeId()).isEqualTo(dossierType.getTypeId());
+                        case "cc" -> assertThat(entry.getTypeId()).isEqualTo(dtType.getTypeId());
+                    }
+                });
     }
 
 }

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

@@ -8,6 +8,7 @@ import java.util.List;
 
 import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
 import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
@@ -55,9 +56,11 @@ public class DocumineFloraTest extends AbstractRedactionIntegrationTest {
 
         AnalyzeRequest request = uploadFileToStorage("files/ImportedRedactions/18 Chlorothalonil RAR 08 Volume 3CA B 6a Oct 2017.pdf");
 
-        ClassPathResource importedRedactionClasspathResource = new ClassPathResource("files/ImportedRedactions/18 Chlorothalonil RAR 08 Volume 3CA B 6a Oct 2017.IMPORTED_REDACTIONS.json");
-        storageService.storeObject(TenantContext.getTenantId(), RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.IMPORTED_REDACTIONS), importedRedactionClasspathResource.getInputStream());
-
+        ClassPathResource importedRedactionClasspathResource = new ClassPathResource(
+                "files/ImportedRedactions/18 Chlorothalonil RAR 08 Volume 3CA B 6a Oct 2017.IMPORTED_REDACTIONS.json");
+        storageService.storeObject(TenantContext.getTenantId(),
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.IMPORTED_REDACTIONS),
+                                   importedRedactionClasspathResource.getInputStream());
 
 //        AnalyzeRequest request = prepareStorage("files/Documine/Flora/ProblemDocs/SOLICITA_VICTRATO-GOLD-II_Item 21_Mutacao_Genica (1).pdf",
 //                "files/Documine/Flora/ProblemDocs/SOLICITA_VICTRATO-GOLD-II_Item 21_Mutacao_Genica (1).TABLES.json");
@@ -86,7 +89,7 @@ public class DocumineFloraTest extends AbstractRedactionIntegrationTest {
 
         // FIXME TableNodeFactory: 36, why has table no rows/cols here.
         AnalyzeRequest request = prepareStorage("files/Documine/Flora/A8591B/2009773e2e05919bb9e46aeedcc8b924.ORIGIN.pdf",
-                "files/Documine/Flora/A8591B/2009773e2e05919bb9e46aeedcc8b924.ORIGIN.TABLES.json");
+                                                "files/Documine/Flora/A8591B/2009773e2e05919bb9e46aeedcc8b924.ORIGIN.TABLES.json");
 
         System.out.println("Start Full integration test");
         analyzeDocumentStructure(LayoutParsingType.DOCUMINE, request);
@@ -166,15 +169,15 @@ public class DocumineFloraTest extends AbstractRedactionIntegrationTest {
 
         when(dictionaryClient.getVersion(TEST_DOSSIER_TEMPLATE_ID)).thenReturn(0L);
         when(dictionaryClient.getAllTypesForDossier(TEST_DOSSIER_ID, true)).thenReturn(List.of(Type.builder()
-                .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
-                .type(DOSSIER_REDACTIONS_INDICATOR)
-                .dossierTemplateId(TEST_DOSSIER_ID)
-                .hexColor("#ffe187")
-                .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .build()));
+                                                                                                       .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
+                                                                                                       .type(DOSSIER_REDACTIONS_INDICATOR)
+                                                                                                       .dossierTemplateId(TEST_DOSSIER_ID)
+                                                                                                       .hexColor("#ffe187")
+                                                                                                       .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .build()));
 
         mockDictionaryCalls(null);
 

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

@@ -87,15 +87,15 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
 
         when(dictionaryClient.getVersion(TEST_DOSSIER_TEMPLATE_ID)).thenReturn(0L);
         when(dictionaryClient.getAllTypesForDossier(TEST_DOSSIER_ID, true)).thenReturn(List.of(Type.builder()
-                .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
-                .type(DOSSIER_REDACTIONS_INDICATOR)
-                .dossierTemplateId(TEST_DOSSIER_ID)
-                .hexColor("#ffe187")
-                .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .build()));
+                                                                                                       .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
+                                                                                                       .type(DOSSIER_REDACTIONS_INDICATOR)
+                                                                                                       .dossierTemplateId(TEST_DOSSIER_ID)
+                                                                                                       .hexColor("#ffe187")
+                                                                                                       .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                       .build()));
 
         mockDictionaryCalls(null);
 
@@ -122,10 +122,11 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
         assertThat(recommendations).containsExactlyInAnyOrder("Michael N.", "Funnarie B.", "Feuer A.");
     }
 
+
     @Test
     public void acceptanceTests() throws IOException {
 
-        AnalyzeRequest request = uploadFileToStorage("files/new/SYNGENTA_EFSA_sanitisation_GFL_v1_moreSections.pdf");
+        AnalyzeRequest request = uploadFileToStorage("files/syngenta/CustomerFiles/SYNGENTA_EFSA_sanitisation_GFL_v1_moreSections.pdf");
         System.out.println("Start Full integration test");
         analyzeDocumentStructure(LayoutParsingType.REDACT_MANAGER, request);
         System.out.println("Finished structure analysis");
@@ -133,8 +134,10 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
         System.out.println("Finished analysis");
         EntityLog entityLog = redactionStorageService.getEntityLog(TEST_DOSSIER_ID, TEST_FILE_ID);
 
-        var publishedInformationEntry1 = findEntityByTypeAndValue(entityLog, "published_information", "Oxford University Press").findFirst().orElseThrow();
-        var asyaLyon1 = findEntityByTypeAndValueAndSectionNumber(entityLog, "CBI_author", "Asya Lyon", publishedInformationEntry1.getContainingNodeId()).findFirst().orElseThrow();
+        var publishedInformationEntry1 = findEntityByTypeAndValue(entityLog, "published_information", "Oxford University Press").findFirst()
+                .orElseThrow();
+        var asyaLyon1 = findEntityByTypeAndValueAndSectionNumber(entityLog, "CBI_author", "Asya Lyon", publishedInformationEntry1.getContainingNodeId()).findFirst()
+                .orElseThrow();
 
         assertEquals(EntryState.SKIPPED, asyaLyon1.getState());
 
@@ -146,8 +149,10 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
 
         entityLog = redactionStorageService.getEntityLog(TEST_DOSSIER_ID, TEST_FILE_ID);
 
-        var publishedInformationEntry2 = findEntityByTypeAndValue(entityLog, "published_information", "Oxford University Press").findFirst().orElseThrow();
-        var asyaLyon2 = findEntityByTypeAndValueAndSectionNumber(entityLog, "CBI_author", "Asya Lyon", publishedInformationEntry2.getContainingNodeId()).findFirst().orElseThrow();
+        var publishedInformationEntry2 = findEntityByTypeAndValue(entityLog, "published_information", "Oxford University Press").findFirst()
+                .orElseThrow();
+        var asyaLyon2 = findEntityByTypeAndValueAndSectionNumber(entityLog, "CBI_author", "Asya Lyon", publishedInformationEntry2.getContainingNodeId()).findFirst()
+                .orElseThrow();
 
         assertEquals(EntryState.APPLIED, asyaLyon2.getState());
 
@@ -168,20 +173,24 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
                 .stream()
                 .filter(entry -> entry.getType().equals(type))
                 .filter(entry -> entry.getValue().equals(value))
-                .filter(entry -> entry.getContainingNodeId().get(0).equals(sectionNumber.get(0)));
+                .filter(entry -> entry.getContainingNodeId()
+                        .get(0).equals(sectionNumber.get(0)));
     }
 
 
     private static Stream<EntityLogEntry> findEntityByTypeAndValue(EntityLog redactionLog, String type, String value) {
 
-        return redactionLog.getEntityLogEntry().stream().filter(entry -> entry.getType().equals(type)).filter(entry -> entry.getValue().equals(value));
+        return redactionLog.getEntityLogEntry()
+                .stream()
+                .filter(entry -> entry.getType().equals(type))
+                .filter(entry -> entry.getValue().equals(value));
     }
 
 
     @Test
     public void noEndlessLoopsTest() {
 
-        AnalyzeRequest request = uploadFileToStorage("files/new/SYNGENTA_EFSA_sanitisation_GFL_v1_moreSections.pdf");
+        AnalyzeRequest request = uploadFileToStorage("files/syngenta/CustomerFiles/SYNGENTA_EFSA_sanitisation_GFL_v1_moreSections.pdf");
         System.out.println("Start Full integration test");
         analyzeDocumentStructure(LayoutParsingType.REDACT_MANAGER, request);
         System.out.println("Finished structure analysis");
@@ -201,7 +210,9 @@ public class RedactionAcceptanceTest extends AbstractRedactionIntegrationTest {
 
         var redactionLog2 = redactionStorageService.getEntityLog(TEST_DOSSIER_ID, TEST_FILE_ID);
         assertEquals(EntryState.IGNORED,
-                findEntityByTypeAndValue(redactionLog2, "CBI_author", "Desiree").filter(entry -> entry.getEntryType().equals(EntryType.ENTITY)).findFirst().get().getState());
+                     findEntityByTypeAndValue(redactionLog2, "CBI_author", "Desiree").filter(entry -> entry.getEntryType().equals(EntryType.ENTITY))
+                             .findFirst()
+                             .get().getState());
     }
 
 

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

@@ -246,6 +246,7 @@ public class RedactionIntegrationTest extends AbstractRedactionIntegrationTest {
 
 
     @Test
+    @SneakyThrows
     public void redactionExpansionOverlap() {
 
         // F. Lastname, J. Doe, M. Mustermann
@@ -297,7 +298,7 @@ public class RedactionIntegrationTest extends AbstractRedactionIntegrationTest {
     @Test
     public void titleExtraction() throws IOException {
 
-        AnalyzeRequest request = uploadFileToStorage("files/Metolachlor/S-Metolachlor_RAR_01_Volume_1_2018-09-06.pdf");
+        AnalyzeRequest request = uploadFileToStorage("files/new/crafted document.pdf");
         System.out.println("Start Full integration test");
         analyzeDocumentStructure(LayoutParsingType.REDACT_MANAGER, request);
         System.out.println("Finished structure analysis");

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

@@ -78,15 +78,15 @@ public class RedactionIntegrationV2Test extends AbstractRedactionIntegrationTest
 
         when(dictionaryClient.getVersion(TEST_DOSSIER_TEMPLATE_ID)).thenReturn(0L);
         when(dictionaryClient.getAllTypesForDossier(TEST_DOSSIER_ID, false)).thenReturn(List.of(Type.builder()
-                .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
-                .type(DOSSIER_REDACTIONS_INDICATOR)
-                .dossierTemplateId(TEST_DOSSIER_ID)
-                .hexColor("#ffe187")
-                .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
-                .build()));
+                                                                                                        .id(DOSSIER_REDACTIONS_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID)
+                                                                                                        .type(DOSSIER_REDACTIONS_INDICATOR)
+                                                                                                        .dossierTemplateId(TEST_DOSSIER_ID)
+                                                                                                        .hexColor("#ffe187")
+                                                                                                        .isHint(hintTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .rank(rankTypeMap.get(DOSSIER_REDACTIONS_INDICATOR))
+                                                                                                        .build()));
 
         mockDictionaryCalls(null);
 
@@ -128,7 +128,8 @@ public class RedactionIntegrationV2Test extends AbstractRedactionIntegrationTest
 
         assertThat(entityLog.getEntityLogEntry().size()).isEqualTo(1);
 
-        EntityLogEntry redactionLogEntry = entityLog.getEntityLogEntry().get(0);
+        EntityLogEntry redactionLogEntry = entityLog.getEntityLogEntry()
+                .get(0);
 
         assertThat(redactionLogEntry.getType()).isEqualTo(DICTIONARY_AUTHOR);
         assertThat(redactionLogEntry.getValue()).isEqualTo(entryAuthorAndPIIDictionary);
@@ -164,7 +165,8 @@ public class RedactionIntegrationV2Test extends AbstractRedactionIntegrationTest
 
         assertThat(redactionLog.getEntityLogEntry().size()).isEqualTo(1);
 
-        EntityLogEntry redactionLogEntry = redactionLog.getEntityLogEntry().get(0);
+        EntityLogEntry redactionLogEntry = redactionLog.getEntityLogEntry()
+                .get(0);
 
         assertThat(redactionLogEntry.getType()).isEqualTo(DICTIONARY_AUTHOR);
         assertThat(redactionLogEntry.getValue()).isEqualTo(entryAuthorDictionary);

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

@@ -136,99 +136,99 @@ public class RulesTest {
     private final Map<String, List<String>> dossierDictionary = new HashMap<>();
     private final Map<String, List<String>> falsePositive = new HashMap<>();
     private static final Map<String, String> typeColorMap = Map.ofEntries(entry(VERTEBRATE, "#ff85f7"),
-            entry(ADDRESS, "#ffe187"),
-            entry(AUTHOR, "#ffe187"),
-            entry(SPONSOR, "#85ebff"),
-            entry(NO_REDACTION_INDICATOR, "#be85ff"),
-            entry(REDACTION_INDICATOR, "#caff85"),
-            entry(HINT_ONLY, "#abc0c4"),
-            entry(MUST_REDACT, "#fab4c0"),
-            entry(PUBLISHED_INFORMATION, "#85ebff"),
-            entry(TEST_METHOD, "#91fae8"),
-            entry(PII, "#66ccff"),
-            entry(PURITY, "#ffe187"),
-            entry(IMAGE, "#fcc5fb"),
-            entry(OCR, "#fcc5fb"),
-            entry(LOGO, "#ffe187"),
-            entry(FORMULA, "#ffe187"),
-            entry(SIGNATURE, "#ffe187"),
-            entry(IMPORTED_REDACTION, "#fcfbe6"));
+                                                                          entry(ADDRESS, "#ffe187"),
+                                                                          entry(AUTHOR, "#ffe187"),
+                                                                          entry(SPONSOR, "#85ebff"),
+                                                                          entry(NO_REDACTION_INDICATOR, "#be85ff"),
+                                                                          entry(REDACTION_INDICATOR, "#caff85"),
+                                                                          entry(HINT_ONLY, "#abc0c4"),
+                                                                          entry(MUST_REDACT, "#fab4c0"),
+                                                                          entry(PUBLISHED_INFORMATION, "#85ebff"),
+                                                                          entry(TEST_METHOD, "#91fae8"),
+                                                                          entry(PII, "#66ccff"),
+                                                                          entry(PURITY, "#ffe187"),
+                                                                          entry(IMAGE, "#fcc5fb"),
+                                                                          entry(OCR, "#fcc5fb"),
+                                                                          entry(LOGO, "#ffe187"),
+                                                                          entry(FORMULA, "#ffe187"),
+                                                                          entry(SIGNATURE, "#ffe187"),
+                                                                          entry(IMPORTED_REDACTION, "#fcfbe6"));
     private static final Map<String, Boolean> hintTypeMap = Map.ofEntries(entry(VERTEBRATE, true),
-            entry(ADDRESS, false),
-            entry(AUTHOR, false),
-            entry(SPONSOR, false),
-            entry(NO_REDACTION_INDICATOR, true),
-            entry(REDACTION_INDICATOR, true),
-            entry(HINT_ONLY, true),
-            entry(MUST_REDACT, true),
-            entry(PUBLISHED_INFORMATION, true),
-            entry(TEST_METHOD, true),
-            entry(PII, false),
-            entry(PURITY, false),
-            entry(IMAGE, true),
-            entry(OCR, true),
-            entry(FORMULA, false),
-            entry(LOGO, false),
-            entry(SIGNATURE, false),
-            entry(DOSSIER_REDACTIONS, false),
-            entry(IMPORTED_REDACTION, false));
+                                                                          entry(ADDRESS, false),
+                                                                          entry(AUTHOR, false),
+                                                                          entry(SPONSOR, false),
+                                                                          entry(NO_REDACTION_INDICATOR, true),
+                                                                          entry(REDACTION_INDICATOR, true),
+                                                                          entry(HINT_ONLY, true),
+                                                                          entry(MUST_REDACT, true),
+                                                                          entry(PUBLISHED_INFORMATION, true),
+                                                                          entry(TEST_METHOD, true),
+                                                                          entry(PII, false),
+                                                                          entry(PURITY, false),
+                                                                          entry(IMAGE, true),
+                                                                          entry(OCR, true),
+                                                                          entry(FORMULA, false),
+                                                                          entry(LOGO, false),
+                                                                          entry(SIGNATURE, false),
+                                                                          entry(DOSSIER_REDACTIONS, false),
+                                                                          entry(IMPORTED_REDACTION, false));
     private static final Map<String, Boolean> caseInSensitiveMap = Map.ofEntries(entry(VERTEBRATE, true),
-            entry(ADDRESS, false),
-            entry(AUTHOR, false),
-            entry(SPONSOR, false),
-            entry(NO_REDACTION_INDICATOR, true),
-            entry(REDACTION_INDICATOR, true),
-            entry(HINT_ONLY, true),
-            entry(MUST_REDACT, true),
-            entry(PUBLISHED_INFORMATION, true),
-            entry(TEST_METHOD, false),
-            entry(PII, false),
-            entry(PURITY, false),
-            entry(IMAGE, true),
-            entry(OCR, true),
-            entry(SIGNATURE, true),
-            entry(LOGO, true),
-            entry(FORMULA, true),
-            entry(DOSSIER_REDACTIONS, false),
-            entry(IMPORTED_REDACTION, false));
+                                                                                 entry(ADDRESS, false),
+                                                                                 entry(AUTHOR, false),
+                                                                                 entry(SPONSOR, false),
+                                                                                 entry(NO_REDACTION_INDICATOR, true),
+                                                                                 entry(REDACTION_INDICATOR, true),
+                                                                                 entry(HINT_ONLY, true),
+                                                                                 entry(MUST_REDACT, true),
+                                                                                 entry(PUBLISHED_INFORMATION, true),
+                                                                                 entry(TEST_METHOD, false),
+                                                                                 entry(PII, false),
+                                                                                 entry(PURITY, false),
+                                                                                 entry(IMAGE, true),
+                                                                                 entry(OCR, true),
+                                                                                 entry(SIGNATURE, true),
+                                                                                 entry(LOGO, true),
+                                                                                 entry(FORMULA, true),
+                                                                                 entry(DOSSIER_REDACTIONS, false),
+                                                                                 entry(IMPORTED_REDACTION, false));
     private static final Map<String, Boolean> recommendationTypeMap = Map.ofEntries(entry(VERTEBRATE, false),
-            entry(ADDRESS, false),
-            entry(AUTHOR, false),
-            entry(SPONSOR, false),
-            entry(NO_REDACTION_INDICATOR, false),
-            entry(REDACTION_INDICATOR, false),
-            entry(HINT_ONLY, false),
-            entry(MUST_REDACT, false),
-            entry(PUBLISHED_INFORMATION, false),
-            entry(TEST_METHOD, false),
-            entry(PII, false),
-            entry(PURITY, false),
-            entry(IMAGE, false),
-            entry(OCR, false),
-            entry(FORMULA, false),
-            entry(SIGNATURE, false),
-            entry(LOGO, false),
-            entry(DOSSIER_REDACTIONS, false),
-            entry(IMPORTED_REDACTION, false));
+                                                                                    entry(ADDRESS, false),
+                                                                                    entry(AUTHOR, false),
+                                                                                    entry(SPONSOR, false),
+                                                                                    entry(NO_REDACTION_INDICATOR, false),
+                                                                                    entry(REDACTION_INDICATOR, false),
+                                                                                    entry(HINT_ONLY, false),
+                                                                                    entry(MUST_REDACT, false),
+                                                                                    entry(PUBLISHED_INFORMATION, false),
+                                                                                    entry(TEST_METHOD, false),
+                                                                                    entry(PII, false),
+                                                                                    entry(PURITY, false),
+                                                                                    entry(IMAGE, false),
+                                                                                    entry(OCR, false),
+                                                                                    entry(FORMULA, false),
+                                                                                    entry(SIGNATURE, false),
+                                                                                    entry(LOGO, false),
+                                                                                    entry(DOSSIER_REDACTIONS, false),
+                                                                                    entry(IMPORTED_REDACTION, false));
     private static final Map<String, Integer> rankTypeMap = Map.ofEntries(entry(PURITY, 155),
-            entry(PII, 150),
-            entry(ADDRESS, 140),
-            entry(AUTHOR, 130),
-            entry(SPONSOR, 120),
-            entry(VERTEBRATE, 110),
-            entry(MUST_REDACT, 100),
-            entry(REDACTION_INDICATOR, 90),
-            entry(NO_REDACTION_INDICATOR, 80),
-            entry(PUBLISHED_INFORMATION, 70),
-            entry(TEST_METHOD, 60),
-            entry(HINT_ONLY, 50),
-            entry(IMAGE, 30),
-            entry(OCR, 29),
-            entry(LOGO, 28),
-            entry(SIGNATURE, 27),
-            entry(FORMULA, 26),
-            entry(DOSSIER_REDACTIONS, 200),
-            entry(IMPORTED_REDACTION, 200));
+                                                                          entry(PII, 150),
+                                                                          entry(ADDRESS, 140),
+                                                                          entry(AUTHOR, 130),
+                                                                          entry(SPONSOR, 120),
+                                                                          entry(VERTEBRATE, 110),
+                                                                          entry(MUST_REDACT, 100),
+                                                                          entry(REDACTION_INDICATOR, 90),
+                                                                          entry(NO_REDACTION_INDICATOR, 80),
+                                                                          entry(PUBLISHED_INFORMATION, 70),
+                                                                          entry(TEST_METHOD, 60),
+                                                                          entry(HINT_ONLY, 50),
+                                                                          entry(IMAGE, 30),
+                                                                          entry(OCR, 29),
+                                                                          entry(LOGO, 28),
+                                                                          entry(SIGNATURE, 27),
+                                                                          entry(FORMULA, 26),
+                                                                          entry(DOSSIER_REDACTIONS, 200),
+                                                                          entry(IMPORTED_REDACTION, 200));
     private final Colors colors = new Colors();
 
     @Autowired
@@ -273,15 +273,15 @@ public class RulesTest {
 
         when(dictionaryClient.getVersion(TEST_DOSSIER_TEMPLATE_ID)).thenReturn(0L);
         when(dictionaryClient.getAllTypesForDossier(TEST_DOSSIER_ID, false)).thenReturn(List.of(Type.builder()
-                .id(DOSSIER_REDACTIONS + ":" + TEST_DOSSIER_TEMPLATE_ID)
-                .type(DOSSIER_REDACTIONS)
-                .dossierTemplateId(TEST_DOSSIER_ID)
-                .hexColor("#ffe187")
-                .isHint(hintTypeMap.get(DOSSIER_REDACTIONS))
-                .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS))
-                .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS))
-                .rank(rankTypeMap.get(DOSSIER_REDACTIONS))
-                .build()));
+                                                                                                        .id(DOSSIER_REDACTIONS + ":" + TEST_DOSSIER_TEMPLATE_ID)
+                                                                                                        .type(DOSSIER_REDACTIONS)
+                                                                                                        .dossierTemplateId(TEST_DOSSIER_ID)
+                                                                                                        .hexColor("#ffe187")
+                                                                                                        .isHint(hintTypeMap.get(DOSSIER_REDACTIONS))
+                                                                                                        .isCaseInsensitive(caseInSensitiveMap.get(DOSSIER_REDACTIONS))
+                                                                                                        .isRecommendation(recommendationTypeMap.get(DOSSIER_REDACTIONS))
+                                                                                                        .rank(rankTypeMap.get(DOSSIER_REDACTIONS))
+                                                                                                        .build()));
 
         mockDictionaryCalls(null);
         mockDictionaryCalls(0L);
@@ -372,10 +372,10 @@ public class RulesTest {
             log.warn("WARNING: {} files from {} failed", failedFiles.size(), fileSize);
             for (String fileName : failedFiles.keySet()) {
                 log.warn(" - '{}' failed with Error: {} See line {} in {}",
-                        fileName,
-                        failedFiles.get(fileName),
-                        failedFiles.get(fileName).getStackTrace()[0].getLineNumber(),
-                        failedFiles.get(fileName).getStackTrace()[0].getClassName());
+                         fileName,
+                         failedFiles.get(fileName),
+                         failedFiles.get(fileName).getStackTrace()[0].getLineNumber(),
+                         failedFiles.get(fileName).getStackTrace()[0].getClassName());
             }
         }
 
@@ -442,9 +442,13 @@ public class RulesTest {
         assertThat(entityLog.getLegalBasisVersion()).isEqualTo(savedRedactionLog.getLegalBasisVersion());
 
         assertThat(entityLog.getEntityLogEntry()
-                .stream().filter(r -> !r.getEntryType().equals(EntryType.FALSE_POSITIVE)).filter(r -> !r.getEntryType().equals(EntryType.FALSE_RECOMMENDATION))
-                .collect(Collectors.toSet())
-                .size()).isEqualTo(savedRedactionLog.getRedactionLogEntry().stream().filter(r -> !r.isFalsePositive()).collect(Collectors.toSet()).size());
+                           .stream()
+                           .filter(r -> !r.getEntryType().equals(EntryType.FALSE_POSITIVE))
+                           .filter(r -> !r.getEntryType().equals(EntryType.FALSE_RECOMMENDATION))
+                           .collect(Collectors.toSet()).size()).isEqualTo(savedRedactionLog.getRedactionLogEntry()
+                                                                                  .stream()
+                                                                                  .filter(r -> !r.isFalsePositive())
+                                                                                  .collect(Collectors.toSet()).size());
         assertThat(entityLog.getLegalBasis().size()).isEqualTo(savedRedactionLog.getLegalBasis().size());
 
         for (EntityLogLegalBasis redactionLegalBasis : entityLog.getLegalBasis()) {
@@ -458,7 +462,10 @@ public class RulesTest {
         }
 
         for (EntityLogEntry redactionLogEntry : entityLog.getEntityLogEntry()) {
-            var savedRedactionLogEntry = savedRedactionLog.getRedactionLogEntry().stream().filter(r -> r.getId().equalsIgnoreCase(redactionLogEntry.getId())).findFirst();
+            var savedRedactionLogEntry = savedRedactionLog.getRedactionLogEntry()
+                    .stream()
+                    .filter(r -> r.getId().equalsIgnoreCase(redactionLogEntry.getId()))
+                    .findFirst();
             assertThat(savedRedactionLogEntry).isPresent();
             assertThat(savedRedactionLogEntry.get().getId()).isEqualTo(redactionLogEntry.getId());
             assertThat(savedRedactionLogEntry.get().getType()).isEqualTo(redactionLogEntry.getType());
@@ -473,7 +480,8 @@ public class RulesTest {
             assertThat(savedRedactionLogEntry.get().isFalsePositive()).isEqualTo(redactionLogEntry.getEntryType().equals(EntryType.FALSE_POSITIVE));
             assertThat(savedRedactionLogEntry.get().getSection()).isEqualTo(redactionLogEntry.getSection());
             assertThat(savedRedactionLogEntry.get().getColor()).isEqualTo(redactionLogEntry.getColor());
-            assertThat(savedRedactionLogEntry.get().getSectionNumber()).isEqualTo(redactionLogEntry.getContainingNodeId().get(0));
+            assertThat(savedRedactionLogEntry.get().getSectionNumber()).isEqualTo(redactionLogEntry.getContainingNodeId()
+                                                                                          .get(0));
             assertThat(savedRedactionLogEntry.get().getTextBefore()).isEqualTo(redactionLogEntry.getTextBefore());
             assertThat(savedRedactionLogEntry.get().getTextAfter()).isEqualTo(redactionLogEntry.getTextAfter());
             assertThat(savedRedactionLogEntry.get().getStartOffset()).isEqualTo(redactionLogEntry.getStartOffset());
@@ -485,8 +493,7 @@ public class RulesTest {
             assertThat(savedRedactionLogEntry.get().isExcluded()).isEqualTo(redactionLogEntry.isExcluded());
 
             for (Position position : redactionLogEntry.getPositions()) {
-                var savedRectangle = savedRedactionLogEntry.get()
-                        .getPositions()
+                var savedRectangle = savedRedactionLogEntry.get().getPositions()
                         .stream()
                         .filter(r -> r.getPage() == position.getPageNumber())
                         .filter(r -> r.getTopLeft().getX() == position.x())
@@ -498,17 +505,16 @@ public class RulesTest {
             }
 
             for (Change change : redactionLogEntry.getChanges()) {
-                var savedChange = savedRedactionLogEntry.get()
-                        .getChanges()
+                var savedChange = savedRedactionLogEntry.get().getChanges()
                         .stream()
-                        .filter(c -> c.getAnalysisNumber() == change.getAnalysisNumber()).filter(c -> c.getType().name().equals(change.getType().name()))
+                        .filter(c -> c.getAnalysisNumber() == change.getAnalysisNumber())
+                        .filter(c -> c.getType().name().equals(change.getType().name()))
                         .findFirst();
                 assertThat(savedChange).isPresent();
             }
 
             for (ManualChange manualChange : redactionLogEntry.getManualChanges()) {
-                var savedManualChange = savedRedactionLogEntry.get()
-                        .getManualChanges()
+                var savedManualChange = savedRedactionLogEntry.get().getManualChanges()
                         .stream()
                         .filter(m -> m.getManualRedactionType().name().equals(manualChange.getManualRedactionType().name()))
                         .filter(m -> m.getUserId().equalsIgnoreCase(manualChange.getUserId()))
@@ -517,7 +523,8 @@ public class RulesTest {
                 assertThat(savedManualChange).isPresent();
             }
 
-            assertThat(savedRedactionLogEntry.get().getEngines()).containsExactlyInAnyOrder(redactionLogEntry.getEngines().toArray(Engine[]::new));
+            assertThat(savedRedactionLogEntry.get().getEngines()).containsExactlyInAnyOrder(redactionLogEntry.getEngines()
+                                                                                                    .toArray(Engine[]::new));
 
             assertThat(savedRedactionLogEntry.get().getReference()).containsAll(redactionLogEntry.getReference());
             assertThat(savedRedactionLogEntry.get().getImportedRedactionIntersections()).containsAll(redactionLogEntry.getImportedRedactionIntersections());
@@ -622,8 +629,8 @@ public class RulesTest {
 
         ClassPathResource responseJson = new ClassPathResource("files/ner_response.json");
         storageService.storeObject(TenantContext.getTenantId(),
-                RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.NER_ENTITIES),
-                responseJson.getInputStream());
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.NER_ENTITIES),
+                                   responseJson.getInputStream());
     }
 
 
@@ -647,8 +654,8 @@ public class RulesTest {
                 .build();
 
         storageService.storeObject(TenantContext.getTenantId(),
-                RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.TABLES),
-                new ClassPathResource("files/cv_service_empty_response.json").getInputStream());
+                                   RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.TABLES),
+                                   new ClassPathResource("files/cv_service_empty_response.json").getInputStream());
         storageService.storeObject(TenantContext.getTenantId(), RedactionStorageService.StorageIdUtils.getStorageId(TEST_DOSSIER_ID, TEST_FILE_ID, FileType.ORIGIN), stream);
 
         return request;
@@ -659,45 +666,102 @@ public class RulesTest {
     private void loadDictionaryForTest() {
 
         dictionary.computeIfAbsent(AUTHOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_author.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_author.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(SPONSOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_sponsor.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_sponsor.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(VERTEBRATE, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/vertebrate.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/vertebrate.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(ADDRESS, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/CBI_address.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/CBI_address.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(NO_REDACTION_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/no_redaction_indicator.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/no_redaction_indicator.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(REDACTION_INDICATOR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/redaction_indicator.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/redaction_indicator.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(HINT_ONLY, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/hint_only.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/hint_only.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(MUST_REDACT, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/must_redact.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/must_redact.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PUBLISHED_INFORMATION, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/published_information.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/published_information.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(TEST_METHOD, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/test_method.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/test_method.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PII, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/PII.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/PII.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(PURITY, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/purity.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/purity.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(IMAGE, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(OCR, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(LOGO, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(SIGNATURE, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dictionary.computeIfAbsent(FORMULA, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/empty.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/empty.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
         dossierDictionary.computeIfAbsent(DOSSIER_REDACTIONS, v -> new ArrayList<>())
-                .addAll(ResourceLoader.load("dictionaries/dossier_redactions.txt").stream().map(this::cleanDictionaryEntry).collect(Collectors.toSet()));
+                .addAll(ResourceLoader.load("dictionaries/dossier_redactions.txt")
+                                .stream()
+                                .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()));
+                .addAll(ResourceLoader.load("dictionaries/PII_false_positive.txt")
+                                .stream()
+                                .map(this::cleanDictionaryEntry)
+                                .collect(Collectors.toSet()));
 
     }
 
@@ -736,12 +800,12 @@ public class RulesTest {
         when(dictionaryClient.getDictionaryForType(AUTHOR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(AUTHOR, false));
         when(dictionaryClient.getDictionaryForType(SPONSOR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(SPONSOR, false));
         when(dictionaryClient.getDictionaryForType(NO_REDACTION_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(NO_REDACTION_INDICATOR,
-                false));
+                                                                                                                                                       false));
         when(dictionaryClient.getDictionaryForType(REDACTION_INDICATOR + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(REDACTION_INDICATOR, false));
         when(dictionaryClient.getDictionaryForType(HINT_ONLY + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(HINT_ONLY, false));
         when(dictionaryClient.getDictionaryForType(MUST_REDACT + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(MUST_REDACT, false));
         when(dictionaryClient.getDictionaryForType(PUBLISHED_INFORMATION + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(PUBLISHED_INFORMATION,
-                false));
+                                                                                                                                                      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(PURITY + ":" + TEST_DOSSIER_TEMPLATE_ID, version)).thenReturn(getDictionaryResponse(PURITY, false));
@@ -809,7 +873,10 @@ public class RulesTest {
     protected LayoutParsingFinishedEvent analyzeDocumentStructure(LayoutParsingType layoutParsingType) {
 
         return layoutParsingPipeline.parseLayoutAndSaveFilesToStorage(LayoutParsingRequestProvider.build(layoutParsingType,
-                AnalyzeRequest.builder().dossierId(TEST_DOSSIER_ID).fileId(TEST_FILE_ID).build()));
+                                                                                                         AnalyzeRequest.builder()
+                                                                                                                 .dossierId(TEST_DOSSIER_ID)
+                                                                                                                 .fileId(TEST_FILE_ID)
+                                                                                                                 .build()));
     }