Rules engine refactoring

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/EtorDomainRegistration.java

@@ -33,8 +33,8 @@
 import gov.hhs.cdc.trustedintermediary.etor.results.ResultResponse;
 import gov.hhs.cdc.trustedintermediary.etor.results.ResultSender;
 import gov.hhs.cdc.trustedintermediary.etor.results.SendResultUseCase;
-import gov.hhs.cdc.trustedintermediary.etor.ruleengine.RuleEngine;
 import gov.hhs.cdc.trustedintermediary.etor.ruleengine.RuleLoader;
+import gov.hhs.cdc.trustedintermediary.etor.ruleengine.ValidationRuleEngine;
 import gov.hhs.cdc.trustedintermediary.external.database.DatabaseMessageLinkStorage;
 import gov.hhs.cdc.trustedintermediary.external.database.DatabasePartnerMetadataStorage;
 import gov.hhs.cdc.trustedintermediary.external.database.DbDao;
@@ -133,7 +133,7 @@ public Map<HttpEndpoint, Function<DomainRequest, DomainResponse>> domainRegistra
                 PartnerMetadataConverter.class, HapiPartnerMetadataConverter.getInstance());
         // Validation rules
         ApplicationContext.register(RuleLoader.class, RuleLoader.getInstance());
-        ApplicationContext.register(RuleEngine.class, RuleEngine.getInstance());
+        ApplicationContext.register(ValidationRuleEngine.class, ValidationRuleEngine.getInstance());
 
         ApplicationContext.register(SendMessageHelper.class, SendMessageHelper.getInstance());
 

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/orders/OrderController.java

@@ -2,7 +2,7 @@
 
 import gov.hhs.cdc.trustedintermediary.domainconnector.DomainRequest;
 import gov.hhs.cdc.trustedintermediary.etor.metadata.EtorMetadataStep;
-import gov.hhs.cdc.trustedintermediary.etor.ruleengine.RuleEngine;
+import gov.hhs.cdc.trustedintermediary.etor.ruleengine.ValidationRuleEngine;
 import gov.hhs.cdc.trustedintermediary.external.hapi.HapiFhirResource;
 import gov.hhs.cdc.trustedintermediary.external.hapi.HapiOrder;
 import gov.hhs.cdc.trustedintermediary.wrappers.FhirParseException;
