subscription bugfix, and 'AND' between conditions 'OR' between requirements added (#33)

Author: emichaf

src/main/java/com/ericsson/ei/jmespath/JmesPathInterface.java

@@ -54,6 +54,7 @@ public JsonNode runRuleOnEvent(String rule, String input) {
             log.info(e.getMessage(), e);
         }
         JsonNode result = expression.search(event);
+
         return result;
     }
 }

src/main/java/com/ericsson/ei/subscriptionhandler/RunSubscription.java

@@ -28,6 +28,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 
+
 /**
  * This class represents the mechanism to fetch the rule conditions from the
  * Subscription Object and match it with the aggregatedObject to check if it is
@@ -49,67 +50,55 @@ public class RunSubscription {
      * This method matches every condition specified in the subscription Object
      * and if all conditions are matched then only the aggregatedObject is
      * eligible for notification via e-mail or REST POST.
+     *
+     * (AND between conditions in requirements, "OR" between requirements with conditions)
      * 
      * @param aggregatedObject
      * @param requirement
      * @param subscriptionJson
      * @return boolean
      */
-    public boolean runSubscriptionOnObject(String aggregatedObject, ArrayNode fulfilledRequirements,
-            JsonNode subscriptionJson) {
-        Iterator<JsonNode> requirementIterator = fulfilledRequirements.elements();
+
+        public boolean runSubscriptionOnObject(String aggregatedObject, Iterator<JsonNode> requirementIterator,
+                JsonNode subscriptionJson) {
         boolean conditionFulfilled = false;
+        int count_condition_fulfillment = 0;
+        int count_conditions = 0;
+
+
         while (requirementIterator.hasNext()) {
             JsonNode requirement = requirementIterator.next();
             log.info("The fulfilled requirement which will condition checked is : " + requirement.toString());
             ArrayNode conditions = (ArrayNode) requirement.get("conditions");
+
+            count_condition_fulfillment = 0;
+            count_conditions = conditions.size();
+
             log.info("Conditions of the subscription : " + conditions.toString());
             Iterator<JsonNode> conditionIterator = conditions.elements();
-            // boolean conditionFulfilled = false;
             while (conditionIterator.hasNext()) {
                 String rule = conditionIterator.next().get("jmespath").toString().replaceAll("^\"|\"$", "");
                 String new_Rule = rule.replace("'", "\"");
                 log.info("Rule : " + rule);
                 log.info("New Rule after replacing single quote : " + new_Rule);
                 JsonNode result = jmespath.runRuleOnEvent(rule, aggregatedObject);
                 log.info("Result : " + result.toString());
-                if (result.toString() != null) {
-                    conditionFulfilled = true;
+                int test = result.toString().length();
+                if (result.toString() != null && result.toString() != "false" && !result.toString().equals("[]")){
+                    count_condition_fulfillment++;
                 }
             }
-        }
-        log.info("The final value of conditionFulfilled is : " + conditionFulfilled);
-        return conditionFulfilled;
 
-    }
+            if(count_conditions != 0 && count_condition_fulfillment == count_conditions){
 
-    /**
-     * This method check if the subscription requirement type and the
-     * aggregatedObject TemplateName are same.
-     * 
-     * @param requirementIterator
-     * @param aggregatedObject
-     * @return JsonNode
-     */
-    public ArrayNode checkRequirementType(Iterator<JsonNode> requirementIterator, String aggregatedObject) {
-        ArrayNode fulfilledRequirements = new ObjectMapper().createArrayNode();
-        ;
-        JsonNode requirement = null;
-        JsonNode aggregatedJson = null;
-        boolean condition = false;
-        try {
-            aggregatedJson = new ObjectMapper().readTree(aggregatedObject);
-            log.info("AggregatedJson : " + aggregatedJson.toString());
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
-        }
-        while (requirementIterator.hasNext()) {
-            requirement = requirementIterator.next();
-            log.info("Requirements : " + requirement.toString());
-            fulfilledRequirements.add(requirement);
+                conditionFulfilled = true;
+            }
         }
 
-        return fulfilledRequirements;
+        log.info("The final value of conditionFulfilled is : " + conditionFulfilled);
+
+        return conditionFulfilled;
+
     }
 
 }

src/main/java/com/ericsson/ei/subscriptionhandler/SubscriptionHandler.java

@@ -33,8 +33,8 @@
 
 /**
  * This class is responsible to take a aggregatedObject and match it with all
- * the Subscription Object, to check if any of them is eligible for
- * notification.
+ * the Subscription Object, to check ALL Conditions/requirement for
+ * notification.  (AND between conditions in requirements, "OR" between requirements with conditions)
  * 
  * @author xjibbal
  *
@@ -109,15 +109,12 @@ public void extractConditions(String aggregatedObject, String subscriptionData)
         ArrayNode requirementNode = (ArrayNode) subscriptionJson.get("requirements");
         log.info("RequirementNode : " + requirementNode.toString());
         Iterator<JsonNode> requirementIterator = requirementNode.elements();
-        ArrayNode fulfilledRequirements = runSubscription.checkRequirementType(requirementIterator, aggregatedObject);
-        if (fulfilledRequirements != null) {
-            log.info("The fulfilled requirements are : " + fulfilledRequirements.toString());
-            if (runSubscription.runSubscriptionOnObject(aggregatedObject, fulfilledRequirements, subscriptionJson)) {
+
+            if (runSubscription.runSubscriptionOnObject(aggregatedObject, requirementIterator, subscriptionJson)) {
                 log.info("The subscription conditions match for the aggregatedObject");
                 informSubscription.informSubscriber(aggregatedObject, subscriptionJson);
             }
-        } else
-            log.info("The subscription conditions did not match for the aggregatedObject");
+
     }
 
     /**

src/main/resources/application.properties

@@ -9,7 +9,7 @@ logging.level.root: INFO
 logging.level.org.springframework.web: DEBUG
 logging.level.com.ericsson.ei: DEBUG
 
-rabbitmq.host: 127.0.0.1
+rabbitmq.host: localhost
 rabbitmq.port: 5672
 rabbitmq.user:
 rabbitmq.password:

src/test/java/com/ericsson/ei/subscriptionhandler/test/SubscriptionHandlerTest.java

@@ -97,37 +97,21 @@ public void initMocks() {
         System.out.println("Database connected");
     }
 
-    @Test
-    public void checkRequirementTypeTest() {
-        ObjectMapper mapper = new ObjectMapper();
-        JsonNode subscriptionJson = null;
-        JsonNode aggregatedJson = null;
-        try {
-            subscriptionJson = mapper.readTree(subscriptionData);
-            aggregatedJson = mapper.readTree(aggregatedObject);
-        } catch (Exception e) {
-            log.error(e.getMessage(), e);
-        }
-        ArrayNode requirementNode = (ArrayNode) subscriptionJson.get("requirements");
-        JsonNode expectedOutput = (JsonNode) requirementNode;
-        log.info("RequirementNode : " + requirementNode.toString());
-        Iterator<JsonNode> requirementIterator = requirementNode.elements();
-        JsonNode output = runSubscription.checkRequirementType(requirementIterator, aggregatedObject);
-        assertEquals(output.toString(), expectedOutput.toString());
-    }
 
     @Test
     public void runSubscriptionOnObjectTest() {
         ObjectMapper mapper = new ObjectMapper();
         JsonNode subscriptionJson = null;
-        ArrayNode fulfilledRequirements = null;
+        ArrayNode requirementNode = null;
+        Iterator<JsonNode> requirementIterator = null;
         try {
             subscriptionJson = mapper.readTree(subscriptionData);
-            fulfilledRequirements = (ArrayNode) subscriptionJson.get("requirements");
+            requirementNode = (ArrayNode) subscriptionJson.get("requirements");
+            requirementIterator = requirementNode.elements();
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
-        boolean output = runSubscription.runSubscriptionOnObject(aggregatedObject, fulfilledRequirements,
+        boolean output = runSubscription.runSubscriptionOnObject(aggregatedObject, requirementIterator,
                 subscriptionJson);
         assertEquals(output, true);
     }