Merge pull request #101 from krgauraw/release-2.7.0

code changes to populate existing relations

ontology-engine/graph-dac-api/src/main/java/org/sunbird/graph/dac/model/Node.java

 package org.sunbird.graph.dac.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.sunbird.graph.common.enums.SystemProperties;
 
@@ -131,7 +132,9 @@ public class Node implements Serializable {
 	}
 
 	public void setAddedRelations(List<Relation> addedRelations) {
-		this.addedRelations = addedRelations;
+        if(CollectionUtils.isEmpty(this.addedRelations))
+		    this.addedRelations = new ArrayList<>();
+        this.addedRelations.addAll(addedRelations);
 	}
 
 	public List<Relation> getDeletedRelations() {

ontology-engine/graph-engine_2.11/src/main/scala/org/sunbird/graph/schema/DefinitionNode.scala

@@ -67,13 +67,15 @@ object DefinitionNode {
         val graphId: String = request.getContext.get("graph_id").asInstanceOf[String]
         val version: String = request.getContext.get("version").asInstanceOf[String]
         val schemaName: String = request.getContext.get("schemaName").asInstanceOf[String]
+	    val req:util.HashMap[String, AnyRef] = new util.HashMap[String, AnyRef](request.getRequest)
         val skipValidation: Boolean = {if(request.getContext.containsKey("skipValidation")) request.getContext.get("skipValidation").asInstanceOf[Boolean] else false}
         val definition = DefinitionFactory.getDefinition(graphId, schemaName, version)
         val dbNodeFuture = definition.getNode(identifier, "update", null)
         val validationResult: Future[Node] = dbNodeFuture.map(dbNode => {
             resetJsonProperties(dbNode, graphId, version, schemaName)
             val inputNode: Node = definition.getNode(dbNode.getIdentifier, request.getRequest, dbNode.getNodeType)
-            setRelationship(dbNode,inputNode)
+	        val dbRels = getDBRelations(graphId, schemaName, version, req, dbNode)
+            setRelationship(dbNode,inputNode, dbRels)
             if (dbNode.getIdentifier.endsWith(".img") && StringUtils.equalsAnyIgnoreCase("Yes", dbNode.getMetadata.get("isImageNodeCreated").asInstanceOf[String])) {
                 inputNode.getMetadata.put("versionKey", dbNode.getMetadata.get("versionKey"))
                 dbNode.getMetadata.remove("isImageNodeCreated")
@@ -115,18 +117,28 @@ object DefinitionNode {
 		node
 	}
 
-    private def setRelationship(dbNode: Node, inputNode: Node): Unit = {
-        var addRels: util.List[Relation] = new util.ArrayList[Relation]()
+    private def setRelationship(dbNode: Node, inputNode: Node, dbRels:util.Map[String, util.List[Relation]]): Unit = {
+	    var addRels: util.List[Relation] = new util.ArrayList[Relation]()
         var delRels: util.List[Relation] = new util.ArrayList[Relation]()
         val inRel: util.List[Relation] = dbNode.getInRelations
         val outRel: util.List[Relation] = dbNode.getOutRelations
-        val inRelReq: util.List[Relation] = inputNode.getInRelations
-        val outRelReq: util.List[Relation] = inputNode.getOutRelations
-        if (CollectionUtils.isNotEmpty(inRelReq))
+        val inRelReq: util.List[Relation] = if(CollectionUtils.isNotEmpty(inputNode.getInRelations)) new util.ArrayList[Relation](inputNode.getInRelations) else new util.ArrayList[Relation]()
+        val outRelReq: util.List[Relation] = if(CollectionUtils.isNotEmpty(inputNode.getOutRelations)) new util.ArrayList[Relation](inputNode.getOutRelations) else new util.ArrayList[Relation]()
+        if (CollectionUtils.isNotEmpty(inRelReq)) {
+	        if(CollectionUtils.isNotEmpty(dbRels.get("in"))){
+		        inRelReq.addAll(dbRels.get("in"))
+		        inputNode.setInRelations(inRelReq)
+	        }
             getNewRelationsList(inRel, inRelReq, addRels, delRels)
-        if (CollectionUtils.isNotEmpty(outRelReq))
+        }
+	    if (CollectionUtils.isNotEmpty(outRelReq)) {
+		    if(CollectionUtils.isNotEmpty(dbRels.get("out"))){
+			    outRelReq.addAll(dbRels.get("out"))
+			    inputNode.setOutRelations(outRelReq)
+		    }
             getNewRelationsList(outRel, outRelReq, addRels, delRels)
-        if (CollectionUtils.isNotEmpty(addRels)) {
+	    }
+	    if (CollectionUtils.isNotEmpty(addRels)) {
             dbNode.setAddedRelations(addRels)
 	        updateRelationMetadata(dbNode)
         }
@@ -178,5 +190,40 @@ object DefinitionNode {
         }
         node
     }
+
+	def getDBRelations(graphId:String, schemaName:String, version:String, request: util.Map[String, AnyRef], dbNode: Node):util.Map[String, util.List[Relation]] = {
+		val inRelations = new util.ArrayList[Relation]()
+		val outRelations = new util.ArrayList[Relation]()
+		val relDefMap = getRelationDefinitionMap(graphId, version, schemaName);
+		if (null != dbNode) {
+			if (CollectionUtils.isNotEmpty(dbNode.getInRelations)) {
+				for (inRel <- dbNode.getInRelations()) {
+					val key = inRel.getRelationType() + "_in_" + inRel.getStartNodeObjectType()
+					if (relDefMap.containsKey(key)) {
+						val value = relDefMap.get(key).get
+						if (!request.containsKey(value)) {
+							inRelations.add(inRel)
+						}
+					}
+				}
+			}
+			if (CollectionUtils.isNotEmpty(dbNode.getOutRelations)) {
+				for (outRel <- dbNode.getOutRelations()) {
+					val key = outRel.getRelationType() + "_out_" + outRel.getEndNodeObjectType()
+					if (relDefMap.containsKey(key)) {
+						val value = relDefMap.get(key).get
+						if (!request.containsKey(value)) {
+							outRelations.add(outRel)
+						}
+					}
+				}
+			}
+		}
+		new util.HashMap[String, util.List[Relation]](){{
+			put("in", inRelations)
+			put("out",outRelations)
+		}}
+	}
+
 }
 

ontology-engine/graph-engine_2.11/src/test/scala/org/sunbird/graph/nodes/TestDataNode.scala

@@ -10,8 +10,7 @@ import org.sunbird.graph.BaseSpec
 import org.sunbird.graph.dac.model.Node
 import org.sunbird.graph.utils.ScalaJsonUtils
 
-import scala.collection.JavaConversions._
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.{Future}
 
 
 class TestDataNode extends BaseSpec {
@@ -150,16 +149,22 @@ class TestDataNode extends BaseSpec {
     }
 
     "update content with valid relation" should "update node with relation" in {
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_content_0000000001',IL_FUNC_OBJECT_TYPE:'Content',status:'Live'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_concept_0000000001',IL_FUNC_OBJECT_TYPE:'Concept',status:'Live'});")
         val request = new Request()
         request.setObjectType("Content")
         request.setContext(getContextMap())
-
         request.put("code", "test")
         request.put("name", "testResource")
         request.put("mimeType", "application/pdf")
         request.put("contentType", "Resource")
         request.put("description", "test")
         request.put("channel", "in.ekstep")
+        request.put("children", new util.ArrayList[util.Map[String, AnyRef]](){{
+            add(new util.HashMap[String, AnyRef](){{
+                put("identifier", "rel_content_0000000001")
+            }})
+        }})
         val future: Future[Node] = DataNode.create(request)
         future map {node => {assert(null != node)
             print(node)
@@ -169,7 +174,7 @@ class TestDataNode extends BaseSpec {
             req.put("name", "updated name")
             req.put("concepts", new util.ArrayList[util.Map[String, AnyRef]](){{
                 add(new util.HashMap[String, AnyRef](){{
-                    put("identifier", "Num:C3:SC2")
+                    put("identifier", "rel_concept_0000000001")
                 }})
             }})
             val updateFuture = DataNode.update(req)
@@ -178,7 +183,7 @@ class TestDataNode extends BaseSpec {
                 readRequest.put("identifier", node.getIdentifier)
                 DataNode.read(readRequest).map(node => {
                     assert(node.getMetadata.get("name").asInstanceOf[String].equalsIgnoreCase("updated name"))
-                    assert(node.getOutRelations.get(0).getEndNodeId().equalsIgnoreCase("Num:C3:SC2"))
+                    assert(node.getOutRelations.size() == 2)
                 })
             }) flatMap(f => f)
         }
@@ -396,4 +401,119 @@ class TestDataNode extends BaseSpec {
         }
         }
     }
+
+    "update content with valid relations having type assosiatedTo and hasSequenceMember" should "update node with relation" in {
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_concept_00000001',IL_FUNC_OBJECT_TYPE:'Concept',status:'Live'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_concept_00000002',IL_FUNC_OBJECT_TYPE:'Concept',status:'Live'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_itemset_00000001',IL_FUNC_OBJECT_TYPE:'ItemSet',status:'Live'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_collections_00000001',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', contentType:'TextBook'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_collections_00000002',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', contentType:'TextBook'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_collections_00000003',IL_FUNC_OBJECT_TYPE:'ContentImage',status:'Live', contentType:'TextBook'});")
+        val request = new Request()
+        request.setObjectType("Content")
+        request.setContext(getContextMap())
+        request.put("code", "test")
+        request.put("name", "testResource")
+        request.put("mimeType", "application/pdf")
+        request.put("contentType", "Resource")
+        request.put("description", "test")
+        request.put("channel", "in.ekstep")
+        request.put("concepts", new util.ArrayList[util.Map[String, AnyRef]](){{
+            add(new util.HashMap[String, AnyRef](){{
+                put("identifier", "rel_concept_00000001")
+            }})
+        }})
+        request.put("collections", new util.ArrayList[util.Map[String, AnyRef]](){{
+            add(new util.HashMap[String, AnyRef](){{
+                put("identifier", "rel_collections_00000001")
+            }})
+        }})
+        val future: Future[Node] = DataNode.create(request)
+        future map {node => {assert(null != node)
+            print(node)
+            assert(node.getMetadata.get("name").asInstanceOf[String].equalsIgnoreCase("testResource"))
+            val req = new Request(request)
+            req.getContext.put("identifier", node.getIdentifier)
+            req.put("name", "updated name")
+            req.put("concepts", new util.ArrayList[util.Map[String, AnyRef]](){{
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_concept_00000002")
+                }})
+            }})
+            req.put("itemSets", new util.ArrayList[util.Map[String, AnyRef]](){{
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_itemset_00000001")
+                }})
+            }})
+            req.put("collections", new util.ArrayList[util.Map[String, AnyRef]](){{
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_collections_00000002")
+                }})
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_collections_00000003")
+                }})
+            }})
+            val updateFuture = DataNode.update(req)
+            updateFuture.map(node => {
+                val readRequest = new Request(request)
+                readRequest.put("identifier", node.getIdentifier)
+                DataNode.read(readRequest).map(node => {
+                    assert(node.getMetadata.get("name").asInstanceOf[String].equalsIgnoreCase("updated name"))
+                    assert(node.getOutRelations.size() == 2)
+                    assert(node.getInRelations.size() == 2)
+                })
+            }) flatMap(f => f)
+        }
+        } flatMap(f => f)
+    }
+
+    "update content with valid relations having in direction" should "update node with relation" in {
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_collections_0000000101',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', contentType:'TextBook'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_collections_0000000102',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', contentType:'TextBook'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_usedbycontent_0000000101',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', IL_SYS_NODE_TYPE:'DATA_NODE', contentType:'TextBook'});")
+        executeNeo4jQuery("CREATE (n:domain{IL_UNIQUE_ID:'rel_usedbycontent_0000000102',IL_FUNC_OBJECT_TYPE:'Content',status:'Live', IL_SYS_NODE_TYPE:'DATA_NODE',contentType:'TextBook'});")
+        val request = new Request()
+        request.setObjectType("Content")
+        request.setContext(getContextMap())
+        request.put("code", "test")
+        request.put("name", "testResource")
+        request.put("mimeType", "application/pdf")
+        request.put("contentType", "Resource")
+        request.put("description", "test")
+        request.put("channel", "in.ekstep")
+        request.put("collections", new util.ArrayList[util.Map[String, AnyRef]](){{
+            add(new util.HashMap[String, AnyRef](){{
+                put("identifier", "rel_collections_0000000101")
+            }})
+            add(new util.HashMap[String, AnyRef](){{
+                put("identifier", "rel_collections_0000000102")
+            }})
+        }})
+        val future: Future[Node] = DataNode.create(request)
+        future map {node => {assert(null != node)
+            print(node)
+            assert(node.getMetadata.get("name").asInstanceOf[String].equalsIgnoreCase("testResource"))
+            val req = new Request(request)
+            req.getContext.put("identifier", node.getIdentifier)
+            req.put("name", "updated name")
+            req.put("usedByContent", new util.ArrayList[util.Map[String, AnyRef]](){{
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_usedbycontent_0000000101")
+                }})
+                add(new util.HashMap[String, AnyRef](){{
+                    put("identifier", "rel_usedbycontent_0000000102")
+                }})
+            }})
+            val updateFuture = DataNode.update(req)
+            updateFuture.map(node => {
+                val readRequest = new Request(request)
+                readRequest.put("identifier", node.getIdentifier)
+                DataNode.read(readRequest).map(node => {
+                    assert(node.getMetadata.get("name").asInstanceOf[String].equalsIgnoreCase("updated name"))
+                    assert(node.getInRelations.size() == 4)
+                })
+            }) flatMap(f => f)
+        }
+        } flatMap(f => f)
+    }
 }