Fix for MongoDBHandling on ObjectToEvent map handling (#472)

SantoshNC68 · Durga Vasaadi · web-flow · commit ce574ffe79d9 · 2020-09-01T22:04:41.000+05:30
* Added fixes to MongoDB connections
* Updated the Mongo query handling to check the object mapping
* Updated java doc for the newly created methods
* Updated DatabaseManager to check expectedEventIds in objects
* Updated DatabaseManager to check expectedEventIds

Co-authored-by: Durga Vasaadi &lt;durga.vasaadi@ericsson.com&gt;
diff --git a/src/functionaltests/java/com/ericsson/ei/utils/DataBaseManager.java b/src/functionaltests/java/com/ericsson/ei/utils/DataBaseManager.java
@@ -149,9 +149,9 @@ private List<String> compareSentEventsWithEventsInDB(List<String> checklist) {
         List<Document> documents = collection.find().into(new ArrayList<>());
         for (Document document : documents) {
             for (String expectedID : new ArrayList<>(checklist)) {
-                if (expectedID.equals(document.get("_id").toString())) {
+            	if (document.get("objects").toString().contains(expectedID)) {
                     checklist.remove(expectedID);
-                }
+            	}
             }
         }
         return checklist;
diff --git a/src/main/java/com/ericsson/ei/handlers/EventToObjectMapHandler.java b/src/main/java/com/ericsson/ei/handlers/EventToObjectMapHandler.java
@@ -81,30 +81,36 @@ public ArrayList<String> getObjectsForEventId(String eventId) {
         return getEventToObjectList(eventId);
     }
 
+    /**
+     * To check and save the eventIds to the objectId in the mapped database.
+     * @param rulesObject
+     * @param event
+     * @param objectId aggregated event object Id
+     */
     public void updateEventToObjectMapInMemoryDB(RulesObject rulesObject, String event, String objectId) {
         String eventId = getEventId(rulesObject, event);
-        String condition = "{\"_id\" : \"" + eventId + "\"}";
-        ArrayList<String> list =  getEventToObjectList(eventId);
-        boolean firstTime = list.isEmpty();
-        list = updateList(list, eventId, objectId);
-        ObjectMapper mapper = new ObjectMapper();
-        JsonNode entry = null;
-
+        String condition = "{\"_id\" : \"" + objectId + "\"}";
+        LOGGER.debug("Checking document exists in the collection with condition : {}\n EventId : {}", condition, eventId);
+        boolean docExists = mongodbhandler.checkDocumentExists(databaseName, collectionName, condition);
         try {
-            entry = new ObjectMapper().readValue(condition, JsonNode.class);
-            ArrayNode jsonNode = mapper.convertValue(list, ArrayNode.class);
-            ((ObjectNode) entry).set(listPropertyName, mapper.readTree(jsonNode.toString()));
-            String mapStr = entry.toString();
-            LOGGER.debug("MongoDbHandler Insert/Update Event: {}\nto database: {} and to Collection: {}", mapStr, databaseName, collectionName);
-            if (firstTime) {
-                mongodbhandler.insertDocument(databaseName, collectionName, mapStr);
+        	if (!docExists) {
+        		ArrayList<String> list =  new ArrayList<String>();
+        		list.add(eventId);
+        		final ObjectMapper mapper = new ObjectMapper();
+    			JsonNode entry = new ObjectMapper().readValue(condition, JsonNode.class);
+        		ArrayNode jsonNode = mapper.convertValue(list, ArrayNode.class);
+        		((ObjectNode) entry).set(listPropertyName, mapper.readTree(jsonNode.toString()));
+                final String mapStr = entry.toString(); 
+            	LOGGER.debug("MongoDbHandler Insert/Update Event: {}\nto database: {} and to Collection: {}", mapStr, databaseName, collectionName);	
+            	mongodbhandler.insertDocument(databaseName, collectionName, mapStr );
             } else {
-                mongodbhandler.updateDocument(databaseName, collectionName, condition, mapStr);
+                mongodbhandler.updateDocumentAddToSet(databaseName, collectionName, condition, eventId);
             }
         } catch (Exception e) {
-            LOGGER.info("Failed to update event object list.", e);
+            LOGGER.error("Failed to update event object list.", e);
         }
     }
+    
 
     public String getEventId(RulesObject rulesObject, String event) {
         String idRule = rulesObject.getIdRule();
@@ -148,7 +154,7 @@ public boolean deleteEventObjectMap(String templateName) {
     }
 
     public boolean isEventInEventObjectMap(String eventId) {
-        String condition = "{\"_id\" : \"" + eventId + "\"}";
+        String condition = "{\"objects\": { \"$in\" : [\"" + eventId + "\"]} }";
         List<String> documents = mongodbhandler.find(databaseName, collectionName, condition);
         return !documents.isEmpty();
     }
diff --git a/src/main/java/com/ericsson/ei/handlers/MongoDBHandler.java b/src/main/java/com/ericsson/ei/handlers/MongoDBHandler.java
@@ -43,6 +43,7 @@
 import com.mongodb.client.MongoDatabase;
 import com.mongodb.client.model.IndexOptions;
 import com.mongodb.client.model.Indexes;
+import com.mongodb.client.model.Updates;
 import com.mongodb.client.result.DeleteResult;
 import com.mongodb.client.result.UpdateResult;
 import com.mongodb.util.JSON;
@@ -137,7 +138,7 @@ public ArrayList<String> getAllDocuments(String dataBaseName, String collectionN
      *
      * @param dataBaseName
      * @param collectionName
-     * @param condition      string json
+     * @param condition      a condition to find a requested object in the database
      * @return
      */
     public ArrayList<String> find(String dataBaseName, String collectionName, String condition) {
@@ -342,4 +343,47 @@ public void dropDatabase(String databaseName) {
         MongoDatabase db = mongoClient.getDatabase(databaseName);
         db.drop();
     }
+    
+    /**
+     * Check if the document exists
+     * @param databaseName
+     * @param collectionName
+     * @param condition      a condition to find a requested object in the database
+     * @return
+     */
+    public boolean checkDocumentExists(String databaseName, String collectionName, String condition) {
+        MongoDatabase db = mongoClient.getDatabase(databaseName);
+    	MongoCollection<Document> mongoCollection = db.getCollection(collectionName);
+        Document doc = mongoCollection.find(BasicDBObject.parse(condition)).first();
+        if (doc == null || doc.isEmpty()) {
+            return false;
+        }
+        return true;
+    }
+    
+    
+    /**
+     * Update the existing documents with unique objects list
+     * Used only in EventToObjectMapHandler.java
+     * @param dataBaseName
+     * @param collectionName
+     * @param condition      a condition to find a requested object in the database
+     * @param eventId eventId to update in the mapper collection
+     * @return 
+     */
+    public boolean updateDocumentAddToSet(String dataBaseName, String collectionName, String condition, String eventId) {
+        try {
+            MongoCollection<Document> collection = getMongoCollection(dataBaseName, collectionName);
+            if (collection != null) {
+                final Document dbObjectInput = Document.parse(condition);
+                UpdateResult updateMany = collection.updateOne(dbObjectInput, Updates.addToSet("objects", eventId));
+                LOGGER.debug("updateDocument() :: database: {} and collection: {} is document Updated : {}", dataBaseName, collectionName, updateMany.wasAcknowledged());
+                return updateMany.wasAcknowledged();
+            }
+        } catch (Exception e) {
+            LOGGER.error("Failed to update document.", e);
+        }
+
+        return false;
+    }
 }
diff --git a/src/main/java/com/ericsson/ei/jmespath/JmesPathInterface.java b/src/main/java/com/ericsson/ei/jmespath/JmesPathInterface.java
@@ -74,6 +74,7 @@ public JsonNode runRuleOnEvent(String rule, String event) {
             Expression<JsonNode> expression = jmespath.compile(rule);
             JsonNode eventJson = objectMapper.readValue(event, JsonNode.class);
             result = expression.search(eventJson);
+            LOGGER.debug("Expression : {} \n RESULT VALUE FROM JMESPATH : {}" , expression, result);
         } catch (Exception e) {
             LOGGER.error("Failed to run rule on event.\nRule: {}\nEvent: {}", rule, event, e);
         }
diff --git a/src/main/java/com/ericsson/ei/jsonmerge/MergeHandler.java b/src/main/java/com/ericsson/ei/jsonmerge/MergeHandler.java
@@ -67,13 +67,15 @@ public String mergeObject(String id, String mergeId, RulesObject rules, String e
         try {
             // lock and get the AggregatedObject
             String aggregatedObject = getAggregatedObject(id, true);
+            LOGGER.debug("AGGREGATED OBJECT : " + aggregatedObject);
             String mergeRule = getMergeRules(rules);
             if (mergeRule != null && !mergeRule.isEmpty()) {
                 String updatedRule = replaceIdMarkerInRules(mergeRule, mergeId);
                 String ruleForMerge = jmesPathInterface.runRuleOnEvent(updatedRule, event).toString();
                 String mergePath = prepareMergePrepareObject.getMergePath(aggregatedObject, ruleForMerge, false);
                 preparedToMergeObject = prepareMergePrepareObject.addMissingLevels(aggregatedObject,
                         objectToMerge.toString(), ruleForMerge, mergePath);
+                LOGGER.debug("PREPARE TO MERGE OBJECT : " + preparedToMergeObject);
             } else {
                 preparedToMergeObject = objectToMerge.toString();
             }
diff --git a/src/main/java/com/ericsson/ei/waitlist/WaitListStorageHandler.java b/src/main/java/com/ericsson/ei/waitlist/WaitListStorageHandler.java
@@ -71,7 +71,7 @@ public class WaitListStorageHandler {
     public void addEventToWaitListIfNotExisting(String event, RulesObject rulesObject) {
         try {
             JsonNode id = extractIdFromEventUsingRules(event, rulesObject);
-            String foundEvent = findEventInWaitList(id);
+            String foundEvent = findEventInWaitList(id.textValue());
             if (foundEvent.isEmpty()) {
                 Date date = createCurrentTimeStamp();
                 BasicDBObject document = createWaitListDocument(event, id, date);
@@ -82,7 +82,7 @@ public void addEventToWaitListIfNotExisting(String event, RulesObject rulesObjec
         }
     }
 
-    private String findEventInWaitList(JsonNode id) {
+    private String findEventInWaitList(String id) {
         String condition = "{\"_id\" : \"" + id + "\"}";
         List<String> foundEventsInWaitList = mongoDbHandler.find(databaseName, collectionName, condition);
         if (foundEventsInWaitList.isEmpty()) {
diff --git a/src/test/java/com/ericsson/ei/handlers/test/MongoDBHandlerTest.java b/src/test/java/com/ericsson/ei/handlers/test/MongoDBHandlerTest.java
@@ -37,16 +37,23 @@ public class MongoDBHandlerTest {
 
     private String dataBaseName = "MongoDBHandlerTestDB";
     private String collectionName = "SampleEvents";
+    private String mapCollectionName = "SampleEventObjectMap";
     private String input = "{\"id\":\"eventId\",\"type\":\"eventType11\",\"test_cases\" : [{\"event_id\" : \"testcaseid1\", \"test_data\" : \"testcase1data\"},{\"event_id\" : \"testcaseid2\", \"test_data\" : \"testcase2data\"}]}";
     private String updateInput = "{\"id\":\"eventId\",\"type\":\"eventType11\",\"test_cases\" : [{\"event_id\" : \"testcaseid1\", \"test_data\" : \"testcase2data\"},{\"event_id\" : \"testcaseid3\", \"test_data\" : \"testcase3data\"}]}";
     private String condition = "{\"test_cases.event_id\" : \"testcaseid1\"}";
+    
+    //Added to test new functionality for EventToObjectMapHandler
+    private String conditionForEventToObjectMap = "{\"_id\" : \"testid1\"}";
+    private String inputForEventToObjectMap = "{\"_id\" : \"testid1\", \"objects\" : [\"eventid1\", \"eventid2\"]}";
+    private String updateInputForEventToObjectMap = "\"eventid3\"";
 
     @Before
     public void init() throws Exception {
         TestConfigs.init();
         mongoDBHandler = new MongoDBHandler();
         mongoDBHandler.setMongoClient(TestConfigs.getMongoClient());
         mongoDBHandler.insertDocument(dataBaseName, collectionName, input);
+        mongoDBHandler.insertDocument(dataBaseName, mapCollectionName, inputForEventToObjectMap);
     }
 
     @Test
@@ -69,5 +76,17 @@ public void testUpdateDocument() {
     @After
     public void dropCollection() {
         assertTrue(mongoDBHandler.dropDocument(dataBaseName, collectionName, condition));
+        mongoDBHandler.dropCollection(dataBaseName, mapCollectionName);
+    }
+    
+    //Added test cases for EventToObjectMapHandler
+    @Test
+    public void checkDocument() {
+    	assertTrue(mongoDBHandler.checkDocumentExists(dataBaseName, mapCollectionName, conditionForEventToObjectMap));
+    }
+    
+    @Test
+    public void updateEventToObjectMap() {
+    	assertTrue(mongoDBHandler.updateDocumentAddToSet(dataBaseName, mapCollectionName, conditionForEventToObjectMap, updateInputForEventToObjectMap));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -149,9 +149,9 @@ private List<String> compareSentEventsWithEventsInDB(List<String> checklist) {`
`149`	`149`	`List<Document> documents = collection.find().into(new ArrayList<>());`
`150`	`150`	`for (Document document : documents) {`
`151`	`151`	`for (String expectedID : new ArrayList<>(checklist)) {`
`152`		`- if (expectedID.equals(document.get("_id").toString())) {`
	`152`	`+ if (document.get("objects").toString().contains(expectedID)) {`
`153`	`153`	`checklist.remove(expectedID);`
`154`		`- }`
	`154`	`+ }`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`	`return checklist;`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ public JsonNode runRuleOnEvent(String rule, String event) {`
`74`	`74`	`Expression<JsonNode> expression = jmespath.compile(rule);`
`75`	`75`	`JsonNode eventJson = objectMapper.readValue(event, JsonNode.class);`
`76`	`76`	`result = expression.search(eventJson);`
	`77`	`+ LOGGER.debug("Expression : {} \n RESULT VALUE FROM JMESPATH : {}" , expression, result);`
`77`	`78`	`} catch (Exception e) {`
`78`	`79`	`LOGGER.error("Failed to run rule on event.\nRule: {}\nEvent: {}", rule, event, e);`
`79`	`80`	`}`