Merge branch 'RED-8451' into 'master'

RED-8451: RECATEGORIZED hint is APPLIED instead of SKIPPED

Closes RED-8451

See merge request redactmanager/redaction-service!273

.gitlab-ci.yml

@@ -12,7 +12,7 @@ deploy:
   script:
     - echo "Building with gradle version ${BUILDVERSION}"
     - gradle -Pversion=${BUILDVERSION} publish
-    - gradle bootBuildImage --cleanCache --publishImage -PbuildbootDockerHostNetwork=true -Pversion=${BUILDVERSION}
+    - gradle bootBuildImage --publishImage -PbuildbootDockerHostNetwork=true -Pversion=${BUILDVERSION}
     - echo "BUILDVERSION=$BUILDVERSION" >> version.env
   artifacts:
     reports:

buildSrc/src/main/kotlin/com.iqser.red.service.java-conventions.gradle.kts

@@ -11,6 +11,10 @@ group = "com.iqser.red.service"
 java.sourceCompatibility = JavaVersion.VERSION_17
 java.targetCompatibility = JavaVersion.VERSION_17
 
+pmd {
+    isConsoleOutput = true
+}
+
 tasks.pmdMain {
     pmd.ruleSetFiles = files("${rootDir}/config/pmd/pmd.xml")
 }

config/pmd/pmd.xml

@@ -9,13 +9,12 @@
     </description>
 
     <rule ref="category/java/errorprone.xml">
-        <exclude name="DataflowAnomalyAnalysis"/>
         <exclude name="MissingSerialVersionUID"/>
-        <exclude name="NullAssignment"/>
         <exclude name="AvoidLiteralsInIfCondition"/>
         <exclude name="AvoidDuplicateLiterals"/>
-        <exclude name="AvoidFieldNameMatchingMethodName"/>
+        <exclude name="NullAssignment"/>
         <exclude name="AssignmentInOperand"/>
+        <exclude name="BeanMembersShouldSerialize"/>
     </rule>
 
-</ruleset>
+</ruleset>

config/pmd/test_pmd.xml

@@ -10,15 +10,13 @@
 
 
     <rule ref="category/java/errorprone.xml">
-        <exclude name="DataflowAnomalyAnalysis"/>
         <exclude name="MissingSerialVersionUID"/>
-        <exclude name="NullAssignment"/>
         <exclude name="AvoidLiteralsInIfCondition"/>
         <exclude name="AvoidDuplicateLiterals"/>
-        <exclude name="AvoidFieldNameMatchingMethodName"/>
-        <exclude name="AvoidFieldNameMatchingTypeName"/>
+        <exclude name="NullAssignment"/>
         <exclude name="AssignmentInOperand"/>
         <exclude name="TestClassWithoutTestCases"/>
+        <exclude name="BeanMembersShouldSerialize"/>
     </rule>
 
-</ruleset>
+</ruleset>

publish-custom-image.sh

@@ -9,7 +9,7 @@ branch=$(git rev-parse --abbrev-ref HEAD)
 commit_hash=$(git rev-parse --short=5 HEAD)
 
 # Combine branch and commit hash
-buildName="${branch}-${commit_hash}"
+buildName="${USER}-${branch}-${commit_hash}"
 
 gradle bootBuildImage --cleanCache --publishImage -PbuildbootDockerHostNetwork=true -Pversion=$buildName
 echo "nexus.knecon.com:5001/red/${dir}-server-v1:$buildName"

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

@@ -1,13 +1,13 @@
 plugins {
     id("com.iqser.red.service.java-conventions")
-    id("io.freefair.lombok") version "8.2.2"
+    id("io.freefair.lombok") version "8.4"
 }
 
 description = "redaction-service-api-v1"
 
 dependencies {
-    implementation("org.springframework:spring-web:6.0.11")
-    implementation("com.iqser.red.service:persistence-service-internal-api-v1:RED-6725")
+    implementation("org.springframework:spring-web:6.0.12")
+    implementation("com.iqser.red.service:persistence-service-internal-api-v1:2.338.0")
 }
 
 publishing {

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

@@ -0,0 +1,18 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+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/DroolsSyntaxValidation.java

@@ -1,5 +1,6 @@
 package com.iqser.red.service.redaction.v1.model;
 
+import java.util.LinkedList;
 import java.util.List;
 
 import lombok.AccessLevel;
@@ -16,6 +17,18 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(level = AccessLevel.PRIVATE)
 public class DroolsSyntaxValidation {
 
-    boolean compiled;
-    List<DroolsSyntaxErrorMessage> droolsSyntaxErrorMessages;
+    @Builder.Default
+    List<DroolsSyntaxErrorMessage> droolsSyntaxErrorMessages = 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/MigrationRequest.java

@@ -0,0 +1,22 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MigrationRequest {
+
+    String dossierTemplateId;
+    String dossierId;
+    String fileId;
+    ManualRedactions manualRedactions;
+
+}

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

@@ -0,0 +1,17 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MigrationResponse {
+
+    String dossierId;
+    String fileId;
+
+}

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

@@ -0,0 +1,14 @@
+package com.iqser.red.service.redaction.v1.model;
+
+public class QueueNames {
+
+    public static final String REDACTION_QUEUE = "redactionQueue";
+    public static final String REDACTION_PRIORITY_QUEUE = "redactionPriorityQueue";
+    public static final String REDACTION_ANALYSIS_RESPONSE_QUEUE = "redactionAnalysisResponseQueue";
+    public static final String REDACTION_DQL = "redactionDQL";
+
+    public static final String MIGRATION_QUEUE = "migrationQueue";
+    public static final String MIGRATION_RESPONSE_QUEUE = "migrationResponseQueue";
+    public static final String MIGRATION_DLQ = "migrationDLQ";
+
+}

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

@@ -0,0 +1,18 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class RuleValidationModel {
+
+    String ruleFileType;
+    String rulesString;
+
+}

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

@@ -0,0 +1,27 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@EqualsAndHashCode
+public class UnprocessedManualEntity {
+
+    private String annotationId;
+    private String textBefore;
+    private String textAfter;
+    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

@@ -5,10 +5,11 @@ 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.RuleValidationModel;
 
 public interface RedactionResource {
 
     @PostMapping(value = "/rules/test", consumes = MediaType.APPLICATION_JSON_VALUE)
-    DroolsSyntaxValidation testRules(@RequestBody String rules);
+    DroolsSyntaxValidation testRules(@RequestBody RuleValidationModel rulesValidationModel);
 
 }

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

@@ -3,24 +3,27 @@ import org.springframework.boot.gradle.tasks.bundling.BootBuildImage
 plugins {
     application
     id("com.iqser.red.service.java-conventions")
-    id("org.springframework.boot") version "3.1.2"
+    id("org.springframework.boot") version "3.1.5"
     id("io.spring.dependency-management") version "1.1.3"
-    id("org.sonarqube") version "4.3.0.3225"
-    id("io.freefair.lombok") version "8.2.2"
+    id("org.sonarqube") version "4.4.1.3373"
+    id("io.freefair.lombok") version "8.4"
 }
 
 description = "redaction-service-server-v1"
 
 
-val layoutParserVersion = "0.25.0"
+val layoutParserVersion = "0.86.0"
 val jacksonVersion = "2.15.2"
-val droolsVersion = "8.43.0.Final"
-val pdfBoxVersion = "3.0.0-alpha2"
-val persistenceServiceVersion = "2.160.0"
+val droolsVersion = "9.44.0.Final"
+val pdfBoxVersion = "3.0.0"
+val persistenceServiceVersion = "2.338.0"
+val springBootStarterVersion = "3.1.5"
 
 configurations {
     all {
-        exclude(group = "org.springframework.boot", module = "spring-boot-starter-logging")
+        exclude(group = "commons-logging", module = "commons-logging")
+        exclude(group = "org.springframework.boot", module = "spring-boot-starter-log4j2")
+        exclude(group = "com.iqser.red.commons", module = "logging-commons")
     }
 }
 
@@ -30,12 +33,13 @@ dependencies {
     implementation("com.iqser.red.service:persistence-service-internal-api-v1:${persistenceServiceVersion}") { exclude(group = "org.springframework.boot") }
     implementation("com.knecon.fforesight:layoutparser-service-internal-api:${layoutParserVersion}")
 
-    implementation("com.iqser.red.commons:spring-commons:2.7.0")
+    implementation("com.iqser.red.commons:spring-commons:6.2.0")
     implementation("com.iqser.red.commons:metric-commons:2.3.0")
 
     implementation("com.iqser.red.commons:dictionary-merge-commons:1.5.0")
-    implementation("com.iqser.red.commons:storage-commons:2.43.0")
-    implementation("com.knecon.fforesight:tenant-commons:0.13.0")
+    implementation("com.iqser.red.commons:storage-commons:2.45.0")
+    implementation("com.knecon.fforesight:tenant-commons:0.21.0")
+    implementation("com.knecon.fforesight:tracing-commons:0.5.0")
 
     implementation("com.fasterxml.jackson.module:jackson-module-afterburner:${jacksonVersion}")
     implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonVersion}")
@@ -49,12 +53,18 @@ dependencies {
     implementation("org.locationtech.jts:jts-core:1.19.0")
 
     implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.0.4")
-    implementation("org.springframework.boot:spring-boot-starter-amqp:3.1.2")
+    implementation("org.springframework.boot:spring-boot-starter-amqp:${springBootStarterVersion}")
+    implementation("org.springframework.boot:spring-boot-starter-cache:${springBootStarterVersion}")
+    implementation("org.springframework.boot:spring-boot-starter-data-redis:${springBootStarterVersion}")
 
+    implementation("net.logstash.logback:logstash-logback-encoder:7.4")
+    implementation("ch.qos.logback:logback-classic")
+
+    testImplementation(project(":rules-management"))
     testImplementation("org.apache.pdfbox:pdfbox:${pdfBoxVersion}")
     testImplementation("org.apache.pdfbox:pdfbox-tools:${pdfBoxVersion}")
 
-    testImplementation("org.springframework.boot:spring-boot-starter-test:3.1.2")
+    testImplementation("org.springframework.boot:spring-boot-starter-test:${springBootStarterVersion}")
     testImplementation("com.knecon.fforesight:layoutparser-service-processor:${layoutParserVersion}") {
         exclude(
             group = "com.iqser.red.service",
@@ -67,15 +77,19 @@ tasks.test {
     configure<JacocoTaskExtension> {
         excludes = listOf("org/drools/**/*")
     }
+    minHeapSize = "512m"
+    maxHeapSize = "1024m"
 }
 
 
+
+
 tasks.named<BootBuildImage>("bootBuildImage") {
 
     environment.put("BPE_DELIM_JAVA_TOOL_OPTIONS", " ")
-    environment.put("BPE_APPEND_JAVA_TOOL_OPTIONS", "-Dfile.encoding=UTF-8")
+    environment.put("BPE_APPEND_JAVA_TOOL_OPTIONS", "-XX:MaxMetaspaceSize=512m -Dfile.encoding=UTF-8")
 
-    imageName.set("nexus.knecon.com:5001/red/${project.name}:${project.version}")
+    imageName.set("nexus.knecon.com:5001/red/${project.name}")// must build image with same name always, otherwise the builder will not know which image to use as cache. DO NOT CHANGE!
     if (project.hasProperty("buildbootDockerHostNetwork")) {
         network.set("host")
     }
@@ -91,5 +105,8 @@ tasks.named<BootBuildImage>("bootBuildImage") {
             email.set(providers.gradleProperty("mavenEmail").getOrNull())
             url.set("https://nexus.knecon.com:5001/")
         }
+
+        val dockerTag = "nexus.knecon.com:5001/red/${project.name}:${project.version}"
+        tags.set(listOf(dockerTag))
     }
 }

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

@@ -6,19 +6,22 @@ import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Import;
 
 import com.iqser.red.service.dictionarymerge.commons.DictionaryMergeService;
 import com.iqser.red.service.redaction.v1.server.client.RulesClient;
-import com.iqser.red.service.redaction.v1.server.settings.RedactionServiceSettings;
 import com.iqser.red.storage.commons.StorageAutoConfiguration;
 import com.knecon.fforesight.tenantcommons.MultiTenancyAutoConfiguration;
 
 import io.micrometer.core.aop.TimedAspect;
 import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.observation.ObservationRegistry;
+import io.micrometer.observation.aop.ObservedAspect;
 
+@EnableCaching
 @ImportAutoConfiguration({MultiTenancyAutoConfiguration.class})
 @Import({MetricsConfiguration.class, StorageAutoConfiguration.class})
 @EnableFeignClients(basePackageClasses = RulesClient.class)
@@ -32,6 +35,10 @@ 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/RedactionServiceSettings.java

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.settings;
+package com.iqser.red.service.redaction.v1.server;
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
 

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

@@ -0,0 +1,31 @@
+package com.iqser.red.service.redaction.v1.server;
+
+import java.time.Duration;
+
+import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+
+@Configuration
+public class RedisCachingConfiguration {
+
+    @Bean
+    public RedisCacheManagerBuilderCustomizer redisCacheManagerBuilderCustomizer() {
+
+        return (builder) -> builder.withCacheConfiguration("documentDataCache",
+                RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).disableCachingNullValues());
+    }
+
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+        return template;
+    }
+
+}

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

@@ -1,8 +1,8 @@
 package com.iqser.red.service.redaction.v1.server.controller;
 
 import com.iqser.red.commons.spring.ErrorMessage;
-import com.iqser.red.service.redaction.v1.server.exception.NotFoundException;
-import com.iqser.red.service.redaction.v1.server.exception.RulesValidationException;
+import com.iqser.red.service.redaction.v1.server.utils.exception.NotFoundException;
+import com.iqser.red.service.redaction.v1.server.utils.exception.RulesValidationException;
 
 import lombok.extern.slf4j.Slf4j;
 

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

@@ -4,9 +4,10 @@ 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.RuleValidationModel;
 import com.iqser.red.service.redaction.v1.resources.RedactionResource;
-import com.iqser.red.service.redaction.v1.server.exception.RulesValidationException;
-import com.iqser.red.service.redaction.v1.server.redaction.service.DroolsExecutionService;
+import com.iqser.red.service.redaction.v1.server.service.drools.DroolsSyntaxValidationService;
+import com.iqser.red.service.redaction.v1.server.utils.exception.RulesValidationException;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -16,14 +17,14 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class RedactionController implements RedactionResource {
 
-    private final DroolsExecutionService droolsExecutionService;
+    private final DroolsSyntaxValidationService droolsSyntaxValidationService;
 
 
     @Override
-    public DroolsSyntaxValidation testRules(@RequestBody String rules) {
+    public DroolsSyntaxValidation testRules(@RequestBody RuleValidationModel rulesValidationModel) {
 
         try {
-            return droolsExecutionService.testRules(rules);
+            return droolsSyntaxValidationService.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

@@ -1,10 +1,11 @@
 package com.iqser.red.service.redaction.v1.server.controller;
 
+import java.util.Collections;
+
 import org.springframework.web.bind.annotation.RestController;
 
 import com.iqser.red.service.redaction.v1.model.RuleBuilderModel;
 import com.iqser.red.service.redaction.v1.resources.RuleBuilderResource;
-import com.iqser.red.service.redaction.v1.server.redaction.service.RuleBuilderModelService;
 
 import lombok.RequiredArgsConstructor;
 
@@ -12,13 +13,16 @@ import lombok.RequiredArgsConstructor;
 @RequiredArgsConstructor
 public class RuleBuilderController implements RuleBuilderResource {
 
-    private final RuleBuilderModelService ruleBuilderModelService;
-
 
     @Override
     public RuleBuilderModel getRuleBuilderModel() {
 
-        return ruleBuilderModelService.getRuleBuilderModel();
+        RuleBuilderModel ruleBuilderModel = new RuleBuilderModel();
+
+        ruleBuilderModel.setWhenClauses(Collections.emptyList());
+        ruleBuilderModel.setThenConditions(Collections.emptyList());
+
+        return ruleBuilderModel;
     }
 
 }

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/document/graph/entity/RuleIdentifier.java

@@ -1,41 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
-
-import java.util.Objects;
-
-public record RuleIdentifier(String type, Integer unit, Integer id) {
-
-    public static RuleIdentifier fromString(String identifier) {
-
-        String[] values = identifier.split("\\.");
-        if (values.length != 3) {
-            throw new IllegalArgumentException("Illegal rule identifier provided: " + identifier);
-        }
-        String type = values[0];
-        Integer group = Integer.parseInt(values[1]);
-        Integer id = Integer.parseInt(values[2]);
-        return new RuleIdentifier(type, group, id);
-    }
-
-
-    public static RuleIdentifier empty() {
-
-        return new RuleIdentifier("", null, null);
-    }
-
-
-    @Override
-    public String toString() {
-
-        StringBuilder sb = new StringBuilder();
-        sb.append(type());
-        if (Objects.nonNull(unit()) && Objects.nonNull(id())) {
-            sb.append(".").append(unit()).append(".").append(id());
-        } else if (Objects.nonNull(id())) {
-            sb.append(".*.").append(id());
-        } else if (Objects.nonNull(unit())) {
-            sb.append(".").append(unit()).append(".*");
-        }
-        return sb.toString();
-    }
-
-}

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

@@ -1,95 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.document.services;
-
-import java.awt.geom.Rectangle2D;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.NoSuchElementException;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualResizeRedaction;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.Entity;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.PositionOnPage;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Image;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.ImageType;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.utils.RectangleTransformations;
-
-import lombok.RequiredArgsConstructor;
-
-@RequiredArgsConstructor
-public class ManualChangesApplicationService {
-
-    private final EntityCreationService entityCreationService;
-
-
-    public void recategorize(Entity entityToBeReCategorized, ManualRecategorization manualRecategorization) {
-
-        if (entityToBeReCategorized instanceof Image image) {
-            image.setImageType(ImageType.fromString(manualRecategorization.getType()));
-            return;
-        }
-        // need to create a new entity and copy over all values, since type is part of the primary key for entities and should never be changed!
-        if (entityToBeReCategorized instanceof TextEntity textEntity) {
-            TextEntity recategorizedEntity = entityCreationService.copyEntity(textEntity, manualRecategorization.getType(), textEntity.getEntityType(), textEntity.getDeepestFullyContainingNode());
-            recategorizedEntity.setPositionsOnPagePerPage(textEntity.getPositionsOnPagePerPage());
-            recategorizedEntity.getManualOverwrite().addChange(manualRecategorization);
-            textEntity.removeFromGraph();
-        }
-    }
-
-
-    public void resizeEntityAndReinsert(TextEntity entityToBeResized, ManualResizeRedaction manualResizeRedaction) {
-
-        PositionOnPage positionOnPageToBeResized = entityToBeResized.getPositionsOnPagePerPage()
-                .stream()
-                .filter(redactionPosition -> redactionPosition.getId().equals(manualResizeRedaction.getAnnotationId()))
-                .findFirst()
-                .orElseThrow(() -> new NoSuchElementException("No redaction position with matching annotation id found!"));
-
-        positionOnPageToBeResized.setRectanglePerLine(manualResizeRedaction.getPositions().stream().map(ManualChangesApplicationService::toRectangle2D).toList());
-
-        int newStartOffset;
-        if (manualResizeRedaction.getValue().length() > entityToBeResized.getValue().length()) {
-            newStartOffset = entityToBeResized.getTextRange().start() - manualResizeRedaction.getValue().indexOf(entityToBeResized.getValue());
-        } else {
-            newStartOffset = entityToBeResized.getTextRange().start() + entityToBeResized.getValue().indexOf(manualResizeRedaction.getValue());
-        }
-
-        // need to reinsert the entity, due to the boundary having changed.
-        removeAndUpdateAndReInsertEntity(entityToBeResized, manualResizeRedaction, newStartOffset);
-        entityToBeResized.getManualOverwrite().addChange(manualResizeRedaction);
-    }
-
-
-    private void removeAndUpdateAndReInsertEntity(TextEntity entityToBeResized, ManualResizeRedaction manualResizeRedaction, int newStartOffset) {
-
-        SemanticNode nodeToInsertInto = entityToBeResized.getDeepestFullyContainingNode().getDocumentTree().getRoot().getNode();
-        entityToBeResized.getIntersectingNodes().forEach(node -> node.getEntities().remove(this));
-        entityToBeResized.getPages().forEach(page -> page.getEntities().remove(this));
-        entityToBeResized.setIntersectingNodes(new LinkedList<>());
-        entityToBeResized.setDeepestFullyContainingNode(null);
-        entityToBeResized.setPages(new HashSet<>());
-        entityToBeResized.getTextRange().setStart(newStartOffset);
-        entityToBeResized.getTextRange().setEnd(newStartOffset + manualResizeRedaction.getValue().length());
-        entityCreationService.addEntityToGraph(entityToBeResized, nodeToInsertInto);
-    }
-
-
-    public void resizeImage(Image image, ManualResizeRedaction manualResizeRedaction) {
-
-        if (manualResizeRedaction.getPositions().isEmpty() || manualResizeRedaction.getPositions() == null) {
-            return;
-        }
-        var bBox = RectangleTransformations.rectangle2DBBox(manualResizeRedaction.getPositions().stream().map(ManualChangesApplicationService::toRectangle2D).toList());
-        image.setPosition(bBox);
-        image.getManualOverwrite().addChange(manualResizeRedaction);
-    }
-
-
-    private static Rectangle2D toRectangle2D(com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle rect) {
-
-        return new Rectangle2D.Double(rect.getTopLeftX() - rect.getWidth(), rect.getTopLeftY() - rect.getHeight(), rect.getWidth(), rect.getHeight());
-    }
-
-}

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

@@ -1,24 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.exception;
-
-import lombok.Data;
-
-@Data
-public class DroolsTimeoutException extends RuntimeException {
-
-    private static final String DROOLS_TIMEOUT_MESSAGE = "Timeout during rules execution. Possible endless loop?";
-
-    private boolean reported;
-
-    public DroolsTimeoutException(Throwable cause,  boolean reported) {
-
-        super(DROOLS_TIMEOUT_MESSAGE, cause);
-        this.reported = reported;
-    }
-
-    public DroolsTimeoutException(boolean reported) {
-
-        super(DROOLS_TIMEOUT_MESSAGE);
-        this.reported = reported;
-    }
-
-}

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

@@ -0,0 +1,417 @@
+package com.iqser.red.service.redaction.v1.server.migration;
+
+import java.time.OffsetDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.AnnotationStatus;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.BaseAnnotation;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.IdRemoval;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualForceRedaction;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualLegalBasisChange;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualResizeRedaction;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Change;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ChangeType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Engine;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ManualChange;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ManualRedactionType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Point;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
+import com.iqser.red.service.redaction.v1.server.service.DictionaryService;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class LegacyRedactionLogMergeService {
+
+    private final DictionaryService dictionaryService;
+
+
+    public RedactionLog mergeManualChanges(RedactionLog redactionLog, ManualRedactions manualRedactions, String dossierTemplateId) {
+
+        var skippedImportedRedactions = new HashSet<>();
+        log.info("Merging Redaction log with manual redactions");
+        if (manualRedactions != null) {
+
+            var manualRedactionLogEntries = addManualAddEntries(manualRedactions.getEntriesToAdd(), redactionLog.getAnalysisNumber());
+
+            redactionLog.getRedactionLogEntry().addAll(manualRedactionLogEntries);
+
+            var manualRedactionWrappers = createManualRedactionWrappers(manualRedactions);
+
+            for (RedactionLogEntry entry : redactionLog.getRedactionLogEntry()) {
+
+                processRedactionLogEntry(manualRedactionWrappers.stream()
+                        .filter(ManualRedactionWrapper::isApproved)
+                        .filter(mr -> entry.getId().equals(mr.getId()))
+                        .collect(Collectors.toList()), entry, dossierTemplateId);
+
+                if (entry.isImported() && !entry.isRedacted()) {
+                    skippedImportedRedactions.add(entry.getId());
+                }
+
+            }
+
+        }
+
+        Set<String> processedIds = new HashSet<>();
+        redactionLog.getRedactionLogEntry().removeIf(entry -> {
+            if (entry.isFalsePositive()) {
+                return true;
+            }
+            if (entry.getImportedRedactionIntersections() != null) {
+                entry.getImportedRedactionIntersections().removeAll(skippedImportedRedactions);
+                if (!entry.getImportedRedactionIntersections().isEmpty() && (!entry.isImage() || entry.isImage() && !(entry.getType().equals("image") || entry.getType()
+                        .equals("ocr")))) {
+                    return true;
+                }
+            }
+            if (processedIds.contains(entry.getId())) {
+                log.info("Duplicate annotation found with id {}", entry.getId());
+                return true;
+            }
+            processedIds.add(entry.getId());
+            return false;
+        });
+        return redactionLog;
+    }
+
+
+    private List<ManualRedactionWrapper> createManualRedactionWrappers(ManualRedactions manualRedactions) {
+
+        List<ManualRedactionWrapper> manualRedactionWrappers = new ArrayList<>();
+
+        manualRedactions.getRecategorizations().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getAnnotationId(), item.getRequestDate(), item, item.isApproved()));
+            }
+        });
+
+        manualRedactions.getIdsToRemove().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getAnnotationId(), item.getRequestDate(), item, item.isApproved()));
+            }
+        });
+
+        manualRedactions.getForceRedactions().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getAnnotationId(), item.getRequestDate(), item, item.isApproved()));
+            }
+        });
+
+        manualRedactions.getLegalBasisChanges().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getAnnotationId(), item.getRequestDate(), item, item.isApproved()));
+            }
+        });
+
+        manualRedactions.getResizeRedactions().forEach(item -> {
+            if (item.getSoftDeletedTime() == null) {
+                manualRedactionWrappers.add(new ManualRedactionWrapper(item.getAnnotationId(), item.getRequestDate(), item, item.isApproved()));
+            }
+        });
+
+        Collections.sort(manualRedactionWrappers);
+
+        return manualRedactionWrappers;
+    }
+
+
+    private void processRedactionLogEntry(List<ManualRedactionWrapper> manualRedactionWrappers, RedactionLogEntry redactionLogEntry, String dossierTemplateId) {
+
+        manualRedactionWrappers.forEach(mrw -> {
+
+            Object item = mrw.getItem();
+            if (item instanceof ManualRecategorization imageRecategorization) {
+                processManualImageRecategorization(redactionLogEntry, dossierTemplateId, imageRecategorization);
+            }
+
+            if (item instanceof IdRemoval manualRemoval) {
+                processIdRemoval(redactionLogEntry, manualRemoval);
+            }
+
+            if (item instanceof ManualForceRedaction manualForceRedact) {
+                processManualForceRedaction(redactionLogEntry, dossierTemplateId, manualForceRedact);
+            }
+
+            if (item instanceof ManualLegalBasisChange manualLegalBasisChange) {
+                processManualLegalBasisChange(redactionLogEntry, manualLegalBasisChange);
+            }
+
+            if (item instanceof ManualResizeRedaction manualResizeRedact) {
+                processManualResizeRedaction(redactionLogEntry, manualResizeRedact);
+            }
+
+        });
+
+    }
+
+
+    private void processManualImageRecategorization(RedactionLogEntry redactionLogEntry, String dossierTemplateId, ManualRecategorization imageRecategorization) {
+
+        String manualOverrideReason = null;
+        if (imageRecategorization.getStatus().equals(AnnotationStatus.APPROVED)) {
+
+            redactionLogEntry.setType(imageRecategorization.getType());
+            redactionLogEntry.setSection("Image:" + redactionLogEntry.getType());
+
+            if (dictionaryService.isHint(imageRecategorization.getType(), dossierTemplateId)) {
+                redactionLogEntry.setRedacted(false);
+                redactionLogEntry.setHint(true);
+            } else {
+                redactionLogEntry.setHint(false);
+            }
+
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", recategorized by manual override");
+        } else if (imageRecategorization.getStatus().equals(AnnotationStatus.REQUESTED)) {
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to recategorize");
+        }
+
+        if (manualOverrideReason != null) {
+            redactionLogEntry.setReason(manualOverrideReason);
+        }
+
+        redactionLogEntry.getManualChanges()
+                .add(ManualChange.from(imageRecategorization).withManualRedactionType(ManualRedactionType.RECATEGORIZE).withChange("type", imageRecategorization.getType()));
+    }
+
+
+    private String mergeReasonIfNecessary(String currentReason, String addition) {
+
+        if (currentReason != null) {
+            if (!currentReason.contains(addition)) {
+                return currentReason + addition;
+            }
+            return currentReason;
+        } else {
+            return "";
+        }
+    }
+
+
+    private void processIdRemoval(RedactionLogEntry redactionLogEntry, IdRemoval manualRemoval) {
+
+        boolean isApprovedRedaction = manualRemoval.getStatus().equals(AnnotationStatus.APPROVED);
+        if (isApprovedRedaction && manualRemoval.isRemoveFromDictionary() && isBasedOnDictionaryOnly(redactionLogEntry)) {
+            log.debug("Skipping merge for dictionary-modifying entry");
+        } else {
+            String manualOverrideReason = null;
+            if (isApprovedRedaction) {
+                redactionLogEntry.setRedacted(false);
+                manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", removed by manual override");
+                redactionLogEntry.setHint(false);
+            } else if (manualRemoval.getStatus().equals(AnnotationStatus.REQUESTED)) {
+                manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to remove");
+            }
+
+            if (manualOverrideReason != null) {
+                redactionLogEntry.setReason(manualOverrideReason);
+            }
+        }
+
+        redactionLogEntry.getManualChanges()
+                .add(ManualChange.from(manualRemoval)
+                        .withManualRedactionType(manualRemoval.isRemoveFromDictionary() ? ManualRedactionType.REMOVE_FROM_DICTIONARY : ManualRedactionType.REMOVE_LOCALLY));
+    }
+
+
+    private boolean isBasedOnDictionaryOnly(RedactionLogEntry redactionLogEntry) {
+
+        return redactionLogEntry.getEngines().contains(Engine.DICTIONARY) && redactionLogEntry.getEngines().size() == 1;
+    }
+
+
+    private void processManualForceRedaction(RedactionLogEntry redactionLogEntry, String dossierTemplateId, ManualForceRedaction manualForceRedact) {
+
+        String manualOverrideReason = null;
+        var dictionaryIsHint = dictionaryService.isHint(redactionLogEntry.getType(), dossierTemplateId);
+        if (manualForceRedact.getStatus().equals(AnnotationStatus.APPROVED)) {
+            // Forcing a skipped hint should result in a hint
+            if (dictionaryIsHint) {
+                redactionLogEntry.setHint(true);
+            } else {
+                redactionLogEntry.setRedacted(true);
+            }
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", forced by manual override");
+            redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
+        } else if (manualForceRedact.getStatus().equals(AnnotationStatus.REQUESTED)) {
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to force " + (dictionaryIsHint ? "hint" : "redact"));
+            redactionLogEntry.setLegalBasis(manualForceRedact.getLegalBasis());
+        }
+
+        if (manualOverrideReason != null) {
+            redactionLogEntry.setReason(manualOverrideReason);
+        }
+
+        var manualChange = ManualChange.from(manualForceRedact).withManualRedactionType(dictionaryIsHint ? ManualRedactionType.FORCE_HINT : ManualRedactionType.FORCE_REDACT);
+
+        redactionLogEntry.getManualChanges().add(manualChange);
+    }
+
+
+    private void processManualLegalBasisChange(RedactionLogEntry redactionLogEntry, ManualLegalBasisChange manualLegalBasisChange) {
+
+        String manualOverrideReason = null;
+        if (manualLegalBasisChange.getStatus().equals(AnnotationStatus.APPROVED)) {
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis was manually changed");
+            redactionLogEntry.setLegalBasis(manualLegalBasisChange.getLegalBasis());
+            redactionLogEntry.setRedacted(true);
+            if (manualLegalBasisChange.getSection() != null) {
+                redactionLogEntry.setSection(manualLegalBasisChange.getSection());
+            }
+            if (redactionLogEntry.isRectangle() && manualLegalBasisChange.getValue() != null) {
+                redactionLogEntry.setValue(manualLegalBasisChange.getValue());
+            }
+        } else if (manualLegalBasisChange.getStatus().equals(AnnotationStatus.REQUESTED)) {
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", legal basis change requested");
+        }
+
+        if (manualOverrideReason != null) {
+            redactionLogEntry.setReason(manualOverrideReason);
+        }
+
+        var manualChange = ManualChange.from(manualLegalBasisChange).withManualRedactionType(ManualRedactionType.LEGAL_BASIS_CHANGE);
+        manualChange.withChange("legalBasis", manualLegalBasisChange.getLegalBasis());
+        if (manualLegalBasisChange.getSection() != null) {
+            manualChange.withChange("section", manualLegalBasisChange.getSection());
+        }
+        if (redactionLogEntry.isRectangle() && manualLegalBasisChange.getValue() != null) {
+            manualChange.withChange("value", manualLegalBasisChange.getValue());
+        }
+        redactionLogEntry.getManualChanges().add(manualChange);
+    }
+
+
+    private void processManualResizeRedaction(RedactionLogEntry redactionLogEntry, ManualResizeRedaction manualResizeRedact) {
+
+        String manualOverrideReason = null;
+        if (manualResizeRedact.getStatus().equals(AnnotationStatus.APPROVED)) {
+            redactionLogEntry.setPositions(convertPositions(manualResizeRedact.getPositions()));
+            if (!"signature".equalsIgnoreCase(redactionLogEntry.getType()) && !"logo".equalsIgnoreCase(redactionLogEntry.getType())) {
+                redactionLogEntry.setValue(manualResizeRedact.getValue());
+            }
+            // This is for backwards compatibility, now the text after/before is calculated during reanalysis because we need to find dict entries on positions where entries are resized to smaller.
+            if (manualResizeRedact.getTextBefore() != null || manualResizeRedact.getTextAfter() != null) {
+                redactionLogEntry.setTextBefore(manualResizeRedact.getTextBefore());
+                redactionLogEntry.setTextAfter(manualResizeRedact.getTextAfter());
+            }
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", resized by manual override");
+        } else if (manualResizeRedact.getStatus().equals(AnnotationStatus.REQUESTED)) {
+            manualOverrideReason = mergeReasonIfNecessary(redactionLogEntry.getReason(), ", requested to resize redact");
+            redactionLogEntry.setPositions(convertPositions(manualResizeRedact.getPositions()));
+
+            // This is for backwards compatibility, now the text after/before is calculated during reanalysis because we need to find dict entries on positions where entries are resized to smaller.
+            if (manualResizeRedact.getTextBefore() != null || manualResizeRedact.getTextAfter() != null) {
+                redactionLogEntry.setTextBefore(manualResizeRedact.getTextBefore());
+                redactionLogEntry.setTextAfter(manualResizeRedact.getTextAfter());
+            }
+        }
+
+        redactionLogEntry.setReason(manualOverrideReason);
+        redactionLogEntry.getManualChanges()
+                .add(ManualChange.from(manualResizeRedact).withManualRedactionType(ManualRedactionType.RESIZE).withChange("value", manualResizeRedact.getValue()));
+    }
+
+
+    public List<RedactionLogEntry> addManualAddEntries(Set<ManualRedactionEntry> manualAdds, int analysisNumber) {
+
+        List<RedactionLogEntry> redactionLogEntries = new ArrayList<>();
+
+        for (ManualRedactionEntry manualRedactionEntry : manualAdds) {
+
+            if (shouldCreateManualEntry(manualRedactionEntry)) {
+                RedactionLogEntry redactionLogEntry = createRedactionLogEntry(manualRedactionEntry, manualRedactionEntry.getAnnotationId(), analysisNumber);
+                redactionLogEntry.setPositions(convertPositions(manualRedactionEntry.getPositions()));
+                redactionLogEntry.setTextBefore(manualRedactionEntry.getTextBefore());
+                redactionLogEntry.setTextAfter(manualRedactionEntry.getTextAfter());
+
+                redactionLogEntries.add(redactionLogEntry);
+            }
+        }
+
+        return redactionLogEntries;
+    }
+
+
+    private List<Rectangle> convertPositions(List<com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle> positions) {
+
+        return positions.stream()
+                .map(pos -> new Rectangle(new Point(pos.getTopLeftX(), pos.getTopLeftY()), pos.getWidth(), pos.getHeight(), pos.getPage()))
+                .collect(Collectors.toList());
+    }
+
+
+    @SuppressWarnings("PMD.UselessParentheses")
+    private boolean shouldCreateManualEntry(ManualRedactionEntry manualRedactionEntry) {
+
+        if (!manualRedactionEntry.isApproved()) {
+            return false;
+        }
+
+        return (!manualRedactionEntry.isAddToDictionary() && !manualRedactionEntry.isAddToDossierDictionary()) || ((manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary()) && manualRedactionEntry.getProcessedDate() == null);
+    }
+
+
+    private RedactionLogEntry createRedactionLogEntry(ManualRedactionEntry manualRedactionEntry, String id, int analysisNumber) {
+
+        var addToDictionary = manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary();
+
+        var change = ManualChange.from(manualRedactionEntry).withManualRedactionType(addToDictionary ? ManualRedactionType.ADD_TO_DICTIONARY : ManualRedactionType.ADD_LOCALLY);
+        List<ManualChange> changeList = new ArrayList<>();
+        changeList.add(change);
+
+        return RedactionLogEntry.builder()
+                .id(id)
+                .reason(manualRedactionEntry.getReason())
+                .isDictionaryEntry(manualRedactionEntry.isAddToDictionary())
+                .isDossierDictionaryEntry(manualRedactionEntry.isAddToDossierDictionary())
+                .legalBasis(manualRedactionEntry.getLegalBasis())
+                .value(manualRedactionEntry.getValue())
+                .sourceId(manualRedactionEntry.getSourceId())
+                .section(manualRedactionEntry.getSection())
+                .type(manualRedactionEntry.getType())
+                .redacted(true)
+                .isHint(false)
+                .sectionNumber(-1)
+                .rectangle(manualRedactionEntry.isRectangle())
+                .manualChanges(changeList)
+                .changes(List.of(new Change(analysisNumber + 1, ChangeType.ADDED, manualRedactionEntry.getRequestDate())))
+                .build();
+    }
+
+
+    @Data
+    @AllArgsConstructor
+    private static class ManualRedactionWrapper implements Comparable<ManualRedactionWrapper> {
+
+        private String id;
+        private OffsetDateTime date;
+        private Object item;
+        private boolean approved;
+
+
+        @Override
+        public int compareTo(ManualRedactionWrapper o) {
+
+            return this.date.compareTo(o.date);
+        }
+
+    }
+
+}

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

