Pull request #221: rule builder model

Merge in RED/redaction-service from rule-builder to master

* commit '7a3924d96ed40c932cfe02fb410060d4e820f88f':
  rule builder model

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

@@ -0,0 +1,15 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Argument {
+
+    private String name;
+    private ArgumentType type;
+
+}

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

@@ -0,0 +1,7 @@
+package com.iqser.red.service.redaction.v1.model;
+
+public enum ArgumentType {
+
+    INTEGER, BOOLEAN, STRING, FILE_ATTRIBUTE, REGEX, TYPE, RULE_NUMBER, LEGAL_BASIS
+
+}

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

@@ -0,0 +1,14 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+public class RuleBuilderModel {
+
+    private List<RuleElement> whenClauses = new ArrayList<>();
+    private List<RuleElement> thenConditions = new ArrayList<>();
+
+}

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

@@ -0,0 +1,18 @@
+package com.iqser.red.service.redaction.v1.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RuleElement {
+
+    private String conditionName;
+    private List<Argument> arguments = new ArrayList<>();
+
+}

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

@@ -0,0 +1,12 @@
+package com.iqser.red.service.redaction.v1.resources;
+
+import com.iqser.red.service.redaction.v1.model.RuleBuilderModel;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.PostMapping;
+
+public interface RuleBuilderResource {
+
+    @PostMapping(value = "/rule-builder-model", produces = MediaType.APPLICATION_JSON_VALUE)
+    RuleBuilderModel getRuleBuilderModel();
+
+}

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

@@ -0,0 +1,21 @@
+package com.iqser.red.service.redaction.v1.server.controller;
+
+
+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.rulebuilder.RuleBuilderModelService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+public class RuleBuilderController implements RuleBuilderResource {
+
+    private final RuleBuilderModelService ruleBuilderModelService;
+
+    @Override
+    public RuleBuilderModel getRuleBuilderModel() {
+        return ruleBuilderModelService.getRuleBuilderModel();
+    }
+
+}

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

@@ -1,5 +1,6 @@
 package com.iqser.red.service.redaction.v1.server.redaction.model;
 
+import com.iqser.red.service.redaction.v1.model.ArgumentType;
 import com.iqser.red.service.redaction.v1.model.FileAttribute;
 import com.iqser.red.service.redaction.v1.server.classification.model.TextBlock;
 import com.iqser.red.service.redaction.v1.server.redaction.utils.EntitySearchUtils;