@@ -20,7 +20,7 @@ public class OrderController {
     @Inject HapiFhir fhir;
     @Inject Logger logger;
     @Inject MetricMetadata metadata;
-    @Inject RuleEngine ruleEngine;
+    @Inject ValidationRuleEngine validationEngine;
 
     private OrderController() {}
 
@@ -31,7 +31,7 @@ public static OrderController getInstance() {
     public Order<?> parseOrders(DomainRequest request) throws FhirParseException {
         logger.logInfo("Parsing orders");
         var fhirBundle = fhir.parseResource(request.getBody(), Bundle.class);
-        ruleEngine.validate(new HapiFhirResource(fhirBundle));
+        validationEngine.runRules(new HapiFhirResource(fhirBundle));
         metadata.put(fhirBundle.getId(), EtorMetadataStep.RECEIVED_FROM_REPORT_STREAM);
         return new HapiOrder(fhirBundle);
     }

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/Rule.java

@@ -12,17 +12,9 @@ public interface Rule {
 
     String getDescription();
 
-    /**
-     * Descriptive message when there's a rule violation Note: When implementing this method, make
-     * sure that no PII or PHI is included in the message!
-     */
-    String getViolationMessage();
-
     List<String> getConditions();
 
-    List<String> getValidations();
-
-    boolean isValid(FhirResource<?> resource);
+    boolean shouldRun(FhirResource<?> resource);
 
-    boolean appliesTo(FhirResource<?> resource);
+    void runRule(FhirResource<?> resource);
 }

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/RuleEngine.java

@@ -1,27 +1,17 @@
 package gov.hhs.cdc.trustedintermediary.etor.ruleengine;
 
-import gov.hhs.cdc.trustedintermediary.wrappers.Logger;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
-import javax.inject.Inject;
 
 /** Manages the application of rules loaded from a definitions file using the RuleLoader. */
 public class RuleEngine {
-
-    private static final RuleEngine INSTANCE = new RuleEngine();
-
     final List<Rule> rules = new ArrayList<>();
+    RuleLoader ruleLoader;
+    String ruleDefinitionsFileName;
 
-    @Inject Logger logger;
-    @Inject RuleLoader ruleLoader;
-
-    private RuleEngine() {}
-
-    public static RuleEngine getInstance() {
-        return INSTANCE;
+    RuleEngine(RuleLoader ruleLoader, String ruleDefinitionsFileName) {
+        this.ruleLoader = ruleLoader;
+        this.ruleDefinitionsFileName = ruleDefinitionsFileName;
     }
 
     public void unloadRules() {
@@ -32,31 +22,22 @@ public void ensureRulesLoaded() {
         if (rules.isEmpty()) {
             synchronized (this) {
                 if (rules.isEmpty()) {
-                    loadRules();
+                    var parsedRules = ruleLoader.loadRules(ruleDefinitionsFileName);
+                    loadRules(parsedRules);
                 }
             }
         }
     }
 
-    private synchronized void loadRules() {
-        String fileName = "rule_definitions.json";
-        try (InputStream ruleDefinitionStream =
-                getClass().getClassLoader().getResourceAsStream(fileName)) {
-            assert ruleDefinitionStream != null;
-            var ruleStream =
-                    new String(ruleDefinitionStream.readAllBytes(), StandardCharsets.UTF_8);
-            rules.addAll(ruleLoader.loadRules(ruleStream));
-        } catch (IOException | RuleLoaderException e) {
-            logger.logError("Failed to load rules definitions from: " + fileName, e);
-        }
+    private synchronized void loadRules(List<Rule> rules) {
+        this.rules.addAll(rules);
     }
 
-    public void validate(FhirResource<?> resource) {
-        logger.logDebug("Validating FHIR resource");
+    public void runRules(FhirResource<?> resource) {
         ensureRulesLoaded();
         for (Rule rule : rules) {
-            if (rule.appliesTo(resource) && !rule.isValid(resource)) {
-                logger.logWarning("Rule violation: " + rule.getViolationMessage());
+            if (rule.shouldRun(resource)) {
+                rule.runRule(resource);
             }
         }
     }

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/RuleLoader.java

@@ -1,8 +1,12 @@
 package gov.hhs.cdc.trustedintermediary.etor.ruleengine;
 
+import gov.hhs.cdc.trustedintermediary.wrappers.Logger;
 import gov.hhs.cdc.trustedintermediary.wrappers.formatter.Formatter;
 import gov.hhs.cdc.trustedintermediary.wrappers.formatter.FormatterProcessingException;
 import gov.hhs.cdc.trustedintermediary.wrappers.formatter.TypeReference;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -12,21 +16,26 @@
 public class RuleLoader {
     private static final RuleLoader INSTANCE = new RuleLoader();
     @Inject Formatter formatter;
+    @Inject Logger logger;
 
     private RuleLoader() {}
 
     public static RuleLoader getInstance() {
         return INSTANCE;
     }
 
-    public List<ValidationRule> loadRules(String ruleStream) throws RuleLoaderException {
-        try {
-            Map<String, List<ValidationRule>> jsonObj =
-                    formatter.convertJsonToObject(ruleStream, new TypeReference<>() {});
+    public List<Rule> loadRules(String fileName) {
+        try (InputStream ruleDefinitionStream =
+                getClass().getClassLoader().getResourceAsStream(fileName)) {
+            assert ruleDefinitionStream != null;
+            var rulesString =
+                    new String(ruleDefinitionStream.readAllBytes(), StandardCharsets.UTF_8);
+            Map<String, List<Rule>> jsonObj =
+                    formatter.convertJsonToObject(rulesString, new TypeReference<>() {});
             return jsonObj.getOrDefault("rules", Collections.emptyList());
-        } catch (FormatterProcessingException e) {
-            throw new RuleLoaderException(
-                    "Failed to load rules definitions for provided stream", e);
+        } catch (IOException | FormatterProcessingException e) {
+            logger.logError("Failed to load rules definitions from: " + fileName, e);
+            return Collections.emptyList();
         }
     }
 }

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/TransformationRule.java

@@ -0,0 +1,28 @@
+package gov.hhs.cdc.trustedintermediary.etor.ruleengine;
+
+import java.util.List;
+
+public class TransformationRule implements Rule {
+    @Override
+    public String getName() {
+        return "";
+    }
+
+    @Override
+    public String getDescription() {
+        return "";
+    }
+
+    @Override
+    public List<String> getConditions() {
+        return List.of();
+    }
+
+    @Override
+    public boolean shouldRun(FhirResource<?> resource) {
+        return false;
+    }
+
+    @Override
+    public void runRule(FhirResource<?> resource) {}
+}

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/ValidationRule.java

@@ -49,7 +49,6 @@ public String getDescription() {
         return description;
     }
 
-    @Override
     public String getViolationMessage() {
         return violationMessage;
     }
@@ -59,34 +58,12 @@ public List<String> getConditions() {
         return conditions;
     }
 
-    @Override
     public List<String> getValidations() {
         return validations;
     }
 
     @Override
-    public boolean isValid(FhirResource<?> resource) {
-        return validations.stream()
-                .allMatch(
-                        validation -> {
-                            try {
-                                return fhirEngine.evaluateCondition(
-                                        resource.getUnderlyingResource(), validation);
-                            } catch (Exception e) {
-                                logger.logError(
-                                        "Rule ["
-                                                + name
-                                                + "]: "
-                                                + "An error occurred while evaluating the validation: "
-                                                + validation,
-                                        e);
-                                return false;
-                            }
-                        });
-    }
-
-    @Override
-    public boolean appliesTo(FhirResource<?> resource) {
+    public boolean shouldRun(FhirResource<?> resource) {
         return conditions.stream()
                 .allMatch(
                         condition -> {
@@ -105,4 +82,25 @@ public boolean appliesTo(FhirResource<?> resource) {
                             }
                         });
     }
+
+    @Override
+    public void runRule(FhirResource<?> resource) {
+        for (String validation : validations) {
+            try {
+                boolean isValid =
+                        fhirEngine.evaluateCondition(resource.getUnderlyingResource(), validation);
+                if (!isValid) {
+                    logger.logWarning("Rule violation: " + violationMessage);
+                }
+            } catch (Exception e) {
+                logger.logError(
+                        "Rule ["
+                                + name
+                                + "]: "
+                                + "An error occurred while evaluating the validation: "
+                                + validation,
+                        e);
+            }
+        }
+    }
 }

etor/src/main/java/gov/hhs/cdc/trustedintermediary/etor/ruleengine/ValidationRuleEngine.java

@@ -0,0 +1,18 @@
+package gov.hhs.cdc.trustedintermediary.etor.ruleengine;
+
+import gov.hhs.cdc.trustedintermediary.wrappers.Logger;
+import javax.inject.Inject;
+
+public class ValidationRuleEngine extends RuleEngine {
+    @Inject Logger logger;
+
+    private static final ValidationRuleEngine INSTANCE = new ValidationRuleEngine();
+
+    private ValidationRuleEngine() {
+        super(RuleLoader.getInstance(), "validation_definitions.json");
+    }
+
+    public static ValidationRuleEngine getInstance() {
+        return INSTANCE;
+    }
+}

etor/src/main/resources/transformation_definitions.json

@@ -0,0 +1,9 @@
+{
+  "rules": [ {
+      "name": "",
+      "description": "",
+      "conditions": [ ],
+      "transformations": [ ]
+    }
+  ]
+}

etor/src/test/groovy/gov/hhs/cdc/trustedintermediary/etor/orders/OrderControllerTest.groovy

@@ -38,7 +38,7 @@ class OrderControllerTest extends Specification {
 
         then:
         actualBundle == expectedBundle
-        (1.._) * ruleEngine.validate(_)
+        (1.._) * ruleEngine.runRules(_)
     }
 
     def "parseOrders registers a metadata step"() {

etor/src/test/groovy/gov/hhs/cdc/trustedintermediary/etor/ruleengine/RuleEngineIntegrationTest.groovy

@@ -41,7 +41,7 @@ class RuleEngineIntegrationTest extends Specification {
         def bundle = new Bundle()
 
         when:
-        engine.validate(new HapiFhirResource(bundle))
+        engine.runRules(new HapiFhirResource(bundle))
 
         then:
         (1.._) * mockLogger.logWarning(_ as String)
@@ -53,7 +53,7 @@ class RuleEngineIntegrationTest extends Specification {
 
         when:
         exampleFhirResources.each { resource ->
-            engine.validate(resource)
+            engine.runRules(resource)
         }
 
         then:

etor/src/test/groovy/gov/hhs/cdc/trustedintermediary/etor/ruleengine/RuleEngineTest.groovy

@@ -66,13 +66,13 @@ class RuleEngineTest extends Specification {
         mockRuleLoader.loadRules(_ as String) >> { throw exception }
 
         when:
-        ruleEngine.validate(Mock(FhirResource))
+        ruleEngine.runRules(Mock(FhirResource))
 
         then:
         1 * mockLogger.logError(_ as String, exception)
     }
 
-    def "validate handles logging warning correctly"() {
+    def 'runRules handles logging warning correctly'() {
         given:
         def ruleViolationMessage = "Rule violation message"
         def fullRuleViolationMessage = "Rule violation: " + ruleViolationMessage
@@ -82,25 +82,25 @@ class RuleEngineTest extends Specification {
         mockRuleLoader.loadRules(_ as String) >> [invalidRule]
 
         when:
-        invalidRule.appliesTo(fhirBundle) >> true
+        invalidRule.shouldRun(fhirBundle) >> true
         invalidRule.isValid(fhirBundle) >> false
-        ruleEngine.validate(fhirBundle)
+        ruleEngine.runRules(fhirBundle)
 
         then:
         1 * mockLogger.logWarning(fullRuleViolationMessage)
 
         when:
-        invalidRule.appliesTo(fhirBundle) >> true
+        invalidRule.shouldRun(fhirBundle) >> true
         invalidRule.isValid(fhirBundle) >> true
-        ruleEngine.validate(fhirBundle)
+        ruleEngine.runRules(fhirBundle)
 
         then:
         0 * mockLogger.logWarning(fullRuleViolationMessage)
 
         when:
-        invalidRule.appliesTo(fhirBundle) >> false
+        invalidRule.shouldRun(fhirBundle) >> false
         invalidRule.isValid(fhirBundle) >> false
-        ruleEngine.validate(fhirBundle)
+        ruleEngine.runRules(fhirBundle)
 
         then:
         0 * mockLogger.logWarning(fullRuleViolationMessage)