@@ -0,0 +1,70 @@
+package com.iqser.red.service.redaction.v1.server.migration;
+
+import java.lang.reflect.Field;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
+
+import lombok.SneakyThrows;
+
+@Service
+@SuppressWarnings("PMD")
+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));
+        for (List<RedactionLogEntry> entries : entriesById.values()) {
+
+            if (entries.isEmpty()) {
+                continue;
+            }
+
+            if (entries.size() == 1) {
+                mergedEntries.add(entries.get(0));
+                continue;
+            }
+
+            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())) {
+                copyNonNullFields(entry, initialEntry);
+            }
+            mergedEntries.add(initialEntry);
+        }
+
+        redactionLog.setRedactionLogEntry(mergedEntries);
+        return redactionLog;
+    }
+
+
+    @SneakyThrows
+    public static void copyNonNullFields(RedactionLogEntry source, RedactionLogEntry destination) {
+
+        if (source == null || destination == null) {
+            throw new IllegalArgumentException("Source and destination objects must not be null");
+        }
+
+        Class<?> sourceClass = source.getClass();
+
+        Field[] sourceFields = sourceClass.getDeclaredFields();
+
+        for (Field field : sourceFields) {
+            field.setAccessible(true);
+            Object value = field.get(source);
+            if (value != null) {
+                field.set(destination, value);
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,84 @@
+package com.iqser.red.service.redaction.v1.server.migration;
+
+import static com.iqser.red.service.redaction.v1.model.QueueNames.MIGRATION_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.MIGRATION_RESPONSE_QUEUE;
+
+import org.springframework.amqp.core.Message;
+import org.springframework.amqp.rabbit.annotation.RabbitHandler;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.stereotype.Service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+import com.iqser.red.service.redaction.v1.model.MigrationRequest;
+import com.iqser.red.service.redaction.v1.model.MigrationResponse;
+import com.iqser.red.service.redaction.v1.server.model.MigratedEntityLog;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.service.DictionaryService;
+import com.iqser.red.service.redaction.v1.server.service.document.DocumentGraphMapper;
+import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class MigrationMessageReceiver {
+
+    ObjectMapper objectMapper;
+    RedactionLogToEntityLogMigrationService redactionLogToEntityLogMigrationService;
+    RedactionStorageService redactionStorageService;
+    LegacyRedactionLogMergeService legacyRedactionLogMergeService;
+    LegacyVersion0MigrationService legacyVersion0MigrationService;
+    RabbitTemplate rabbitTemplate;
+    DictionaryService dictionaryService;
+
+
+    @SneakyThrows
+    @RabbitHandler
+    @RabbitListener(queues = MIGRATION_QUEUE)
+    public void receiveMigrationRequest(Message message) {
+
+        MigrationRequest migrationRequest = objectMapper.readValue(message.getBody(), MigrationRequest.class);
+        log.info("--------------------------------------------------------------------");
+        log.info("Starting redactionLog to entityLog migration for dossierId {} and fileId {}", migrationRequest.getDossierId(), migrationRequest.getFileId());
+
+        dictionaryService.updateDictionary(migrationRequest.getDossierTemplateId(), migrationRequest.getDossierId());
+
+        Document document = DocumentGraphMapper.toDocumentGraph(redactionStorageService.getDocumentData(migrationRequest.getDossierId(), migrationRequest.getFileId()));
+        RedactionLog redactionLog = redactionStorageService.getRedactionLog(migrationRequest.getDossierId(), migrationRequest.getFileId());
+
+        if (redactionLog.getAnalysisVersion() == 0) {
+            redactionLog = legacyVersion0MigrationService.mergeDuplicateAnnotationIds(redactionLog);
+        } else if (migrationRequest.getManualRedactions() != null) {
+            redactionLog = legacyRedactionLogMergeService.mergeManualChanges(redactionLog, migrationRequest.getManualRedactions(), migrationRequest.getDossierTemplateId());
+        }
+
+        MigratedEntityLog migratedEntityLog = redactionLogToEntityLogMigrationService.migrate(redactionLog, document, migrationRequest.getDossierTemplateId());
+
+        redactionStorageService.storeObject(migrationRequest.getDossierId(), migrationRequest.getFileId(), FileType.ENTITY_LOG, migratedEntityLog.getEntityLog());
+        redactionStorageService.storeObject(migrationRequest.getDossierId(), migrationRequest.getFileId(), FileType.MIGRATED_IDS, migratedEntityLog.getMigratedIds());
+
+        sendFinished(MigrationResponse.builder().dossierId(migrationRequest.getDossierId()).fileId(migrationRequest.getFileId()).build());
+        log.info("Migrated {} redactionLog entries for dossierId {} and fileId {}",
+                migratedEntityLog.getEntityLog().getEntityLogEntry().size(),
+                migrationRequest.getDossierId(),
+                migrationRequest.getFileId());
+        log.info("");
+    }
+
+
+    @SneakyThrows
+    public void sendFinished(MigrationResponse migrationResponse) {
+
+        rabbitTemplate.convertAndSend(MIGRATION_RESPONSE_QUEUE, migrationResponse);
+    }
+
+}

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

@@ -0,0 +1,263 @@
+package com.iqser.red.service.redaction.v1.server.migration;
+
+import java.awt.geom.Rectangle2D;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogLegalBasis;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.migration.MigratedIds;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ManualRedactionType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogLegalBasis;
+import com.iqser.red.service.redaction.v1.server.model.PrecursorEntity;
+import com.iqser.red.service.redaction.v1.server.model.MigratedEntityLog;
+import com.iqser.red.service.redaction.v1.server.model.MigrationEntity;
+import com.iqser.red.service.redaction.v1.server.model.RectangleWithPage;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.EntityType;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Image;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.ImageType;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.service.DictionaryService;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityCreationService;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityEnrichmentService;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityFindingUtility;
+import com.iqser.red.service.redaction.v1.server.utils.IdBuilder;
+import com.iqser.red.service.redaction.v1.server.utils.MigratedIdsCollector;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+//TODO: remove this, once the migration is done
+public class RedactionLogToEntityLogMigrationService {
+
+    private static final double MATCH_THRESHOLD = 10;
+    EntityFindingUtility entityFindingUtility;
+    EntityEnrichmentService entityEnrichmentService;
+    DictionaryService dictionaryService;
+
+
+    public MigratedEntityLog migrate(RedactionLog redactionLog, Document document, String dossierTemplateId) {
+
+        List<MigrationEntity> entitiesToMigrate = calculateMigrationEntitiesFromRedactionLog(redactionLog, document, dossierTemplateId);
+        MigratedIds migratedIds = entitiesToMigrate.stream().collect(new MigratedIdsCollector());
+
+        EntityLog entityLog = new EntityLog();
+        entityLog.setAnalysisNumber(redactionLog.getAnalysisNumber());
+        entityLog.setRulesVersion(redactionLog.getRulesVersion());
+        entityLog.setDictionaryVersion(redactionLog.getDictionaryVersion());
+        entityLog.setDossierDictionaryVersion(redactionLog.getDossierDictionaryVersion());
+        entityLog.setLegalBasisVersion(redactionLog.getLegalBasisVersion());
+        entityLog.setAnalysisVersion(redactionLog.getAnalysisVersion());
+        entityLog.setLegalBasis(redactionLog.getLegalBasis().stream().map(RedactionLogToEntityLogMigrationService::toEntityLogLegalBasis).toList());
+
+        Map<String, String> oldToNewIDMapping = migratedIds.buildOldToNewMapping();
+        entityLog.setEntityLogEntry(entitiesToMigrate.stream().map(migrationEntity -> migrationEntity.toEntityLogEntry(oldToNewIDMapping)).toList());
+
+        if (getNumberOfApprovedEntries(redactionLog) != entityLog.getEntityLogEntry().size()) {
+            String message = String.format("Not all entities have been found during the migration redactionLog has %d entries and new entityLog %d",
+                    redactionLog.getRedactionLogEntry().size(),
+                    entityLog.getEntityLogEntry().size());
+            log.error(message);
+            throw new AssertionError(message);
+        }
+
+        MigratedIds idsToMigrateInDb = entitiesToMigrate.stream()
+                .filter(MigrationEntity::hasManualChangesOrComments)
+                .filter(m -> !m.getOldId().equals(m.getNewId()))
+                .collect(new MigratedIdsCollector());
+
+        return new MigratedEntityLog(idsToMigrateInDb, entityLog);
+    }
+
+
+    private static long getNumberOfApprovedEntries(RedactionLog redactionLog) {
+
+        return redactionLog.getRedactionLogEntry().size();
+    }
+
+
+    private List<MigrationEntity> calculateMigrationEntitiesFromRedactionLog(RedactionLog redactionLog, Document document, String dossierTemplateId) {
+
+        List<MigrationEntity> images = getImageBasedMigrationEntities(redactionLog, document, dossierTemplateId);
+        List<MigrationEntity> textMigrationEntities = getTextBasedMigrationEntities(redactionLog, document, dossierTemplateId);
+        return Stream.of(textMigrationEntities.stream(), images.stream()).flatMap(Function.identity()).toList();
+    }
+
+
+    private static EntityLogLegalBasis toEntityLogLegalBasis(RedactionLogLegalBasis redactionLogLegalBasis) {
+
+        return new EntityLogLegalBasis(redactionLogLegalBasis.getName(), redactionLogLegalBasis.getDescription(), redactionLogLegalBasis.getReason());
+    }
+
+
+    private List<MigrationEntity> getImageBasedMigrationEntities(RedactionLog redactionLog, Document document, String dossierTemplateId) {
+
+        List<Image> images = document.streamAllImages().collect(Collectors.toList());
+
+        List<RedactionLogEntry> redactionLogImages = redactionLog.getRedactionLogEntry().stream().filter(RedactionLogEntry::isImage).toList();
+
+        List<MigrationEntity> migrationEntities = new LinkedList<>();
+        for (RedactionLogEntry redactionLogImage : redactionLogImages) {
+            List<RectangleWithPage> imagePositions = redactionLogImage.getPositions().stream().map(RectangleWithPage::fromRedactionLogRectangle).toList();
+            assert imagePositions.size() == 1;
+            Optional<Image> optionalClosestImage = images.stream()
+                    .filter(image -> image.onPage(redactionLogImage.getPositions().get(0).getPage()))
+                    .min(Comparator.comparingDouble(image -> entityFindingUtility.calculateDistance(image.getPosition(), imagePositions.get(0).rectangle2D())))
+                    .filter(image -> entityFindingUtility.calculateDistance(image.getPosition(), imagePositions.get(0).rectangle2D()) <= MATCH_THRESHOLD);
+
+            Image closestImage;
+            if (optionalClosestImage.isEmpty()) { // if no fitting image can be found create a new one with the previous values!
+                closestImage = buildImageDirectly(document, redactionLogImage);
+            } else {
+                closestImage = optionalClosestImage.get();
+                images.remove(closestImage);
+            }
+
+            String ruleIdentifier;
+            if (redactionLogImage.getMatchedRule().isBlank() || redactionLogImage.getMatchedRule() == null) {
+                ruleIdentifier = "OLDIMG.0.0";
+            } else {
+                ruleIdentifier = "OLDIMG." + redactionLogImage.getMatchedRule() + ".0";
+            }
+
+            if (redactionLogImage.lastChangeIsRemoved()) {
+                closestImage.remove(ruleIdentifier, redactionLogImage.getReason());
+            } else if (redactionLogImage.isRedacted()) {
+                closestImage.apply(ruleIdentifier, redactionLogImage.getReason(), redactionLogImage.getLegalBasis());
+            } else {
+                closestImage.skip(ruleIdentifier, redactionLogImage.getReason());
+            }
+            migrationEntities.add(new MigrationEntity(null, redactionLogImage, closestImage, redactionLogImage.getId(), closestImage.getId()));
+        }
+        return migrationEntities;
+    }
+
+
+    private static Image buildImageDirectly(Document document, RedactionLogEntry redactionLogImage) {
+
+        Image image = Image.builder()
+                .documentTree(document.getDocumentTree())
+                .imageType(ImageType.fromString(redactionLogImage.getType()))
+                .transparent(redactionLogImage.isImageHasTransparency())
+                .page(document.getPages().stream().filter(p -> p.getNumber() == redactionLogImage.getPositions().get(0).getPage()).findFirst().orElseThrow())
+                .position(toRectangle2D(redactionLogImage.getPositions().get(0)))
+                .build();
+
+        List<Integer> treeId = document.getDocumentTree().createNewMainEntryAndReturnId(image);
+        image.setTreeId(treeId);
+        image.setId(IdBuilder.buildId(image.getPages(), image.getBBox().values().stream().toList(), "", ""));
+
+        return image;
+    }
+
+
+    private static Rectangle2D toRectangle2D(Rectangle rect) {
+
+        return new Rectangle2D.Double(rect.getTopLeft().getX(), rect.getTopLeft().getY(), rect.getWidth(), rect.getHeight());
+    }
+
+
+    private List<MigrationEntity> getTextBasedMigrationEntities(RedactionLog redactionLog, Document document, String dossierTemplateId) {
+
+        List<MigrationEntity> entitiesToMigrate = redactionLog.getRedactionLogEntry()
+                .stream()
+                .filter(redactionLogEntry -> !redactionLogEntry.isImage())
+                .map(entry -> MigrationEntity.fromRedactionLogEntry(entry, dictionaryService.isHint(entry.getType(), dossierTemplateId)))
+                .peek(migrationEntity -> {
+                    if (migrationEntity.getPrecursorEntity().getEntityType().equals(EntityType.HINT) &&//
+                            !migrationEntity.getRedactionLogEntry().isHint() &&//
+                            !migrationEntity.getRedactionLogEntry().isRedacted()) {
+                        migrationEntity.getPrecursorEntity().ignore(migrationEntity.getPrecursorEntity().getRuleIdentifier(), migrationEntity.getRedactionLogEntry().getReason());
+                    } else if (migrationEntity.getRedactionLogEntry().lastChangeIsRemoved()) {
+                        migrationEntity.getPrecursorEntity().remove(migrationEntity.getPrecursorEntity().getRuleIdentifier(), migrationEntity.getRedactionLogEntry().getReason());
+                    } else if (lastManualChangeIsRemove(migrationEntity)) {
+                        migrationEntity.getPrecursorEntity().ignore(migrationEntity.getPrecursorEntity().getRuleIdentifier(), migrationEntity.getPrecursorEntity().getReason());
+                    } else if (migrationEntity.getPrecursorEntity().isApplied() && migrationEntity.getRedactionLogEntry().isRecommendation()) {
+                        migrationEntity.getPrecursorEntity().skip(migrationEntity.getPrecursorEntity().getRuleIdentifier(), migrationEntity.getPrecursorEntity().getReason());
+                    } else if (migrationEntity.getPrecursorEntity().isApplied()) {
+                        migrationEntity.getPrecursorEntity()
+                                .apply(migrationEntity.getPrecursorEntity().getRuleIdentifier(),
+                                        migrationEntity.getPrecursorEntity().getReason(),
+                                        migrationEntity.getPrecursorEntity().getLegalBasis());
+                    } else {
+                        migrationEntity.getPrecursorEntity().skip(migrationEntity.getPrecursorEntity().getRuleIdentifier(), migrationEntity.getPrecursorEntity().getReason());
+                    }
+                })
+                .toList();
+
+        Map<String, List<TextEntity>> tempEntitiesByValue = entityFindingUtility.findAllPossibleEntitiesAndGroupByValue(document,
+                entitiesToMigrate.stream().map(MigrationEntity::getPrecursorEntity).toList());
+
+        for (MigrationEntity migrationEntity : entitiesToMigrate) {
+            Optional<TextEntity> optionalTextEntity = entityFindingUtility.findClosestEntityAndReturnEmptyIfNotFound(migrationEntity.getPrecursorEntity(),
+                    tempEntitiesByValue,
+                    MATCH_THRESHOLD);
+
+            if (optionalTextEntity.isEmpty()) {
+                migrationEntity.setMigratedEntity(migrationEntity.getPrecursorEntity());
+                migrationEntity.setOldId(migrationEntity.getPrecursorEntity().getId());
+                migrationEntity.setNewId(migrationEntity.getPrecursorEntity().getId());
+                continue;
+            }
+
+            TextEntity entity = createCorrectEntity(migrationEntity.getPrecursorEntity(), document, optionalTextEntity.get().getTextRange());
+            migrationEntity.setMigratedEntity(entity);
+            migrationEntity.setOldId(migrationEntity.getPrecursorEntity().getId());
+            migrationEntity.setNewId(entity.getPositionsOnPagePerPage().get(0).getId()); // Can only be on one page, since redactionLogEntries can only be on one page
+
+        }
+
+        tempEntitiesByValue.values().stream().flatMap(Collection::stream).forEach(TextEntity::removeFromGraph);
+        return entitiesToMigrate;
+    }
+
+
+    private static boolean lastManualChangeIsRemove(MigrationEntity migrationEntity) {
+
+        if (migrationEntity.getRedactionLogEntry().getManualChanges() == null) {
+            return false;
+        }
+
+        return migrationEntity.getRedactionLogEntry()
+                .getManualChanges()
+                .stream()
+                .reduce((a, b) -> b)
+                .map(m -> m.getManualRedactionType().equals(ManualRedactionType.REMOVE_LOCALLY))
+                .orElse(false);
+    }
+
+
+    private TextEntity createCorrectEntity(PrecursorEntity precursorEntity, SemanticNode node, TextRange closestTextRange) {
+
+        EntityCreationService entityCreationService = new EntityCreationService(entityEnrichmentService);
+        TextEntity correctEntity = entityCreationService.forceByTextRange(closestTextRange, precursorEntity.getType(), precursorEntity.getEntityType(), node);
+
+        correctEntity.addMatchedRules(precursorEntity.getMatchedRuleList());
+        correctEntity.setDictionaryEntry(precursorEntity.isDictionaryEntry());
+        correctEntity.setDossierDictionaryEntry(precursorEntity.isDossierDictionaryEntry());
+        correctEntity.getManualOverwrite().addChanges(precursorEntity.getManualOverwrite().getManualChangeLog());
+        return correctEntity;
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package com.iqser.red.service.redaction.v1.server.model;
+
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Builder
+@Getter
+@Setter
+public class ClosestEntity {
+
+    private double distance;
+    private TextEntity textEntity;
+
+}

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

@@ -0,0 +1,17 @@
+package com.iqser.red.service.redaction.v1.server.model;
+
+import org.kie.api.runtime.KieContainer;
+
+public record KieWrapper(KieContainer container, long rulesVersion) {
+
+    public static KieWrapper empty() {
+
+        return new KieWrapper(null, -1);
+    }
+
+
+    public boolean isPresent() {
+
+        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

@@ -0,0 +1,20 @@
+package com.iqser.red.service.redaction.v1.server.model;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.migration.MigratedIds;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+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

@@ -0,0 +1,364 @@
+package com.iqser.red.service.redaction.v1.server.model;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ChangeType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Change;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Engine;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ManualChange;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ManualRedactionType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.EntityType;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.IEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.ManualChangeOverwrite;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.PositionOnPage;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Image;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.ImageType;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@RequiredArgsConstructor
+public final class MigrationEntity {
+
+    private final PrecursorEntity precursorEntity;
+    private final RedactionLogEntry redactionLogEntry;
+    private IEntity migratedEntity;
+    private String oldId;
+    private String newId;
+
+
+    public static MigrationEntity fromRedactionLogEntry(RedactionLogEntry redactionLogEntry, boolean hint) {
+
+        return new MigrationEntity(createManualEntity(redactionLogEntry, hint), redactionLogEntry);
+    }
+
+
+    public static PrecursorEntity createManualEntity(RedactionLogEntry redactionLogEntry, boolean hint) {
+
+        String ruleIdentifier = buildRuleIdentifier(redactionLogEntry);
+        List<RectangleWithPage> rectangleWithPages = redactionLogEntry.getPositions().stream().map(RectangleWithPage::fromRedactionLogRectangle).toList();
+        EntityType entityType = getEntityType(redactionLogEntry, hint);
+        return PrecursorEntity.builder()
+                .id(redactionLogEntry.getId())
+                .value(redactionLogEntry.getValue())
+                .entityPosition(rectangleWithPages)
+                .ruleIdentifier(ruleIdentifier)
+                .reason(redactionLogEntry.getReason())
+                .legalBasis(redactionLogEntry.getLegalBasis())
+                .type(redactionLogEntry.getType())
+                .section(redactionLogEntry.getSection())
+                .entityType(entityType)
+                .applied(redactionLogEntry.isRedacted())
+                .isDictionaryEntry(redactionLogEntry.isDictionaryEntry())
+                .isDossierDictionaryEntry(redactionLogEntry.isDossierDictionaryEntry())
+                .rectangle(redactionLogEntry.isRectangle())
+                .manualOverwrite(new ManualChangeOverwrite(entityType))
+                .build();
+    }
+
+
+    private static String buildRuleIdentifier(RedactionLogEntry redactionLogEntry) {
+
+        String ruleIdentifier;
+        if (redactionLogEntry.getMatchedRule() != null) {
+            ruleIdentifier = "OLD." + redactionLogEntry.getMatchedRule() + ".0";
+        } else {
+            ruleIdentifier = "MAN.5.0"; // pure ManualRedactions used to have no matched rule
+        }
+        return ruleIdentifier;
+    }
+
+
+    private static EntityType getEntityType(RedactionLogEntry redactionLogEntry, boolean hint) {
+
+        if (hint) {
+            return EntityType.HINT;
+        }
+        if (redactionLogEntry.isFalsePositive()) {
+            return EntityType.FALSE_POSITIVE;
+        }
+        if (redactionLogEntry.isHint()) {
+            return EntityType.HINT;
+        }
+        if (redactionLogEntry.isRecommendation()) {
+            return EntityType.RECOMMENDATION;
+        }
+        return EntityType.ENTITY;
+    }
+
+
+    private static com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change toEntityLogChanges(Change change) {
+
+        return new com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change(change.getAnalysisNumber(),
+                toEntityLogType(change.getType()),
+                change.getDateTime());
+    }
+
+
+    private static EntryType getEntryType(EntityType entityType) {
+
+        return switch (entityType) {
+            case ENTITY -> EntryType.ENTITY;
+            case HINT -> EntryType.HINT;
+            case FALSE_POSITIVE -> EntryType.FALSE_POSITIVE;
+            case RECOMMENDATION -> EntryType.RECOMMENDATION;
+            case FALSE_RECOMMENDATION -> EntryType.FALSE_RECOMMENDATION;
+        };
+    }
+
+
+    private static com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualChange toEntityLogManualChanges(ManualChange manualChange) {
+
+        return new com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualChange(toManualRedactionType(manualChange.getManualRedactionType()),
+                manualChange.getProcessedDate(),
+                manualChange.getRequestedDate(),
+                manualChange.getUserId(),
+                manualChange.getPropertyChanges());
+    }
+
+
+    private static ChangeType toEntityLogType(com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.ChangeType type) {
+
+        return switch (type) {
+            case ADDED -> ChangeType.ADDED;
+            case REMOVED -> ChangeType.REMOVED;
+            case CHANGED -> ChangeType.CHANGED;
+        };
+    }
+
+
+    private static com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType toManualRedactionType(ManualRedactionType manualRedactionType) {
+
+        return switch (manualRedactionType) {
+            case ADD_LOCALLY -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.ADD_LOCALLY;
+            case ADD_TO_DICTIONARY -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.ADD_TO_DICTIONARY;
+            case REMOVE_LOCALLY -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.REMOVE_LOCALLY;
+            case REMOVE_FROM_DICTIONARY -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.REMOVE_FROM_DICTIONARY;
+            case FORCE_REDACT -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.FORCE_REDACT;
+            case FORCE_HINT -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.FORCE_HINT;
+            case RECATEGORIZE -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.RECATEGORIZE;
+            case LEGAL_BASIS_CHANGE -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.LEGAL_BASIS_CHANGE;
+            case RESIZE -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.RESIZE;
+        };
+    }
+
+
+    public EntityLogEntry toEntityLogEntry(Map<String, String> oldToNewIdMapping) {
+
+        EntityLogEntry entityLogEntry;
+        if (migratedEntity instanceof Image image) {
+            entityLogEntry = createEntityLogEntry(image);
+        } else if (migratedEntity instanceof TextEntity textEntity) {
+            entityLogEntry = createEntityLogEntry(textEntity);
+        } else if (migratedEntity instanceof PrecursorEntity entity) {
+            entityLogEntry = createEntityLogEntry(entity);
+        } else {
+            throw new UnsupportedOperationException("Unknown subclass " + migratedEntity.getClass());
+        }
+        entityLogEntry.setChanges(redactionLogEntry.getChanges().stream().map(MigrationEntity::toEntityLogChanges).toList());
+        entityLogEntry.setManualChanges(migrateManualChanges(redactionLogEntry.getManualChanges()));
+        entityLogEntry.setColor(redactionLogEntry.getColor());
+        entityLogEntry.setReference(migrateSetOfIds(redactionLogEntry.getReference(), oldToNewIdMapping));
+        entityLogEntry.setImportedRedactionIntersections(migrateSetOfIds(redactionLogEntry.getImportedRedactionIntersections(), oldToNewIdMapping));
+        entityLogEntry.setEngines(getMigratedEngines(redactionLogEntry));
+        if (redactionLogEntry.getLegalBasis() != null) {
+            entityLogEntry.setLegalBasis(redactionLogEntry.getLegalBasis());
+        }
+
+        if (entityLogEntry.getEntryType().equals(EntryType.HINT) && lastManualChangeIsRemoveLocally(entityLogEntry)) {
+            entityLogEntry.setState(EntryState.IGNORED);
+        }
+
+        return entityLogEntry;
+    }
+
+
+    private static boolean lastManualChangeIsRemoveLocally(EntityLogEntry entityLogEntry) {
+
+        return entityLogEntry.getManualChanges()
+                .stream()
+                .reduce((a, b) -> b)
+                .filter(mc -> mc.getManualRedactionType()
+                        .equals(com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType.REMOVE_LOCALLY))
+                .isPresent();
+    }
+
+    private List<com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualChange> migrateManualChanges(List<ManualChange> manualChanges) {
+
+        if (manualChanges == null) {
+            return Collections.emptyList();
+        }
+        return manualChanges.stream()
+                .map(MigrationEntity::toEntityLogManualChanges)
+                .toList();
+    }
+
+
+    private static Set<com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine> getMigratedEngines(RedactionLogEntry entry) {
+
+        if (entry.getEngines() == null) {
+            return Collections.emptySet();
+        }
+        return entry.getEngines().stream().map(MigrationEntity::toEntityLogEngine).collect(Collectors.toSet());
+    }
+
+
+    private Set<String> migrateSetOfIds(Set<String> ids, Map<String, String> oldToNewIdMapping) {
+
+        if (ids == null) {
+            return Collections.emptySet();
+        }
+        return ids.stream().map(oldToNewIdMapping::get).collect(Collectors.toSet());
+    }
+
+
+    private static com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine toEntityLogEngine(Engine engine) {
+
+        return switch (engine) {
+            case DICTIONARY -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine.DICTIONARY;
+            case NER -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine.NER;
+            case RULE -> com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine.RULE;
+        };
+    }
+
+
+    public EntityLogEntry createEntityLogEntry(Image image) {
+
+        String imageType = image.getImageType().equals(ImageType.OTHER) ? "image" : image.getImageType().toString().toLowerCase(Locale.ENGLISH);
+        return EntityLogEntry.builder()
+                .id(image.getId())
+                .value(image.value())
+                .type(imageType)
+                .reason(image.buildReasonWithManualChangeDescriptions())
+                .legalBasis(image.legalBasis())
+                .matchedRule(image.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(false)
+                .positions(List.of(new Position(image.getPosition(), image.getPage().getNumber())))
+                .containingNodeId(image.getTreeId())
+                .closestHeadline(image.getHeadline().getTextBlock().getSearchText())
+                .section(redactionLogEntry.getSection())
+                .textAfter(redactionLogEntry.getTextAfter())
+                .textBefore(redactionLogEntry.getTextBefore())
+                .imageHasTransparency(image.isTransparent())
+                .state(buildEntryState(image))
+                .entryType(redactionLogEntry.isHint() ? EntryType.IMAGE_HINT : EntryType.IMAGE)
+                .build();
+
+    }
+
+
+    public EntityLogEntry createEntityLogEntry(PrecursorEntity precursorEntity) {
+
+        String type = precursorEntity.getManualOverwrite().getType().orElse(precursorEntity.getType());
+        return EntityLogEntry.builder()
+                .id(precursorEntity.getId())
+                .reason(precursorEntity.buildReasonWithManualChangeDescriptions())
+                .legalBasis(precursorEntity.legalBasis())
+                .value(precursorEntity.value())
+                .type(type)
+                .state(buildEntryState(precursorEntity))
+                .entryType(buildEntryType(precursorEntity))
+                .section(redactionLogEntry.getSection())
+                .textAfter(redactionLogEntry.getTextAfter())
+                .textBefore(redactionLogEntry.getTextBefore())
+                .containingNodeId(Collections.emptyList())
+                .closestHeadline("")
+                .matchedRule(precursorEntity.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(precursorEntity.isDictionaryEntry())
+                .dossierDictionaryEntry(precursorEntity.isDossierDictionaryEntry())
+                .startOffset(-1)
+                .endOffset(-1)
+                .positions(precursorEntity.getManualOverwrite()
+                        .getPositions()
+                        .orElse(precursorEntity.getEntityPosition())
+                        .stream()
+                        .map(entityPosition -> new Position(entityPosition.rectangle2D(), entityPosition.pageNumber()))
+                        .toList())
+                .engines(Collections.emptySet())
+                .build();
+    }
+
+
+    public EntityLogEntry createEntityLogEntry(TextEntity entity) {
+
+        assert entity.getPositionsOnPagePerPage().size() == 1;
+        PositionOnPage positionOnPage = entity.getPositionsOnPagePerPage().get(0);
+        List<Position> rectanglesPerLine = positionOnPage.getRectanglePerLine()
+                .stream()
+                .map(rectangle2D -> new Position(rectangle2D, positionOnPage.getPage().getNumber()))
+                .toList();
+        return EntityLogEntry.builder()
+                .id(positionOnPage.getId())
+                .positions(rectanglesPerLine)
+                .reason(entity.buildReasonWithManualChangeDescriptions())
+                .legalBasis(entity.legalBasis())
+                .value(entity.getManualOverwrite().getValue().orElse(entity.getMatchedRule().isWriteValueWithLineBreaks() ? entity.getValueWithLineBreaks() : entity.getValue()))
+                .type(entity.type())
+                .section(redactionLogEntry.getSection())
+                .textAfter(redactionLogEntry.getTextAfter())
+                .textBefore(redactionLogEntry.getTextBefore())
+                .containingNodeId(entity.getDeepestFullyContainingNode().getTreeId())
+                .closestHeadline(entity.getDeepestFullyContainingNode().getHeadline().getTextBlock().getSearchText())
+                .matchedRule(entity.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(entity.isDictionaryEntry())
+                .startOffset(entity.getTextRange().start())
+                .endOffset(entity.getTextRange().end())
+                .dossierDictionaryEntry(entity.isDossierDictionaryEntry())
+                .engines(entity.getEngines() != null ? entity.getEngines() : Collections.emptySet())
+                .state(buildEntryState(entity))
+                .entryType(buildEntryType(entity))
+                .build();
+    }
+
+
+    private EntryState buildEntryState(IEntity entity) {
+
+        if (entity.applied() && entity.active()) {
+            return EntryState.APPLIED;
+        } else if (entity.skipped() && entity.active()) {
+            return EntryState.SKIPPED;
+        } else if (entity.ignored()) {
+            return EntryState.IGNORED;
+        } else {
+            return EntryState.REMOVED;
+        }
+    }
+
+
+    private EntryType buildEntryType(IEntity entity) {
+
+        if (entity instanceof TextEntity textEntity) {
+            return getEntryType(textEntity.getEntityType());
+        } else if (entity instanceof PrecursorEntity precursorEntity) {
+            if (precursorEntity.isRectangle()) {
+                return EntryType.AREA;
+            }
+            return getEntryType(precursorEntity.getEntityType());
+        } else if (entity instanceof Image) {
+            return EntryType.IMAGE;
+        }
+        throw new UnsupportedOperationException(String.format("Entity subclass %s is not implemented!", entity.getClass()));
+    }
+
+
+    public boolean hasManualChangesOrComments() {
+
+        return !(redactionLogEntry.getManualChanges() == null || redactionLogEntry.getManualChanges().isEmpty()) || //
+                !(redactionLogEntry.getComments() == null || redactionLogEntry.getComments().isEmpty());
+    }
+
+}

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

@@ -1,10 +1,10 @@
-package com.iqser.red.service.redaction.v1.server.redaction.adapter;
+package com.iqser.red.service.redaction.v1.server.model;
 
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;

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

@@ -0,0 +1,181 @@
+package com.iqser.red.service.redaction.v1.server.model;
+
+import static com.iqser.red.service.redaction.v1.server.service.NotFoundImportedEntitiesService.IMPORTED_REDACTION_TYPE;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.UUID;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.imported.ImportedRedaction;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualResizeRedaction;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.EntityType;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.IEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.ManualChangeOverwrite;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.MatchedRule;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.FieldDefaults;
+
+@Getter
+@Builder
+@AllArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
+public class PrecursorEntity implements IEntity {
+
+    // The id must be mapped into a TextEntity as is for comments to work correctly
+    String id;
+    String value;
+    List<RectangleWithPage> entityPosition;
+    String ruleIdentifier;
+    String reason;
+    String legalBasis;
+    String type;
+    String section;
+    EntityType entityType;
+    EntryType entryType;
+    boolean applied;
+    boolean isDictionaryEntry;
+    boolean isDossierDictionaryEntry;
+    boolean rectangle;
+    Set<Engine> engines;
+
+    @Builder.Default
+    PriorityQueue<MatchedRule> matchedRuleList = new PriorityQueue<>();
+    ManualChangeOverwrite manualOverwrite;
+
+
+    public static PrecursorEntity fromManualRedactionEntry(ManualRedactionEntry manualRedactionEntry, boolean hint) {
+
+        List<RectangleWithPage> rectangleWithPages = manualRedactionEntry.getPositions().stream().map(RectangleWithPage::fromAnnotationRectangle).toList();
+        var entityType = hint ? EntityType.HINT : EntityType.ENTITY;
+        var entryType = hint ? EntryType.HINT : EntryType.ENTITY;
+        ManualChangeOverwrite manualChangeOverwrite = new ManualChangeOverwrite(entityType);
+        manualChangeOverwrite.addChange(manualRedactionEntry);
+        return PrecursorEntity.builder()
+                .id(manualRedactionEntry.getAnnotationId())
+                .value(manualRedactionEntry.getValue())
+                .entityPosition(rectangleWithPages)
+                .ruleIdentifier("MAN.0.0")
+                .reason(manualRedactionEntry.getReason())
+                .legalBasis(manualRedactionEntry.getLegalBasis())
+                .type(manualRedactionEntry.getType())
+                .section(manualRedactionEntry.getSection())
+                .entityType(entityType)
+                .entryType(entryType)
+                .applied(true)
+                .isDictionaryEntry(false)
+                .isDossierDictionaryEntry(false)
+                .rectangle(manualRedactionEntry.isRectangle())
+                .manualOverwrite(manualChangeOverwrite)
+                .engines(Set.of(Engine.MANUAL))
+                .build();
+    }
+
+
+    public static PrecursorEntity fromEntityLogEntry(EntityLogEntry entityLogEntry) {
+
+        List<RectangleWithPage> rectangleWithPages = entityLogEntry.getPositions().stream().map(RectangleWithPage::fromEntityLogPosition).toList();
+        EntityType entityType = getEntityType(entityLogEntry.getEntryType());
+        return PrecursorEntity.builder()
+                .id(entityLogEntry.getId())
+                .value(entityLogEntry.getValue())
+                .entityPosition(rectangleWithPages)
+                .ruleIdentifier(entityLogEntry.getMatchedRule())
+                .reason(entityLogEntry.getReason())
+                .legalBasis(entityLogEntry.getLegalBasis())
+                .type(entityLogEntry.getType())
+                .section(entityLogEntry.getSection())
+                .entityType(entityType)
+                .entryType(entityLogEntry.getEntryType())
+                .isDictionaryEntry(entityLogEntry.isDictionaryEntry())
+                .isDossierDictionaryEntry(entityLogEntry.isDossierDictionaryEntry())
+                .manualOverwrite(new ManualChangeOverwrite(entityType))
+                .engines(entityLogEntry.getEngines())
+                .build();
+    }
+
+
+    public static PrecursorEntity fromImportedEntry(ImportedRedaction importedRedaction) {
+
+        List<RectangleWithPage> rectangleWithPages = importedRedaction.getPositions().stream().map(RectangleWithPage::fromEntityLogPosition).toList();
+        EntryType entryType = Optional.ofNullable(importedRedaction.getEntryType()).orElse(EntryType.ENTITY);
+        EntityType entityType = getEntityType(entryType);
+        String value = Optional.ofNullable(importedRedaction.getValue()).orElse("");
+        return PrecursorEntity.builder()
+                .id(importedRedaction.getId())
+                .value(value)
+                .entityPosition(rectangleWithPages)
+                .reason(Optional.ofNullable(importedRedaction.getReason()).orElse(""))
+                .legalBasis(Optional.ofNullable(importedRedaction.getLegalBasis()).orElse(""))
+                .type(Optional.ofNullable(importedRedaction.getType()).orElse(IMPORTED_REDACTION_TYPE))
+                .entityType(entityType)
+                .entryType(entryType)
+                .isDictionaryEntry(false)
+                .isDossierDictionaryEntry(false)
+                .rectangle(value.isBlank() || entryType.equals(EntryType.IMAGE) || entryType.equals(EntryType.IMAGE_HINT) || entryType.equals(EntryType.AREA))
+                .manualOverwrite(new ManualChangeOverwrite(entityType))
+                .engines(Set.of(Engine.IMPORTED))
+                .build();
+    }
+
+
+    public static PrecursorEntity fromManualResizeRedaction(ManualResizeRedaction manualResizeRedaction) {
+
+        List<RectangleWithPage> rectangleWithPages = manualResizeRedaction.getPositions().stream().map(RectangleWithPage::fromAnnotationRectangle).toList();
+        return PrecursorEntity.builder()
+                .id(UUID.randomUUID().toString())
+                .value(manualResizeRedaction.getValue())
+                .entityPosition(rectangleWithPages)
+                .entityType(EntityType.ENTITY)
+                .manualOverwrite(new ManualChangeOverwrite(EntityType.ENTITY))
+                .build();
+    }
+
+
+    @Override
+    public TextRange getTextRange() {
+
+        return new TextRange(-1, -1);
+    }
+
+
+    @Override
+    public String type() {
+
+        return getManualOverwrite().getType().orElse(type);
+    }
+
+
+    private static EntityType getEntityType(EntryType entryType) {
+
+        switch (entryType) {
+            case FALSE_RECOMMENDATION -> {
+                return EntityType.FALSE_RECOMMENDATION;
+            }
+            case FALSE_POSITIVE -> {
+                return EntityType.FALSE_POSITIVE;
+            }
+            case HINT -> {
+                return EntityType.HINT;
+            }
+            case RECOMMENDATION -> {
+                return EntityType.RECOMMENDATION;
+            }
+            default -> {
+                return EntityType.ENTITY;
+            }
+        }
+    }
+
+}

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

@@ -1,7 +1,8 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model;
+package com.iqser.red.service.redaction.v1.server.model;
 
 import java.awt.geom.Rectangle2D;
 
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
 
 public record RectangleWithPage(int pageNumber, Rectangle2D rectangle2D) {
@@ -12,6 +13,12 @@ public record RectangleWithPage(int pageNumber, Rectangle2D rectangle2D) {
     }
 
 
+    public static RectangleWithPage fromEntityLogPosition(Position position) {
+
+        return new RectangleWithPage(position.getPageNumber(), toRectangle2D(position));
+    }
+
+
     public static RectangleWithPage fromAnnotationRectangle(com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle rectangle) {
 
         return new RectangleWithPage(rectangle.getPage(), toRectangle2D(rectangle));
@@ -20,13 +27,19 @@ public record RectangleWithPage(int pageNumber, Rectangle2D rectangle2D) {
 
     private static Rectangle2D toRectangle2D(Rectangle rectangle) {
 
-        return new Rectangle2D.Float(rectangle.getTopLeft().getX(), rectangle.getTopLeft().getY() + rectangle.getHeight(), rectangle.getWidth(), -rectangle.getHeight());
+        return new Rectangle2D.Float(rectangle.getTopLeft().getX(), rectangle.getTopLeft().getY(), rectangle.getWidth(), rectangle.getHeight());
+    }
+
+
+    private static Rectangle2D toRectangle2D(Position position) {
+
+        return new Rectangle2D.Float(position.x(), position.y(), position.w(), position.h());
     }
 
 
     private static Rectangle2D toRectangle2D(com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle rectangle) {
 
-        return new Rectangle2D.Float(rectangle.getTopLeft().getX(), rectangle.getTopLeft().getY() + rectangle.getHeight(), rectangle.getWidth(), -rectangle.getHeight());
+        return new Rectangle2D.Float(rectangle.getTopLeft().getX(), rectangle.getTopLeft().getY(), rectangle.getWidth(), rectangle.getHeight());
     }
 
 }

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

@@ -0,0 +1,41 @@
+package com.iqser.red.service.redaction.v1.server.model.component;
+
+import java.util.Collection;
+import java.util.List;
+
+import com.iqser.red.service.redaction.v1.server.model.drools.RuleIdentifier;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class Component {
+
+    RuleIdentifier matchedRule;
+    String name;
+    String value;
+    String valueDescription;
+
+    List<Entity> references;
+
+
+    public boolean addReference(Entity entity) {
+
+        return references.add(entity);
+    }
+
+
+    public boolean addReferences(Collection<Entity> entities) {
+
+        return references.addAll(entities);
+    }
+
+}

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

@@ -0,0 +1,104 @@
+package com.iqser.red.service.redaction.v1.server.model.component;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualChange;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.FieldDefaults;
+
+@Getter
+@Builder
+@AllArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class Entity {
+
+    String id;
+    String type;
+    EntryType entryType;
+    EntryState state;
+    String value;
+    String reason;
+    String matchedRule;
+    String legalBasis;
+
+    boolean imported;
+
+    SemanticNode containingNode;
+    String section;
+    float[] color;
+
+    List<Position> positions;
+
+    String textBefore;
+    String textAfter;
+
+    int startOffset;
+    int endOffset;
+    int length;
+
+    boolean imageHasTransparency;
+
+    boolean isDictionaryEntry;
+    boolean isDossierDictionaryEntry;
+
+    boolean excluded;
+
+    List<Change> changes;
+
+    List<ManualChange> manualChanges;
+
+    Set<Engine> engines;
+
+    Set<String> reference;
+
+    Set<String> importedRedactionIntersections;
+
+
+    public static Entity fromEntityLogEntry(EntityLogEntry e, Document document) {
+
+        return Entity.builder()
+                .id(e.getId())
+                .type(e.getType())
+                .entryType(e.getEntryType())
+                .state(e.getState())
+                .value(e.getValue())
+                .reason(e.getReason())
+                .matchedRule(e.getMatchedRule())
+                .legalBasis(e.getLegalBasis())
+                .imported(e.isImported())
+                .section(e.getSection())
+                .color(e.getColor())
+                .positions(e.getPositions())
+                .containingNode(document.getDocumentTree().getEntryById(e.getContainingNodeId()).getNode())
+                .textBefore(e.getTextBefore())
+                .textAfter(e.getTextAfter())
+                .startOffset(e.getStartOffset())
+                .endOffset(e.getEndOffset())
+                .length(Optional.ofNullable(e.getValue()).orElse("").length())
+                .imageHasTransparency(e.isImageHasTransparency())
+                .isDictionaryEntry(e.isDictionaryEntry())
+                .isDossierDictionaryEntry(e.isDossierDictionaryEntry())
+                .excluded(e.isExcluded())
+                .changes(e.getChanges())
+                .manualChanges(e.getManualChanges())
+                .engines(e.getEngines())
+                .reference(e.getReference())
+                .importedRedactionIntersections(e.getImportedRedactionIntersections())
+                .build();
+    }
+
+}

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

@@ -1,24 +1,24 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import static java.lang.String.format;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.apache.commons.lang3.StringUtils;
 
-import com.iqser.red.service.redaction.v1.server.exception.NotFoundException;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.MatchedRule;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.redaction.utils.Patterns;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.MatchedRule;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.utils.Patterns;
+import com.iqser.red.service.redaction.v1.server.utils.exception.NotFoundException;
 
 import lombok.Data;
 import lombok.Getter;
@@ -107,39 +107,53 @@ public class Dictionary {
         if (StringUtils.isEmpty(value)) {
             throw new IllegalArgumentException(format("%s is not a valid dictionary entry", value));
         }
+        boolean isCaseInsensitive = localAccessMap.get(type).isCaseInsensitive();
         Set<MatchedRule> matchedRulesSet = new HashSet<>(matchedRules);
-        localAccessMap.get(type).getLocalEntriesWithMatchedRules().merge(value.trim(), matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
+
+        String cleanedValue = value;
+        if (isCaseInsensitive) {
+            cleanedValue = cleanedValue.toLowerCase(Locale.US);
+        }
+        localAccessMap.get(type)
+                .getLocalEntriesWithMatchedRules()
+                .merge(cleanedValue.trim(), matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
         if (alsoAddLastname) {
-            String lastname = value.split(" ")[0];
-            localAccessMap.get(type).getLocalEntriesWithMatchedRules().merge(lastname, matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
+            String lastname = cleanedValue.split(" ")[0];
+            localAccessMap.get(type)
+                    .getLocalEntriesWithMatchedRules()
+                    .merge(lastname, matchedRulesSet, (set1, set2) -> Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet()));
         }
     }
 
 
     public void recommendEverywhere(TextEntity textEntity) {
 
-        addLocalDictionaryEntry(textEntity.getType(), textEntity.getValue(), textEntity.getMatchedRuleList(), false);
+        addLocalDictionaryEntry(textEntity.type(), textEntity.getValue(), textEntity.getMatchedRuleList(), false);
     }
 
 
     public void recommendEverywhereWithLastNameSeparately(TextEntity textEntity) {
 
-        addLocalDictionaryEntry(textEntity.getType(), textEntity.getValue(), textEntity.getMatchedRuleList(), true);
+        addLocalDictionaryEntry(textEntity.type(), textEntity.getValue(), textEntity.getMatchedRuleList(), true);
     }
 
 
     public void addMultipleAuthorsAsRecommendation(TextEntity textEntity) {
 
-        String cleanedWord = textEntity.getValue().replaceAll(",", " ").replaceAll("  ", " ").trim() + " ";
-        Pattern pattern = Patterns.AUTHOR_TABLE_SPLITTER;
-        Matcher matcher = pattern.matcher(cleanedWord);
+        splitIntoAuthorNames(textEntity).forEach(authorName -> addLocalDictionaryEntry(textEntity.type(), authorName, textEntity.getMatchedRuleList(), true));
 
-        while (matcher.find()) {
-            String match = matcher.group().trim();
-            if (match.length() >= 3) {
-                addLocalDictionaryEntry(textEntity.getType(), match, textEntity.getMatchedRuleList(), true);
-            }
+    }
+
+
+    public static List<String> splitIntoAuthorNames(TextEntity textEntity) {
+
+        List<String> splitAuthorNames;
+        if (textEntity.getValue().contains(",")) {
+            splitAuthorNames = Arrays.asList(textEntity.getValue().split(","));
+        } else {
+            splitAuthorNames = Arrays.asList(textEntity.getValueWithLineBreaks().split("\n"));
         }
+        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/DictionaryEntries.java

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.util.HashSet;
 import java.util.Set;

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.util.Set;
 

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;

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

@@ -1,13 +1,15 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.io.Serializable;
 import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
 import java.util.Set;
 import java.util.stream.Collectors;
 
 import com.iqser.red.service.dictionarymerge.commons.DictionaryEntry;
 import com.iqser.red.service.dictionarymerge.commons.DictionaryEntryModel;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.MatchedRule;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.MatchedRule;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -109,4 +111,11 @@ public class DictionaryModel implements Serializable {
         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/DictionaryRepresentation.java

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.util.ArrayList;
 import java.util.HashMap;

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import lombok.AllArgsConstructor;
 import lombok.Builder;

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -9,7 +9,7 @@ import java.util.stream.Collectors;
 
 import org.ahocorasick.trie.Trie;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model.dictionary;
+package com.iqser.red.service.redaction.v1.server.model.dictionary;
 
 import java.util.HashMap;
 import java.util.Map;

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph;
+package com.iqser.red.service.redaction.v1.server.model.document;
 
 import java.util.LinkedList;
 import java.util.List;

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

@@ -1,4 +1,6 @@
-package com.iqser.red.service.redaction.v1.server.document.data;
+package com.iqser.red.service.redaction.v1.server.model.document;
+
+import java.io.Serializable;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPage;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionData;
@@ -9,13 +11,15 @@ import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
 @Data
 @Builder
 @AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class DocumentData {
+@NoArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class DocumentData implements Serializable {
 
     DocumentPage[] documentPages;
     DocumentTextData[] documentTextData;

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

@@ -1,20 +1,21 @@
-package com.iqser.red.service.redaction.v1.server.document.graph;
+package com.iqser.red.service.redaction.v1.server.model.document;
 
 import static java.lang.String.format;
 
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.GenericSemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.NodeType;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.TableCell;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Document;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Table;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.GenericSemanticNode;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.NodeType;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Table;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.TableCell;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -135,6 +136,48 @@ public class DocumentTree {
     }
 
 
+    public Optional<SemanticNode> getNextSibling(List<Integer> treeId) {
+
+        var siblingTreeId = getNextSiblingId(treeId);
+        if (!entryExists(siblingTreeId)) {
+            return Optional.empty();
+        }
+        return Optional.of(getEntryById(siblingTreeId).getNode());
+    }
+
+
+    public List<Integer> getNextSiblingId(List<Integer> treeId) {
+
+        List<Integer> siblingTreeId = new LinkedList<>();
+        for (int i = 0; i < treeId.size() - 1; i++) {
+            siblingTreeId.add(treeId.get(i));
+        }
+        siblingTreeId.add(treeId.get(treeId.size() - 1) + 1);
+        return siblingTreeId;
+    }
+
+
+    public Optional<SemanticNode> getPreviousSibling(List<Integer> treeId) {
+
+        var siblingTreeId = getPreviousSiblingId(treeId);
+        if (!entryExists(siblingTreeId)) {
+            return Optional.empty();
+        }
+        return Optional.of(getEntryById(siblingTreeId).getNode());
+    }
+
+
+    public List<Integer> getPreviousSiblingId(List<Integer> treeId) {
+
+        List<Integer> siblingTreeId = new LinkedList<>();
+        for (int i = 0; i < treeId.size() - 1; i++) {
+            siblingTreeId.add(treeId.get(i));
+        }
+        siblingTreeId.add(treeId.get(treeId.size() - 1) - 1);
+        return siblingTreeId;
+    }
+
+
     public Entry getEntryById(List<Integer> treeId) {
 
         if (treeId.isEmpty()) {

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph;
+package com.iqser.red.service.redaction.v1.server.model.document;
 
 import static java.lang.String.format;
 
@@ -6,13 +6,14 @@ import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
 
 import lombok.EqualsAndHashCode;
 import lombok.Setter;
 
 @Setter
 @EqualsAndHashCode
+@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
 public class TextRange implements Comparable<TextRange> {
 
     private int start;

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

@@ -1,7 +1,8 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 public enum EntityType {
     ENTITY,
+    HINT,
     RECOMMENDATION,
     FALSE_POSITIVE,
     FALSE_RECOMMENDATION

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

@@ -1,13 +1,16 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.PriorityQueue;
 import java.util.Set;
 
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.drools.RuleIdentifier;
+
 import lombok.NonNull;
 
-public interface Entity {
+public interface IEntity {
 
     PriorityQueue<MatchedRule> getMatchedRuleList();
 
@@ -15,7 +18,40 @@ public interface Entity {
     ManualChangeOverwrite getManualOverwrite();
 
 
-    // Don't use default accessor pattern (e.g. isIgnored()), as it might lead to errors in drools due to property-specific optimization of the drools planner.
+    String getValue();
+
+
+    TextRange getTextRange();
+
+
+    String type();
+
+
+    default int length() {
+
+        return value().length();
+    }
+
+
+    default String value() {
+
+        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());
+    }
+
+
+    default boolean skipped() {
+
+        return !applied();
+    }
+
+
     default boolean ignored() {
 
         return getManualOverwrite().getIgnored().orElse(getMatchedRule().isIgnored());
@@ -34,9 +70,9 @@ public interface Entity {
     }
 
 
-    default boolean applied() {
+    default boolean active() {
 
-        return getManualOverwrite().getApplied().orElse(getMatchedRule().isApplied());
+        return !(removed() || ignored());
     }
 
 
@@ -52,12 +88,6 @@ public interface Entity {
     }
 
 
-    default boolean active() {
-
-        return !(removed() || ignored());
-    }
-
-
     default void redact(@NonNull String ruleIdentifier, String reason, @NonNull String legalBasis) {
 
         if (legalBasis.isBlank() || legalBasis.isEmpty()) {
@@ -79,17 +109,6 @@ public interface Entity {
     }
 
 
-    default void force(@NonNull String ruleIdentifier, String reason, String legalBasis) {
-
-        addMatchedRule(MatchedRule.builder()
-                .ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier))
-                .reason(reason)
-                .legalBasis(getLegalBasisOrPreviousLegalBasisOrPlaceHolder(legalBasis))
-                .applied(true)
-                .build());
-    }
-
-
     default void skip(@NonNull String ruleIdentifier, String reason) {
 
         addMatchedRule(MatchedRule.builder().ruleIdentifier(RuleIdentifier.fromString(ruleIdentifier)).reason(reason).build());
@@ -108,18 +127,6 @@ public interface Entity {
     }
 
 
-    private String getLegalBasisOrPreviousLegalBasisOrPlaceHolder(String legalBasis) {
-
-        if (legalBasis == null || legalBasis.isBlank() || legalBasis.isEmpty()) {
-            if (getMatchedRule() == null || !getMatchedRule().isApplied()) {
-                return "n-a";
-            }
-            return getMatchedRule().getLegalBasis();
-        }
-        return legalBasis;
-    }
-
-
     default void applyWithLineBreaks(@NonNull String ruleIdentifier, String reason, @NonNull String legalBasis) {
 
         if (legalBasis.isBlank() || legalBasis.isEmpty()) {

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 import java.util.Collections;
 import java.util.Comparator;
@@ -10,19 +10,18 @@ import java.util.Optional;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.BaseAnnotation;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.IdRemoval;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualForceRedaction;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualLegalBasisChange;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualResizeRedaction;
+import com.iqser.red.service.redaction.v1.server.model.RectangleWithPage;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
-import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
 @Builder
-@NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
 public class ManualChangeOverwrite {
@@ -42,11 +41,25 @@ public class ManualChangeOverwrite {
     String legalBasis;
     String section;
     String value;
+    List<RectangleWithPage> positions;
     Boolean applied;
     Boolean removed;
     Boolean ignored;
     Boolean resized;
     Boolean recategorized;
+    EntityType entityType;
+
+
+    public ManualChangeOverwrite() {
+
+        this(EntityType.ENTITY);
+    }
+
+
+    public ManualChangeOverwrite(EntityType entityType) {
+
+        this.entityType = entityType;
+    }
 
 
     public void calculateCurrentOverride() {
@@ -80,13 +93,20 @@ public class ManualChangeOverwrite {
 
             if (manualChange instanceof IdRemoval) {
                 applied = false;
-                ignored = true;
+                if (sortedManualChanges.get(0) instanceof ManualRedactionEntry) { // set to removed if it's a Manual Redaction
+                    removed = true;
+                } else {
+                    ignored = true;
+                }
+            }
+
+            if (manualChange instanceof ManualRedactionEntry manualRedactionEntry) {
+                setToApplied();
+                legalBasis = manualRedactionEntry.getLegalBasis();
             }
 
             if (manualChange instanceof ManualForceRedaction manualForceRedaction) {
-                removed = false;
-                ignored = false;
-                applied = true;
+                setToApplied();
                 legalBasis = manualForceRedaction.getLegalBasis();
             }
 
@@ -96,9 +116,12 @@ public class ManualChangeOverwrite {
                 value = manualLegalBasisChange.getValue();
             }
 
-            if (manualChange instanceof ManualResizeRedaction) {
-                // resizing logic happens in ManualChangesApplicationService.
+            if (manualChange instanceof ManualResizeRedaction manualResizeRedaction) {
+                // resizing logic for TextEntities and Images happens in ManualChangesApplicationService.
                 resized = true;
+                // This is only for not found Manual Entities.
+                value = manualResizeRedaction.getValue();
+                positions = manualResizeRedaction.getPositions().stream().map(RectangleWithPage::fromAnnotationRectangle).toList();
             }
 
             if (manualChange instanceof ManualRecategorization recategorization) {
@@ -114,6 +137,16 @@ public class ManualChangeOverwrite {
     }
 
 
+    private void setToApplied() {
+
+        removed = false;
+        ignored = false;
+        if (!isHint(entityType)) {
+            applied = true;
+        }
+    }
+
+
     public void addChange(BaseAnnotation manualChange) {
 
         changed = true;
@@ -197,4 +230,17 @@ public class ManualChangeOverwrite {
         return descriptions == null ? Collections.emptyList() : descriptions;
     }
 
+
+    public Optional<List<RectangleWithPage>> getPositions() {
+
+        calculateCurrentOverride();
+        return positions == null ? Optional.empty() : Optional.of(positions);
+    }
+
+
+    private boolean isHint(EntityType entityType) {
+
+        return entityType.equals(EntityType.HINT);
+    }
+
 }

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

@@ -1,10 +1,13 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
+import com.iqser.red.service.redaction.v1.server.model.drools.RuleIdentifier;
+import com.iqser.red.service.redaction.v1.server.model.drools.RuleType;
+
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -19,28 +22,42 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
 public final class MatchedRule implements Comparable<MatchedRule> {
 
-    public static final String FINAL_TYPE = "FINAL";
-    public static final String ELIMINATION_RULE_TYPE = "X";
-    private static final List<String> RULE_TYPE_PRIORITIES = List.of(FINAL_TYPE, ELIMINATION_RULE_TYPE);
+    public static final RuleType FINAL_TYPE = RuleType.fromString("FINAL");
+    public static final RuleType ELIMINATION_RULE_TYPE = RuleType.fromString("X");
+    public static final RuleType IMPORTED_TYPE = RuleType.fromString("IMP");
+    private static final List<RuleType> RULE_TYPE_PRIORITIES = List.of(FINAL_TYPE, ELIMINATION_RULE_TYPE, IMPORTED_TYPE);
 
-    @Builder.Default
-    RuleIdentifier ruleIdentifier = RuleIdentifier.empty();
+    RuleIdentifier ruleIdentifier;
     @Builder.Default
     String reason = "";
     @Builder.Default
     String legalBasis = "";
-    boolean applied;
     boolean writeValueWithLineBreaks;
+    boolean applied;
     boolean removed;
     boolean ignored;
-    boolean resized;
+
     @Builder.Default
     Set<TextEntity> references = Collections.emptySet();
 
 
     public static MatchedRule empty() {
 
-        return MatchedRule.builder().build();
+        return MatchedRule.builder().ruleIdentifier(RuleIdentifier.empty()).build();
+    }
+
+
+    public MatchedRule asSkippedIfApplied() {
+
+        if (!this.isApplied()) {
+            return this;
+        }
+        return MatchedRule.builder().ruleIdentifier(getRuleIdentifier())
+                .writeValueWithLineBreaks(this.isWriteValueWithLineBreaks())
+                .legalBasis(this.getLegalBasis())
+                .reason(this.getReason())
+                .references(this.getReferences())
+                .build();
     }
 
 

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

@@ -1,9 +1,9 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 import java.awt.geom.Rectangle2D;
 import java.util.List;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Page;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;

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

@@ -1,6 +1,7 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.entity;
+package com.iqser.red.service.redaction.v1.server.model.document.entity;
 
 import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashSet;
@@ -10,11 +11,11 @@ import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Set;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Engine;
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.redaction.utils.IdBuilder;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Page;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.utils.IdBuilder;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -28,21 +29,23 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
 @EqualsAndHashCode(onlyExplicitlyIncluded = true)
-public class TextEntity implements Entity {
+@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
+public class TextEntity implements IEntity {
 
     // primary key
     @EqualsAndHashCode.Include
-    final TextRange textRange;
-    @EqualsAndHashCode.Include
-    final String type;
-    @EqualsAndHashCode.Include
-    final EntityType entityType;
+    final String id;
     // primary key end
 
+    TextRange textRange;
+    @Builder.Default
+    List<TextRange> duplicateTextRanges = new ArrayList<>();
+    String type; // TODO: make final once ManualChangesApplicatioService recategorize is deleted
+    final EntityType entityType;
+
     @Builder.Default
     final PriorityQueue<MatchedRule> matchedRuleList = new PriorityQueue<>();
-    @Builder.Default
-    final ManualChangeOverwrite manualOverwrite = new ManualChangeOverwrite();
+    final ManualChangeOverwrite manualOverwrite;
 
     boolean dictionaryEntry;
     boolean dossierDictionaryEntry;
@@ -50,7 +53,6 @@ public class TextEntity implements Entity {
     @Builder.Default
     Set<Engine> engines = new HashSet<>();
 
-
     // inferred on graph insertion
     String value;
     String textBefore;
@@ -63,12 +65,30 @@ public class TextEntity implements Entity {
     SemanticNode deepestFullyContainingNode;
 
 
-    public static TextEntity initialEntityNode(TextRange textRange, String type, EntityType entityType) {
+    public static TextEntity initialEntityNode(TextRange textRange, String type, EntityType entityType, SemanticNode node) {
 
-        return TextEntity.builder().type(type).entityType(entityType).textRange(textRange).build();
+        return TextEntity.builder().id(buildId(node, textRange, type, entityType)).type(type).entityType(entityType).textRange(textRange).manualOverwrite(new ManualChangeOverwrite(entityType)).build();
     }
 
 
+    public static TextEntity initialEntityNode(TextRange textRange, String type, EntityType entityType, String id) {
+
+        return TextEntity.builder().id(id).type(type).entityType(entityType).textRange(textRange).manualOverwrite(new ManualChangeOverwrite(entityType)).build();
+    }
+
+
+    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());
+    }
+
+
+    public void addTextRange(TextRange textRange) {
+
+        duplicateTextRanges.add(textRange);
+    }
+
     public boolean occursInNodeOfType(Class<? extends SemanticNode> clazz) {
 
         return intersectingNodes.stream().anyMatch(clazz::isInstance);
@@ -83,13 +103,13 @@ public class TextEntity implements Entity {
 
     public boolean isType(String type) {
 
-        return this.type.equals(type);
+        return type().equals(type);
     }
 
 
     public boolean isAnyType(List<String> types) {
 
-        return types.contains(type);
+        return types.contains(type());
     }
 
 
@@ -126,7 +146,6 @@ public class TextEntity implements Entity {
                     .min(Comparator.comparingInt(Page::getNumber))
                     .orElseThrow(() -> new RuntimeException("No Positions found on any page!"));
 
-            String id = IdBuilder.buildId(pages, rectanglesPerLinePerPage.values().stream().flatMap(Collection::stream).toList(), type, entityType.name());
             positionsOnPagePerPage = rectanglesPerLinePerPage.entrySet().stream().map(entry -> buildPositionOnPage(firstPage, id, entry)).toList();
         }
         return positionsOnPagePerPage;
@@ -194,11 +213,25 @@ public class TextEntity implements Entity {
         });
         sb.delete(sb.length() - 2, sb.length());
         sb.append("], type = \"");
-        sb.append(type);
+        sb.append(type());
         sb.append("\", EntityType.");
         sb.append(entityType);
         sb.append("]");
         return sb.toString();
     }
 
+
+    @Override
+    public String type() {
+
+        return getManualOverwrite().getType().orElse(type);
+    }
+
+
+    @Override
+    public String 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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.awt.geom.Rectangle2D;
 import java.util.Collections;
@@ -10,15 +10,16 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
@@ -27,8 +28,12 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Document implements GenericSemanticNode {
 
+    @EqualsAndHashCode.Include
+    List<Integer> treeId = Collections.emptyList();
+
     Set<Page> pages;
     DocumentTree documentTree;
     Integer numberOfPages;
@@ -67,13 +72,6 @@ public class Document implements GenericSemanticNode {
     }
 
 
-    @Override
-    public List<Integer> getTreeId() {
-
-        return Collections.emptyList();
-    }
-
-
     @Override
     public void setTreeId(List<Integer> tocId) {
 

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

@@ -1,12 +1,14 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -21,21 +23,23 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Footer implements GenericSemanticNode {
 
-    @Builder.Default
     final static SectionIdentifier sectionIdentifier = SectionIdentifier.empty();
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
+
     TextBlock leafTextBlock;
 
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -71,4 +75,14 @@ public class Footer implements GenericSemanticNode {
         return treeId + ": " + NodeType.FOOTER + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 public interface GenericSemanticNode extends SemanticNode {
 

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

@@ -1,12 +1,14 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -21,21 +23,23 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Header implements GenericSemanticNode {
 
-    @Builder.Default
     final static SectionIdentifier sectionIdentifier = SectionIdentifier.empty();
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
+
     TextBlock leafTextBlock;
 
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public boolean isLeaf() {
@@ -71,4 +75,14 @@ public class Header implements GenericSemanticNode {
         return treeId + ": " + NodeType.HEADER + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

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

@@ -1,13 +1,15 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.AtomicTextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+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 lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -22,19 +24,21 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Headline implements GenericSemanticNode {
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
     TextBlock leafTextBlock;
     SectionIdentifier sectionIdentifier;
 
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -71,6 +75,16 @@ public class Headline implements GenericSemanticNode {
     }
 
 
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
+
     @Override
     public SectionIdentifier getSectionIdentifier() {
 

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

@@ -1,21 +1,23 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.awt.geom.Rectangle2D;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.Entity;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.ManualChangeOverwrite;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.MatchedRule;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.IEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.ManualChangeOverwrite;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.MatchedRule;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -30,8 +32,10 @@ import lombok.experimental.FieldDefaults;
 @AllArgsConstructor
 @NoArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class Image implements GenericSemanticNode, Entity {
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
+public class Image implements GenericSemanticNode, IEntity {
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
     String id;
 
@@ -77,6 +81,20 @@ public class Image implements GenericSemanticNode, Entity {
     }
 
 
+    @Override
+    public TextRange getTextRange() {
+
+        return GenericSemanticNode.super.getTextRange();
+    }
+
+
+    @Override
+    public String type() {
+
+        return getManualOverwrite().getType().orElse(imageType.toString());
+    }
+
+
     @Override
     public String toString() {
 
@@ -92,4 +110,23 @@ public class Image implements GenericSemanticNode, Entity {
         return bBoxPerPage;
     }
 
+
+    @Override
+    public String getValue() {
+
+        return NodeType.IMAGE + ":" + camelCase(imageType.toString());
+    }
+
+
+    private String camelCase(String name) {
+
+        return name.charAt(0) + name.substring(1).toLowerCase(Locale.ENGLISH);
+    }
+
+
+    public int length() {
+
+        return 0;
+    }
+
 }

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.util.Locale;
 

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.util.Locale;
 
@@ -16,6 +16,6 @@ public enum NodeType {
 
     public String toString() {
 
-        return this.name().charAt(0) + this.name().substring(1).toLowerCase(Locale.ROOT);
+        return this.name().charAt(0) + this.name().substring(1).toLowerCase(Locale.ENGLISH);
     }
 }

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

@@ -1,12 +1,12 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -23,26 +23,23 @@ import lombok.experimental.FieldDefaults;
 @NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Page {
 
+    @EqualsAndHashCode.Include
     Integer number;
     Integer height;
     Integer width;
     Integer rotation;
 
-    @EqualsAndHashCode.Exclude
     List<SemanticNode> mainBody;
-    @EqualsAndHashCode.Exclude
     Header header;
-    @EqualsAndHashCode.Exclude
     Footer footer;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<Image> images = new HashSet<>();
 
 
@@ -57,19 +54,4 @@ public class Page {
 
         return String.valueOf(number);
     }
-
-
-    @Override
-    public int hashCode() {
-
-        return number;
-    }
-
-
-    @Override
-    public boolean equals(Object o) {
-
-        return o instanceof Page && o.hashCode() == this.hashCode();
-    }
-
 }

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

@@ -1,12 +1,14 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.textblock.TextBlock;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -19,18 +21,20 @@ import lombok.experimental.FieldDefaults;
 @Builder
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Paragraph implements GenericSemanticNode {
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
     TextBlock leafTextBlock;
 
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -59,4 +63,14 @@ public class Paragraph implements GenericSemanticNode {
         return treeId + ": " + NodeType.PARAGRAPH + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

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

@@ -1,13 +1,15 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -22,18 +24,19 @@ import lombok.extern.slf4j.Slf4j;
 @Builder
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Section implements GenericSemanticNode {
-
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
 
     TextBlock textBlock;
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -92,4 +95,14 @@ public class Section implements GenericSemanticNode {
         return streamAllSubNodesOfType(NodeType.HEADLINE).anyMatch(h -> h.containsStringIgnoreCase(value));
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.util.Collections;
 import java.util.LinkedList;

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import static java.lang.String.format;
 
@@ -9,17 +9,19 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.AtomicTextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.utils.RectangleTransformations;
-import com.iqser.red.service.redaction.v1.server.document.utils.RedactionSearchUtility;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+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.service.document.NodeVisitor;
+import com.iqser.red.service.redaction.v1.server.utils.RectangleTransformations;
+import com.iqser.red.service.redaction.v1.server.utils.RedactionSearchUtility;
 
 public interface SemanticNode {
 
@@ -60,6 +62,7 @@ public interface SemanticNode {
         return getTextBlock().getPages();
     }
 
+
     /**
      * Finds the first page associated with this Node.
      *
@@ -78,13 +81,19 @@ public interface SemanticNode {
      */
     default Set<Page> getPages(TextRange textRange) {
 
-        if (!getTextRange().contains(textRange)) {
-            throw new IllegalArgumentException(format("%s which was used to query for pages is not contained in the %s of this node!", textRange, getTextRange()));
+        if (!getTextRange().intersects(textRange)) {
+            throw new IllegalArgumentException(format("%s which was used to query for pages is not intersected in the %s of this node!", textRange, getTextRange()));
         }
         return getTextBlock().getPages(textRange);
     }
 
 
+    /**
+     * Checks if the given page number exists in the list of pages.
+     *
+     * @param pageNumber the page number to be checked
+     * @return true if the page number exists, otherwise false
+     */
     default boolean onPage(int pageNumber) {
 
         return getPages().stream().anyMatch(page -> page.getNumber() == pageNumber);
@@ -170,6 +179,30 @@ public interface SemanticNode {
     }
 
 
+    /**
+     * Returns the next sibling node of this SemanticNode in the document tree, if any.
+     * If there is no next sibling node, an empty Optional is returned.
+     *
+     * @return Optional containing the next sibling node, or empty if there is none
+     */
+    default Optional<SemanticNode> getNextSibling() {
+
+        return getDocumentTree().getNextSibling(getTreeId());
+    }
+
+
+    /**
+     * Returns the previous sibling node of this SemanticNode in the document tree, if any.
+     * If there is no previous sibling node, an empty Optional is returned.
+     *
+     * @return Optional containing the previous sibling node, or empty if there is none
+     */
+    default Optional<SemanticNode> getPreviousSibling() {
+
+        return getDocumentTree().getPreviousSibling(getTreeId());
+    }
+
+
     /**
      * Leaf means a SemanticNode has direct access to a TextBlock, by default this is false and must be overridden.
      * Currently only Sections, Images, and Tables are not leaves.
@@ -215,7 +248,7 @@ public interface SemanticNode {
      */
     default boolean hasEntitiesOfType(String type) {
 
-        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> redactionEntity.getType().equals(type));
+        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> redactionEntity.type().equals(type));
     }
 
 
@@ -224,11 +257,11 @@ public interface SemanticNode {
      * Ignores Entity with ignored == true or removed == true.
      *
      * @param types an array of strings representing the types of entities to check for
-     * @return true, if this SemanticNode has at least one Entity of any of the provided types
+     * @return true, if this SemanticNode has at least one Entity of the provided types
      */
     default boolean hasEntitiesOfAnyType(String... types) {
 
-        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> Arrays.stream(types).anyMatch(type -> redactionEntity.getType().equals(type)));
+        return getEntities().stream().filter(TextEntity::active).anyMatch(redactionEntity -> Arrays.stream(types).anyMatch(type -> redactionEntity.type().equals(type)));
     }
 
 
@@ -241,11 +274,7 @@ public interface SemanticNode {
      */
     default boolean hasEntitiesOfAllTypes(String... types) {
 
-        return getEntities().stream()
-                .filter(TextEntity::active)
-                .map(TextEntity::getType)
-                .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());
     }
 
 
@@ -258,7 +287,7 @@ public interface SemanticNode {
      */
     default List<TextEntity> getEntitiesOfType(String type) {
 
-        return getEntities().stream().filter(TextEntity::active).filter(redactionEntity -> redactionEntity.getType().equals(type)).toList();
+        return getEntities().stream().filter(TextEntity::active).filter(redactionEntity -> redactionEntity.type().equals(type)).toList();
     }
 
 
@@ -400,6 +429,78 @@ public interface SemanticNode {
     }
 
 
+    /**
+     * Checks whether this SemanticNode contains exactly the provided String as a word.
+     *
+     * @param word - String which the TextBlock might contain
+     * @return true, if this node's TextBlock contains string
+     */
+    default boolean containsWord(String word) {
+
+        return getTextBlock().getWords().stream().anyMatch(s -> s.equals(word));
+    }
+
+
+    /**
+     * Checks whether this SemanticNode contains exactly the provided String as a word ignoring case.
+     *
+     * @param word - String which the TextBlock might contain
+     * @return true, if this node's TextBlock contains string
+     */
+    default boolean containsWordIgnoreCase(String word) {
+
+        return getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(s -> s.equals(word.toLowerCase(Locale.ENGLISH)));
+    }
+
+
+    /**
+     * Checks whether this SemanticNode contains any of the provided Strings as a word.
+     *
+     * @param words - A List of Strings which the TextBlock might contain
+     * @return true, if this node's TextBlock contains any of the provided strings
+     */
+    default boolean containsAnyWord(String... words) {
+
+        return Arrays.stream(words).anyMatch(word -> getTextBlock().getWords().stream().anyMatch(word::equals));
+    }
+
+
+    /**
+     * Checks whether this SemanticNode contains any of the provided Strings as a word ignoring case.
+     *
+     * @param words - A List of Strings which the TextBlock might contain
+     * @return true, if this node's TextBlock contains any of the provided strings
+     */
+    default boolean containsAnyWordIgnoreCase(String... words) {
+
+        return Arrays.stream(words).map(String::toLowerCase).anyMatch(word -> getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(word::equals));
+    }
+
+
+    /**
+     * Checks whether this SemanticNode contains all the provided Strings as word.
+     *
+     * @param words - A List of Strings which the TextBlock might contain
+     * @return true, if this node's TextBlock contains all the provided strings
+     */
+    default boolean containsAllWords(String... words) {
+
+        return Arrays.stream(words).allMatch(word -> getTextBlock().getWords().stream().anyMatch(word::equals));
+    }
+
+
+    /**
+     * Checks whether this SemanticNode contains all the provided Strings as word ignoring case.
+     *
+     * @param words - A List of Strings which the TextBlock might contain
+     * @return true, if this node's TextBlock contains all the provided strings
+     */
+    default boolean containsAllWordsIgnoreCase(String... words) {
+
+        return Arrays.stream(words).map(String::toLowerCase).allMatch(word -> getTextBlock().getWords().stream().map(String::toLowerCase).anyMatch(word::equals));
+    }
+
+
     /**
      * Checks whether this SemanticNode matches the provided regex pattern.
      *
@@ -426,11 +527,12 @@ public interface SemanticNode {
 
     /**
      * Checks whether this SemanticNode intersects the provided rectangle.
-     * @param x the lower left corner X value
-     * @param y the lower left corner Y value
-     * @param w width
-     * @param h height
-     * @param pageNumber the pagenumber of the rectangle
+     *
+     * @param x          the lower left corner X value
+     * @param y          the lower left corner Y value
+     * @param w          width
+     * @param h          height
+     * @param pageNumber the pageNumber of the rectangle
      * @return true if intersects, false otherwise
      */
     default boolean intersectsRectangle(int x, int y, int w, int h, int pageNumber) {
@@ -526,6 +628,27 @@ public interface SemanticNode {
     }
 
 
+    /**
+     * For a given TextRange this function returns a List of rectangle around the text in the range.
+     * These Rectangles are split either by a new line or by a large gap in the current line.
+     * This is mainly used to find the positions of TextEntities
+     *
+     * @param textRange A TextRange to calculate the positions for.
+     * @return A Map, where the keys are the pages and the values are a list of rectangles describing the position of words
+     */
+    default Map<Page, List<Rectangle2D>> getPositionsPerPage(TextRange textRange) {
+
+        if (isLeaf()) {
+            return getTextBlock().getPositionsPerPage(textRange);
+        }
+        Optional<SemanticNode> containingChildNode = streamChildren().filter(child -> child.getTextRange().contains(textRange)).findFirst();
+        if (containingChildNode.isEmpty()) {
+            return getTextBlock().getPositionsPerPage(textRange);
+        }
+        return containingChildNode.get().getPositionsPerPage(textRange);
+    }
+
+
     /**
      * If this Node is a Leaf it will calculate the boundingBox of its LeafTextBlock, otherwise it will calculate the Union of the BoundingBoxes of all its Children.
      * If called on the Document, it will return the cropbox of each page
@@ -534,12 +657,11 @@ public interface SemanticNode {
      */
     default Map<Page, Rectangle2D> getBBox() {
 
-        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
         if (isLeaf()) {
-            return getBBoxFromLeafTextBlock(bBoxPerPage);
+            return getBBoxFromLeafTextBlock();
         }
 
-        return getBBoxFromChildren(bBoxPerPage);
+        return getBBoxFromChildren();
     }
 
 
@@ -562,28 +684,49 @@ public interface SemanticNode {
 
     /**
      * TODO: this produces unwanted results for sections spanning multiple columns.
+     * Computes the Union of the bounding boxes of all children recursively.
      *
-     * @param bBoxPerPage initial empty BoundingBox
      * @return The union of the BoundingBoxes of all children
      */
-    private Map<Page, Rectangle2D> getBBoxFromChildren(Map<Page, Rectangle2D> bBoxPerPage) {
+    private Map<Page, Rectangle2D> getBBoxFromChildren() {
 
-        return streamChildren().map(SemanticNode::getBBox).reduce((map1, map2) -> {
-            map1.forEach((page, rectangle) -> map2.merge(page, rectangle, (rect1, rect2) -> rect1.createUnion(rect2).getBounds2D()));
-            return map2;
-        }).orElse(bBoxPerPage);
+        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());
+        for (Page page : pages) {
+            Rectangle2D bBoxOnPage = childrenBBoxes.stream()
+                    .filter(childBboxPerPage -> childBboxPerPage.containsKey(page))
+                    .map(childBboxPerPage -> childBboxPerPage.get(page))
+                    .collect(RectangleTransformations.collectBBox());
+            bBoxPerPage.put(page, bBoxOnPage);
+        }
+        return bBoxPerPage;
     }
 
 
     /**
-     * @param bBoxPerPage initial empty BoundingBox
      * @return The union of all BoundingBoxes of the TextBlock of this node
      */
-    private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock(Map<Page, Rectangle2D> bBoxPerPage) {
+    private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock() {
 
+        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
         Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks().stream().collect(Collectors.groupingBy(AtomicTextBlock::getPage));
-        atomicTextBlockPerPage.forEach((page, atbs) -> bBoxPerPage.put(page, RectangleTransformations.atomicTextBlockBBox(atbs)));
+        atomicTextBlockPerPage.forEach((page, atomicTextBlocks) -> bBoxPerPage.put(page, RectangleTransformations.atomicTextBlockBBox(atomicTextBlocks)));
         return bBoxPerPage;
     }
 
-}
+
+    /**
+     * Accepts a {@link NodeVisitor} and initiates a depth-first traversal of the semantic tree rooted at this node.
+     * The visitor's {@link NodeVisitor#visit(SemanticNode)} method is invoked for each node encountered during the traversal.
+     *
+     * @param visitor The {@link NodeVisitor} to accept and apply during the traversal.
+     * @see NodeVisitor
+     */
+    default void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+        streamChildren().forEach(childNode -> childNode.accept(visitor));
+    }
+
+}

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

@@ -1,19 +1,21 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import static java.lang.String.format;
 
+import java.awt.geom.Rectangle2D;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -26,8 +28,10 @@ import lombok.experimental.FieldDefaults;
 @Builder
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class Table implements SemanticNode {
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
     DocumentTree documentTree;
 
@@ -37,9 +41,20 @@ public class Table implements SemanticNode {
     TextBlock textBlock;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
+    Map<Page, Rectangle2D> bBoxCache;
+
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = SemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 
     /**
      * Streams all entities in this table, that appear in a row, which contains any of the provided strings.
@@ -113,7 +128,7 @@ public class Table implements SemanticNode {
 
         List<Integer> rowsWithEntityOfType = getEntities().stream()
                 .filter(TextEntity::active)
-                .filter(redactionEntity -> types.stream().anyMatch(type -> type.equals(redactionEntity.getType())))
+                .filter(redactionEntity -> types.stream().anyMatch(type -> type.equals(redactionEntity.type())))
                 .map(TextEntity::getIntersectingNodes)
                 .filter(node -> node instanceof TableCell)
                 .map(node -> (TableCell) node)
@@ -138,7 +153,7 @@ public class Table implements SemanticNode {
                 .filter(rowNumber -> streamRow(rowNumber).map(TableCell::getEntities)
                         .flatMap(Collection::stream)
                         .filter(TextEntity::active)
-                        .noneMatch(entity -> types.contains(entity.getType())))
+                        .noneMatch(entity -> types.contains(entity.type())))
                 .flatMap(this::streamRow)
                 .map(TableCell::getEntities)
                 .flatMap(Collection::stream);
@@ -173,6 +188,18 @@ public class Table implements SemanticNode {
     }
 
 
+    /**
+     * Streams all TableCells that contain at least one entity of a given type in this Table row-wise.
+     *
+     * @param type The type of the entity
+     * @return Stream of filtered TableCells
+     */
+    public Stream<TableCell> streamTableCellsWhichContainType(String type) {
+
+        return streamTableCells().filter(tableCell -> tableCell.getEntities().stream().filter(TextEntity::active).anyMatch(entity -> entity.type().equals(type)));
+    }
+
+
     /**
      * Streams all TableCells in this Table which have the provided header row-wise.
      *
@@ -255,7 +282,11 @@ public class Table implements SemanticNode {
      */
     public boolean hasHeaderIgnoreCase(String header) {
 
-        return streamHeaders().anyMatch(tableCellNode -> tableCellNode.getTextBlock().getSearchText().strip().toLowerCase(Locale.ENGLISH).equals(header.toLowerCase(Locale.ENGLISH)));
+        return streamHeaders().anyMatch(tableCellNode -> tableCellNode.getTextBlock()
+                .getSearchText()
+                .strip()
+                .toLowerCase(Locale.ENGLISH)
+                .equals(header.toLowerCase(Locale.ENGLISH)));
     }
 
 
@@ -289,7 +320,7 @@ public class Table implements SemanticNode {
      * Finds all entities of the provided type, which appear in the same row that the provided entity appears in.
      * Ignores Entity with ignored == true or removed == true.
      *
-     * @param type            the type of entities to search for
+     * @param type       the type of entities to search for
      * @param textEntity the entity, which appears in the row to search
      * @return List of all entities of the provided type, which appear in the same row that the provided entity appears in.
      */

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.nodes;
+package com.iqser.red.service.redaction.v1.server.model.document.nodes;
 
 import java.awt.geom.Rectangle2D;
 import java.util.HashMap;
@@ -7,10 +7,10 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.DocumentTree;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlock;
-import com.iqser.red.service.redaction.v1.server.document.graph.textblock.TextBlockCollector;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.DocumentTree;
+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.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -23,8 +23,10 @@ import lombok.experimental.FieldDefaults;
 @Builder
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
 public class TableCell implements GenericSemanticNode {
 
+    @EqualsAndHashCode.Include
     List<Integer> treeId;
     int row;
     int col;
@@ -36,11 +38,9 @@ public class TableCell implements GenericSemanticNode {
 
     TextBlock textBlock;
 
-    @EqualsAndHashCode.Exclude
     DocumentTree documentTree;
 
     @Builder.Default
-    @EqualsAndHashCode.Exclude
     Set<TextEntity> entities = new HashSet<>();
 
 

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

@@ -1,21 +1,24 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.textblock;
+package com.iqser.red.service.redaction.v1.server.model.document.textblock;
 
 import static java.lang.String.format;
 
 import java.awt.geom.Rectangle2D;
+import java.text.BreakIterator;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.utils.RectangleTransformations;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Page;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.utils.RectangleTransformations;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionData;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentTextData;
 
@@ -40,6 +43,7 @@ public class AtomicTextBlock implements TextBlock {
     //string coordinates
     TextRange textRange;
     String searchText;
+    List<String> words;
     List<Integer> lineBreaks;
 
     //position coordinates
@@ -114,6 +118,20 @@ 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) {
+            words = new ArrayList<>();
+            BreakIterator iterator = BreakIterator.getWordInstance(Locale.ENGLISH);
+            iterator.setText(searchText);
+            int start = iterator.first();
+            for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
+                words.add(searchText.substring(start, end));
+            }
+        }
+        return words;
+    }
+
 
     @Override
     public List<AtomicTextBlock> getAtomicTextBlocks() {

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.textblock;
+package com.iqser.red.service.redaction.v1.server.model.document.textblock;
 
 import static java.lang.String.format;
 
@@ -7,11 +7,12 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Collection;
 import java.util.Map;
 import java.util.stream.Stream;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Page;
 
 import lombok.AccessLevel;
 import lombok.Data;
@@ -70,7 +71,16 @@ public class ConcatenatedTextBlock implements TextBlock {
 
     private List<AtomicTextBlock> getAllAtomicTextBlocksPartiallyInStringBoundary(TextRange textRange) {
 
-        return atomicTextBlocks.stream().filter(tb -> tb.getTextRange().intersects(textRange)).toList();
+        List<AtomicTextBlock> intersectingAtomicTextBlocks = new LinkedList<>();
+        for (AtomicTextBlock atomicTextBlock : atomicTextBlocks) {
+            if (atomicTextBlock.getTextRange().start() > textRange.end()) {
+                break; // early stop, following TextBlocks will never intersect
+            }
+            if (atomicTextBlock.getTextRange().intersects(textRange)) {
+                intersectingAtomicTextBlocks.add(atomicTextBlock);
+            }
+        }
+        return intersectingAtomicTextBlocks;
     }
 
 
@@ -86,6 +96,13 @@ public class ConcatenatedTextBlock implements TextBlock {
     }
 
 
+    @Override
+    public List<String> getWords() {
+
+        return atomicTextBlocks.stream().map(AtomicTextBlock::getWords).flatMap(Collection::stream).toList();
+    }
+
+
     @Override
     public int numberOfLines() {
 
@@ -114,13 +131,13 @@ public class ConcatenatedTextBlock implements TextBlock {
     }
 
 
-
     @Override
     public Rectangle2D getPosition(int stringIdx) {
 
         return getAtomicTextBlockByStringIndex(stringIdx).getPosition(stringIdx);
     }
 
+
     public TextRange getLineTextRange(int lineNumber) {
 
         if (atomicTextBlocks.size() == 1) {
@@ -136,10 +153,10 @@ public class ConcatenatedTextBlock implements TextBlock {
         return new TextRange(textRange.start(), textRange.start());
     }
 
+
     @Override
     public List<Rectangle2D> getPositions(TextRange stringTextRange) {
 
-
         List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringTextRange);
 
         if (textBlocks.isEmpty()) {

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.textblock;
+package com.iqser.red.service.redaction.v1.server.model.document.textblock;
 
 import static java.lang.String.format;
 
@@ -10,14 +10,15 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
-import com.iqser.red.service.redaction.v1.server.document.utils.RectangleTransformations;
+import com.iqser.red.service.redaction.v1.server.model.document.TextRange;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Page;
+import com.iqser.red.service.redaction.v1.server.utils.RectangleTransformations;
 
 public interface TextBlock extends CharSequence {
 
     String getSearchText();
 
+    List<String> getWords();
 
     List<AtomicTextBlock> getAtomicTextBlocks();
 

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.document.graph.textblock;
+package com.iqser.red.service.redaction.v1.server.model.document.textblock;
 
 import java.util.Set;
 import java.util.function.BiConsumer;

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

@@ -0,0 +1,15 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import lombok.AccessLevel;
+import lombok.Data;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class BasicQuery {
+
+    String name;
+    int line;
+    String code;
+
+}

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

@@ -0,0 +1,42 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import org.drools.drl.ast.descr.AttributeDescr;
+import org.drools.drl.ast.descr.RuleDescr;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.experimental.FieldDefaults;
+
+@Getter
+@AllArgsConstructor
+@EqualsAndHashCode(onlyExplicitlyIncluded = true)
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class BasicRule {
+
+    @EqualsAndHashCode.Include
+    RuleIdentifier identifier;
+    String name;
+    String code;
+    String agendaGroup;
+    int line;
+
+
+    public static BasicRule fromRuleDescr(RuleDescr rule, String rulesString) {
+
+        RuleIdentifier identifier = RuleIdentifier.fromName(rule.getName());
+        String nameWithoutIdentifier = rule.getName().replace(identifier + ":", "");
+        String code = rulesString.substring(rule.getStartCharacter(), rule.getEndCharacter());
+        String agendaGroup = rule.getAttributes().getOrDefault("agenda-group", new AttributeDescr("agenda-group", "DEFAULT")).getValue();
+        return new BasicRule(identifier, nameWithoutIdentifier, code, agendaGroup, rule.getLine());
+    }
+
+
+    @Override
+    public String toString() {
+
+        return "BasicRule[identifier=" + identifier + ", name=" + name + ", code=" + code + ']';
+    }
+
+}

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

@@ -0,0 +1,15 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+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();
+    }
+
+}

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

@@ -0,0 +1,84 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
+
+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 final class RuleFileBluePrint {
+
+    String imports;
+    int importLine;
+    String globals;
+    int globalsLine;
+    List<BasicQuery> queries;
+    List<RuleClass> ruleClasses;
+    DroolsSyntaxValidation droolsSyntaxValidation;
+
+
+    public Optional<RuleClass> findRuleClassByType(RuleType ruleType) {
+
+        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());
+    }
+
+
+    public List<BasicRule> findRulesByIdentifier(RuleIdentifier ruleIdentifier) {
+
+        if (Objects.isNull(ruleIdentifier.unit())) {
+            return findRuleClassByType(ruleIdentifier.type()).map(RuleClass::ruleUnits)
+                    .orElse(Collections.emptyList())
+                    .stream()
+                    .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)))
+                .orElse(Stream.empty())
+                .toList();
+    }
+
+
+    public List<RuleIdentifier> getAllRuleIdentifiers() {
+
+        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);
+    }
+
+
+    @Override
+    public String toString() {
+
+        return "RuleFileBluePrint[imports=" + imports + ", globals=" + globals + ", queries=" + queries + ", ruleClasses=" + ruleClasses + ']';
+    }
+
+}

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

@@ -0,0 +1,81 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import java.util.Objects;
+
+import lombok.NonNull;
+
+public record RuleIdentifier(@NonNull RuleType type, Integer unit, Integer id) {
+
+    public static RuleIdentifier fromName(String name) {
+
+        String identifier = name.split(":")[0];
+        return fromString(identifier);
+    }
+
+
+    public static RuleIdentifier fromString(String identifier) {
+
+        String[] values = identifier.split("\\.");
+        if (values.length != 3) {
+            throw new IllegalArgumentException(String.format("Identifier %s must conform to the pattern \"[a-zA-Z0-9]+.\\d+.\\d+\"", identifier));
+        }
+        RuleType type = RuleType.fromString(values[0]);
+        Integer group = Integer.parseInt(values[1]);
+        Integer id = Integer.parseInt(values[2]);
+        return new RuleIdentifier(type, group, id);
+    }
+
+
+    public static RuleIdentifier empty() {
+
+        return new RuleIdentifier(new RuleType(""), null, null);
+    }
+
+
+    /**
+     * This is used to filter rules, if the field Integer unit or Integer id is null, the field will match any other RuleIdentifier.
+     * Therefore, to compare RuleIdentifiers one should always use the function matches.
+     *
+     * @param ruleIdentifier RuleIdentifier to check if this one matches it.
+     * @return true, if all fields match. If a field is null, it matches any field.
+     */
+    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()));
+
+    }
+
+
+    @Override
+    public String toString() {
+
+        if (type.name().isBlank() || type.name().isEmpty()) {
+            return "";
+        }
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(type().name());
+        if (Objects.nonNull(unit())) {
+            sb.append(".");
+            sb.append(unit());
+        } else {
+            sb.append(".*");
+        }
+        if (Objects.nonNull(id())) {
+            sb.append(".");
+            sb.append(id());
+        } else {
+            sb.append(".*");
+        }
+        return sb.toString();
+    }
+
+
+    public String toRuleUnitString() {
+
+        return String.format("Rule unit: %s.%d", type.name(), unit);
+    }
+
+}

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

@@ -0,0 +1,18 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import java.util.regex.Pattern;
+
+public record RuleType(String name) {
+
+    static Pattern alphaNumeric = Pattern.compile("^[a-zA-Z0-9]+$");
+
+
+    public static RuleType fromString(String value) {
+
+        if (!alphaNumeric.matcher(value).matches()) {
+            throw new IllegalArgumentException(String.format("The rule type %s must only contain numbers and letters!", value));
+        }
+        return new RuleType(value);
+    }
+
+}

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

@@ -0,0 +1,7 @@
+package com.iqser.red.service.redaction.v1.server.model.drools;
+
+import java.util.List;
+
+public record RuleUnit(Integer unit, List<BasicRule> rules) {
+
+}

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

@@ -1,13 +1,11 @@
 package com.iqser.red.service.redaction.v1.server.queue;
 
-import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.REDACTION_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_QUEUE;
 
 import org.springframework.amqp.core.Message;
 import org.springframework.amqp.rabbit.annotation.RabbitHandler;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 

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

@@ -1,6 +1,11 @@
 package com.iqser.red.service.redaction.v1.server.queue;
 
-import lombok.RequiredArgsConstructor;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.MIGRATION_DLQ;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.MIGRATION_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_ANALYSIS_RESPONSE_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_DQL;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_PRIORITY_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_QUEUE;
 
 import org.springframework.amqp.core.Queue;
 import org.springframework.amqp.core.QueueBuilder;
@@ -8,15 +13,12 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import lombok.RequiredArgsConstructor;
+
 @Configuration
 @RequiredArgsConstructor
 public class MessagingConfiguration {
 
-    public static final String REDACTION_QUEUE = "redactionQueue";
-    public static final String REDACTION_DQL = "redactionDQL";
-
-    public static final String REDACTION_PRIORITY_QUEUE = "redactionPriorityQueue";
-
     public static final String X_ERROR_INFO_HEADER = "x-error-message";
     public static final String X_ERROR_INFO_TIMESTAMP_HEADER = "x-error-message-timestamp";
 
@@ -37,6 +39,20 @@ public class MessagingConfiguration {
     }
 
 
+    @Bean
+    public Queue migrationQueue() {
+
+        return QueueBuilder.durable(MIGRATION_QUEUE).withArgument("x-dead-letter-exchange", "").withArgument("x-dead-letter-routing-key", MIGRATION_DLQ).maxPriority(2).build();
+    }
+
+
+    @Bean
+    public Queue migrationDLQ() {
+
+        return QueueBuilder.durable(MIGRATION_DLQ).build();
+    }
+
+
     @Bean
     public Queue redactionQueue() {
 
@@ -54,6 +70,16 @@ public class MessagingConfiguration {
                 .build();
     }
 
+    @Bean
+    public Queue redactionAnalysisResponseQueue() {
+
+        return QueueBuilder.durable(REDACTION_ANALYSIS_RESPONSE_QUEUE)
+                .withArgument("x-dead-letter-exchange", "")
+                .withArgument("x-dead-letter-routing-key", REDACTION_DQL)
+                .maxPriority(2)
+                .build();
+    }
+
 
     @Bean
     public Queue redactionDeadLetterQueue() {

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

@@ -1,13 +1,11 @@
 package com.iqser.red.service.redaction.v1.server.queue;
 
-import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.REDACTION_PRIORITY_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_PRIORITY_QUEUE;
 
 import org.springframework.amqp.core.Message;
 import org.springframework.amqp.rabbit.annotation.RabbitHandler;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 

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

@@ -1,28 +1,35 @@
 package com.iqser.red.service.redaction.v1.server.queue;
 
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_DQL;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_PRIORITY_QUEUE;
+import static com.iqser.red.service.redaction.v1.model.QueueNames.REDACTION_QUEUE;
+import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.X_ERROR_INFO_HEADER;
+import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.X_ERROR_INFO_TIMESTAMP_HEADER;
+import static java.lang.String.format;
+
+import java.io.IOException;
+import java.time.OffsetDateTime;
+import java.time.temporal.ChronoUnit;
+
+import org.springframework.amqp.AmqpRejectAndDontRequeueException;
+import org.springframework.amqp.core.Message;
+import org.springframework.amqp.rabbit.annotation.RabbitHandler;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Service;
+
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeResult;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileErrorInfo;
 import com.iqser.red.service.redaction.v1.server.client.FileStatusProcessingUpdateClient;
 import com.iqser.red.service.redaction.v1.server.client.RulesClient;
-import com.iqser.red.service.redaction.v1.server.exception.DroolsTimeoutException;
-import com.iqser.red.service.redaction.v1.server.redaction.service.AnalyzeService;
+import com.iqser.red.service.redaction.v1.server.service.AnalyzeService;
+import com.iqser.red.service.redaction.v1.server.service.UnprocessedChangesService;
+import com.iqser.red.service.redaction.v1.server.utils.exception.DroolsTimeoutException;
+
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.amqp.AmqpRejectAndDontRequeueException;
-import org.springframework.amqp.core.Message;
-import org.springframework.amqp.rabbit.annotation.RabbitHandler;
-import org.springframework.amqp.rabbit.annotation.RabbitListener;
-import org.springframework.stereotype.Service;
-
-import java.io.IOException;
-import java.time.OffsetDateTime;
-import java.time.temporal.ChronoUnit;
-
-import static com.iqser.red.service.redaction.v1.server.queue.MessagingConfiguration.*;
-import static java.lang.String.format;
 
 @Slf4j
 @Service
@@ -33,6 +40,7 @@ public class RedactionMessageReceiver {
     private final AnalyzeService analyzeService;
     private final FileStatusProcessingUpdateClient fileStatusProcessingUpdateClient;
     private final RulesClient rulesClient;
+    private final UnprocessedChangesService unprocessedChangesService;
 
 
     @SneakyThrows
@@ -64,7 +72,8 @@ public class RedactionMessageReceiver {
         log.info("");
         log.info("Processing AnalyzeRequest for file: {},  priority: {} ", analyzeRequest.getFileId(), priority);
         log.info("");
-        AnalyzeResult result;
+        AnalyzeResult result = new AnalyzeResult();
+        boolean shouldRespond = true;
 
         try {
             switch (analyzeRequest.getMessageType()) {
@@ -92,32 +101,50 @@ public class RedactionMessageReceiver {
                             format("%.2f", result.getDuration() / 1000.0));
                     log.info("----------------------------------------------------------------------------------");
                     break;
+                case SURROUNDING_TEXT_ANALYSIS:
+                    log.info("------------------------------Surrounding Text Analysis------------------------------------------");
+                    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("-------------------------------------------------------------------------------------------------");
+                    shouldRespond = false;
+                    break;
 
                 default:
                     throw new IllegalArgumentException("Unknown MessageType: " + analyzeRequest.getMessageType());
             }
             log.info("");
-            result.setMessageType(analyzeRequest.getMessageType());
-            fileStatusProcessingUpdateClient.analysisSuccessful(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), result);
-
-        } catch (Exception e) {
-
-            if (e instanceof DroolsTimeoutException && !((DroolsTimeoutException) e).isReported()) {
-                rulesClient.setRulesTimeoutDetected(analyzeRequest.getDossierTemplateId());
+            if (shouldRespond) {
+                result.setMessageType(analyzeRequest.getMessageType());
+                fileStatusProcessingUpdateClient.analysisSuccessful(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), result);
             }
-
-            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));
+        } catch (DroolsTimeoutException droolsTimeoutException) {
+            if (!droolsTimeoutException.isReported()) {
+                rulesClient.setRulesTimeoutDetected(analyzeRequest.getDossierTemplateId(), droolsTimeoutException.getRuleFileType());
+            }
+            sendAnalysisFailed(analyzeRequest, priority, droolsTimeoutException);
+        } catch (Exception e) {
+            sendAnalysisFailed(analyzeRequest, priority, e);
         }
     }
 
 
+    private void sendAnalysisFailed(AnalyzeRequest analyzeRequest, boolean priority, Exception e) {
+
+        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));
+    }
+
+
     @RabbitHandler
     @RabbitListener(queues = REDACTION_DQL)
-    public void receiveAnalyzeRequestDQL(Message in) throws IOException {
+    public void receiveAnalyzeRequestDLQ(Message in) throws IOException {
 
         var analyzeRequest = objectMapper.readValue(in.getBody(), AnalyzeRequest.class);
         log.info("Failed to process analyze request: {}", analyzeRequest);

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

@@ -1,240 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.adapter;
-
-import static java.lang.String.format;
-import static java.util.stream.Collectors.groupingBy;
-
-import java.awt.geom.Rectangle2D;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
-import com.iqser.red.service.redaction.v1.server.document.graph.TextRange;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.EntityType;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.TextEntity;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.PositionOnPage;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Page;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.services.EntityCreationService;
-import com.iqser.red.service.redaction.v1.server.document.services.EntityEnrichmentService;
-import com.iqser.red.service.redaction.v1.server.redaction.model.ManualEntity;
-import com.iqser.red.service.redaction.v1.server.redaction.model.RectangleWithPage;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.SearchImplementation;
-
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-public class CustomEntityCreationAdapter {
-
-    private static final double MATCH_THRESHOLD = 5; // sum of distances for each corner
-    private final EntityCreationService entityCreationService;
-
-
-    @Autowired
-    public CustomEntityCreationAdapter(EntityEnrichmentService entityEnrichmentService) {
-
-        entityCreationService = new EntityCreationService(entityEnrichmentService);
-    }
-
-
-    public List<ManualEntity> toRedactionEntity(RedactionLog redactionLog, SemanticNode node) {
-
-        List<ManualEntity> manualEntities = redactionLog.getRedactionLogEntry().stream().map(ManualEntity::fromRedactionLogEntry).toList();
-        return toRedactionEntity(manualEntities, node);
-    }
-
-
-    public List<ManualEntity> createRedactionEntitiesIfFoundAndReturnNotFoundEntries(Set<ManualRedactionEntry> manualRedactionEntries, SemanticNode node) {
-
-        List<ManualEntity> manualEntities = manualRedactionEntries.stream()
-                .filter(manualRedactionEntry -> !(manualRedactionEntry.isAddToDictionary() || manualRedactionEntry.isAddToDossierDictionary()))
-                .map(ManualEntity::fromManualRedactionEntry)
-                .toList();
-
-        return toRedactionEntity(manualEntities, node);
-    }
-
-
-    private List<ManualEntity> toRedactionEntity(List<ManualEntity> manualEntities, SemanticNode node) {
-
-        Set<Integer> pageNumbers = manualEntities.stream().flatMap(entry -> entry.getEntityPosition().stream().map(RectangleWithPage::pageNumber)).collect(Collectors.toSet());
-        Set<String> entryValues = manualEntities.stream().map(ManualEntity::getValue).map(String::toLowerCase).collect(Collectors.toSet());
-
-        Map<String, List<TextEntity>> tempEntitiesByValue = findAllPossibleEntitiesAndGroupByValue(node, pageNumbers, entryValues);
-
-        List<ManualEntity> notFoundManualEntities = new LinkedList<>();
-        for (ManualEntity manualEntity : manualEntities) {
-            Optional<TextEntity> optionalRedactionEntity = findClosestEntityAndReturnEmptyIfNotFound(manualEntity, tempEntitiesByValue);
-            if (optionalRedactionEntity.isEmpty()) {
-                notFoundManualEntities.add(manualEntity);
-                continue;
-            }
-            createCorrectEntity(manualEntity, node, optionalRedactionEntity.get().getTextRange());
-        }
-        tempEntitiesByValue.values().stream().flatMap(Collection::stream).forEach(TextEntity::removeFromGraph);
-        return notFoundManualEntities;
-    }
-
-
-    /**
-     * Deletes the temp Entity and creates a RedactionEntity with correct values, based on the given parameters.
-     *
-     * @param manualEntity The entity identifier for the RedactionEntity.
-     * @param node             The SemanticNode associated with the RedactionEntity.
-     * @param closestTextRange  The closest Boundary to the RedactionEntity.
-     */
-    private void createCorrectEntity(ManualEntity manualEntity, SemanticNode node, TextRange closestTextRange) {
-
-        TextEntity correctEntity = entityCreationService.forceByBoundary(closestTextRange, manualEntity.getType(), manualEntity.getEntityType(), node);
-
-        if (manualEntity.isApplied()) {
-            correctEntity.force(manualEntity.getRuleIdentifier(), manualEntity.getReason(), manualEntity.getLegalBasis());
-        } else {
-            correctEntity.skip(manualEntity.getRuleIdentifier(), manualEntity.getReason());
-        }
-        correctEntity.setDictionaryEntry(manualEntity.isDictionaryEntry());
-        correctEntity.setDossierDictionaryEntry(manualEntity.isDossierDictionaryEntry());
-        correctEntity.getManualOverwrite().addChanges(manualEntity.getManualOverwrite().getManualChangeLog());
-
-
-        // AnnotationIds must match the IDs in the add requests, or comments break. Maybe think about migrating IDs on the fly!
-        List<PositionOnPage> redactionPositionsWithIdOfManualOnPage = new ArrayList<>(correctEntity.getPositionsOnPagePerPage().size());
-        for (PositionOnPage positionOnPage : correctEntity.getPositionsOnPagePerPage()) {
-            redactionPositionsWithIdOfManualOnPage.add(new PositionOnPage(manualEntity.getId(), positionOnPage.getPage(), positionOnPage.getRectanglePerLine()));
-        }
-        correctEntity.setPositionsOnPagePerPage(redactionPositionsWithIdOfManualOnPage);
-    }
-
-
-    private Optional<TextEntity> findClosestEntityAndReturnEmptyIfNotFound(ManualEntity identifier, Map<String, List<TextEntity>> entitiesWithSameValue) {
-
-        List<TextEntity> possibleEntities = entitiesWithSameValue.get(identifier.getValue().toLowerCase(Locale.ROOT));
-
-        if (entityIdentifierValueNotFound(possibleEntities)) {
-            log.warn("Entity could not be created with identifier: {}, due to the value {} not being found anywhere.", identifier, identifier.getValue());
-            return Optional.empty();
-        }
-
-        Optional<TextEntity> optionalClosestEntity = possibleEntities.stream()
-                .filter(entity -> pagesMatch(entity, identifier.getEntityPosition()))
-                .min(Comparator.comparingDouble(entity -> calculateMinDistance(identifier.getEntityPosition(), entity)));
-
-        if (optionalClosestEntity.isEmpty()) {
-            log.warn("No Entity with value {} found on page {}", identifier.getValue(), identifier.getEntityPosition());
-            return Optional.empty();
-        }
-
-        TextEntity closestEntity = optionalClosestEntity.get();
-        double distance = calculateMinDistance(identifier.getEntityPosition(), closestEntity);
-        if (distance > MATCH_THRESHOLD) {
-            log.warn(format("Distance to closest found entity is %.2f and therefore higher than the threshold of %.2f for \n%s \n%s",
-                    distance,
-                    MATCH_THRESHOLD,
-                    identifier.getEntityPosition(),
-                    closestEntity.getPositionsOnPagePerPage()));
-            return Optional.empty();
-        }
-
-        return Optional.of(closestEntity);
-    }
-
-
-    private static boolean entityIdentifierValueNotFound(List<TextEntity> possibleEntities) {
-
-        return possibleEntities == null || possibleEntities.isEmpty();
-    }
-
-
-    private Map<String, List<TextEntity>> findAllPossibleEntitiesAndGroupByValue(SemanticNode node, Set<Integer> pageNumbers, Set<String> entryValues) {
-
-        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()));
-        }
-        SearchImplementation searchImplementation = new SearchImplementation(entryValues, true);
-
-        return searchImplementation.getBoundaries(node.getTextBlock(), node.getTextRange())
-                .stream()
-                .map(boundary -> entityCreationService.forceByBoundary(boundary, "temp", EntityType.ENTITY, node))
-                .collect(groupingBy(entity -> entity.getValue().toLowerCase(Locale.ROOT)));
-    }
-
-
-    private static boolean allValuesFound(Map<String, List<TextEntity>> entitiesByValue, Set<String> entryValues) {
-
-        return entitiesByValue.keySet().equals(entryValues);
-    }
-
-
-    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());
-        return entityPageNumbers.containsAll(originalPageNumbers);
-    }
-
-
-    private double calculateMinDistance(List<RectangleWithPage> originalPositions, TextEntity entity) {
-
-        if (originalPositions.size() != countRectangles(entity)) {
-            return Double.MAX_VALUE;
-        }
-        return originalPositions.stream()
-                .mapToDouble(rectangleWithPage -> calculateMinDistancePerRectangle(entity, rectangleWithPage.pageNumber(), rectangleWithPage.rectangle2D()))
-                .sum();
-    }
-
-
-    private static long countRectangles(TextEntity entity) {
-
-        return entity.getPositionsOnPagePerPage().stream().mapToLong(redactionPosition -> redactionPosition.getRectanglePerLine().size()).sum();
-    }
-
-
-    private double calculateMinDistancePerRectangle(TextEntity entity, int pageNumber, Rectangle2D originalRectangle) {
-
-        return entity.getPositionsOnPagePerPage()
-                .stream()
-                .filter(redactionPosition -> redactionPosition.getPage().getNumber() == pageNumber)
-                .map(PositionOnPage::getRectanglePerLine)
-                .flatMap(Collection::stream)
-                .mapToDouble(rectangle -> calculateDistance(rectangle, originalRectangle))
-                .min()
-                .orElse(Double.MAX_VALUE);
-    }
-
-
-    private double calculateDistance(Rectangle2D rectangle, Rectangle2D rectangle2D) {
-
-        // mirrored coordinates safe comparison
-        double minX1 = Math.min(rectangle.getMinX(), rectangle.getMaxX());
-        double minY1 = Math.min(rectangle.getMinY(), rectangle.getMaxY());
-        double maxX1 = Math.max(rectangle.getMinX(), rectangle.getMaxX());
-        double maxY1 = Math.max(rectangle.getMinY(), rectangle.getMaxY());
-
-        double minX2 = Math.min(rectangle2D.getMinX(), rectangle2D.getMaxX());
-        double minY2 = Math.min(rectangle2D.getMinY(), rectangle2D.getMaxY());
-        double maxX2 = Math.max(rectangle2D.getMinX(), rectangle2D.getMaxX());
-        double maxY2 = Math.max(rectangle2D.getMinY(), rectangle2D.getMaxY());
-
-        return Math.abs(minX1 - minX2) //
-                + Math.abs(minY1 - minY2) //
-                + Math.abs(maxX1 - maxX2) //
-                + Math.abs(maxY1 - maxY2);
-    }
-
-}

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

@@ -1,7 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model;
-
-import org.kie.api.runtime.KieContainer;
-
-public record KieWrapper( KieContainer container,long rulesVersion) {
-
-}

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

@@ -1,91 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.model;
-
-import java.util.List;
-import java.util.PriorityQueue;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.Entity;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.EntityType;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.ManualChangeOverwrite;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.MatchedRule;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.experimental.FieldDefaults;
-
-@Getter
-@Builder
-@AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class ManualEntity implements Entity {
-
-    // must be mapped into a TextEntity as is for comments to work correctly
-    String id;
-    String value;
-    List<RectangleWithPage> entityPosition;
-    String ruleIdentifier;
-    String reason;
-    String legalBasis;
-    String type;
-    String section;
-    EntityType entityType;
-    boolean applied;
-    boolean isDictionaryEntry;
-    boolean isDossierDictionaryEntry;
-    boolean rectangle;
-
-    @Builder.Default
-    PriorityQueue<MatchedRule> matchedRuleList = new PriorityQueue<>();
-    @Builder.Default
-    ManualChangeOverwrite manualOverwrite = new ManualChangeOverwrite();
-
-
-    public static ManualEntity fromRedactionLogEntry(RedactionLogEntry redactionLogEntry) {
-
-        String ruleIdentifier = redactionLogEntry.getType() + "." + redactionLogEntry.getMatchedRule() + ".0";
-        List<RectangleWithPage> rectangleWithPages = redactionLogEntry.getPositions().stream().map(RectangleWithPage::fromRedactionLogRectangle).toList();
-        return ManualEntity.builder()
-                .id(redactionLogEntry.getId())
-                .value(redactionLogEntry.getValue())
-                .entityPosition(rectangleWithPages)
-                .ruleIdentifier(ruleIdentifier)
-                .reason(redactionLogEntry.getReason())
-                .legalBasis(redactionLogEntry.getLegalBasis())
-                .type(redactionLogEntry.getType())
-                .section(redactionLogEntry.getSection())
-                .entityType(redactionLogEntry.isRecommendation() ? EntityType.RECOMMENDATION : EntityType.ENTITY)
-                .applied(redactionLogEntry.isRedacted())
-                .isDictionaryEntry(redactionLogEntry.isDictionaryEntry())
-                .isDossierDictionaryEntry(redactionLogEntry.isDossierDictionaryEntry())
-                .rectangle(redactionLogEntry.isRectangle())
-                .build();
-    }
-
-
-    public static ManualEntity fromManualRedactionEntry(ManualRedactionEntry manualRedactionEntry) {
-
-        List<RectangleWithPage> rectangleWithPages = manualRedactionEntry.getPositions().stream().map(RectangleWithPage::fromAnnotationRectangle).toList();
-        ManualChangeOverwrite manualChangeOverwrite = new ManualChangeOverwrite();
-        manualChangeOverwrite.addChange(manualRedactionEntry);
-        return ManualEntity.builder()
-                .id(manualRedactionEntry.getAnnotationId())
-                .value(manualRedactionEntry.getValue())
-                .entityPosition(rectangleWithPages)
-                .ruleIdentifier("MAN.0.0")
-                .reason(manualRedactionEntry.getReason())
-                .legalBasis(manualRedactionEntry.getLegalBasis())
-                .type(manualRedactionEntry.getType())
-                .section(manualRedactionEntry.getSection())
-                .entityType(EntityType.ENTITY)
-                .applied(true)
-                .isDictionaryEntry(false)
-                .isDossierDictionaryEntry(false)
-                .rectangle(manualRedactionEntry.isRectangle())
-                .manualOverwrite(manualChangeOverwrite)
-                .build();
-    }
-
-}

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

@@ -1,326 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
-
-import static com.iqser.red.service.redaction.v1.server.redaction.service.ImportedRedactionService.IMPORTED_REDACTION_TYPE;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import org.springframework.stereotype.Service;
-import org.springframework.web.bind.annotation.RequestBody;
-
-import com.iqser.gin4.commons.metrics.meters.FunctionTimerValues;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeResult;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.FileAttribute;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Comment;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.legalbasis.LegalBasis;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogChanges;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogLegalBasis;
-import com.iqser.red.service.redaction.v1.server.client.LegalBasisClient;
-import com.iqser.red.service.redaction.v1.server.client.model.NerEntitiesModel;
-import com.iqser.red.service.redaction.v1.server.document.data.mapper.DocumentGraphMapper;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Document;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.redaction.adapter.NerEntities;
-import com.iqser.red.service.redaction.v1.server.redaction.adapter.NerEntitiesAdapter;
-import com.iqser.red.service.redaction.v1.server.redaction.model.ManualEntity;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.Dictionary;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryIncrement;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryVersion;
-import com.iqser.red.service.redaction.v1.server.settings.RedactionServiceSettings;
-import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
-
-import io.micrometer.core.annotation.Timed;
-import lombok.AccessLevel;
-import lombok.RequiredArgsConstructor;
-import lombok.SneakyThrows;
-import lombok.experimental.FieldDefaults;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-@RequiredArgsConstructor
-public class AnalyzeService {
-
-    private static final String REDACTMANAGER_ANALYZE_PAGEWISE_METRIC_NAME = "redactmanager_analyze.pagewise";
-
-    DictionaryService dictionaryService;
-    DroolsExecutionService droolsExecutionService;
-    EntityRedactionService entityRedactionService;
-    RedactionLogCreatorService redactionLogCreatorService;
-    RedactionStorageService redactionStorageService;
-    RedactionChangeLogService redactionChangeLogService;
-    LegalBasisClient legalBasisClient;
-    RedactionServiceSettings redactionServiceSettings;
-    ImportedRedactionService importedRedactionService;
-    SectionFinderService sectionFinderService;
-    ManualRedactionEntryService manualRedactionEntryService;
-
-    FunctionTimerValues redactmanagerAnalyzePagewiseValues;
-
-
-    @Timed("redactmanager_analyze")
-    public AnalyzeResult analyze(AnalyzeRequest analyzeRequest) {
-
-        long startTime = System.currentTimeMillis();
-
-        var wrapper = droolsExecutionService.getLatestKieContainer(analyzeRequest.getDossierTemplateId());
-        log.info("Updated Rules to Version {} for file {} in dossier {}", wrapper.rulesVersion(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        Document document = DocumentGraphMapper.toDocumentGraph(redactionStorageService.getDocumentData(analyzeRequest.getDossierId(), analyzeRequest.getFileId()));
-        log.info("Loaded Document Graph for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        NerEntities nerEntities = getEntityRecognitionEntities(analyzeRequest, document);
-        log.info("Loaded Ner Entities for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        dictionaryService.updateDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
-        Dictionary dictionary = dictionaryService.getDeepCopyDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
-        log.info("Updated Dictionaries for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-
-        List<ManualEntity> notFoundManualRedactionEntries = manualRedactionEntryService.addManualRedactionEntriesAndReturnNotFoundEntries(analyzeRequest, document);
-
-        entityRedactionService.addDictionaryEntities(dictionary, document);
-        log.info("Finished Dictionary Search for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        Set<FileAttribute> addedFileAttributes = entityRedactionService.addRuleEntities(dictionary, document, wrapper.container(), analyzeRequest, nerEntities);
-        log.info("Finished Rule Execution for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        List<RedactionLogEntry> redactionLogEntries = redactionLogCreatorService.createRedactionLog(document,
-                analyzeRequest.getDossierTemplateId(),
-                notFoundManualRedactionEntries,
-                getComments(analyzeRequest));
-
-        List<LegalBasis> legalBasis = legalBasisClient.getLegalBasisMapping(analyzeRequest.getDossierTemplateId());
-        RedactionLog redactionLog = new RedactionLog(redactionServiceSettings.getAnalysisVersion(),
-                analyzeRequest.getAnalysisNumber(),
-                redactionLogEntries,
-                toSimplifiedSectionText(legalBasis),
-                dictionary.getVersion().getDossierTemplateVersion(),
-                dictionary.getVersion().getDossierVersion(),
-                wrapper.rulesVersion(),
-                legalBasisClient.getVersion(analyzeRequest.getDossierTemplateId()));
-
-        List<RedactionLogEntry> importedRedactionFilteredEntries = importedRedactionService.processImportedRedactions(analyzeRequest.getDossierTemplateId(),
-                analyzeRequest.getDossierId(),
-                analyzeRequest.getFileId(),
-                redactionLog.getRedactionLogEntry(),
-                true);
-        redactionLog.setRedactionLogEntry(importedRedactionFilteredEntries);
-
-        return finalizeAnalysis(analyzeRequest, startTime, redactionLog, document.getNumberOfPages(), dictionary.getVersion(), false, addedFileAttributes);
-    }
-
-
-    private static Map<String, List<Comment>> getComments(AnalyzeRequest analyzeRequest) {
-
-        if (analyzeRequest.getManualRedactions() == null) {
-            return Collections.emptyMap();
-        }
-        if (analyzeRequest.getManualRedactions().getComments() == null) {
-            return Collections.emptyMap();
-        }
-        return analyzeRequest.getManualRedactions().getComments();
-    }
-
-
-    @Timed("redactmanager_reanalyze")
-    @SneakyThrows
-    public AnalyzeResult reanalyze(@RequestBody AnalyzeRequest analyzeRequest) {
-
-        long startTime = System.currentTimeMillis();
-        RedactionLog previousRedactionLog = redactionStorageService.getRedactionLog(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
-        log.info("Loaded previous redaction log for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        Document document = DocumentGraphMapper.toDocumentGraph(redactionStorageService.getDocumentData(analyzeRequest.getDossierId(), analyzeRequest.getFileId()));
-        log.info("Loaded Document Graph for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        // not yet ready for reanalysis
-        if (previousRedactionLog == null || document == null || document.getNumberOfPages() == 0) {
-            return analyze(analyzeRequest);
-        }
-
-        DictionaryIncrement dictionaryIncrement = dictionaryService.getDictionaryIncrements(analyzeRequest.getDossierTemplateId(),
-                new DictionaryVersion(previousRedactionLog.getDictionaryVersion(), previousRedactionLog.getDossierDictionaryVersion()),
-                analyzeRequest.getDossierId());
-
-        Set<Integer> sectionsToReanalyseIds = getSectionsToReanalyseIds(analyzeRequest, previousRedactionLog, document, dictionaryIncrement);
-        List<SemanticNode> sectionsToReAnalyse = getSectionsToReAnalyse(document, sectionsToReanalyseIds);
-        log.info("{} Sections to reanalyze found for file {} in dossier {}", sectionsToReanalyseIds.size(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        if (sectionsToReAnalyse.isEmpty()) {
-            return finalizeAnalysis(analyzeRequest,
-                    startTime,
-                    previousRedactionLog,
-                    document.getNumberOfPages(),
-                    dictionaryIncrement.getDictionaryVersion(),
-                    true,
-                    new HashSet<>());
-        }
-
-        NerEntities nerEntities = getEntityRecognitionEntitiesFilteredBySectionIds(analyzeRequest, document, sectionsToReanalyseIds);
-        log.info("Loaded Ner Entities for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        var wrapper = droolsExecutionService.getLatestKieContainer(analyzeRequest.getDossierTemplateId());
-        log.info("Updated Rules to version {} for file {} in dossier {}", wrapper.rulesVersion(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        List<ManualEntity> notFoundManualRedactionEntries = manualRedactionEntryService.addManualRedactionEntriesAndReturnNotFoundEntries(analyzeRequest, document);
-
-        Dictionary dictionary = dictionaryService.getDeepCopyDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
-        log.info("Updated Dictionaries for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        sectionsToReAnalyse.forEach(node -> entityRedactionService.addDictionaryEntities(dictionary, node));
-        log.info("Finished Dictionary Search for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        Set<FileAttribute> addedFileAttributes = entityRedactionService.addRuleEntities(dictionary,
-                document,
-                sectionsToReAnalyse,
-                wrapper.container(),
-                analyzeRequest,
-                nerEntities);
-        log.info("Finished Rule Execution for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        List<RedactionLogEntry> newRedactionLogEntries = redactionLogCreatorService.createRedactionLog(document,
-                analyzeRequest.getDossierTemplateId(),
-                notFoundManualRedactionEntries,
-                getComments(analyzeRequest));
-
-        var importedRedactionFilteredEntries = importedRedactionService.processImportedRedactions(analyzeRequest.getDossierTemplateId(),
-                analyzeRequest.getDossierId(),
-                analyzeRequest.getFileId(),
-                newRedactionLogEntries,
-                false);
-
-        previousRedactionLog.getRedactionLogEntry()
-                .removeIf(entry -> sectionsToReanalyseIds.contains(entry.getSectionNumber()) && !entry.getType().equals(IMPORTED_REDACTION_TYPE));
-        previousRedactionLog.getRedactionLogEntry().addAll(importedRedactionFilteredEntries);
-
-        return finalizeAnalysis(analyzeRequest,
-                startTime,
-                previousRedactionLog,
-                document.getNumberOfPages(),
-                dictionaryIncrement.getDictionaryVersion(),
-                true,
-                addedFileAttributes);
-    }
-
-
-    private AnalyzeResult finalizeAnalysis(AnalyzeRequest analyzeRequest,
-                                           long startTime,
-                                           RedactionLog redactionLog,
-                                           int numberOfPages,
-                                           DictionaryVersion dictionaryVersion,
-                                           boolean isReanalysis,
-                                           Set<FileAttribute> addedFileAttributes) {
-
-        redactionLog.setDictionaryVersion(dictionaryVersion.getDossierTemplateVersion());
-        redactionLog.setDossierDictionaryVersion(dictionaryVersion.getDossierVersion());
-
-        excludeExcludedPages(redactionLog, analyzeRequest.getExcludedPages());
-
-        RedactionLogChanges redactionLogChange = redactionChangeLogService.computeChanges(analyzeRequest.getDossierId(),
-                analyzeRequest.getFileId(),
-                redactionLog,
-                analyzeRequest.getAnalysisNumber());
-        log.info("Created Redaction Log for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        redactionStorageService.storeObject(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), FileType.REDACTION_LOG, redactionLogChange.getRedactionLog());
-        log.info("Stored Redaction Log for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
-
-        long duration = System.currentTimeMillis() - startTime;
-
-        redactmanagerAnalyzePagewiseValues.increase(numberOfPages, duration);
-
-        return AnalyzeResult.builder()
-                .dossierId(analyzeRequest.getDossierId())
-                .fileId(analyzeRequest.getFileId())
-                .duration(duration)
-                .numberOfPages(numberOfPages)
-                .hasUpdates(redactionLogChange.isHasChanges())
-                .analysisVersion(redactionServiceSettings.getAnalysisVersion())
-                .analysisNumber(analyzeRequest.getAnalysisNumber())
-                .rulesVersion(redactionLog.getRulesVersion())
-                .dictionaryVersion(redactionLog.getDictionaryVersion())
-                .legalBasisVersion(redactionLog.getLegalBasisVersion())
-                .dossierDictionaryVersion(redactionLog.getDossierDictionaryVersion())
-                .wasReanalyzed(isReanalysis)
-                .manualRedactions(analyzeRequest.getManualRedactions())
-                .addedFileAttributes(addedFileAttributes)
-                .build();
-    }
-
-
-    private static List<SemanticNode> getSectionsToReAnalyse(Document document, Set<Integer> sectionsToReanalyseIds) {
-
-        return document.streamChildren().filter(section -> sectionsToReanalyseIds.contains(section.getTreeId().get(0))).collect(Collectors.toList());
-    }
-
-
-    private Set<Integer> getSectionsToReanalyseIds(AnalyzeRequest analyzeRequest, RedactionLog redactionLog, Document document, DictionaryIncrement dictionaryIncrement) {
-
-        return analyzeRequest.getSectionsToReanalyse().isEmpty() //
-                ? sectionFinderService.findSectionsToReanalyse(dictionaryIncrement, redactionLog, document, analyzeRequest) //
-                : analyzeRequest.getSectionsToReanalyse();
-    }
-
-
-    private NerEntities getEntityRecognitionEntitiesFilteredBySectionIds(AnalyzeRequest analyzeRequest, Document document, Set<Integer> sectionsToReanalyseIds) {
-
-        NerEntities nerEntities;
-        if (redactionServiceSettings.isNerServiceEnabled()) {
-            NerEntitiesModel nerEntitiesModel = redactionStorageService.getNerEntities(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
-            nerEntitiesModel = filterNerEntitiesModelBySectionIds(sectionsToReanalyseIds, nerEntitiesModel);
-            nerEntities = NerEntitiesAdapter.toNerEntities(nerEntitiesModel, document);
-        } else {
-            nerEntities = new NerEntities(Collections.emptyList());
-        }
-        return nerEntities;
-    }
-
-
-    private static NerEntitiesModel filterNerEntitiesModelBySectionIds(Set<Integer> sectionsToReanalyseIds, NerEntitiesModel nerEntitiesModel) {
-
-        return new NerEntitiesModel(nerEntitiesModel.getData().entrySet().stream() //
-                .filter(entry -> sectionsToReanalyseIds.contains(entry.getKey())) //
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
-    }
-
-
-    private NerEntities getEntityRecognitionEntities(AnalyzeRequest analyzeRequest, Document document) {
-
-        NerEntities nerEntities;
-        if (redactionServiceSettings.isNerServiceEnabled()) {
-            nerEntities = NerEntitiesAdapter.toNerEntities(redactionStorageService.getNerEntities(analyzeRequest.getDossierId(), analyzeRequest.getFileId()), document);
-        } else {
-            nerEntities = new NerEntities(Collections.emptyList());
-        }
-        return nerEntities;
-    }
-
-
-    public List<RedactionLogLegalBasis> toSimplifiedSectionText(List<LegalBasis> legalBasis) {
-
-        return legalBasis.stream().map(l -> new RedactionLogLegalBasis(l.getName(), l.getDescription(), l.getReason())).collect(Collectors.toList());
-    }
-
-
-    private void excludeExcludedPages(RedactionLog redactionLog, Set<Integer> excludedPages) {
-
-        if (excludedPages != null && !excludedPages.isEmpty()) {
-            redactionLog.getRedactionLogEntry().forEach(entry -> entry.getPositions().forEach(pos -> {
-                if (excludedPages.contains(pos.getPage())) {
-                    entry.setExcluded(true);
-                }
-            }));
-        }
-    }
-
-}

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

@@ -1,28 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
-
-import java.util.List;
-
-import org.kie.api.builder.KieBuilder;
-import org.kie.api.builder.Message;
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxErrorMessage;
-import com.iqser.red.service.redaction.v1.model.DroolsSyntaxValidation;
-
-@Service
-public class DroolsSyntaxValidationFactory {
-
-    public DroolsSyntaxValidation buildDroolsSyntaxValidation(KieBuilder kieBuilder) {
-
-        List<Message> errorMessages = kieBuilder.getResults().getMessages(Message.Level.ERROR);
-        List<DroolsSyntaxErrorMessage> droolsSyntaxErrorMessages = errorMessages.stream().map(this::buildDroolsSyntaxErrorMessage).toList();
-        return DroolsSyntaxValidation.builder().compiled(droolsSyntaxErrorMessages.isEmpty()).droolsSyntaxErrorMessages(droolsSyntaxErrorMessages).build();
-    }
-
-
-    public DroolsSyntaxErrorMessage buildDroolsSyntaxErrorMessage(Message message) {
-
-        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/redaction/service/EntityRedactionService.java

@@ -1,102 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
-
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import org.kie.api.runtime.KieContainer;
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.FileAttribute;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Engine;
-import com.iqser.red.service.redaction.v1.server.document.graph.entity.EntityType;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.Document;
-import com.iqser.red.service.redaction.v1.server.document.graph.nodes.SemanticNode;
-import com.iqser.red.service.redaction.v1.server.document.services.EntityCreationService;
-import com.iqser.red.service.redaction.v1.server.document.services.EntityEnrichmentService;
-import com.iqser.red.service.redaction.v1.server.redaction.adapter.CustomEntityCreationAdapter;
-import com.iqser.red.service.redaction.v1.server.redaction.adapter.NerEntities;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.Dictionary;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.SearchImplementation;
-
-import lombok.AccessLevel;
-import lombok.RequiredArgsConstructor;
-import lombok.experimental.FieldDefaults;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class EntityRedactionService {
-
-    DroolsExecutionService droolsExecutionService;
-    EntityEnrichmentService entityEnrichmentService;
-    CustomEntityCreationAdapter customEntityCreationAdapter;
-
-
-    public Set<FileAttribute> addRuleEntities(Dictionary dictionary, Document document, KieContainer kieContainer, AnalyzeRequest analyzeRequest, NerEntities nerEntities) {
-
-        log.debug("Starting Drools Execution");
-        long droolsStart = System.currentTimeMillis();
-        List<FileAttribute> allFileAttributes = droolsExecutionService.executeRules(kieContainer,
-                document,
-                dictionary,
-                analyzeRequest.getFileAttributes(),
-                analyzeRequest.getManualRedactions(),
-                nerEntities);
-        log.debug("Finished Drools Execution in {} ms", System.currentTimeMillis() - droolsStart);
-        return allFileAttributes.stream().filter(fileAttribute -> !analyzeRequest.getFileAttributes().contains(fileAttribute)).collect(Collectors.toUnmodifiableSet());
-    }
-
-
-    public Set<FileAttribute> addRuleEntities(Dictionary dictionary,
-                                              Document document,
-                                              List<SemanticNode> sectionsToReanalyze,
-                                              KieContainer kieContainer,
-                                              AnalyzeRequest analyzeRequest,
-                                              NerEntities nerEntities) {
-
-        log.debug("Starting Drools execution");
-        long ruleExecutionStart = System.currentTimeMillis();
-        List<FileAttribute> allFileAttributes = droolsExecutionService.executeRules(kieContainer,
-                document,
-                sectionsToReanalyze,
-                dictionary,
-                analyzeRequest.getFileAttributes(),
-                analyzeRequest.getManualRedactions(),
-                nerEntities);
-        log.debug("Finished Drools execution in {} ms", System.currentTimeMillis() - ruleExecutionStart);
-
-        return allFileAttributes.stream().filter(fileAttribute -> !analyzeRequest.getFileAttributes().contains(fileAttribute)).collect(Collectors.toUnmodifiableSet());
-    }
-
-
-    public void addDictionaryEntities(Dictionary dictionary, SemanticNode node) {
-
-        for (var model : dictionary.getDictionaryModels()) {
-            bySearchImplementationAsDictionary(model.getEntriesSearch(), model.getType(), EntityType.ENTITY, node, model.isDossierDictionary());
-            bySearchImplementationAsDictionary(model.getFalsePositiveSearch(), model.getType(), EntityType.FALSE_POSITIVE, node, model.isDossierDictionary());
-            bySearchImplementationAsDictionary(model.getFalseRecommendationsSearch(), model.getType(), EntityType.FALSE_RECOMMENDATION, node, model.isDossierDictionary());
-        }
-    }
-
-
-    public void bySearchImplementationAsDictionary(SearchImplementation searchImplementation,
-                                                   String type,
-                                                   EntityType entityType,
-                                                   SemanticNode node,
-                                                   boolean isDossierDictionaryEntry) {
-
-        EntityCreationService entityCreationService = new EntityCreationService(entityEnrichmentService);
-        searchImplementation.getBoundaries(node.getTextBlock(), node.getTextRange())
-                .stream()
-                .filter(boundary -> entityCreationService.isValidEntityBoundary(node.getTextBlock(), boundary))
-                .map(bounds -> entityCreationService.forceByBoundary(bounds, type, entityType, node))
-                .peek(entity -> entity.setDictionaryEntry(true))
-                .peek(entity -> entity.setDossierDictionaryEntry(isDossierDictionaryEntry))
-                .forEach(entity -> entity.addEngine(Engine.DICTIONARY));
-    }
-
-}

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

@@ -1,153 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
-
-import java.util.HashSet;
-import java.util.List;
-
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Point;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.imported.ImportedRedaction;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.imported.ImportedRedactions;
-import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
-
-import io.micrometer.core.annotation.Timed;
-import lombok.RequiredArgsConstructor;
-
-@Service
-@RequiredArgsConstructor
-public class ImportedRedactionService {
-
-    public static final String IMPORTED_REDACTION_TYPE = "imported_redaction";
-
-    private final DictionaryService dictionaryService;
-    private final RedactionStorageService redactionStorageService;
-
-
-    @Timed("redactmanager_processImportedRedactions")
-    public List<RedactionLogEntry> processImportedRedactions(String dossierTemplateId,
-                                                             String dossierId,
-                                                             String fileId,
-                                                             List<RedactionLogEntry> redactionLogEntries,
-                                                             boolean addImportedRedactions) {
-
-        var importedRedactions = redactionStorageService.getImportedRedactions(dossierId, fileId);
-        if (importedRedactions == null) {
-            return redactionLogEntries;
-        }
-
-        redactionLogEntries.forEach(redactionLogEntry -> addIntersections(redactionLogEntry, importedRedactions));
-
-        if (addImportedRedactions) {
-            return addImportedRedactionsRedactionLogEntries(dossierTemplateId, redactionLogEntries, importedRedactions);
-        }
-
-        return redactionLogEntries;
-    }
-
-
-    private List<RedactionLogEntry> addImportedRedactionsRedactionLogEntries(String dossierTemplateId,
-                                                                             List<RedactionLogEntry> redactionLogEntries,
-                                                                             ImportedRedactions importedRedactions) {
-
-        for (var importedRedactionsValues : importedRedactions.getImportedRedactions().values()) {
-            for (var importedRedaction : importedRedactionsValues) {
-                RedactionLogEntry redactionLogEntry = RedactionLogEntry.builder()
-                        .id(importedRedaction.getId())
-                        .type(IMPORTED_REDACTION_TYPE)
-                        .imported(true)
-                        .redacted(true)
-                        .positions(importedRedaction.getPositions())
-                        .color(getColor(IMPORTED_REDACTION_TYPE, dossierTemplateId))
-                        .build();
-
-                redactionLogEntries.add(redactionLogEntry);
-            }
-        }
-
-        return redactionLogEntries;
-    }
-
-
-    private void addIntersections(RedactionLogEntry redactionLogEntry, ImportedRedactions importedRedactions) {
-
-        for (Rectangle rectangle : redactionLogEntry.getPositions()) {
-            var normalizedRectangle = normalize(rectangle);
-            if (importedRedactions.getImportedRedactions().containsKey(rectangle.getPage())) {
-                var importedRedactionsOnPage = importedRedactions.getImportedRedactions().get(rectangle.getPage());
-                for (ImportedRedaction importedRedaction : importedRedactionsOnPage) {
-                    for (Rectangle importedRedactionPosition : importedRedaction.getPositions()) {
-                        if (rectOverlap(normalizedRectangle, normalize(importedRedactionPosition))) {
-                            if (redactionLogEntry.getImportedRedactionIntersections() == null) {
-                                redactionLogEntry.setImportedRedactionIntersections(new HashSet<>());
-                            }
-                            redactionLogEntry.getImportedRedactionIntersections().add(importedRedaction.getId());
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-    boolean valueInRange(float value, float min, float max) {
-
-        return round(value) >= round(min) && round(value) <= round(max);
-    }
-
-
-    boolean rectOverlap(Rectangle a, Rectangle b) {
-
-        boolean xOverlap = valueInRange(a.getTopLeft().getX(), b.getTopLeft().getX(), b.getTopLeft().getX() + b.getWidth()) || valueInRange(b.getTopLeft().getX(),
-                a.getTopLeft().getX(),
-                a.getTopLeft().getX() + a.getWidth());
-
-        boolean yOverlap = valueInRange(a.getTopLeft().getY(), b.getTopLeft().getY(), b.getTopLeft().getY() + b.getHeight()) || valueInRange(b.getTopLeft().getY(),
-                a.getTopLeft().getY(),
-                a.getTopLeft().getY() + a.getHeight());
-
-        return xOverlap && yOverlap;
-    }
-
-
-    private Rectangle normalize(Rectangle rectangle) {
-
-        Rectangle r = new Rectangle();
-        Point p = new Point();
-
-        if (rectangle.getWidth() < 0) {
-            p.setX(rectangle.getTopLeft().getX() + rectangle.getWidth());
-            r.setWidth(Math.abs(rectangle.getWidth()));
-        } else {
-            p.setX(rectangle.getTopLeft().getX());
-            r.setWidth(rectangle.getWidth());
-        }
-
-        if (rectangle.getHeight() < 0) {
-            p.setY(rectangle.getTopLeft().getY() + rectangle.getHeight());
-            r.setHeight(Math.abs(rectangle.getHeight()));
-        } else {
-            p.setY(rectangle.getTopLeft().getY());
-            r.setHeight(rectangle.getHeight());
-        }
-
-        r.setTopLeft(p);
-        r.setPage(rectangle.getPage());
-        return r;
-    }
-
-
-    private float round(float value) {
-
-        double d = Math.pow(10, 0);
-        return (float) (Math.round(value * d) / d);
-    }
-
-
-    private float[] getColor(String type, String dossierTemplateId) {
-
-        return dictionaryService.getColor(type, dossierTemplateId);
-    }
-
-}

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

@@ -1,23 +0,0 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
-
-import java.util.Collections;
-
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.redaction.v1.model.RuleBuilderModel;
-
-@Service
-public class RuleBuilderModelService {
-
-    // TODO: Evaluate if we need to implement this or remove it entirely.
-    public RuleBuilderModel getRuleBuilderModel() {
-
-        RuleBuilderModel ruleBuilderModel = new RuleBuilderModel();
-
-        ruleBuilderModel.setWhenClauses(Collections.emptyList());
-        ruleBuilderModel.setThenConditions(Collections.emptyList());
-
-        return ruleBuilderModel;
-    }
-
-}

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

@@ -0,0 +1,431 @@
+package com.iqser.red.service.redaction.v1.server.service;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import com.iqser.gin4.commons.metrics.meters.FunctionTimerValues;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeResult;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.FileAttribute;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.componentlog.ComponentLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogChanges;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.imported.ImportedRedactions;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.legalbasis.LegalBasis;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogChanges;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLogLegalBasis;
+import com.iqser.red.service.redaction.v1.server.RedactionServiceSettings;
+import com.iqser.red.service.redaction.v1.server.client.LegalBasisClient;
+import com.iqser.red.service.redaction.v1.server.client.model.NerEntitiesModel;
+import com.iqser.red.service.redaction.v1.server.model.KieWrapper;
+import com.iqser.red.service.redaction.v1.server.model.PrecursorEntity;
+import com.iqser.red.service.redaction.v1.server.model.NerEntities;
+import com.iqser.red.service.redaction.v1.server.model.component.Component;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.Dictionary;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryIncrement;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryVersion;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.service.document.DocumentGraphMapper;
+import com.iqser.red.service.redaction.v1.server.service.document.ImportedRedactionEntryService;
+import com.iqser.red.service.redaction.v1.server.service.document.ManualRedactionEntryService;
+import com.iqser.red.service.redaction.v1.server.service.document.NerEntitiesAdapter;
+import com.iqser.red.service.redaction.v1.server.service.document.SectionFinderService;
+import com.iqser.red.service.redaction.v1.server.service.drools.ComponentDroolsExecutionService;
+import com.iqser.red.service.redaction.v1.server.service.drools.EntityDroolsExecutionService;
+import com.iqser.red.service.redaction.v1.server.service.drools.KieContainerCreationService;
+import com.iqser.red.service.redaction.v1.server.storage.ObservedStorageService;
+import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
+
+import io.micrometer.core.annotation.Timed;
+import io.micrometer.observation.annotation.Observed;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@RequiredArgsConstructor
+public class AnalyzeService {
+
+    DictionaryService dictionaryService;
+    EntityDroolsExecutionService entityDroolsExecutionService;
+    ComponentDroolsExecutionService componentDroolsExecutionService;
+    KieContainerCreationService kieContainerCreationService;
+    DictionarySearchService dictionarySearchService;
+    RedactionLogCreatorService redactionLogCreatorService;
+    EntityLogCreatorService entityLogCreatorService;
+    ComponentLogCreatorService componentLogCreatorService;
+    RedactionStorageService redactionStorageService;
+    RedactionChangeLogService redactionChangeLogService;
+    LegalBasisClient legalBasisClient;
+    RedactionServiceSettings redactionServiceSettings;
+    NotFoundImportedEntitiesService notFoundImportedEntitiesService;
+    SectionFinderService sectionFinderService;
+    ManualRedactionEntryService manualRedactionEntryService;
+    ImportedRedactionEntryService importedRedactionEntryService;
+    ObservedStorageService observedStorageService;
+
+    FunctionTimerValues redactmanagerAnalyzePagewiseValues;
+
+
+    @Timed("redactmanager_reanalyze")
+    @SneakyThrows
+    @Observed(name = "AnalyzeService", contextualName = "reanalyze")
+    public AnalyzeResult reanalyze(@RequestBody AnalyzeRequest analyzeRequest) {
+
+        long startTime = System.currentTimeMillis();
+        RedactionLog previousRedactionLog = redactionStorageService.getRedactionLog(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+        EntityLog previousEntityLog = redactionStorageService.getEntityLog(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+        log.info("Loaded previous entity log for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        Document document = DocumentGraphMapper.toDocumentGraph(observedStorageService.getDocumentData(analyzeRequest.getDossierId(), analyzeRequest.getFileId()));
+        log.info("Loaded Document Graph for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        ImportedRedactions importedRedactions = redactionStorageService.getImportedRedactions(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+        log.info("Loaded Imported Redactions for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        // not yet ready for reanalysis
+        if (previousEntityLog == null || document == null || document.getNumberOfPages() == 0) {
+            return analyze(analyzeRequest);
+        }
+
+        DictionaryIncrement dictionaryIncrement = dictionaryService.getDictionaryIncrements(analyzeRequest.getDossierTemplateId(),
+                new DictionaryVersion(previousEntityLog.getDictionaryVersion(), previousEntityLog.getDossierDictionaryVersion()),
+                analyzeRequest.getDossierId());
+
+        Set<Integer> sectionsToReanalyseIds = getSectionsToReanalyseIds(analyzeRequest, previousEntityLog, document, dictionaryIncrement, importedRedactions);
+        List<SemanticNode> sectionsToReAnalyse = getSectionsToReAnalyse(document, sectionsToReanalyseIds);
+        log.info("{} Sections to reanalyze found for file {} in dossier {}", sectionsToReanalyseIds.size(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        if (sectionsToReAnalyse.isEmpty()) {
+
+            EntityLogChanges entityLogChanges = entityLogCreatorService.updateVersionsAndReturnChanges(previousEntityLog,
+                    dictionaryIncrement.getDictionaryVersion(),
+                    analyzeRequest,
+                    false);
+
+            return finalizeAnalysis(analyzeRequest,
+                    startTime,
+                    kieContainerCreationService.getLatestKieContainer(analyzeRequest.getDossierTemplateId(), RuleFileType.COMPONENT),
+                    entityLogChanges,
+                    document,
+                    previousRedactionLog,
+                    document.getNumberOfPages(),
+                    dictionaryIncrement.getDictionaryVersion(),
+                    true,
+                    Collections.emptySet());
+        }
+
+        KieWrapper kieWrapperEntityRules = kieContainerCreationService.getLatestKieContainer(analyzeRequest.getDossierTemplateId(), RuleFileType.ENTITY);
+        log.info("Updated entity rules to version {} for file {} in dossier {}", kieWrapperEntityRules.rulesVersion(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        NerEntities nerEntities = getEntityRecognitionEntitiesFilteredBySectionIds(analyzeRequest, document, sectionsToReanalyseIds);
+        log.info("Loaded Ner Entities for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        var notFoundManualRedactionEntries = manualRedactionEntryService.addManualRedactionEntriesAndReturnNotFoundEntries(analyzeRequest,
+                document,
+                analyzeRequest.getDossierTemplateId());
+        var notFoundImportedEntries = importedRedactionEntryService.addImportedEntriesAndReturnNotFoundEntries(analyzeRequest, importedRedactions, document);
+        var notFoundManualOrImportedEntries = Stream.of(notFoundManualRedactionEntries, notFoundImportedEntries).flatMap(Collection::stream).collect(Collectors.toList());
+
+        Dictionary dictionary = dictionaryService.getDeepCopyDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
+        log.info("Updated Dictionaries for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        dictionarySearchService.addDictionaryEntities(dictionary, sectionsToReAnalyse);
+        log.info("Finished Dictionary Search for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        // we could add the imported redactions similar to the manual redactions here as well for additional processing
+        List<FileAttribute> allFileAttributes = entityDroolsExecutionService.executeRules(kieWrapperEntityRules.container(),
+                document,
+                sectionsToReAnalyse,
+                dictionary,
+                analyzeRequest.getFileAttributes(),
+                analyzeRequest.getManualRedactions(),
+                nerEntities);
+        log.info("Finished entity rule execution for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        RedactionLog redactionLog = updatePreviousRedactionLog(analyzeRequest, document, notFoundManualOrImportedEntries, previousRedactionLog, sectionsToReanalyseIds);
+        EntityLogChanges entityLogChanges = entityLogCreatorService.updatePreviousEntityLog(analyzeRequest,
+                document,
+                notFoundManualOrImportedEntries,
+                previousEntityLog,
+                sectionsToReanalyseIds,
+                dictionary.getVersion());
+
+        notFoundImportedEntitiesService.processEntityLog(entityLogChanges.getEntityLog(), analyzeRequest, notFoundImportedEntries);
+
+        return finalizeAnalysis(analyzeRequest,
+                startTime,
+                kieContainerCreationService.getLatestKieContainer(analyzeRequest.getDossierTemplateId(), RuleFileType.COMPONENT),
+                entityLogChanges,
+                document,
+                redactionLog,
+                document.getNumberOfPages(),
+                dictionaryIncrement.getDictionaryVersion(),
+                true,
+                new HashSet<>(allFileAttributes));
+    }
+
+
+    @Timed("redactmanager_analyze")
+    @Observed(name = "AnalyzeService", contextualName = "analyze")
+    public AnalyzeResult analyze(AnalyzeRequest analyzeRequest) {
+
+        long startTime = System.currentTimeMillis();
+
+        var kieWrapperEntityRules = kieContainerCreationService.getLatestKieContainer(analyzeRequest.getDossierTemplateId(), RuleFileType.ENTITY);
+        log.info("Updated Rules to Version {} for file {} in dossier {}", kieWrapperEntityRules.rulesVersion(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        var kieWrapperComponentRules = kieContainerCreationService.getLatestKieContainer(analyzeRequest.getDossierTemplateId(), RuleFileType.COMPONENT);
+        log.info("Updated Rules to Version {} for file {} in dossier {}", kieWrapperEntityRules.rulesVersion(), analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        Document document = DocumentGraphMapper.toDocumentGraph(observedStorageService.getDocumentData(analyzeRequest.getDossierId(), analyzeRequest.getFileId()));
+        log.info("Loaded Document Graph for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        ImportedRedactions importedRedactions = redactionStorageService.getImportedRedactions(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+        log.info("Loaded Imported Redactions for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        NerEntities nerEntities = getEntityRecognitionEntities(analyzeRequest, document);
+        log.info("Loaded Ner Entities for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        dictionaryService.updateDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
+        Dictionary dictionary = dictionaryService.getDeepCopyDictionary(analyzeRequest.getDossierTemplateId(), analyzeRequest.getDossierId());
+        log.info("Updated Dictionaries for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        var notFoundManualRedactionEntries = manualRedactionEntryService.addManualRedactionEntriesAndReturnNotFoundEntries(analyzeRequest,
+                document,
+                analyzeRequest.getDossierTemplateId());
+        var notFoundImportedEntries = importedRedactionEntryService.addImportedEntriesAndReturnNotFoundEntries(analyzeRequest, importedRedactions, document);
+        var notFoundManualOrImportedEntries = Stream.of(notFoundManualRedactionEntries, notFoundImportedEntries).flatMap(Collection::stream).collect(Collectors.toList());
+
+        dictionarySearchService.addDictionaryEntities(dictionary, document);
+        log.info("Finished Dictionary Search for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        // we could add the imported redactions similar to the manual redactions here as well for additional processing
+        List<FileAttribute> allFileAttributes = entityDroolsExecutionService.executeRules(kieWrapperEntityRules.container(),
+                document,
+                dictionary,
+                analyzeRequest.getFileAttributes(),
+                analyzeRequest.getManualRedactions(),
+                nerEntities);
+        log.info("Finished entity rule execution for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        RedactionLog redactionLog = createRedactionLog(analyzeRequest, document, notFoundManualOrImportedEntries, dictionary, kieWrapperEntityRules);
+        EntityLog entityLog = entityLogCreatorService.createInitialEntityLog(analyzeRequest,
+                document,
+                notFoundManualOrImportedEntries,
+                dictionary.getVersion(),
+                kieWrapperEntityRules.rulesVersion());
+
+        notFoundImportedEntitiesService.processEntityLog(entityLog, analyzeRequest, notFoundImportedEntries);
+
+        return finalizeAnalysis(analyzeRequest,
+                startTime,
+                kieWrapperComponentRules,
+                new EntityLogChanges(entityLog, false),
+                document,
+                redactionLog,
+                document.getNumberOfPages(),
+                dictionary.getVersion(),
+                false,
+                new HashSet<>(allFileAttributes));
+    }
+
+
+    @Deprecated(forRemoval = true)
+    private RedactionLog updatePreviousRedactionLog(AnalyzeRequest analyzeRequest,
+                                                    Document document,
+                                                    List<PrecursorEntity> notFoundEntries,
+                                                    RedactionLog previousRedactionLog,
+                                                    Set<Integer> sectionsToReanalyseIds) {
+
+        List<RedactionLogEntry> newRedactionLogEntries = redactionLogCreatorService.createRedactionLog(document, analyzeRequest.getDossierTemplateId(), notFoundEntries);
+
+        previousRedactionLog.getRedactionLogEntry()
+                .removeIf(entry -> sectionsToReanalyseIds.contains(entry.getSectionNumber()) && !entry.getType().equals(NotFoundImportedEntitiesService.IMPORTED_REDACTION_TYPE));
+
+
+        return previousRedactionLog;
+    }
+
+
+    private AnalyzeResult finalizeAnalysis(AnalyzeRequest analyzeRequest,
+                                           long startTime,
+                                           KieWrapper kieWrapperComponentRules,
+                                           EntityLogChanges entityLogChanges,
+                                           Document document,
+                                           RedactionLog redactionLog,
+                                           int numberOfPages,
+                                           DictionaryVersion dictionaryVersion,
+                                           boolean isReanalysis,
+                                           Set<FileAttribute> addedFileAttributes) {
+
+        finalizeRedactionLog(analyzeRequest, redactionLog, dictionaryVersion);
+
+        EntityLog entityLog = entityLogChanges.getEntityLog();
+        redactionStorageService.storeObject(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), FileType.ENTITY_LOG, entityLogChanges.getEntityLog());
+
+        log.info("Created entity log for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+        if (entityLogChanges.isHasChanges() || !isReanalysis) {
+            computeComponentsWhenRulesArePresent(analyzeRequest, kieWrapperComponentRules, document, addedFileAttributes, entityLogChanges, dictionaryVersion);
+        }
+
+        log.info("Stored analysis logs for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        long duration = System.currentTimeMillis() - startTime;
+
+        redactmanagerAnalyzePagewiseValues.increase(numberOfPages, duration);
+
+        return AnalyzeResult.builder()
+                .dossierId(analyzeRequest.getDossierId())
+                .fileId(analyzeRequest.getFileId())
+                .duration(duration)
+                .numberOfPages(numberOfPages)
+                .hasUpdates(entityLogChanges.isHasChanges())
+                .analysisVersion(redactionServiceSettings.getAnalysisVersion())
+                .analysisNumber(analyzeRequest.getAnalysisNumber())
+                .rulesVersion(entityLog.getRulesVersion())
+                .componentRulesVersion(kieWrapperComponentRules.rulesVersion())
+                .dictionaryVersion(entityLog.getDictionaryVersion())
+                .legalBasisVersion(entityLog.getLegalBasisVersion())
+                .dossierDictionaryVersion(entityLog.getDossierDictionaryVersion())
+                .wasReanalyzed(isReanalysis)
+                .manualRedactions(analyzeRequest.getManualRedactions())
+                .addedFileAttributes(addedFileAttributes)
+                .build();
+    }
+
+
+    private void computeComponentsWhenRulesArePresent(AnalyzeRequest analyzeRequest,
+                                                      KieWrapper kieWrapperComponentRules,
+                                                      Document document,
+                                                      Set<FileAttribute> addedFileAttributes,
+                                                      EntityLogChanges entityLogChanges,
+                                                      DictionaryVersion dictionaryVersion) {
+
+        if (!kieWrapperComponentRules.isPresent()) {
+            return;
+        }
+
+        List<Component> components = componentDroolsExecutionService.executeRules(kieWrapperComponentRules.container(),
+                entityLogChanges.getEntityLog(),
+                document,
+                addedFileAttributes.stream().toList());
+        log.info("Finished component rule execution for file {} in dossier {}", analyzeRequest.getFileId(), analyzeRequest.getDossierId());
+
+        ComponentLog componentLog = componentLogCreatorService.buildComponentLog(analyzeRequest.getAnalysisNumber(), components, kieWrapperComponentRules.rulesVersion());
+
+        redactionStorageService.storeObject(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), FileType.COMPONENT_LOG, componentLog);
+
+    }
+
+
+    private RedactionLogChanges finalizeRedactionLog(AnalyzeRequest analyzeRequest, RedactionLog redactionLog, DictionaryVersion dictionaryVersion) {
+        // TODO: remove redactionLog related stuff
+
+        RedactionLog previousRedactionLog = redactionStorageService.getRedactionLog(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+
+        redactionLog.setDictionaryVersion(dictionaryVersion.getDossierTemplateVersion());
+        redactionLog.setDossierDictionaryVersion(dictionaryVersion.getDossierVersion());
+
+        RedactionLogChanges redactionLogChange = redactionChangeLogService.computeChanges(previousRedactionLog, redactionLog, analyzeRequest.getAnalysisNumber());
+
+        redactionStorageService.storeObject(analyzeRequest.getDossierId(), analyzeRequest.getFileId(), FileType.REDACTION_LOG, redactionLogChange.getRedactionLog());
+
+        return redactionLogChange;
+    }
+
+
+    private static List<SemanticNode> getSectionsToReAnalyse(Document document, Set<Integer> sectionsToReanalyseIds) {
+
+        return document.streamChildren().filter(section -> sectionsToReanalyseIds.contains(section.getTreeId().get(0))).collect(Collectors.toList());
+    }
+
+
+    private Set<Integer> getSectionsToReanalyseIds(AnalyzeRequest analyzeRequest, EntityLog entityLog, Document document, DictionaryIncrement dictionaryIncrement, ImportedRedactions importedRedactions) {
+
+        return sectionFinderService.findSectionsToReanalyse(dictionaryIncrement, entityLog, document, analyzeRequest, importedRedactions);
+    }
+
+
+    private NerEntities getEntityRecognitionEntitiesFilteredBySectionIds(AnalyzeRequest analyzeRequest, Document document, Set<Integer> sectionsToReanalyseIds) {
+
+        NerEntities nerEntities;
+        if (redactionServiceSettings.isNerServiceEnabled()) {
+            NerEntitiesModel nerEntitiesModel = redactionStorageService.getNerEntities(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+            nerEntitiesModel = filterNerEntitiesModelBySectionIds(sectionsToReanalyseIds, nerEntitiesModel);
+            nerEntities = NerEntitiesAdapter.toNerEntities(nerEntitiesModel, document);
+        } else {
+            nerEntities = new NerEntities(Collections.emptyList());
+        }
+        return nerEntities;
+    }
+
+
+    private static NerEntitiesModel filterNerEntitiesModelBySectionIds(Set<Integer> sectionsToReanalyseIds, NerEntitiesModel nerEntitiesModel) {
+
+        return new NerEntitiesModel(nerEntitiesModel.getData().entrySet().stream() //
+                .filter(entry -> sectionsToReanalyseIds.contains(entry.getKey())) //
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+    }
+
+
+    private NerEntities getEntityRecognitionEntities(AnalyzeRequest analyzeRequest, Document document) {
+
+        NerEntities nerEntities;
+        if (redactionServiceSettings.isNerServiceEnabled()) {
+            nerEntities = NerEntitiesAdapter.toNerEntities(redactionStorageService.getNerEntities(analyzeRequest.getDossierId(), analyzeRequest.getFileId()), document);
+        } else {
+            nerEntities = new NerEntities(Collections.emptyList());
+        }
+        return nerEntities;
+    }
+
+
+    @Deprecated(forRemoval = true)
+    private RedactionLog createRedactionLog(AnalyzeRequest analyzeRequest,
+                                            Document document,
+                                            List<PrecursorEntity> notFoundManualRedactionEntries,
+                                            Dictionary dictionary,
+                                            KieWrapper wrapper) {
+
+        List<RedactionLogEntry> redactionLogEntries = redactionLogCreatorService.createRedactionLog(document,
+                analyzeRequest.getDossierTemplateId(),
+                notFoundManualRedactionEntries);
+
+        List<LegalBasis> legalBasis = legalBasisClient.getLegalBasisMapping(analyzeRequest.getDossierTemplateId());
+        RedactionLog redactionLog = new RedactionLog(redactionServiceSettings.getAnalysisVersion(),
+                analyzeRequest.getAnalysisNumber(),
+                redactionLogEntries,
+                toRedactionLogLegalBasis(legalBasis),
+                dictionary.getVersion().getDossierTemplateVersion(),
+                dictionary.getVersion().getDossierVersion(),
+                wrapper.rulesVersion(),
+                legalBasisClient.getVersion(analyzeRequest.getDossierTemplateId()));
+
+        return redactionLog;
+    }
+
+
+    public List<RedactionLogLegalBasis> toRedactionLogLegalBasis(List<LegalBasis> legalBasis) {
+
+        return legalBasis.stream().map(l -> new RedactionLogLegalBasis(l.getName(), l.getDescription(), l.getReason())).collect(Collectors.toList());
+    }
+
+}

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

@@ -0,0 +1,63 @@
+package com.iqser.red.service.redaction.v1.server.service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.componentlog.ComponentLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.componentlog.ComponentLogEntityReference;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.componentlog.ComponentLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.componentlog.ComponentLogEntryValue;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
+import com.iqser.red.service.redaction.v1.server.model.component.Component;
+import com.iqser.red.service.redaction.v1.server.model.component.Entity;
+import com.iqser.red.service.redaction.v1.server.service.document.ComponentComparator;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityComparators;
+
+@Service
+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()))
+                .toList();
+        return new ComponentLog(analysisNumber, componentRulesVersion, componentLogComponents);
+    }
+
+
+    private ComponentLogEntryValue buildComponentLogEntry(Component component) {
+
+        return ComponentLogEntryValue.builder()
+                .value(component.getValue()).originalValue(component.getValue())
+                .componentRuleId(component.getMatchedRule().toString())
+                .valueDescription(component.getValueDescription())
+                .componentLogEntityReferences(toComponentEntityReferences(component.getReferences().stream().sorted(EntityComparators.first()).toList()))
+                .build();
+    }
+
+
+    private List<ComponentLogEntityReference> toComponentEntityReferences(List<Entity> references) {
+
+        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())
+                .type(entity.getType())
+                .build();
+    }
+
+}

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

@@ -0,0 +1,65 @@
+package com.iqser.red.service.redaction.v1.server.service;
+
+import java.util.List;
+import java.util.Set;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Engine;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.EntityType;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.SemanticNode;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.SearchImplementation;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.Dictionary;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityCreationService;
+import com.iqser.red.service.redaction.v1.server.service.document.EntityEnrichmentService;
+
+import io.micrometer.observation.annotation.Observed;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class DictionarySearchService {
+
+    EntityEnrichmentService entityEnrichmentService;
+
+
+    @Observed(name = "DictionarySearchService", contextualName = "add-dictionary-entries")
+    public void addDictionaryEntities(Dictionary dictionary, List<SemanticNode> semanticNodes) {
+
+        semanticNodes.forEach(node -> addDictionaryEntities(dictionary, node));
+    }
+
+
+    @Observed(name = "DictionarySearchService", contextualName = "add-dictionary-entries")
+    public void addDictionaryEntities(Dictionary dictionary, SemanticNode node) {
+
+        for (var model : dictionary.getDictionaryModels()) {
+            bySearchImplementationAsDictionary(model.getEntriesSearch(), model.getType(), model.isHint() ? EntityType.HINT : EntityType.ENTITY, node, model.isDossierDictionary());
+            bySearchImplementationAsDictionary(model.getFalsePositiveSearch(), model.getType(), EntityType.FALSE_POSITIVE, node, model.isDossierDictionary());
+            bySearchImplementationAsDictionary(model.getFalseRecommendationsSearch(), model.getType(), EntityType.FALSE_RECOMMENDATION, node, model.isDossierDictionary());
+        }
+    }
+
+
+    public void bySearchImplementationAsDictionary(SearchImplementation searchImplementation,
+                                                   String type,
+                                                   EntityType entityType,
+                                                   SemanticNode node,
+                                                   boolean isDossierDictionaryEntry) {
+
+        EntityCreationService entityCreationService = new EntityCreationService(entityEnrichmentService);
+        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);
+                }));
+    }
+
+}

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

@@ -1,4 +1,4 @@
-package com.iqser.red.service.redaction.v1.server.redaction.service;
+package com.iqser.red.service.redaction.v1.server.service;
 
 import java.awt.Color;
 import java.util.ArrayList;
@@ -23,20 +23,21 @@ import com.iqser.red.service.dictionarymerge.commons.DictionaryEntry;
 import com.iqser.red.service.dictionarymerge.commons.DictionaryEntryModel;
 import com.iqser.red.service.dictionarymerge.commons.DictionaryMergeService;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.configuration.Colors;
+import com.iqser.red.service.redaction.v1.server.RedactionServiceSettings;
 import com.iqser.red.service.redaction.v1.server.client.DictionaryClient;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.Dictionary;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryEntries;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryIncrement;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryIncrementValue;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryModel;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryRepresentation;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.DictionaryVersion;
-import com.iqser.red.service.redaction.v1.server.redaction.model.dictionary.TenantDictionary;
-import com.iqser.red.service.redaction.v1.server.settings.RedactionServiceSettings;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.Dictionary;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryEntries;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryIncrement;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryIncrementValue;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryModel;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryRepresentation;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryVersion;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.TenantDictionary;
 import com.knecon.fforesight.tenantcommons.TenantContext;
 
 import feign.FeignException;
 import io.micrometer.core.annotation.Timed;
+import io.micrometer.observation.annotation.Observed;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
@@ -47,7 +48,7 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class DictionaryService {
 
-    private static final String DEFAULT_COLOR = "#cccccc";
+    public static final String DEFAULT_COLOR = "#cccccc";
     private final DictionaryClient dictionaryClient;
 
     private final RedactionServiceSettings settings;
@@ -73,6 +74,7 @@ public class DictionaryService {
 
 
     @SneakyThrows
+    @Observed(name = "DictionaryService", contextualName = "update-dictionary")
     @Timed("redactmanager_updateDictionary")
     public DictionaryVersion updateDictionary(String dossierTemplateId, String dossierId) {
 
@@ -94,6 +96,7 @@ public class DictionaryService {
 
 
     @SneakyThrows
+    @Observed(name = "DictionaryService", contextualName = "update-dictionary-increments")
     @Timed("redactmanager_getDictionaryIncrements")
     public DictionaryIncrement getDictionaryIncrements(String dossierTemplateId, DictionaryVersion fromVersion, String dossierId) {
 
@@ -101,6 +104,7 @@ public class DictionaryService {
 
         Set<DictionaryIncrementValue> newValues = new HashSet<>();
         List<DictionaryModel> dictionaryModels = getDossierTemplateDictionary(dossierTemplateId).getDictionary();
+
         dictionaryModels.forEach(dictionaryModel -> {
             dictionaryModel.getEntries().forEach(dictionaryEntry -> {
                 if (dictionaryEntry.getVersion() > fromVersion.getDossierTemplateVersion()) {
@@ -150,19 +154,25 @@ public class DictionaryService {
         try {
             DictionaryRepresentation dictionaryRepresentation = new DictionaryRepresentation();
 
-            var typeResponse = dossierId == null ? dictionaryClient.getAllTypesForDossierTemplate(dossierTemplateId, false) : dictionaryClient.getAllTypesForDossier(dossierId,
-                    false);
+            var typeResponse = dossierId == null ? dictionaryClient.getAllTypesForDossierTemplate(dossierTemplateId, true) : dictionaryClient.getAllTypesForDossier(dossierId,
+                    true);
             if (CollectionUtils.isNotEmpty(typeResponse)) {
 
                 List<DictionaryModel> dictionary = typeResponse.stream().map(t -> {
 
-                    Optional<DictionaryModel> oldModel;
+                    Optional<DictionaryModel> optionalOldModel;
                     if (dossierId == null) {
                         var representation = getDossierTemplateDictionary(dossierTemplateId);
-                        oldModel = representation != null ? representation.getDictionary().stream().filter(f -> f.getType().equals(t.getType())).findAny() : Optional.empty();
+                        optionalOldModel = representation != null ? representation.getDictionary()
+                                .stream()
+                                .filter(f -> f.getType().equals(t.getType()))
+                                .findAny() : Optional.empty();
                     } else {
                         var representation = getDossierDictionary(dossierId);
-                        oldModel = representation != null ? representation.getDictionary().stream().filter(f -> f.getType().equals(t.getType())).findAny() : Optional.empty();
+                        optionalOldModel = representation != null ? representation.getDictionary()
+                                .stream()
+                                .filter(f -> f.getType().equals(t.getType()))
+                                .findAny() : Optional.empty();
                     }
 
                     Set<DictionaryEntryModel> entries = new HashSet<>();
@@ -175,19 +185,38 @@ public class DictionaryService {
                     var newFalsePositivesValues = newEntries.getFalsePositives().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
                     var newFalseRecommendationsValues = newEntries.getFalseRecommendations().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
 
-                    oldModel.ifPresent(oldDictionaryModel -> {
+                    optionalOldModel.ifPresent(oldDictionaryModel -> {
 
                     });
-                    // add old entries from existing DictionaryModel
-                    oldModel.ifPresent(dictionaryModel -> entries.addAll(dictionaryModel.getEntries().stream().filter(f -> !newValues.contains(f.getValue())).toList()));
-                    oldModel.ifPresent(dictionaryModel -> falsePositives.addAll(dictionaryModel.getFalsePositives()
-                            .stream()
-                            .filter(f -> !newFalsePositivesValues.contains(f.getValue()))
-                            .toList()));
-                    oldModel.ifPresent(dictionaryModel -> falseRecommendations.addAll(dictionaryModel.getFalseRecommendations()
-                            .stream()
-                            .filter(f -> !newFalseRecommendationsValues.contains(f.getValue()))
-                            .toList()));
+                    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());
+
+                        } 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());
@@ -292,6 +321,7 @@ public class DictionaryService {
 
     @SneakyThrows
     @Timed("redactmanager_getDeepCopyDictionary")
+    @Observed(name = "DictionaryService", contextualName = "deep-copy-dictionary")
     public Dictionary getDeepCopyDictionary(String dossierTemplateId, String dossierId) {
 
         List<DictionaryModel> mergedDictionaries;

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

@@ -0,0 +1,114 @@
+package com.iqser.red.service.redaction.v1.server.service;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ChangeType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.IdRemoval;
+
+import io.micrometer.core.annotation.Timed;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@FieldDefaults(makeFinal=true, level= AccessLevel.PRIVATE)
+public class EntityChangeLogService {
+
+    ManualChangeFactory manualChangeFactory;
+
+
+    @Timed("redactmanager_computeChanges")
+    public boolean computeChanges(List<EntityLogEntry> previousEntityLogEntries, List<EntityLogEntry> newEntityLogEntries, ManualRedactions manualRedactions, int analysisNumber) {
+
+        var now = OffsetDateTime.now();
+        if (previousEntityLogEntries.isEmpty()) {
+            newEntityLogEntries.forEach(entry -> entry.getChanges().add(new Change(analysisNumber, ChangeType.ADDED, now)));
+            return true;
+        }
+
+        boolean hasChanges = false;
+
+        for (EntityLogEntry entityLogEntry : newEntityLogEntries) {
+            Optional<EntityLogEntry> optionalPreviousEntity = previousEntityLogEntries.stream().filter(entry -> entry.getId().equals(entityLogEntry.getId())).findAny();
+            if (optionalPreviousEntity.isEmpty()) {
+                hasChanges = true;
+                entityLogEntry.getChanges().add(new Change(analysisNumber, ChangeType.ADDED, now));
+                continue;
+            }
+            var previousEntity = optionalPreviousEntity.get();
+            entityLogEntry.getChanges().addAll(previousEntity.getChanges());
+            if (!previousEntity.getState().equals(entityLogEntry.getState())) {
+                hasChanges = true;
+                ChangeType changeType = calculateChangeType(entityLogEntry.getState(), previousEntity.getState());
+                entityLogEntry.getChanges().add(new Change(analysisNumber, changeType, now));
+            }
+        }
+        addRemovedEntriesAsRemoved(previousEntityLogEntries, newEntityLogEntries, manualRedactions, analysisNumber, now);
+        return hasChanges;
+    }
+
+
+    private void addRemovedEntriesAsRemoved(List<EntityLogEntry> previousEntityLogEntries,
+                                                   List<EntityLogEntry> newEntityLogEntries,
+                                                   ManualRedactions manualRedactions,
+                                                   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()))
+                .toList();
+        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)) {
+            throw new IllegalArgumentException("States are equal, can't calculate ChangeType.");
+        }
+        if (!isRemoved(previousState) && isRemoved(state)) {
+            return ChangeType.REMOVED;
+        }
+        if (isRemoved(previousState) && !isRemoved(state)) {
+            return ChangeType.ADDED;
+        }
+        return ChangeType.CHANGED;
+    }
+
+
+    private static boolean isRemoved(EntryState state) {
+
+        return (state.equals(EntryState.REMOVED) || state.equals(EntryState.IGNORED));
+    }
+
+}

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

@@ -0,0 +1,320 @@
+package com.iqser.red.service.redaction.v1.server.service;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogChanges;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogLegalBasis;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
+import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.legalbasis.LegalBasis;
+import com.iqser.red.service.redaction.v1.server.RedactionServiceSettings;
+import com.iqser.red.service.redaction.v1.server.client.LegalBasisClient;
+import com.iqser.red.service.redaction.v1.server.model.PrecursorEntity;
+import com.iqser.red.service.redaction.v1.server.model.dictionary.DictionaryVersion;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.EntityType;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.IEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.PositionOnPage;
+import com.iqser.red.service.redaction.v1.server.model.document.entity.TextEntity;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Document;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.Image;
+import com.iqser.red.service.redaction.v1.server.model.document.nodes.ImageType;
+import com.iqser.red.service.redaction.v1.server.storage.RedactionStorageService;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class EntityLogCreatorService {
+
+    DictionaryService dictionaryService;
+    ManualChangeFactory manualChangeFactory;
+    RedactionServiceSettings redactionServiceSettings;
+    LegalBasisClient legalBasisClient;
+    EntityChangeLogService entityChangeLogService;
+    RedactionStorageService redactionStorageService;
+
+
+    private static boolean notFalsePositiveOrFalseRecommendation(TextEntity textEntity) {
+
+        return !(textEntity.getEntityType().equals(EntityType.FALSE_POSITIVE) || textEntity.getEntityType().equals(EntityType.FALSE_RECOMMENDATION));
+    }
+
+
+    public EntityLog createInitialEntityLog(AnalyzeRequest analyzeRequest,
+                                            Document document,
+                                            List<PrecursorEntity> notFoundEntities,
+                                            DictionaryVersion dictionaryVersion,
+                                            long rulesVersion) {
+
+        List<EntityLogEntry> entityLogEntries = createEntityLogEntries(document, analyzeRequest, notFoundEntities);
+
+        List<LegalBasis> legalBasis = legalBasisClient.getLegalBasisMapping(analyzeRequest.getDossierTemplateId());
+        EntityLog entityLog = new EntityLog(redactionServiceSettings.getAnalysisVersion(),
+                analyzeRequest.getAnalysisNumber(),
+                entityLogEntries,
+                toEntityLogLegalBasis(legalBasis),
+                dictionaryVersion.getDossierTemplateVersion(),
+                dictionaryVersion.getDossierVersion(),
+                rulesVersion,
+                legalBasisClient.getVersion(analyzeRequest.getDossierTemplateId()));
+
+        List<EntityLogEntry> previousExistingEntityLogEntries = getPreviousEntityLogEntries(analyzeRequest.getDossierId(), analyzeRequest.getFileId());
+
+        entityChangeLogService.computeChanges(previousExistingEntityLogEntries, entityLogEntries, analyzeRequest.getManualRedactions(), analyzeRequest.getAnalysisNumber());
+
+        return entityLog;
+    }
+
+
+    private List<EntityLogEntry> getPreviousEntityLogEntries(String dossierId, String fileId) {
+
+        if (redactionStorageService.entityLogExists(dossierId, fileId)) {
+            return redactionStorageService.getEntityLog(dossierId, fileId).getEntityLogEntry();
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+
+    public EntityLogChanges updateVersionsAndReturnChanges(EntityLog entityLog, DictionaryVersion dictionaryVersion, AnalyzeRequest analyzeRequest, boolean hasChanges) {
+
+        List<LegalBasis> legalBasis = legalBasisClient.getLegalBasisMapping(analyzeRequest.getDossierTemplateId());
+        entityLog.setLegalBasisVersion(legalBasisClient.getVersion(analyzeRequest.getDossierTemplateId()));
+        entityLog.setLegalBasis(toEntityLogLegalBasis(legalBasis));
+        entityLog.setDictionaryVersion(dictionaryVersion.getDossierTemplateVersion());
+        entityLog.setDossierDictionaryVersion(dictionaryVersion.getDossierVersion());
+        entityLog.setAnalysisNumber(analyzeRequest.getAnalysisNumber());
+
+        return new EntityLogChanges(entityLog, hasChanges);
+    }
+
+
+    public EntityLogChanges updatePreviousEntityLog(AnalyzeRequest analyzeRequest,
+                                                    Document document,
+                                                    List<PrecursorEntity> notFoundEntries,
+                                                    EntityLog previousEntityLog,
+                                                    Set<Integer> sectionsToReanalyseIds,
+                                                    DictionaryVersion dictionaryVersion) {
+
+        List<EntityLogEntry> newEntityLogEntries = createEntityLogEntries(document, analyzeRequest, notFoundEntries).stream()
+                .filter(entry -> entry.getContainingNodeId().isEmpty() || sectionsToReanalyseIds.contains(entry.getContainingNodeId().get(0)))
+                .collect(Collectors.toList());
+        Set<String> newEntityIds = newEntityLogEntries.stream().map(EntityLogEntry::getId).collect(Collectors.toSet());
+
+        List<EntityLogEntry> previousEntriesFromReAnalyzedSections = previousEntityLog.getEntityLogEntry()
+                .stream()
+                .filter(entry -> (newEntityIds.contains(entry.getId()) || entry.getContainingNodeId().isEmpty() || sectionsToReanalyseIds.contains(entry.getContainingNodeId()
+                        .get(0))))
+                .toList();
+        previousEntityLog.getEntityLogEntry().removeAll(previousEntriesFromReAnalyzedSections);
+
+        boolean hasChanges = entityChangeLogService.computeChanges(previousEntriesFromReAnalyzedSections, newEntityLogEntries, analyzeRequest.getManualRedactions(), analyzeRequest.getAnalysisNumber());
+        previousEntityLog.getEntityLogEntry().addAll(newEntityLogEntries);
+
+        return updateVersionsAndReturnChanges(previousEntityLog, dictionaryVersion, analyzeRequest, hasChanges);
+    }
+
+
+    private List<EntityLogEntry> createEntityLogEntries(Document document, AnalyzeRequest analyzeRequest, List<PrecursorEntity> notFoundPrecursorEntries) {
+
+        String dossierTemplateId = analyzeRequest.getDossierTemplateId();
+        List<EntityLogEntry> entries = new ArrayList<>();
+        document.getEntities()
+                .stream()
+                .filter(entity -> !entity.getValue().isEmpty())
+                .filter(EntityLogCreatorService::notFalsePositiveOrFalseRecommendation)
+                .filter(entity -> !entity.removed())
+                .forEach(entityNode -> entries.addAll(toEntityLogEntries(entityNode)));
+        document.streamAllImages().filter(entity -> !entity.removed()).forEach(imageNode -> entries.add(createEntityLogEntry(imageNode, dossierTemplateId)));
+        notFoundPrecursorEntries.stream()
+                .filter(entity -> !entity.removed())
+                .forEach(precursorEntity -> entries.add(createEntityLogEntry(precursorEntity, dossierTemplateId)));
+        return entries;
+    }
+
+
+    private List<EntityLogEntry> toEntityLogEntries(TextEntity textEntity) {
+
+        List<EntityLogEntry> entityLogEntries = new ArrayList<>();
+
+        // split entity into multiple entries if it occurs on multiple pages, since FE can't handle multi page entities
+        for (PositionOnPage positionOnPage : textEntity.getPositionsOnPagePerPage()) {
+
+            EntityLogEntry entityLogEntry = createEntityLogEntry(textEntity);
+
+            List<Position> rectanglesPerLine = positionOnPage.getRectanglePerLine()
+                    .stream()
+                    .map(rectangle2D -> new Position(rectangle2D, positionOnPage.getPage().getNumber()))
+                    .toList();
+
+            // set the ID from the positions, since it might contain a "-" with the page number if the entity is split across multiple pages
+            entityLogEntry.setId(positionOnPage.getId());
+            entityLogEntry.setPositions(rectanglesPerLine);
+            entityLogEntries.add(entityLogEntry);
+        }
+
+        return entityLogEntries;
+    }
+
+
+    private EntityLogEntry createEntityLogEntry(Image image, String dossierTemplateId) {
+
+        String imageType = image.getImageType().equals(ImageType.OTHER) ? "image" : image.getImageType().toString().toLowerCase(Locale.ENGLISH);
+        boolean isHint = dictionaryService.isHint(imageType, dossierTemplateId);
+        return EntityLogEntry.builder()
+                .id(image.getId())
+                .value(image.value())
+                .type(imageType)
+                .reason(image.buildReasonWithManualChangeDescriptions())
+                .legalBasis(image.legalBasis())
+                .matchedRule(image.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(false)
+                .positions(List.of(new Position(image.getPosition(), image.getPage().getNumber())))
+                .containingNodeId(image.getTreeId())
+                .closestHeadline(image.getHeadline().getTextBlock().getSearchText())
+                .section(image.getManualOverwrite().getSection().orElse(image.getParent().toString()))
+                .imageHasTransparency(image.isTransparent())
+                .manualChanges(manualChangeFactory.toManualChangeList(image.getManualOverwrite().getManualChangeLog(), isHint))
+                .state(buildEntryState(image))
+                .entryType(isHint ? EntryType.IMAGE_HINT : EntryType.IMAGE)
+                .build();
+
+    }
+
+
+    private EntityLogEntry createEntityLogEntry(PrecursorEntity precursorEntity, String dossierTemplateId) {
+
+        String type = precursorEntity.getManualOverwrite().getType().orElse(precursorEntity.getType());
+        boolean isHint = isHint(precursorEntity.getEntityType());
+        return EntityLogEntry.builder()
+                .id(precursorEntity.getId())
+                .reason(precursorEntity.buildReasonWithManualChangeDescriptions())
+                .legalBasis(precursorEntity.legalBasis())
+                .value(precursorEntity.value())
+                .type(type)
+                .state(buildEntryState(precursorEntity))
+                .entryType(buildEntryType(precursorEntity))
+                .section(precursorEntity.getManualOverwrite().getSection().orElse(precursorEntity.getSection()))
+                .containingNodeId(Collections.emptyList())
+                .closestHeadline("")
+                .matchedRule(precursorEntity.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(precursorEntity.isDictionaryEntry())
+                .dossierDictionaryEntry(precursorEntity.isDossierDictionaryEntry())
+                .textAfter("")
+                .textBefore("")
+                .startOffset(-1)
+                .endOffset(-1)
+                .positions(precursorEntity.getManualOverwrite()
+                        .getPositions()
+                        .orElse(precursorEntity.getEntityPosition())
+                        .stream()
+                        .map(entityPosition -> new Position(entityPosition.rectangle2D(), entityPosition.pageNumber()))
+                        .toList())
+                .engines(precursorEntity.getEngines())
+                //imported is no longer used, frontend should check engines
+                //(was .imported(precursorEntity.getEngines() != null && precursorEntity.getEngines().contains(Engine.IMPORTED)))
+                .imported(false)
+                .reference(Collections.emptySet())
+                .manualChanges(manualChangeFactory.toManualChangeList(precursorEntity.getManualOverwrite().getManualChangeLog(), isHint))
+                .build();
+    }
+
+
+    private EntityLogEntry createEntityLogEntry(TextEntity entity) {
+
+        Set<String> referenceIds = new HashSet<>();
+        entity.references().stream().filter(TextEntity::active).forEach(ref -> ref.getPositionsOnPagePerPage().forEach(pos -> referenceIds.add(pos.getId())));
+        boolean isHint = isHint(entity.getEntityType());
+        return EntityLogEntry.builder()
+                .reason(entity.buildReasonWithManualChangeDescriptions())
+                .legalBasis(entity.legalBasis())
+                .value(entity.getManualOverwrite().getValue().orElse(entity.getMatchedRule().isWriteValueWithLineBreaks() ? entity.getValueWithLineBreaks() : entity.getValue()))
+                .type(entity.type())
+                .section(entity.getManualOverwrite().getSection().orElse(entity.getDeepestFullyContainingNode().toString()))
+                .containingNodeId(entity.getDeepestFullyContainingNode().getTreeId())
+                .closestHeadline(entity.getDeepestFullyContainingNode().getHeadline().getTextBlock().getSearchText())
+                .matchedRule(entity.getMatchedRule().getRuleIdentifier().toString())
+                .dictionaryEntry(entity.isDictionaryEntry())
+                .textAfter(entity.getTextAfter())
+                .textBefore(entity.getTextBefore())
+                .startOffset(entity.getTextRange().start())
+                .endOffset(entity.getTextRange().end())
+                .dossierDictionaryEntry(entity.isDossierDictionaryEntry())
+                .engines(entity.getEngines() != null ? entity.getEngines() : Collections.emptySet())
+                //imported is no longer used, frontend should check engines
+                //(was .imported(entity.getEngines() != null && entity.getEngines().contains(Engine.IMPORTED)))
+                .imported(false)
+                .reference(referenceIds)
+                .manualChanges(manualChangeFactory.toManualChangeList(entity.getManualOverwrite().getManualChangeLog(), isHint))
+                .state(buildEntryState(entity))
+                .entryType(buildEntryType(entity))
+                .build();
+    }
+
+
+    private boolean isHint(EntityType entityType) {
+
+        return entityType.equals(EntityType.HINT);
+    }
+
+
+    private EntryState buildEntryState(IEntity entity) {
+
+        if (entity.applied() && entity.active()) {
+            return EntryState.APPLIED;
+        } else if (entity.skipped() && entity.active()) {
+            return EntryState.SKIPPED;
+        } else if (entity.ignored()) {
+            return EntryState.IGNORED;
+        } else {
+            return EntryState.REMOVED;
+        }
+    }
+
+
+    private EntryType buildEntryType(IEntity entity) {
+
+        if (entity instanceof TextEntity textEntity) {
+            return getEntryType(textEntity.getEntityType());
+        } else if (entity instanceof PrecursorEntity precursorEntity) {
+            return precursorEntity.getEntryType();
+        }
+        throw new UnsupportedOperationException(String.format("Entity subclass %s is not implemented!", entity.getClass()));
+    }
+
+
+    private static EntryType getEntryType(EntityType entityType) {
+
+        return switch (entityType) {
+            case ENTITY -> EntryType.ENTITY;
+            case HINT -> EntryType.HINT;
+            case FALSE_POSITIVE -> EntryType.FALSE_POSITIVE;
+            case RECOMMENDATION -> EntryType.RECOMMENDATION;
+            case FALSE_RECOMMENDATION -> EntryType.FALSE_RECOMMENDATION;
+        };
+    }
+
+
+    private List<EntityLogLegalBasis> toEntityLogLegalBasis(List<LegalBasis> legalBasis) {
+
+        return legalBasis.stream().map(l -> new EntityLogLegalBasis(l.getName(), l.getDescription(), l.getReason())).collect(Collectors.toList());
+    }
+
+}