@@ -9,13 +10,11 @@ import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 
-import java.util.ArrayList;
+import java.lang.annotation.ElementType;
-import java.util.Collection;
+import java.lang.annotation.Retention;
-import java.util.HashMap;
+import java.lang.annotation.RetentionPolicy;
-import java.util.HashSet;
+import java.lang.annotation.Target;
-import java.util.List;
+import java.util.*;
-import java.util.Map;
-import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -59,33 +58,45 @@ public class Section {
     private List<FileAttribute> fileAttributes = new ArrayList<>();
 
 
-    public boolean fileAttributeByIdEquals(String id, String value){
+    @WhenCondition
+    public boolean fileAttributeByIdEquals(@Argument(ArgumentType.FILE_ATTRIBUTE) String id,
+                                           @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> id.equals(attribute.getId()) && value.equals(attribute.getValue())).findFirst().isPresent();
     }
 
-    public boolean fileAttributeByPlaceholderEquals(String placeholder, String value){
+    @WhenCondition
+    public boolean fileAttributeByPlaceholderEquals(@Argument(ArgumentType.FILE_ATTRIBUTE) String placeholder,
+                                                    @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> placeholder.equals(attribute.getPlaceholder()) && value.equals(attribute.getValue())).findFirst().isPresent();
     }
 
-    public boolean fileAttributeByLabelEquals(String label, String value){
+    @WhenCondition
+    public boolean fileAttributeByLabelEquals(@Argument(ArgumentType.FILE_ATTRIBUTE) String label,
+                                              @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> label.equals(attribute.getLabel()) && value.equals(attribute.getValue())).findFirst().isPresent();
     }
 
-
+    @WhenCondition
-    public boolean fileAttributeByIdEqualsIgnoreCase(String id, String value){
+    public boolean fileAttributeByIdEqualsIgnoreCase(@Argument(ArgumentType.FILE_ATTRIBUTE) String id,
+                                                     @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> id.equals(attribute.getId()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
     }
 
-    public boolean fileAttributeByPlaceholderEqualsIgnoreCase(String placeholder, String value){
+    @WhenCondition
+    public boolean fileAttributeByPlaceholderEqualsIgnoreCase(@Argument(ArgumentType.FILE_ATTRIBUTE) String placeholder,
+                                                              @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> placeholder.equals(attribute.getPlaceholder()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
     }
 
-    public boolean fileAttributeByLabelEqualsIgnoreCase(String label, String value){
+    @WhenCondition
+    public boolean fileAttributeByLabelEqualsIgnoreCase(@Argument(ArgumentType.FILE_ATTRIBUTE) String label,
+                                                        @Argument(ArgumentType.STRING) String value) {
         return fileAttributes != null && fileAttributes.stream().filter(attribute -> label.equals(attribute.getLabel()) && value.equalsIgnoreCase(attribute.getValue())).findFirst().isPresent();
     }
 
-
+    @WhenCondition
-    public boolean rowEquals(String headerName, String value) {
+    public boolean rowEquals(@Argument(ArgumentType.STRING) String headerName,
+                             @Argument(ArgumentType.STRING) String value) {
 
         String cleanHeaderName = headerName.replaceAll("\n", "").replaceAll(" ", "").replaceAll("-", "");
 
@@ -94,33 +105,36 @@ public class Section {
                 .equals(value);
     }
 
-
+    @WhenCondition
-    public boolean hasTableHeader(String headerName) {
+    public boolean hasTableHeader(@Argument(ArgumentType.STRING) String headerName) {
 
         String cleanHeaderName = headerName.replaceAll("\n", "").replaceAll(" ", "").replaceAll("-", "");
         return tabularData != null && tabularData.containsKey(cleanHeaderName);
     }
 
-
+    @WhenCondition
-    public boolean matchesType(String type) {
+    public boolean matchesType(@Argument(ArgumentType.TYPE) String type) {
 
         return entities.stream().anyMatch(entity -> entity.getType().equals(type));
     }
 
-
+    @WhenCondition
-    public boolean matchesImageType(String type) {
+    public boolean matchesImageType(@Argument(ArgumentType.TYPE) String type) {
 
         return images.stream().anyMatch(image -> image.getType().equals(type));
     }
 
-
+    @WhenCondition
-    public boolean headlineContainsWord(String word) {
+    public boolean headlineContainsWord(@Argument(ArgumentType.STRING) String word) {
 
         return StringUtils.containsIgnoreCase(headline, word);
     }
 
-
+    @ThenAction
-    public void expandByRegEx(String type, String pattern, boolean patternCaseInsensitive, int group) {
+    public void expandByRegEx(@Argument(ArgumentType.TYPE) String type,
+                              @Argument(ArgumentType.REGEX) String pattern,
+                              @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                              @Argument(ArgumentType.INTEGER) int group) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -147,8 +161,11 @@ public class Section {
         EntitySearchUtils.removeEntitiesContainedInLarger(entities);
     }
 
-
+    @ThenAction
-    public void redactImage(String type, int ruleNumber, String reason, String legalBasis) {
+    public void redactImage(@Argument(ArgumentType.TYPE) String type,
+                            @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                            @Argument(ArgumentType.STRING) String reason,
+                            @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         images.forEach(image -> {
             if (image.getType().equals(type)) {
@@ -160,8 +177,11 @@ public class Section {
         });
     }
 
-
+    @ThenAction
-    public void redact(String type, int ruleNumber, String reason, String legalBasis) {
+    public void redact(@Argument(ArgumentType.TYPE) String type,
+                       @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                       @Argument(ArgumentType.STRING) String reason,
+                       @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         boolean hasRecommendationDictionary = dictionaryTypes.contains(RECOMMENDATION_PREFIX + type);
 
@@ -176,8 +196,10 @@ public class Section {
         });
     }
 
-
+    @ThenAction
-    public void redactNotImage(String type, int ruleNumber, String reason) {
+    public void redactNotImage(@Argument(ArgumentType.TYPE) String type,
+                               @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                               @Argument(ArgumentType.STRING) String reason) {
 
         images.forEach(image -> {
             if (image.getType().equals(type)) {
@@ -188,8 +210,10 @@ public class Section {
         });
     }
 
-
+    @ThenAction
-    public void redactNot(String type, int ruleNumber, String reason) {
+    public void redactNot(@Argument(ArgumentType.TYPE) String type,
+                          @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                          @Argument(ArgumentType.STRING) String reason) {
 
         boolean hasRecommendationDictionary = dictionaryTypes.contains(RECOMMENDATION_PREFIX + type);
 
@@ -203,9 +227,12 @@ public class Section {
         });
     }
 
-
+    @ThenAction
-    public void expandToHintAnnotationByRegEx(String type, String pattern, boolean patternCaseInsensitive, int group,
+    public void expandToHintAnnotationByRegEx(@Argument(ArgumentType.TYPE) String type,
-                                              String asType) {
+                                              @Argument(ArgumentType.STRING) String pattern,
+                                              @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                                              @Argument(ArgumentType.INTEGER) int group,
+                                              @Argument(ArgumentType.TYPE) String asType) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -230,8 +257,11 @@ public class Section {
         EntitySearchUtils.removeEntitiesContainedInLarger(entities);
     }
 
-
+    @ThenAction
-    public void addHintAnnotationByRegEx(String pattern, boolean patternCaseInsensitive, int group, String asType) {
+    public void addHintAnnotationByRegEx(@Argument(ArgumentType.REGEX) String pattern,
+                                         @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                                         @Argument(ArgumentType.INTEGER) int group,
+                                         @Argument(ArgumentType.TYPE) String asType) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -246,8 +276,12 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void redactIfPrecededBy(String prefix, String type, int ruleNumber, String reason, String legalBasis) {
+    public void redactIfPrecededBy(@Argument(ArgumentType.STRING) String prefix,
+                                   @Argument(ArgumentType.TYPE) String type,
+                                   @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                                   @Argument(ArgumentType.STRING) String reason,
+                                   @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         entities.forEach(entity -> {
             if (entity.getType().equals(type) && searchText.indexOf(prefix + entity.getWord()) != 1) {
@@ -259,23 +293,32 @@ public class Section {
         });
     }
 
-
+    @ThenAction
-    public void addHintAnnotation(String value, String asType) {
+    public void addHintAnnotation(@Argument(ArgumentType.STRING) String value,
+                                  @Argument(ArgumentType.TYPE) String asType) {
 
         Set<Entity> found = findEntities(value.trim(), asType, true, false, 0, null, null);
         EntitySearchUtils.addEntitiesIgnoreRank(entities, found);
     }
 
-
+    @ThenAction
-    public void addRedaction(String value, String asType, int ruleNumber, String reason, String legalBasis) {
+    public void addRedaction(@Argument(ArgumentType.STRING) String value,
+                             @Argument(ArgumentType.TYPE) String asType,
+                             @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                             @Argument(ArgumentType.STRING) String reason,
+                             @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         Set<Entity> found = findEntities(value.trim(), asType, true, true, ruleNumber, reason, legalBasis);
         EntitySearchUtils.addEntitiesIgnoreRank(entities, found);
     }
 
-
+    @ThenAction
-    public void redactLineAfter(String start, String asType, int ruleNumber, boolean redactEverywhere, String reason,
+    public void redactLineAfter(@Argument(ArgumentType.STRING) String start,
-                                String legalBasis) {
+                                @Argument(ArgumentType.TYPE) String asType,
+                                @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                                @Argument(ArgumentType.BOOLEAN) boolean redactEverywhere,
+                                @Argument(ArgumentType.STRING) String reason,
+                                @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         String[] values = StringUtils.substringsBetween(text, start, "\n");
 
@@ -293,8 +336,9 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void recommendLineAfter(String start, String asType) {
+    public void recommendLineAfter(@Argument(ArgumentType.STRING) String start,
+                                   @Argument(ArgumentType.TYPE) String asType) {
 
         String[] values = StringUtils.substringsBetween(text, start, "\n");
 
@@ -317,9 +361,14 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void redactByRegEx(String pattern, boolean patternCaseInsensitive, int group, String asType, int ruleNumber,
+    public void redactByRegEx(@Argument(ArgumentType.REGEX) String pattern,
-                              String reason, String legalBasis) {
+                              @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                              @Argument(ArgumentType.INTEGER) int group,
+                              @Argument(ArgumentType.TYPE) String asType,
+                              @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                              @Argument(ArgumentType.STRING) String reason,
+                              @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -334,8 +383,11 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void addRecommendationByRegEx(String pattern, boolean patternCaseInsensitive, int group, String asType) {
+    public void addRecommendationByRegEx(@Argument(ArgumentType.REGEX) String pattern,
+                                         @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                                         @Argument(ArgumentType.INTEGER) int group,
+                                         @Argument(ArgumentType.TYPE) String asType) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -349,9 +401,14 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void redactAndRecommendByRegEx(String pattern, boolean patternCaseInsensitive, int group, String asType,
+    public void redactAndRecommendByRegEx(@Argument(ArgumentType.REGEX) String pattern,
-                                          int ruleNumber, String reason, String legalBasis) {
+                                          @Argument(ArgumentType.BOOLEAN) boolean patternCaseInsensitive,
+                                          @Argument(ArgumentType.INTEGER) int group,
+                                          @Argument(ArgumentType.TYPE) String asType,
+                                          @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                                          @Argument(ArgumentType.STRING) String reason,
+                                          @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         Pattern compiledPattern = Patterns.getCompiledPattern(pattern, patternCaseInsensitive);
 
@@ -366,9 +423,14 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void redactBetween(String start, String stop, String asType, int ruleNumber, boolean redactEverywhere,
+    public void redactBetween(@Argument(ArgumentType.STRING) String start,
-                              String reason, String legalBasis) {
+                              @Argument(ArgumentType.STRING) String stop,
+                              @Argument(ArgumentType.TYPE) String asType,
+                              @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                              @Argument(ArgumentType.BOOLEAN) boolean redactEverywhere,
+                              @Argument(ArgumentType.STRING) String reason,
+                              @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         String[] values = StringUtils.substringsBetween(searchText, start, stop);
 
@@ -387,9 +449,14 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void redactLinesBetween(String start, String stop, String asType, int ruleNumber, boolean redactEverywhere,
+    public void redactLinesBetween(@Argument(ArgumentType.STRING) String start,
-                                   String reason, String legalBasis) {
+                                   @Argument(ArgumentType.STRING) String stop,
+                                   @Argument(ArgumentType.TYPE) String asType,
+                                   @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                                   @Argument(ArgumentType.BOOLEAN) boolean redactEverywhere,
+                                   @Argument(ArgumentType.STRING) String reason,
+                                   @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         String[] values = StringUtils.substringsBetween(text, start, stop);
 
@@ -416,29 +483,43 @@ public class Section {
         }
     }
 
-
+    @ThenAction
-    public void highlightCell(String cellHeader, int ruleNumber, String type) {
+    public void highlightCell(@Argument(ArgumentType.STRING) String cellHeader,
+                              @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                              @Argument(ArgumentType.TYPE) String type) {
 
         annotateCell(cellHeader, ruleNumber, type, false, false, null, null);
     }
 
-
+    @ThenAction
-    public void redactCell(String cellHeader, int ruleNumber, String type, boolean addAsRecommendations, String reason,
+    public void redactCell(@Argument(ArgumentType.STRING) String cellHeader,
-                           String legalBasis) {
+                           @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                           @Argument(ArgumentType.TYPE) String type,
+                           @Argument(ArgumentType.BOOLEAN) boolean addAsRecommendations,
+                           @Argument(ArgumentType.STRING) String reason,
+                           @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         annotateCell(cellHeader, ruleNumber, type, true, addAsRecommendations, reason, legalBasis);
     }
 
-
+    @ThenAction
-    public void redactNotCell(String cellHeader, int ruleNumber, String type, boolean addAsRecommendations,
+    public void redactNotCell(@Argument(ArgumentType.STRING) String cellHeader,
-                              String reason) {
+                              @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                              @Argument(ArgumentType.TYPE) String type,
+                              @Argument(ArgumentType.BOOLEAN) boolean addAsRecommendations,
+                              @Argument(ArgumentType.STRING) String reason) {
 
         annotateCell(cellHeader, ruleNumber, type, false, addAsRecommendations, reason, null);
     }
 
 
-    private Set<Entity> findEntities(String value, String asType, boolean caseInsensitive, boolean redacted,
+    private Set<Entity> findEntities(@Argument(ArgumentType.STRING) String value,
-                                     int ruleNumber, String reason, String legalBasis) {
+                                     @Argument(ArgumentType.TYPE) String asType,
+                                     @Argument(ArgumentType.BOOLEAN) boolean caseInsensitive,
+                                     @Argument(ArgumentType.BOOLEAN) boolean redacted,
+                                     @Argument(ArgumentType.RULE_NUMBER) int ruleNumber,
+                                     @Argument(ArgumentType.STRING) String reason,
+                                     @Argument(ArgumentType.LEGAL_BASIS) String legalBasis) {
 
         String text = caseInsensitive ? searchText.toLowerCase() : searchText;
         String searchValue = caseInsensitive ? value.toLowerCase() : value;
@@ -507,6 +588,25 @@ public class Section {
         }
     }
 
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface WhenCondition {
+
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface ThenAction {
+
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.PARAMETER)
+    public @interface Argument {
+
+        ArgumentType value() default ArgumentType.STRING;
+    }
+
 }
 
 

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

@@ -0,0 +1,36 @@
+package com.iqser.red.service.redaction.v1.server.redaction.rulebuilder;
+
+import com.iqser.red.service.redaction.v1.model.Argument;
+import com.iqser.red.service.redaction.v1.model.RuleBuilderModel;
+import com.iqser.red.service.redaction.v1.model.RuleElement;
+import com.iqser.red.service.redaction.v1.server.redaction.model.Section;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class RuleBuilderModelService {
+
+    public RuleBuilderModel getRuleBuilderModel() {
+
+        var whenConditions = Arrays.stream(Section.class.getDeclaredMethods()).filter(m -> m.isAnnotationPresent(Section.WhenCondition.class)).collect(Collectors.toList());
+        var thenActions = Arrays.stream(Section.class.getDeclaredMethods()).filter(m -> m.isAnnotationPresent(Section.ThenAction.class)).collect(Collectors.toList());
+
+        RuleBuilderModel ruleBuilderModel = new RuleBuilderModel();
+
+
+        ruleBuilderModel.setWhenClauses(whenConditions.stream().map(c -> new RuleElement(c.getName(), toArguments(c))).collect(Collectors.toList()));
+        ruleBuilderModel.setThenConditions(thenActions.stream().map(c -> new RuleElement(c.getName(), toArguments(c))).collect(Collectors.toList()));
+
+        return ruleBuilderModel;
+    }
+
+    private List<Argument> toArguments(Method c) {
+        return Arrays.stream(c.getParameters())
+                .map(parameter -> new Argument(parameter.getName(), parameter.getAnnotation(Section.Argument.class).value()))
+                .collect(Collectors.toList());
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.iqser.red.service.redaction.v1.server.redaction.rulebuilder;
+
+import com.iqser.red.service.redaction.v1.model.RuleBuilderModel;
+import org.junit.Test;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class RuleBuilderModelServiceTest {
+
+    @Test
+    public void testRuleBuilderModelProvider() {
+
+        RuleBuilderModel model = new RuleBuilderModelService().getRuleBuilderModel();
+
+        assertThat(model.getWhenClauses().size()).isGreaterThan(1);
+        assertThat(model.getThenConditions().size()).isGreaterThan(1);
+    }
+}