添加筛选节点的接口

src/main/java/com/keymobile/metadata/metadataRelation/controller/RelationalGraphController.java

@@ -223,6 +223,14 @@ public class RelationalGraphController {
         return returnReslult;
     }
 
+    @ApiOperation(tags = "", value = "传入前端的json，过滤的模型，保留的模型，返回在json中过滤后的节点与关系")
+    @RequestMapping(path = "/filterNode", method = RequestMethod.GET)
+    public ReturnReslult filterNode(String resultJson,String filterModel,String retainModel) {
+        logger.info("需要过滤的模型是："+filterModel+"，需要保留的模型是："+retainModel);
+
+        ReturnReslult returnReslult = metadataRelationService.filterJosnByModelName(resultJson,filterModel,retainModel);
+        return returnReslult;
+    }
 
     //表的分析，链路分析，表与其他表的上下游关系，其他表可以继续下钻，并且可以收缩。
     @ApiOperation(tags = "", value = "传入表的id，返回表的上下游一层关系。")

src/main/java/com/keymobile/metadata/metadataRelation/service/IMetadataRelationService.java

@@ -5,4 +5,7 @@ import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 public interface IMetadataRelationService {
 
     ReturnReslult expandNodeByMetadataId(String metadataId,String direction);
+
+    ReturnReslult filterJosnByModelName(String reulstJson,String filterModel,String retainModel);
+
 }

src/main/java/com/keymobile/metadata/metadataRelation/service/impl/MetadataRelationServiceImpl.java

@@ -8,6 +8,9 @@ import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import com.keymobile.metadata.metadataRelation.service.IMetadataRelationService;
 import com.keymobile.metadata.metadataRelation.util.Neo4jTool;
+import net.sf.json.JSON;
+import net.sf.json.JSONArray;
+import net.sf.json.JSONObject;
 import org.neo4j.driver.v1.*;
 import org.neo4j.driver.v1.types.Node;
 import org.neo4j.driver.v1.types.Path;
