1添加逐层展开的接口

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

@@ -54,9 +54,15 @@ public class MetaDataController {
     private MultiModelService multiModelService;
 
 
+
+    @Autowired
+    private IETLScriptService etlScriptService  ;
+
     @Autowired
     private ITableService tableService;
 
+    @Autowired
+    private IETLJobService etlJobService ;
 
     /**
      * 获取所有的节点
@@ -119,10 +125,14 @@ public class MetaDataController {
         Map<String,String> attributeMap = new HashMap<>();
         if(metadataId.startsWith("Table=")){
             attributeMap = tableService.getAttributeByTableId(metadataId);
-        } else {
+        } else if(metadataId.startsWith("ETLJob=")){
+            attributeMap = etlJobService.getAttributeByETLJobId(metadataId);
+        }else if(metadataId.startsWith("ETLScript=")) {
+            attributeMap = etlScriptService.getAttributeByETLScriptId(metadataId);
+        }else {
             attributeMap = metadataService.getMetaDataByMetadataId(metadataId);
         }
-       return  attributeMap;
+        return  attributeMap;
     }
 
 

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

@@ -6,10 +6,7 @@ import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import com.keymobile.metadata.metadataRelation.remote.DataAssertRemoteService;
 import com.keymobile.metadata.metadataRelation.remote.DataStandardRemoteService;
 import com.keymobile.metadata.metadataRelation.remote.TagRemoteService;
-import com.keymobile.metadata.metadataRelation.service.IMetadataService;
-import com.keymobile.metadata.metadataRelation.service.ISchemaService;
-import com.keymobile.metadata.metadataRelation.service.ISystemService;
-import com.keymobile.metadata.metadataRelation.service.ITableService;
+import com.keymobile.metadata.metadataRelation.service.*;
 import com.keymobile.metadata.metadataRelation.service.impl.SystemServiceImpl;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -33,7 +30,8 @@ public class RelationalGraphController {
 
     @Autowired
     private IMetadataService metadataService;
-
+    @Autowired
+    private IMetadataRelationService metadataRelationService;
     @Autowired
     private ISystemService systemService;
     @Autowired
@@ -41,6 +39,15 @@ public class RelationalGraphController {
 
     @Autowired
     private ITableService tableService;
+
+    @Autowired
+    private MultiModelService multiModelService;
+
+    @Autowired
+    private IETLScriptService etlScriptService  ;
+    @Autowired
+    private IETLJobService etlJobService ;
+
     @Autowired
     private DataStandardRemoteService dataStandardRemoteService;
 
@@ -49,11 +56,11 @@ public class RelationalGraphController {
 
     //测试标准的接口
     @ApiOperation(tags = "", value = "测试标准的接口")
-    @RequestMapping(path = "/dataAssertRemoteService", method = RequestMethod.GET)
-    public void dataAssertRemoteService(String metadataid){
+    @RequestMapping(path = "/testDataAssertRemoteService", method = RequestMethod.GET)
+    public void testDataAssertRemoteService(String metadataId){
         int size = 300;
         Map<String,Object> maps = new HashMap<>();
-        maps.put("metadataId",metadataid);
+        maps.put("metadataId",metadataId);
         Map<String, Object> standardMaps = dataStandardRemoteService.findStandardByMetadatId(1, 10,
                 maps);
         List<LinkedHashMap<String,Object>> contentList = (List<LinkedHashMap<String,Object>>) standardMaps.get("content");
@@ -65,8 +72,66 @@ public class RelationalGraphController {
             }
         }
     }
-    
-    
+
+    //查找孤立点
+    @ApiOperation(tags = "", value = "查找指定节点下的孤立点")
+    @RequestMapping(path = "/getNodeWithoutRelations", method = RequestMethod.GET)
+    public ReturnReslult getNodeWithoutRelations(String metadataId,String retlationType){
+       return  multiModelService.getNodeWithoutRelations(metadataId,retlationType);
+    }
+
+    @ApiOperation(tags = "", value = "表的重要性分析")
+    @RequestMapping(path = "/getImportantTable", method = RequestMethod.GET)
+    public ReturnReslult getImportantTable(String schemaId){
+        return  multiModelService.getImportantTable(schemaId);
+    }
+
+    /**
+     * 获取所有neo4j算法
+     * @return
+     */
+    @ApiOperation(tags = "", value = "获取所有neo4j算法")
+    @RequestMapping(path = "/getAllAlgorithm", method = RequestMethod.GET)
+    public Map<String,List<String>> getAllAlgorithm(){
+        Map<String,List<String>> allAlgorithmMap = new HashMap<>();
+
+        List<String> algorithm1 = new ArrayList<>();
+        algorithm1.add("页面排名算法(PageRank)");
+        algorithm1.add("文档排名算法(ArticleRank)");
+        algorithm1.add("中介中心性(Betweenness Centrality)");
+        algorithm1.add("紧密中心性(Closeness Centrality)");
+        algorithm1.add("谐波中心性(Harmonic Centrality)");
+        allAlgorithmMap.put("中心性算法（Centrality algorithms）",algorithm1);
+
+
+        List<String> algorithm2 = new ArrayList<>();
+        algorithm2.add("鲁汶算法(Louvain)");
+        algorithm2.add("标签传播算法(Label Propagation)");
+        algorithm2.add("连通组件算法(Connected Components)");
+        algorithm2.add("聚类系数(Clustering Coefficient)");
+        allAlgorithmMap.put("社区发现算法（Community detection algorithms）",algorithm2);
+
+        List<String> algorithm3 = new ArrayList<>();
+        algorithm3.add("最小权重生成树(Ｍinimum Weight Spanning Tree)");
+        algorithm3.add("最短路径(Shortest Path)");
+        algorithm3.add("单源最短路径(Single Source Shortesr Path)");
+        algorithm3.add("A星(Ａ＊)");
+        algorithm3.add("Yen k最短路径(Yen’s K-shortest paths)");
+        allAlgorithmMap.put("路径寻找算法（Path Finding algorithms）",algorithm3);
+
+        List<String> algorithm4 = new ArrayList<>();
+        algorithm4.add("Jaccard相似度(Jaccard Similarity)");
+        algorithm4.add("余弦相似度(Consine Similarity)");
+        algorithm4.add("Pearson相似度(Pearson Similarity)");
+        algorithm4.add("欧式距离(Euclidean Distance)");
+        algorithm4.add("重叠相似度(Overlap Similarity)");
+        allAlgorithmMap.put("相似度算法（Similarity algorithms）",algorithm4);
+
+
+        return allAlgorithmMap;
+    }
+
+
     //系统总图的接口
     @ApiOperation(tags = "", value = "按照环境参数返回系统总图")
     @RequestMapping(path = "/getAllSystemGraph", method = RequestMethod.GET)
@@ -75,6 +140,8 @@ public class RelationalGraphController {
         return metadataService.getSystemGraph(environment,size);
     }
 
+
+
 //    //系统总图的接口
 //    @ApiOperation(tags = "", value = "按照环境参数返回系统总图")
 //    @RequestMapping(path = "/getAllSystemGraphByEnvironment", method = RequestMethod.GET)
@@ -94,31 +161,65 @@ public class RelationalGraphController {
         int size = 300;
         return stringListMap;
     }
+
+    @ApiOperation(tags = "", value = "根据系统id，获取etljob的接口")
+    @RequestMapping(path = "/getEtlJobBySystem", method = RequestMethod.GET)
+    public Map<String,List<ReturnNode>> getEtlJobBySystem(String systemId){
+
+        return systemService.getEtlJobsBySystemId(systemId);
+
+    }
+
     //单个schema的数据，包括表，视图，函数，过程等，列表形势
-    @ApiOperation(tags = "", value = "传入schemaid，返回表，视图，函数，存储过程")
+    @ApiOperation(tags = "", value = "传入schemaId，返回表，视图，函数，存储过程")
     @RequestMapping(path = "/getTableBySchemaId", method = RequestMethod.GET)
     public Map<String, List<ReturnNode>> getTableBySchemaId(String schemaId){
         //传入一个系统名称/id，返回系统下的所有schema，注意分层
-
         Map<String, List<ReturnNode>> stringListMap = schemaService.getTablesBySchemaId(schemaId);
         int size = 300;
         return stringListMap;
     }
 
     //传入metadataId，详细属性
-    @ApiOperation(tags = "", value = "传入metadataId，详细属性")
+    @ApiOperation(tags = "", value = "传入metadataId，返回详细属性")
     @RequestMapping(path = "/getAttributeByMetadataId", method = RequestMethod.GET)
     public Map<String,String> getAttributeByMetadataId(String metadataId){
-        return  metadataService.getMetaDataByMetadataId(metadataId);
+        Map<String,String> attributeMap = new HashMap<>();
+        if(metadataId.startsWith("Table=")){
+            attributeMap = tableService.getAttributeByTableId(metadataId);
+        } else if(metadataId.startsWith("ETLJob=")){
+            attributeMap = etlJobService.getAttributeByETLJobId(metadataId);
+        }else if(metadataId.startsWith("ETLScript=")) {
+            attributeMap = etlScriptService.getAttributeByETLScriptId(metadataId);
+        }else {
+            attributeMap = metadataService.getMetaDataByMetadataId(metadataId);
+        }
+        return  attributeMap;
+
+//        return  metadataService.getMetaDataByMetadataId(metadataId);
+    }
+
+
+    //展开当前节点
+    @ApiOperation(tags = "", value = "传入一个节点id，返回改节点的子节点，比如表--字段")
+    @RequestMapping(path = "/getChildren", method = RequestMethod.GET)
+    public Map<String, List<ReturnNode>> getChildren(String metadataId,String size) {
+        logger.info("传入的元数据Id是："+metadataId);
+        Map<String ,List<ReturnNode>> returnNodeMap = new HashMap<>();
+        if(metadataId.startsWith("Table=")){
+            returnNodeMap =  tableService.getchildrenByTableId(metadataId);
+        }else if(metadataId.startsWith("ETLJob=")) {
+            returnNodeMap =  etlJobService.getchildrenByEtlJobId(metadataId);
+        }
+        return   returnNodeMap;
     }
 
     //展开当前节点
-    @ApiOperation(tags = "", value = "传入一个节点的元数据id，返回当前节点的关系")
+    @ApiOperation(tags = "", value = "传入一个节点的元数据id与方向，返回当前节点的关系")
     @RequestMapping(path = "/expandNode", method = RequestMethod.GET)
-    public ReturnReslult expandNode(String dataId,String size) {
+    public ReturnReslult expandNode(String dataId ,String direction) {
         logger.info("传入的元模型名称是："+dataId);
-        ReturnReslult returnReslult = new ReturnReslult();
-
+        ReturnReslult returnReslult = metadataRelationService.expandNodeByMetadataId(dataId,direction);
         return returnReslult;
     }
 

src/main/java/com/keymobile/metadata/metadataRelation/pojo/metadata/Neo4jETLJob.java

@@ -5,5 +5,13 @@ import org.neo4j.ogm.annotation.NodeEntity;
 
 @NodeEntity(label="Neo4jETLJob")
 public class Neo4jETLJob extends BaseNode {
+    public String getServerName() {
+        return serverName;
+    }
 
+    public void setServerName(String serverName) {
+        this.serverName = serverName;
+    }
+
+    private String serverName;
 }

src/main/java/com/keymobile/metadata/metadataRelation/remote/MetadataRepoRemoteService.java

@@ -2,11 +2,9 @@ package com.keymobile.metadata.metadataRelation.remote;
 
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.data.mongodb.core.mapping.Document;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.*;
 
+import java.util.List;
 import java.util.Map;
 
 @FeignClient(name = "MetadataRepo")
@@ -17,4 +15,7 @@ public interface MetadataRepoRemoteService {
     @RequestMapping(value = "/rest/metadata/get/{id}", method = RequestMethod.GET)
     Map<String, Object> getMetadata(@PathVariable("id") String id);
 
+    @RequestMapping(value = "/rest/metadata/getChild", method = RequestMethod.POST)
+    List<Map<String, Object>> getChild(
+            @RequestParam String parentId, @RequestBody(required = false) List<String> model);
 }

src/main/java/com/keymobile/metadata/metadataRelation/respository/metadata/Neo4jSystemRepository.java

 package com.keymobile.metadata.metadataRelation.respository.metadata;
 
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jETLJob;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSchema;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSystem;
 import org.springframework.data.neo4j.annotation.Query;
@@ -15,6 +16,10 @@ public interface Neo4jSystemRepository extends Neo4jRepository<Neo4jSystem, Long
 
     List<Neo4jSystem> findNeo4jSystemByName(String metadataName);
 //  @Query("MATCH p=(n:MetaData {metadataId:{parentId}})-[r:Composition]->(m) RETURN m limit {limit} ")
-    @Query("match (n:Neo4jSystem{metadataId:{systemId}} )-[r:Composition]->(m)   return m ")
+    @Query("match (n:Neo4jSystem{metadataId:{systemId}} )-[r:Composition]->(m:Neo4jSchema)   return m ")
     List<Neo4jSchema> getSchemaBySystemId(@Param("systemId") String systemId);
+
+
+    @Query("match (n:Neo4jSystem{metadataId:{systemId}} )-[r:Composition]->(m:Neo4jETLJob)   return m ")
+    List<Neo4jETLJob> getEtlJobBySystemId(@Param("systemId") String systemId);
 }

src/main/java/com/keymobile/metadata/metadataRelation/respository/metadata/Neo4jTableRepository.java

 package com.keymobile.metadata.metadataRelation.respository.metadata;
 
 import com.keymobile.metadata.metadataRelation.pojo.BaseNode;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jColumn;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jTable;
 import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import javax.persistence.Column;
 import java.util.List;
 
 @Repository
@@ -37,4 +39,8 @@ public interface Neo4jTableRepository extends Neo4jRepository<Neo4jTable,Long> {
 
     @Query("match (n{metadataId:{tableId}} ) <-[r:Composition]-(m)   return m ")
     List<BaseNode> getSchema(@Param("tableId") String tableId);
+
+    @Query("match (n{metadataId:{tableId}} ) -[r:Composition]->(m:Neo4jColumn)   return m ")
+    List<Neo4jColumn> getColumnByTableId(@Param("tableId") String tableId);
+
 }

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

+package com.keymobile.metadata.metadataRelation.service;
+
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
+
+import java.util.List;
+import java.util.Map;
+
+public interface IETLJobService {
+
+    Map<String, List<ReturnNode>> getEtlJobByCatalogName(String catalogName);
+
+    Map<String ,String> getAttributeByETLJobId(String etlJobId);
+    Map<String, List<ReturnNode>>  getchildrenByEtlJobId(String etlJobId);
+}

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

+package com.keymobile.metadata.metadataRelation.service;
+
+import java.util.Map;
+
+public interface IETLScriptService {
+
+    Map<String ,String> getAttributeByETLScriptId(String tableId);
+}

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

+package com.keymobile.metadata.metadataRelation.service;
+
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
+
+public interface IMetadataRelationService {
+
+    ReturnReslult expandNodeByMetadataId(String metadataId,String direction);
+}

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

@@ -98,9 +98,13 @@ public interface IMetadataService {
 
     ReturnReslult searchGraphBySystem(String metadataId, int layerLong);
 
+
+
     void syschroMetadataFromMongo(String catalogName,List<MongoData> mongoDataList);
     //同步mongo中表与表，表与作业的关系
     void syschroTable2EtlJobRelations(String catalogName);
 
     void deleteNodeByCatalogName(String catalogName);
+
+
 }

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

@@ -11,5 +11,7 @@ public interface ISystemService {
 
     Map<String ,List<ReturnNode>> getSchemaBySystemId(String systemId);
 
+    Map<String ,List<ReturnNode>> getEtlJobsBySystemId(String systemId);
+
     ReturnReslult getAllSystem();
 }

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

@@ -16,4 +16,6 @@ public interface ITableService {
 
     Map<String ,String> getAttributeByTableId(String tableId);
 
+    Map<String ,List<ReturnNode>> getchildrenByTableId(String tableId);
+
 }

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

@@ -3,8 +3,14 @@ package com.keymobile.metadata.metadataRelation.service;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 
 import java.util.List;
+import java.util.Map;
 
 public interface MultiModelService {
 
     ReturnReslult findResultByModelNameList(List<String> modelNameList, int count );
+
+    List<Map<String,String>> getAllAlgorithm();
+
+    ReturnReslult getNodeWithoutRelations(String metadataId,String relationType);
+    ReturnReslult  getImportantTable(String schemaId);
 }

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

+package com.keymobile.metadata.metadataRelation.service.impl;
+
+import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jTable;
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
+import com.keymobile.metadata.metadataRelation.remote.MetadataRepoRemoteService;
+import com.keymobile.metadata.metadataRelation.service.IETLJobService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class ETLJobServiceImpl implements IETLJobService {
+
+    @Autowired
+    private MetadataRepoRemoteService metadataRepoRemoteService;
+
+
+    @Override
+    public Map<String, List<ReturnNode>> getEtlJobByCatalogName(String catalogName) {
+        return null;
+    }
+
+    @Override
+    public Map<String, String> getAttributeByETLJobId(String tableId) {
+        Map<String,String> attributeMap =  getAttributeMap(tableId);
+        return attributeMap;
+    }
+
+    @Override
+    public Map<String, List<ReturnNode>> getchildrenByEtlJobId(String etlJobId) {
+
+//        List<Neo4jColumn> neo4jColumns = neo4jTableRepository.getColumnByTableId(tableId);
+        List<Map<String, Object>> columnRemoteList = metadataRepoRemoteService.getChild(etlJobId, Arrays.asList("Catalog,Server,ETLJob,ETLScript"));
+
+        Map<String, List<ReturnNode>> columnMap = new HashMap<>();
+        List<ReturnNode> returnColumnList = new ArrayList<>();
+        for(Map<String, Object> columnRemote:columnRemoteList ){
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(""+columnRemote.get("_id"));
+            Map<String,String> attributeMap = new HashMap<>();
+            attributeMap.put("源码",""+columnRemote.get("source_code"));
+            attributeMap.put("维护人",""+columnRemote.get("maintainer"));
+
+            returnNode.setName(columnRemote.get("name")+"");
+            returnNode.setType("ETLScript");
+            returnNode.setAttributeMaps(attributeMap);
+            returnColumnList.add(returnNode);
+        }
+        columnMap.put("ETLScript",returnColumnList);
+        return columnMap;
+    }
+
+    private Map<String,String> getAttributeMap(String EtlJobId){
+        Map<String,String> returnMap = new LinkedHashMap<>();
+        Map<String, Object> attriuteMap = metadataRepoRemoteService.getMetadata(EtlJobId);
+        if (attriuteMap == null) {
+            return returnMap;
+        }
+
+//        英文名称，中文名称，说明，作业描述,作业队列,作业组ID，作业组内序号，作业命令，作业调度日期，作业调度时间，创建时间，修改时间，作业优先级
+        returnMap.put("英文名称",(String) attriuteMap.get("name"));
+        returnMap.put("中文名称",(String) attriuteMap.get("cnName"));
+        returnMap.put("说明",(String) attriuteMap.get("comment"));
+        returnMap.put("作业描述",(String) attriuteMap.get("jobDesc"));
+        returnMap.put("作业队列",(String) attriuteMap.get("jobQueue"));
+        returnMap.put("作业调度日历",(String) attriuteMap.get("jobCalendarType"));
+        returnMap.put("作业调度周期",(String) attriuteMap.get("jobSchedulePeriod"));
+        returnMap.put("作业命令",(String) attriuteMap.get("jobCommand"));
+        returnMap.put("作业优先级",""+ attriuteMap.get("jobPriority"));
+        returnMap.put("作业调度日期",(String) attriuteMap.get("jobScheduleDate"));
+        returnMap.put("作业调度时间",(String) attriuteMap.get("jobScheduleTime"));
+        //所属系统
+        return returnMap;
+    }
+
+}

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

+package com.keymobile.metadata.metadataRelation.service.impl;
+
+import com.keymobile.metadata.metadataRelation.remote.MetadataRepoRemoteService;
+import com.keymobile.metadata.metadataRelation.service.IETLScriptService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@Service
+public class ETLScriptServiceImpl implements IETLScriptService {
+
+
+    @Autowired
+    private MetadataRepoRemoteService metadataRepoRemoteService;
+
+
+    @Override
+    public Map<String, String> getAttributeByETLScriptId(String tableId) {
+        Map<String,String> attributeMap =  getAttributeMap(tableId);
+        return attributeMap;
+    }
+    private Map<String,String> getAttributeMap(String EtlJobId){
+        Map<String,String> returnMap = new LinkedHashMap<>();
+        Map<String, Object> attriuteMap = metadataRepoRemoteService.getMetadata(EtlJobId);
+        if (attriuteMap == null) {
+            return returnMap;
+        }
+
+//        英文名称，中文名称，说明，作业描述,作业队列,作业组ID，作业组内序号，作业命令，作业调度日期，作业调度时间，创建时间，修改时间，作业优先级
+        returnMap.put("英文名称",(String) attriuteMap.get("name"));
+        returnMap.put("中文名称",(String) attriuteMap.get("cnName"));
+        returnMap.put("说明",(String) attriuteMap.get("comment"));
+
+
+        returnMap.put("源码",(String) attriuteMap.get("source_code"));
+        returnMap.put("维护人",(String) attriuteMap.get("maintainer"));
+        returnMap.put("SQL",(String) attriuteMap.get("SQL"));
+        returnMap.put("路径",(String) attriuteMap.get("path"));
+        //所属系统
+        return returnMap;
+    }
+}

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

+package com.keymobile.metadata.metadataRelation.service.impl;
+
+import com.keymobile.metadata.metadataRelation.config.Neo4jConfig;
+import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnEdge;
+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 org.neo4j.driver.v1.*;
+import org.neo4j.driver.v1.types.Node;
+import org.neo4j.driver.v1.types.Path;
+import org.neo4j.driver.v1.types.Relationship;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class MetadataRelationServiceImpl implements IMetadataRelationService {
+
+
+    private static final Logger logger = LoggerFactory.getLogger(MetadataRelationServiceImpl.class);
+
+    @Override
+    public ReturnReslult expandNodeByMetadataId(String metadataId, String direction){
+        //方向有，forward，backword，all
+        logger.info("开始展开节点，元数据id："+metadataId);
+        long start = System.currentTimeMillis();
+        String directionNeo4j = "";
+        if(direction.equals("forward")){
+            directionNeo4j = "-[r:流向]->";
+        }else if(direction.equals("backward")){
+            directionNeo4j = "<-[r:流向]-";
+        }else if(direction.equals("all")){
+            directionNeo4j = "<-[r:流向]->";
+        }
+        ReturnReslult returnReslult = new ReturnReslult();
+        //区分是表，还是job、script、sql，再调用相应的展开接口
+        String cypher = "";
+        if(metadataId.startsWith("Table=")){
+            cypher = " match p=(n:Neo4jTable {metadataId:\""+metadataId+"\"})"+directionNeo4j+"(m) return p  ";
+        }else if(metadataId.startsWith("ETLJob=")){
+            cypher = " match p=(n:Neo4jETLJob {metadataId:\""+metadataId+"\"})"+directionNeo4j+"(m) return p " +
+                    "union  match p=(n:Neo4jETLJob {metadataId:\""+metadataId+"\"}) -[r:Composition]->(m) return p ";
+        }else if(metadataId.startsWith("ETLScript=")){
+            cypher = " match p=(n:Neo4jETLScript {metadataId:\""+metadataId+"\"})"+directionNeo4j+"(m) return p " +
+                    "union  match p=(n:Neo4jETLScript {metadataId:\""+metadataId+"\"}) <-[r:Composition]->(m) return p ";
+        }else if(metadataId.startsWith("SQL=")){
+            cypher="match p=(n:Neo4jETLSql {metadataId:\""+metadataId+"\"}) <-[r:Composition]->(m) return p";
+        }else {
+
+        }
+        Map<Long, MetaData> longMetaDataMap = new HashMap<>();
+        Map<String, ReturnEdge> edgeMap = new HashMap<>();
+        Neo4jConfig neo4jConfig = new Neo4jConfig();
+        Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
+        Session session = neo4jConnection.session();
+        StatementResult result = session.run(cypher);
+        while(result.hasNext()){
+            Record record = result.next();
+            List<Value> values = record.values();
+            for (Value value : values) {
+                if(value.type().name().equals("PATH")){
+                    Path path = value.asPath();
+                    Iterable<Node> nodes = path.nodes();
+                    for(Node node:nodes){
+                        Map<String, Object> stringObjectMap = node.asMap();
+                        MetaData metaData = new MetaData();
+                        Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                        longMetaDataMap.put(node.id(),metaData);
+                    }
+                    Iterable<Relationship> relationships = path.relationships();
+                    for(Relationship relationship:relationships){
+                        long startLong = relationship.startNodeId();
+                        long endLong = relationship.endNodeId();
+                        String relationType  =  relationship.type();
+                        String relationName = ""+relationship.get("name");
+                        if(longMetaDataMap.containsKey(startLong )&& longMetaDataMap.containsKey(endLong)){
+                            ReturnEdge edge = new ReturnEdge();
+                            String edgeId = startLong+"_"+endLong;
+                            if(edgeMap.containsKey(edgeId)){
+                                continue;
+                            }
+                            edge.setEdgeId(edgeId);
+                            edgeMap.put(edgeId,edge);
+                            edge.setFromId(longMetaDataMap.get(startLong).getMetadataId());
+                            edge.setToId(longMetaDataMap.get(endLong).getMetadataId());
+                            edge.setType(relationType);
+                        }
+                    }
+                }
+            }
+        }
+        for(Object obj : longMetaDataMap.keySet()){
+            MetaData metaData = longMetaDataMap.get(obj);
+
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(metaData.getMetadataId());
+            returnNode.setName(metaData.getName());
+            returnReslult.getNodes().add(returnNode);
+        }
+
+        for(Object obj : edgeMap.keySet()){
+            ReturnEdge edge = edgeMap.get(obj);
+            returnReslult.getEdges().add(edge);
+        }
+
+        return returnReslult;
+    }
+
+}

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

@@ -74,7 +74,7 @@ public class MongoDbServiceImpl {
      * @return
      */
     public List<MongoData> findDataByparentId(String parentId,String catalogName) {
-        logger.info("开始从mongo获取元数据："+ parentId);
+//        logger.info("开始从mongo获取元数据："+ parentId);
         try {
             Query query = new Query();
             query.addCriteria(Criteria.where("parentId").is(parentId));

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

 package com.keymobile.metadata.metadataRelation.service.impl;
 
+import com.keymobile.metadata.metadataRelation.config.Neo4jConfig;
 import com.keymobile.metadata.metadataRelation.pojo.*;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jTable;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnEdge;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.MetaModel;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import com.keymobile.metadata.metadataRelation.respository.*;
 import com.keymobile.metadata.metadataRelation.service.MultiModelService;
+import com.keymobile.metadata.metadataRelation.util.Neo4jTool;
+import org.neo4j.driver.v1.*;
+import org.neo4j.driver.v1.types.Node;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -18,10 +23,8 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+
 @Service
 public class MultiModelServiceImpl implements MultiModelService {
 
@@ -313,6 +316,142 @@ public class MultiModelServiceImpl implements MultiModelService {
         return returnReslult;
     }
 
+    @Override
+    public List<Map<String, String>> getAllAlgorithm() {
+        List<Map<String, String>> returnResult = new ArrayList<>() ;
+        Neo4jConfig neo4jConfig = new Neo4jConfig();
+        Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
+        Session session = neo4jConnection.session();
+        String cypher = " call algo.list() ";
+        StatementResult result = session.run(cypher);
+
+        while (result.hasNext()) {
+            Record record = result.next();
+            Map<String, Object> objectMap = record.asMap();
+            for(Object obj : objectMap.keySet()){
+                if(obj.equals("name")){
+
+                    System.out.println("obj :"+ obj + " value :"+ objectMap.get("name"));
+                }
+            }
+        }
+        return returnResult;
+    }
+
+    @Override
+    public ReturnReslult getImportantTable(String schemaId) {
+        ReturnReslult returnReslult = new ReturnReslult();
+        Neo4jConfig neo4jConfig = new Neo4jConfig();
+        Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
+        Session session = neo4jConnection.session();
+        String cypher = "MATCH (p:Neo4jTable)<-[:流向]->(c) \n" +
+                "WITH p,count(c) as rels\n" +
+                "RETURN p, rels order by rels desc";
+        StatementResult result = session.run(cypher);
+
+        Map<String, MetaModel> metaModelMap = new HashMap<>();
+
+        while (result.hasNext()) {
+            Record record = result.next();
+            List<Value> values = record.values();
+            for (Value value : values) {
+                if (value.type().name().equals("NODE")) {
+                    Node node = value.asNode();
+
+                    Map<String, Object> stringObjectMap = node.asMap();
+                    Neo4jTable neo4jTable = new Neo4jTable();
+                    Neo4jTool.transMap2Bean(stringObjectMap, neo4jTable);
+                    if(neo4jTable.getMetadataId() == null ){
+                        neo4jTable.setMetadataId("System="+neo4jTable.getName());
+                    }
+
+                    ReturnNode returnNode = new ReturnNode();
+                    returnNode.setId(neo4jTable.getMetadataId());
+                    returnNode.setName(neo4jTable.getName());
+
+                    String[] strings = neo4jTable.getMetadataId().split("=");
+                    String modelName = strings[0];
+
+                    returnNode.setIcon(modelName);
+                    if (!metaModelMap.containsKey(modelName)) {
+                        MetaModel model = new MetaModel();
+                        String iconContext = getIconByModelId(modelName);
+                        model.setModelName(modelName);
+                        model.setCnName(modelName);
+                        model.setDescription("");
+                        model.setIcon(iconContext);
+                        metaModelMap.put(modelName, model);
+                    }
+                    returnNode.setType(modelName);
+
+                    returnReslult.getNodes().add(returnNode);
+                }
+            }
+
+
+        }
+
+        return returnReslult;
+    }
+
+    @Override
+    public ReturnReslult getNodeWithoutRelations(String metadataId, String relationType) {
+        ReturnReslult returnReslult = new ReturnReslult();
+
+        Map<String, MetaModel> metaModelMap = new HashMap<>();
+
+        Neo4jConfig neo4jConfig = new Neo4jConfig();
+        Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
+        Session session = neo4jConnection.session();
+        String cypher = " MATCH (a:Neo4jTable)<-- (m:Neo4jSchema{metadataId:\""+metadataId+"\"}) WHERE  not ((a)-[:"+relationType+"]->()) RETURN a limit 20;";
+        StatementResult result = session.run(cypher);
+
+        while (result.hasNext()) {
+            Record record = result.next();
+            List<Value> values = record.values();
+            for (Value value : values) {
+
+                if (value.type().name().equals("NODE")) {
+                    Node node = value.asNode();
+
+                    Map<String, Object> stringObjectMap = node.asMap();
+                    Neo4jTable neo4jTable = new Neo4jTable();
+                    Neo4jTool.transMap2Bean(stringObjectMap, neo4jTable);
+                    if(neo4jTable.getMetadataId() == null ){
+                        neo4jTable.setMetadataId("System="+neo4jTable.getName());
+                    }
+
+
+                    ReturnNode returnNode = new ReturnNode();
+                    returnNode.setId(neo4jTable.getMetadataId());
+                    returnNode.setName(neo4jTable.getName());
+
+                    String[] strings = neo4jTable.getMetadataId().split("=");
+                    String modelName = strings[0];
+
+                    returnNode.setIcon(modelName);
+                    if (!metaModelMap.containsKey(modelName)) {
+                        MetaModel model = new MetaModel();
+                        String iconContext = getIconByModelId(modelName);
+                        model.setModelName(modelName);
+                        model.setCnName(modelName);
+                        model.setDescription("");
+                        model.setIcon(iconContext);
+                        metaModelMap.put(modelName, model);
+                    }
+                    returnNode.setType(modelName);
+                    returnReslult.getNodes().add(returnNode);
+
+                }
+            }
+        }
+
+        return returnReslult;
+    }
+
+
+
+
 //    private void ss{
 //        ReturnReslult returnReslult = new ReturnReslult();
 //        String metadataId = "Table=368=19155ece609c4b4ca3cf8d23f9349b64";

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

@@ -33,7 +33,7 @@ public class SchemaServiceImpl implements ISchemaService {
 
         Map<String ,List<ReturnNode>> schemaMap = new HashMap<>();
 
-        List<BaseNode> baseNodeList = neo4jSchemaRepository.getTableBySchemaId(schemaId);
+        List<BaseNode> baseNodeList = neo4jSchemaRepository.getChildrenBySchemaId(schemaId);
 
         for(BaseNode baseNode:baseNodeList){
 

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

 package com.keymobile.metadata.metadataRelation.service.impl;
 
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jETLJob;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSchema;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSystem;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
@@ -119,6 +120,25 @@ public class SystemServiceImpl implements ISystemService {
     }
 
     @Override
+    public Map<String, List<ReturnNode>> getEtlJobsBySystemId(String systemId) {
+        Map<String ,List<ReturnNode>> etlJobList = new LinkedHashMap<>();
+
+        List<Neo4jETLJob> etlJobs =  neo4jSystemRepository.getEtlJobBySystemId(systemId);
+        List<ReturnNode> returnNodeList = new ArrayList<>();
+
+        for(Neo4jETLJob neo4jETLJob:etlJobs){
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(neo4jETLJob.getMetadataId());
+            returnNode.setName(neo4jETLJob.getName());
+            returnNode.setType("ETLJob");
+
+            returnNodeList.add(returnNode);
+        }
+        etlJobList.put("ETLJOB",returnNodeList);
+        return etlJobList;
+    }
+
+    @Override
     public ReturnReslult getAllSystem() {
         Iterable<Neo4jSystem> neo4jSystems = neo4jSystemRepository.findAll();
         for(Neo4jSystem neo4jSystem:neo4jSystems){

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

@@ -3,6 +3,7 @@ package com.keymobile.metadata.metadataRelation.service.impl;
 import com.keymobile.metadata.metadataRelation.config.Neo4jConfig;
 import com.keymobile.metadata.metadataRelation.pojo.BaseNode;
 import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jColumn;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSchema;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSystem;
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jTable;
@@ -38,6 +39,8 @@ public class TableServiceImpl implements ITableService {
     @Autowired
     private DataAssertRemoteService dataAssertRemoteService;
 
+    @Autowired
+    private   MetadataRepoRemoteService metadataRepoRemoteService;
     @Override
     public Map<String, List<ReturnNode>> getRelationObjectByTableId(String tableId) {
         //传入表id，查找与该表相关的“模型，资产，标准，质量，作业”，
@@ -235,6 +238,31 @@ public class TableServiceImpl implements ITableService {
         return attributeMap;
     }
 
+    @Override
+    public Map<String, List<ReturnNode>> getchildrenByTableId(String tableId) {
+
+//        List<Neo4jColumn> neo4jColumns = neo4jTableRepository.getColumnByTableId(tableId);
+        List<Map<String, Object>> columnRemoteList = metadataRepoRemoteService.getChild(tableId, Arrays.asList("Catalog,Database,Schema,Table,Column"));
+
+        Map<String, List<ReturnNode>> columnMap = new HashMap<>();
+        List<ReturnNode> returnColumnList = new ArrayList<>();
+        for(Map<String, Object> columnRemote:columnRemoteList ){
+            ReturnNode returnNode = new ReturnNode();
+            returnNode.setId(""+columnRemote.get("_id"));
+            Map<String,String> attributeMap = new HashMap<>();
+            attributeMap.put("类型",""+columnRemote.get("typeName"));
+            attributeMap.put("长度",""+columnRemote.get("size"));
+            attributeMap.put("主键",""+columnRemote.get("isPrimaryKey"));
+
+            returnNode.setName(columnRemote.get("name")+"");
+            returnNode.setType("Column");
+            returnNode.setAttributeMaps(attributeMap);
+            returnColumnList.add(returnNode);
+        }
+        columnMap.put("Column",returnColumnList);
+        return columnMap;
+    }
+
 
     @Override
     public Map<String, List<ReturnNode>> getSourceAndTargetTableByTableId(String tableId) {