新增接口：1表的属性，2表的上下有关系，3表与模型、标准、质量、资产、作业等的关系

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

@@ -6,9 +6,11 @@ import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 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.impl.SystemServiceImpl;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import org.hibernate.loader.custom.Return;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -23,7 +25,6 @@ import java.util.Map;
 @Api(value = "关系图谱的接口", tags = "relational graph controller")
 public class RelationalGraphController {
 
-
     private static final Logger logger = LoggerFactory.getLogger(RelationalGraphController.class);
 
     @Autowired
@@ -34,6 +35,9 @@ public class RelationalGraphController {
     @Autowired
     private ISchemaService schemaService;
 
+    @Autowired
+    private ITableService tableService;
+
     //系统总图的接口
     @ApiOperation(tags = "", value = "系统总图")
     @RequestMapping(path = "/getAllSystemGraph", method = RequestMethod.GET)
@@ -42,7 +46,7 @@ public class RelationalGraphController {
         return metadataService.getSystemGraph(size);
 
     }
-
+    //schema的分层，图的形式，由里到外，同上面的分层接口
     //系统总图下钻获取schema，schema要分层
     @ApiOperation(tags = "", value = "按照系统获取schema，要分层")
     @RequestMapping(path = "/getSchemaBySystemId", method = RequestMethod.GET)
@@ -64,13 +68,32 @@ public class RelationalGraphController {
         return stringListMap;
     }
 
+    //传入metadataId，详细属性
+    @ApiOperation(tags = "", value = "传入metadataId，详细属性")
+    @RequestMapping(path = "/getAttributeByMetadataId", method = RequestMethod.GET)
+    public Map<String,String> getAttributeByMetadataId(String metadataId){
+        return  metadataService.getMetaDataByMetadataId(metadataId);
+    }
 
-    //关系的分层，图的形势，由里到外
-    //表的分析，关系分析--表与模型，表与质量，表与标准，表与作业的关系
-    //表的分析，链路分析，表与其他表的关系，其他表可以下钻，并且可以收缩。
 
+
+
+    //表的分析，链路分析，表与其他表的上下游关系，其他表可以继续下钻，并且可以收缩。
+    @ApiOperation(tags = "", value = "传入表的id，返回表的上下游一层关系。")
+    @RequestMapping(path = "/getRelationTablesTableId", method = RequestMethod.GET)
+    public Map<String,List<ReturnNode>> getRelationTablesTableId(String tableId){
+        return tableService.getSourceAndTargetTableByTableId (tableId);
+    }
+
+    //表的分析，关系分析--表与模型，表与质量，表与标准，表与作业的关系
+//表的分析，链路分析，表与其他表的上下游关系，其他表可以继续下钻，并且可以收缩。
+    @ApiOperation(tags = "", value = "传入表的id，返回与表相关的模型，标准，质量，资产，作业等对象")
+    @RequestMapping(path = "/getRelationObjectByTableId", method = RequestMethod.GET)
+    public Map<String,List<ReturnNode>> getRelationObjectByTableId(String tableId){
+        return tableService.getRelationObjectByTableId (tableId);
+    }
     //搜索接口，多个搜索结果，则先弹出列表（对象的全路径），再进行选择哪个对象
 
-    //同步数据，从mongo到neo4j，从“环境，系统，schema，表”的结构
+    //同步数据，从mongo到neo4j，从“环境，系统，schema，表”的结构---完成
 
 }

src/main/java/com/keymobile/metadata/metadataRelation/pojo/returnBean/ReturnNode.java

 package com.keymobile.metadata.metadataRelation.pojo.returnBean;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class ReturnNode {
 
     private String name;
     private String id;
 
+    private String icon;
+
+    private String type;
+
+    private String cnName;
+
+    public Map<String, String> getAttributeMaps() {
+        return attributeMaps;
+    }
+
+    public void setAttributeMaps(Map<String, String> attributeMaps) {
+        this.attributeMaps = attributeMaps;
+    }
+
+    Map<String ,String> attributeMaps  = new HashMap<>();
+
+    public String getCnName() {
+        return cnName;
+    }
+
+    public void setCnName(String cnName) {
+        this.cnName = cnName;
+    }
+
+
     public String getIcon() {
         return icon;
     }
@@ -13,9 +41,6 @@ public class ReturnNode {
         this.icon = icon;
     }
 
-    private String icon;
-
-    private String type;
 
     public String getType() {
         return type;

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.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 java.util.List;
@@ -9,4 +12,11 @@ import java.util.List;
 @Repository
 public interface Neo4jTableRepository extends Neo4jRepository<Neo4jTable,Long> {
     List<Neo4jTable> findNeo4jTableByMetadataId(String metadataId);
+
+    @Query("match (n:Neo4jTable{metadataId:{tableId}} )<-[r:流向]-(m)   return m ")
+    List<BaseNode> getSourceTable(@Param("tableId") String tableId);
+
+    @Query("match (n:Neo4jTable{metadataId:{tableId}} )-[r:流向]->(m)   return m ")
+    List<BaseNode> getTargetTable(@Param("tableId") String tableId);
+
 }

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

@@ -47,10 +47,12 @@ public class AsyncDataFromMongoToNeo4j {
             }
         });
 
-        metadataService.syschroMetadataFromMongo(catalogName,mongoDataList);
+//        metadataService.syschroMetadataFromMongo(catalogName,mongoDataList);
 
         //先同步元数据，纵向关系,root开始
         //再同步元数据的横向关系
+        metadataService.syschroTable2EtlJobRelations(catalogName);
+
 //        metadataService.syschroRelationFromMongo(catalogName);
 //        // 同步其他数据（模型，标准，质量等）
 //

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

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

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

@@ -2,6 +2,7 @@ package com.keymobile.metadata.metadataRelation.service;
 
 import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSchema;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 
 import java.util.List;
 import java.util.Map;
@@ -10,4 +11,5 @@ public interface ISystemService {
 
     Map<String ,List<ReturnNode>> getSchemaBySystemId(String systemId);
 
+    ReturnReslult getAllSystem();
 }

src/main/java/com/keymobile/metadata/metadataRelation/service/ITableService.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 ITableService {
+    Map<String , List<ReturnNode>> getSourceAndTargetTableByTableId(String tableId);
+
+    Map<String, List<ReturnNode>> getRelationObjectByTableId(String tableId);
+}

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

@@ -367,7 +367,8 @@ public class MetadataServiceImpl implements IMetadataService {
         Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
         Session session = neo4jConnection.session();
 //        match (n:MetaData ) where n.metadataId =~"Table=.*" return n
-        String cypher = "match data=(na:softplatform)-[r]->(nb:softplatform) return data   ";
+        String cypher = "match data=(na:Neo4jSystem)<-[r]->(nb:Neo4jSystem) return data " +
+                "        union match data=(na:Neo4jSystem) return data ";
         logger.info("系统总图的查询语句:" + cypher);
 
         long starttime = System.currentTimeMillis();
@@ -375,7 +376,6 @@ public class MetadataServiceImpl implements IMetadataService {
         long endtime = System.currentTimeMillis();
         logger.info("查询耗时："+(endtime-starttime));
         String modelName = "System";
-        List<String> metadataIdList = new ArrayList<>();
 
         Map<Long, ReturnNode> nodesMap = new HashMap<>();
         Map<String, MetaModel> metaModelMap = new HashMap<>();
@@ -393,17 +393,16 @@ public class MetadataServiceImpl implements IMetadataService {
                         }
                         Map<String, Object> stringObjectMap = node.asMap();
 
-                        MetaData metaData = new MetaData();
-                        Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                        Neo4jSystem neo4jSystem = new Neo4jSystem();
+                        Neo4jTool.transMap2Bean(stringObjectMap, neo4jSystem);
 //                        metaDataList.add(data);
-                        if(metaData.getMetadataId() == null ){
-                            metaData.setMetadataId("System="+metaData.getName());
+                        if(neo4jSystem.getMetadataId() == null ){
+                            neo4jSystem.setMetadataId("System="+neo4jSystem.getName());
                         }
                         ReturnNode returnNode = new ReturnNode();
-                        returnNode.setId(metaData.getMetadataId());
-                        returnNode.setName(metaData.getName());
+                        returnNode.setId(neo4jSystem.getMetadataId());
+                        returnNode.setName(neo4jSystem.getName());
 
-                        String[] strings = metaData.getMetadataId().split("=");
                         returnNode.setIcon(modelName);
                         if (!metaModelMap.containsKey(modelName)) {
                             MetaModel model = new MetaModel();
@@ -415,7 +414,7 @@ public class MetadataServiceImpl implements IMetadataService {
                             metaModelMap.put(modelName, model);
                         }
 
-                        returnNode.setType("MetaData");
+                        returnNode.setType("Neo4jSystem");
                         nodesMap.put(node.id(), returnNode);
                     }
                     Iterable<Relationship> relationships = p.relationships();
@@ -442,9 +441,6 @@ public class MetadataServiceImpl implements IMetadataService {
                         }
                         if(!StringUtils.isBlank(startMetaId) && !StringUtils.isBlank(endMEtaId)){
                             ReturnEdge edge = new ReturnEdge();
-                            String relationName =
-                                    nodesMap.get(startID).getId() + "-" + rType + "-"
-                                            + nodesMap.get(endID).getId();
 
                             edge.setEdgeId(String.valueOf(relationship.id()));
                             edge.setFromId(startMetaId);
@@ -1245,6 +1241,8 @@ public class MetadataServiceImpl implements IMetadataService {
     @Override
     public void syschroMetadataFromMongo(String catalogName,List<MongoData> systemDataList) {
 
+        String collectionName = "Metadata_"+catalogName;
+
         List<String> layer = new ArrayList<>();
 
         layer.add("贴源数据层");
@@ -1255,7 +1253,6 @@ public class MetadataServiceImpl implements IMetadataService {
         layer.add("集市数据层");
         layer.add("应用数据层");
 
-        String collectionName = "Metadata_"+catalogName;
         Random r = new Random(1);
 
         List<MongoData> catalogDataList = mongoDbServiceImpl.findDatabaseByparentId("root",collectionName);
@@ -1384,6 +1381,95 @@ public class MetadataServiceImpl implements IMetadataService {
     }
 
     @Override
+    public void syschroTable2EtlJobRelations(String catalogName) {
+
+        Map<String, String> relationMap = new HashMap<>();
+        List<RelationMongo> relationMongoList = mongoDbServiceImpl.findAllRelationByCatalog(catalogName);
+        int size = 0;
+        for (RelationMongo relationMongo : relationMongoList) {
+            String sourceId = relationMongo.getSource();
+            String targetId = relationMongo.getTarget();
+            Map<String, Object> sourceData = metadataRepoRemoteService.getMetadata(sourceId);
+            Map<String, Object> targetData = metadataRepoRemoteService.getMetadata(targetId);
+            if(sourceData==null || targetData==null){
+                continue;
+            }
+            String startId = "";
+            String endId = "";
+            //如果是字段，上升到表，如果是sql，上升到etljob，其他的模型站不处理
+            if(sourceId.contains("Column=") && targetId.contains("Column=") ){
+
+                Map<String, Object> sourceParent = metadataRepoRemoteService.getParent(sourceId);
+                Map<String, Object> targetParent = metadataRepoRemoteService.getParent(targetId);
+                if (sourceParent == null ) {
+                    logger.info("没有找到id：" + sourceId + "的父节点元数据。");
+                    continue;
+                }
+                if (targetParent==null) {
+                    logger.info("没有找到id：" + targetId + "的父节点元数据。");
+                    continue;
+                }
+                startId = (String )sourceParent.get("_id");
+                endId = (String )targetParent.get("_id");
+            } else if(sourceId.contains("Column=") && targetId.contains("SQL=") ){
+                Map<String, Object> sourceParent = metadataRepoRemoteService.getParent(sourceId);
+                Map<String, Object> targetParent = metadataRepoRemoteService.getParent(targetId);
+                if (sourceParent == null ) {
+                    logger.info("没有找到id：" + sourceId + "的父节点元数据。");
+                    continue;
+                }
+                if (targetParent==null) {
+                    logger.info("没有找到id：" + targetId + "的父节点元数据。");
+                    continue;
+                }
+                String targetParentId = (String) targetParent.get("_id");
+                Map<String, Object> targetParentParent =  metadataRepoRemoteService.getParent(targetParentId);
+                if (targetParentParent==null) {
+                    logger.info("没有找到id：" + targetId + "的祖父节点元数据。");
+                    continue;
+                }
+
+                startId = (String )sourceParent.get("_id");
+                endId = (String )targetParentParent.get("_id");
+            }else if(sourceId.contains("SQL=") && targetId.contains("Column=")){
+                Map<String, Object> targetParent = metadataRepoRemoteService.getParent(sourceId);
+
+                Map<String, Object> sourceParent = metadataRepoRemoteService.getParent(targetId);
+
+                if (sourceParent == null ) {
+                    logger.info("没有找到id：" + sourceId + "的父节点元数据。");
+                    continue;
+                }
+                if (targetParent==null) {
+                    logger.info("没有找到id：" + targetId + "的父节点元数据。");
+                    continue;
+                }
+                String sourceParenttId = (String) sourceParent.get("_id");
+                Map<String, Object> sourceParentParent =  metadataRepoRemoteService.getParent(sourceParenttId);
+                if (sourceParentParent==null) {
+                    logger.info("没有找到id：" + sourceId + "的祖父节点元数据。");
+                    continue;
+                }
+
+                startId = (String )sourceParentParent.get("_id");
+                endId = (String )targetParent.get("_id");
+            }
+
+            String type = relationMongo.getType();
+            String relationId = startId+"_"+endId;
+            if(!relationMap.containsKey(relationId)){
+                if(relationMap.size()%200 == 0){
+                    logger.info("创建第"+relationMap.size()+"多少关系：");
+                }
+                relationMap.put(relationId,"");
+                relationshipService.saveRelation(startId,endId,"流向");
+            }
+
+        }
+        logger.info("创建了多少关系："+relationMap.size());
+    }
+
+    @Override
     public void syschroRelationFromMongo(String catalogName) {
         //先从mongo读取关系，写入neo4j
         Map<String, MetaData> metaDataMap = new HashMap<>();

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.Neo4jSchema;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSystem;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import com.keymobile.metadata.metadataRelation.respository.metadata.Neo4jSystemRepository;
 import com.keymobile.metadata.metadataRelation.service.ISystemService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -30,7 +32,6 @@ public class SystemServiceImpl implements ISystemService {
             returnNode.setName(neo4jSchema.getName());
             returnNode.setType("Schema");
 
-
             String label = neo4jSchema.getLabel();
             if(label == null || label.equals("")){
                 label = "未分层";
@@ -48,4 +49,15 @@ public class SystemServiceImpl implements ISystemService {
         }
         return schemaMap;
     }
+
+    @Override
+    public ReturnReslult getAllSystem() {
+        Iterable<Neo4jSystem> neo4jSystems = neo4jSystemRepository.findAll();
+        for(Neo4jSystem neo4jSystem:neo4jSystems){
+
+            neo4jSystem.getName();
+
+        }
+        return null;
+    }
 }

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

+package com.keymobile.metadata.metadataRelation.service.impl;
+
+import com.keymobile.metadata.metadataRelation.pojo.BaseNode;
+import com.keymobile.metadata.metadataRelation.pojo.metadata.Neo4jSystem;
+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.respository.metadata.Neo4jSystemRepository;
+import com.keymobile.metadata.metadataRelation.respository.metadata.Neo4jTableRepository;
+import com.keymobile.metadata.metadataRelation.service.ITableService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class TableServiceImpl implements ITableService {
+
+    private static final Logger logger = LoggerFactory.getLogger(TableServiceImpl.class);
+
+    @Autowired
+    private Neo4jTableRepository neo4jTableRepository;
+
+    @Autowired
+    private Neo4jSystemRepository neo4jSystemRepository;
+
+    @Autowired
+    private MetadataRepoRemoteService metadataRepoRemoteService;
+
+    @Override
+    public Map<String, List<ReturnNode>> getRelationObjectByTableId(String tableId) {
+        //传入表id，查找与该表相关的“模型，资产，标准，质量，作业”，
+        Map<String, List<ReturnNode>> relationObjects = new HashMap<>();
+        //获取关联作业，
+        List<BaseNode> sourceBaseNodes = neo4jTableRepository.getSourceTable(tableId);
+
+        List<ReturnNode> etlJobs = new ArrayList<>();
+        for(BaseNode sourceBaseNode:sourceBaseNodes){
+            if(sourceBaseNode.getMetadataId().startsWith("EtlJob")){
+                ReturnNode returnNode = new ReturnNode();
+                returnNode.setId(sourceBaseNode.getMetadataId());
+                returnNode.setName(sourceBaseNode.getName());
+                returnNode.setType("EtlJob");
+                etlJobs.add(returnNode);
+            }
+        }
+        List<BaseNode> targetBaseNodes = neo4jTableRepository.getTargetTable(tableId);
+        for(BaseNode targetBaseNode:targetBaseNodes){
+            if(targetBaseNode.getMetadataId().startsWith("EtlJob")){
+                ReturnNode returnNode = new ReturnNode();
+                returnNode.setId(targetBaseNode.getMetadataId());
+                returnNode.setName(targetBaseNode.getName());
+                returnNode.setType("EtlJob");
+                etlJobs.add(returnNode);
+            }
+        }
+
+        List<ReturnNode> qualityList = new ArrayList<>();
+
+        List<ReturnNode> modelList = new ArrayList<>();
+
+        List<ReturnNode> assetList = new ArrayList<>();
+
+        List<ReturnNode> standardList = new ArrayList<>();
+
+        relationObjects.put("模型",modelList);
+        relationObjects.put("资产",assetList);
+        relationObjects.put("标准",standardList);
+        relationObjects.put("质量",qualityList);
+        relationObjects.put("作业",etlJobs);
+        return relationObjects;
+    }
+
+    @Override
+    public Map<String, List<ReturnNode>> getSourceAndTargetTableByTableId(String tableId) {
+        Map<String, List<ReturnNode>> sourceAndTargetTable = new HashMap<>();
+        List<ReturnNode> sourceTables = new ArrayList<>();
+
+        Map<String ,String> systemIdAndName = new HashMap<>();
+        Iterable<Neo4jSystem> neo4jSystems = neo4jSystemRepository.findAll();
+        for(Neo4jSystem neo4jSystem:neo4jSystems ){
+            systemIdAndName.put(neo4jSystem.getMetadataId(),neo4jSystem.getName());
+        }
+
+        getSourceTable(tableId ,sourceTables,systemIdAndName);
+
+        List<ReturnNode> targetTables = new ArrayList<>();
+        getTargetTable(tableId ,targetTables,systemIdAndName);
+
+        sourceAndTargetTable.put("来源",sourceTables);
+        sourceAndTargetTable.put("目标",targetTables);
+
+        return sourceAndTargetTable;
+    }
+
+    private Map<String,String> getAttributeMap(String tableId){
+        Map<String,String> returnMap = new HashMap<>();
+
+
+        Map<String, Object> attriuteMap = metadataRepoRemoteService.getMetadata(tableId);
+        if (attriuteMap == null) {
+            logger.info("没有找到id：" + tableId + "的元数据。");
+
+            List<Neo4jTable> neo4jTableList = neo4jTableRepository.findNeo4jTableByMetadataId(tableId);
+            Neo4jTable neo4jTable = neo4jTableList.get(0);
+            returnMap.put("名字", neo4jTable.getName());
+            returnMap.put("别名", neo4jTable.getCnName());
+            returnMap.put("中文名","");
+            returnMap.put("最后更新时间","");
+            return returnMap;
+        }
+        // 英文名称，中文名称，说明，表规模（行），表大小（字节），更新时间，
+        // 所属系统，所属分层，加载脚本，质量情况，相关模型
+        String name = (String) attriuteMap.get("name");
+//        if (attriuteMap.get("cnName") != null && !attriuteMap.get("cnName").equals("")) {
+//            name = (String) attriuteMap.get("cnName");
+//        }
+        returnMap.put("英文名称",name);
+        String cnName = (String) attriuteMap.get("cnName");
+        returnMap.put("中文名称",cnName);
+
+        String comment = (String) attriuteMap.get("comment");
+        returnMap.put("说明",comment);
+
+        int  tableRowsCount = (Integer) attriuteMap.get("tableRowsCount");
+        returnMap.put("表规模（行）",tableRowsCount+"");
+
+        int tableSize = (Integer) attriuteMap.get("tableSize");
+        returnMap.put("表大小（字节）",tableSize+"");
+
+        String lastUpdateTime = (String) attriuteMap.get("lastUpdateTime");
+        returnMap.put("最后更新时间",lastUpdateTime);
+
+        //所属系统
+        String belongSystemString = "";
+        List<String> belongSystems = (List<String>) attriuteMap.get("sysList");
+        for(String belongSystem:belongSystems){
+            belongSystemString +=belongSystem+",";
+        }
+        returnMap.put("所属系统",belongSystemString);
+
+        //所属分层,从schema获取
+        String parentId = (String) attriuteMap.get("parentId");
+        Map<String, Object> schemaAttributeMap = metadataRepoRemoteService.getMetadata(parentId);
+        String label  = (String)schemaAttributeMap.get("label");
+        if(label== null ){
+            List<String> layer = new ArrayList<>();
+
+            layer.add("贴源数据层");
+            layer.add("基础数据层");
+            layer.add("整合数据层");
+            layer.add("统计数据层");
+            layer.add("分析数据层");
+            layer.add("集市数据层");
+            layer.add("应用数据层");
+
+            Random r = new Random(1);
+            int ran1 = r.nextInt(6);
+            if(ran1>6){
+                ran1 = 6;
+            }
+            label = layer.get(ran1);
+        }
+        returnMap.put("所属分层",label);
+
+        List<String> paths =(List<String>) attriuteMap.get("namePathList");
+        if(paths !=null ){
+            StringBuffer sb = new StringBuffer();
+            int size = paths.size();
+            for(int i =0 ;i<size;i++){
+                sb.append(paths.get(i)+";");
+            }
+            returnMap.put("路径",sb.toString());
+        }
+        return returnMap;
+    }
+
+    private void getTargetTable(String tableId, List<ReturnNode> targetTables,
+    Map<String, String> systemIdAndName) {
+        List<BaseNode> sourceBaseNodeList = neo4jTableRepository.getTargetTable(tableId);
+        for(BaseNode baseNode:sourceBaseNodeList){
+            String metadataId = baseNode.getMetadataId();
+            if(metadataId.startsWith("Table=")){
+                ReturnNode returnNode = new ReturnNode();
+                returnNode.setId(baseNode.getMetadataId());
+                returnNode.setName(baseNode.getName());
+                returnNode.setType("Table");
+//                获取属性
+                Map<String,String> attributeMap =  getAttributeMap(tableId);
+                String systemString = attributeMap.get("所属系统");
+
+                String belongSystem = "";
+                String[] systemList = systemString.split(",");
+                for(String system :systemList ){
+                    if(systemIdAndName.containsKey("System="+system)){
+                        belongSystem += systemIdAndName.get("System="+system)+",";
+                    }
+                }
+                attributeMap.put("所属系统",belongSystem);
+
+                returnNode.setAttributeMaps(attributeMap);
+                if(!targetTables.contains(returnNode)){
+                    targetTables.add(returnNode);
+                }
+            }else {
+                getTargetTable(metadataId,targetTables,systemIdAndName);
+            }
+        }
+    }
+
+    private void getSourceTable(String tableId, List<ReturnNode> sourceTables,
+                                Map<String, String> systemIdAndName) {
+        List<BaseNode> sourceBaseNodeList = neo4jTableRepository.getSourceTable(tableId);
+        for(BaseNode baseNode:sourceBaseNodeList){
+            String metadataId = baseNode.getMetadataId();
+            if(metadataId.startsWith("Table=")){
+                ReturnNode returnNode = new ReturnNode();
+                returnNode.setId(baseNode.getMetadataId());
+                returnNode.setName(baseNode.getName());
+                returnNode.setType("Table");
+
+//                获取属性
+                Map<String,String> attributeMap =  getAttributeMap(tableId);
+                String systemString = attributeMap.get("所属系统");
+
+                String belongSystem = "";
+                String[] systemList = systemString.split(",");
+                for(String system :systemList ){
+                    if(systemIdAndName.containsKey("System="+system)){
+                        belongSystem += systemIdAndName.get("System="+system)+",";
+                    }
+                }
+                attributeMap.put("所属系统",belongSystem);
+                if(!sourceTables.contains(returnNode)){
+                    sourceTables.add(returnNode);
+                }
+                returnNode.setAttributeMaps(attributeMap);
+            }else {
+                getSourceTable(metadataId,sourceTables, systemIdAndName);
+            }
+
+
+        }
+    }
+}