@@ -16,6 +19,8 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
+import java.awt.image.renderable.RenderableImageOp;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -97,7 +102,6 @@ public class MetadataRelationServiceImpl implements IMetadataRelationService {
                         returnReslult.getNodes().add(returnNode);
                         nodesMap.put(node.id(), metaData);
 
-
                         ReturnEdge edge = new ReturnEdge();
                         String edgeId = metadataId+"_"+metaData.getMetadataId();
                         if(edgeMap.containsKey(edgeId)){
@@ -113,11 +117,8 @@ public class MetadataRelationServiceImpl implements IMetadataRelationService {
                             edge.setFromId(metaData.getMetadataId());
                             edge.setToId(metadataId );
                         }
-
                         edge.setType("流向");
                     }
-
-
                 }
 
                 if(value.type().name().equals("PATH")){
@@ -168,4 +169,131 @@ public class MetadataRelationServiceImpl implements IMetadataRelationService {
         return returnReslult;
     }
 
+    @Override
+    public ReturnReslult filterJosnByModelName(String reulstJson, String filterModel,String retainModel) {
+        ReturnReslult newReslult = new ReturnReslult();
+
+        ReturnReslult oldResult = convertorToReturnResult(reulstJson);
+        List<ReturnNode> oldNodeList = oldResult.getNodes();
+        List<ReturnEdge> oldEdgeList = oldResult.getEdges();
+
+        List<String> filterNodeIdList = new ArrayList<>();
+        List<String> remianNodeIdList = new ArrayList<>();
+
+        Map<String,List<String>> source2Target = new HashMap<>();
+        Map<String,List<String>> target2Source = new HashMap<>();
+
+        for(ReturnNode oldNode:oldNodeList){
+            String metadataId = oldNode.getId();
+            if(metadataId.startsWith(retainModel)){
+                //需要保留的，先存起来
+                remianNodeIdList .add(metadataId);
+                newReslult.getNodes().add(oldNode);
+            }
+            else if(metadataId.startsWith(filterModel)){
+                filterNodeIdList.add(metadataId);
+                //需要过滤的，注意两边的关系要连起来
+            }
+        }
+
+        for(ReturnEdge oldEdge:oldEdgeList){
+            String formId = oldEdge.getFromId();
+            String toId = oldEdge.getToId();
+            if(source2Target.containsKey(formId)){
+                source2Target.get(formId).add(toId);
+            }else {
+                List<String > toIdList = new ArrayList<>();
+                toIdList.add(toId);
+                source2Target.put(formId,toIdList);
+            }
+
+            if(target2Source.containsKey(toId)){
+                target2Source.get(toId).add(formId);
+            }else {
+                List<String> fromIdList = new ArrayList<>();
+                fromIdList.add(formId);
+                target2Source.put(toId,fromIdList);
+            }
+        }
+
+        //如果是要过滤的，过滤节点后，要把两端的关系接上
+        Map<String ,ReturnEdge> newEdgeMap = new HashMap<>();
+        for(String filterNodeId :filterNodeIdList){
+            if(source2Target.containsKey(filterNodeId)
+            && target2Source.containsKey(filterNodeId)){
+
+                List<String> toIdList = source2Target.get(filterNodeId);
+                List<String> fromIdList = target2Source.get(filterNodeId);
+
+                for(String fromId :fromIdList){
+                    for(String toId : toIdList){
+                        ReturnEdge newEdge = new ReturnEdge();
+                        newEdge.setEdgeId(fromId+"_"+toId);
+                        newEdge.setFromId(fromId);
+                        newEdge.setToId(toId);
+                        newEdge.setType("流向");
+
+                        newEdgeMap.put(newEdge.getEdgeId(),newEdge);
+                    }
+                }
+            }
+        }
+        for(Object obj : newEdgeMap.keySet()){
+            ReturnEdge newEdge = newEdgeMap.get(obj);
+            newReslult.getEdges().add(newEdge);
+        }
+        return newReslult;
+    }
+
+
+    private ReturnReslult convertorToReturnResult(String reulstJson){
+        ReturnReslult returnReslult = new ReturnReslult();
+        Map<String,List<JSONObject>> nodeMap = JSONObject.fromObject(reulstJson);
+
+        String currentNodeId = "";
+        List<JSONObject> currentObjectList = nodeMap.get("当前表");
+        if(currentObjectList!=null){
+            for(JSONObject currentObject:currentObjectList){
+                currentNodeId = (String) currentObject.get("id");
+                ReturnNode returnNode = new ReturnNode();
+                returnNode.setId(currentNodeId);
+                returnNode.setName((String) currentObject.get("name"));
+                returnReslult.getNodes().add(returnNode);
+            }
+        }
+
+        List<JSONObject> sourceObjectList = nodeMap.get("来源");
+        for(JSONObject sourceNode:sourceObjectList){
+            ReturnEdge edge = new ReturnEdge();
+            String sourceId = (String) sourceNode.get("id");
+            edge.setFromId(sourceId);
+            edge.setToId(currentNodeId);
+            edge.setEdgeId(sourceId+"_"+currentNodeId);
+            returnReslult.getEdges().add(edge);
+
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(sourceId);
+            returnNode.setName((String) sourceNode.get("name"));
+            returnReslult.getNodes().add(returnNode);
+
+        }
+
+        List<JSONObject> targetObjectList = nodeMap.get("目标");
+        for(JSONObject targetObject:targetObjectList){
+            ReturnEdge edge = new ReturnEdge();
+            String targetId = (String) targetObject.get("id");
+            edge.setFromId(currentNodeId);
+            edge.setToId(targetId );
+            edge.setEdgeId(currentNodeId+"_"+targetId );
+            returnReslult.getEdges().add(edge);
+
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(targetId);
+            returnNode.setName((String) targetObject.get("name"));
+            returnReslult.getNodes().add(returnNode);
+
+        }
+
+        return returnReslult;
+    }
 }