修改数据模型影响关系图谱

修改数据模型血缘关系图谱
修改数据模型全链路图谱

app/core/data_model/model.py

@@ -758,40 +758,63 @@ def model_kinship_graph(nodeid, meta=False):
         if not start_record:
             return {"nodes": [], "lines": []}
         
-        # 查询与模型关联的数据资源
-        resource_query = """
+        # 查询与模型关联的血缘关系（包括数据资源和其他数据模型），表示哪些节点是当前节点的上级血缘关系
+        lineage_query = """
         MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:DataResource)
-        RETURN resource
+        OPTIONAL MATCH (n)-[:DERIVED_FROM]->(resource:DataResource)
+        OPTIONAL MATCH (n)-[:DERIVED_FROM]->(model:DataModel)
+        RETURN resource, model
         """
         
-        resource_result = session.run(resource_query, nodeId=nodeid)
+        lineage_result = session.run(lineage_query, nodeId=nodeid)
         
         nodes = [{"id": str(nodeid), "text": start_record['name'], "type": "model"}]
         lines = []
         
-        # 处理资源节点
-        for record in resource_result:
-            if 'resource' in record:
+        # 处理血缘节点（数据资源和数据模型）
+        for record in lineage_result:
+            # 处理数据资源节点
+            if record['resource']:
                 resource = record['resource']
                 resource_id = str(resource.id)
                 resource_name = resource.get('name', '')
-                resource_en_name = resource.get('en_name', '')
                 
                 # 创建资源节点
                 resource_node = {
                     "id": resource_id,
                     "text": resource_name,
-                    "type": "resource"
+                    "type": "DataResource"
                 }
                 nodes.append(resource_node)
                 
-                # 创建资源到模型的关系
+                # 创建模型到资源的关系
                 line = {
                     "from": str(nodeid),
                     "to": resource_id,
-                    "text": "resource"
+                    "text": "DERIVED_FROM"
+                }
+                lines.append(line)
+            
+            # 处理数据模型节点
+            if record['model']:
+                model = record['model']
+                model_id = str(model.id)
+                model_name = model.get('name', '')
+                
+                # 创建模型节点
+                model_node = {
+                    "id": model_id,
+                    "text": model_name,
+                    "type": "DataModel"
+                }
+                nodes.append(model_node)
+                
+                # 创建模型到模型的关系
+                line = {
+                    "from": str(nodeid),
+                    "to": model_id,
+                    "text": "DERIVED_FROM"
                 }
                 lines.append(line)
 
@@ -799,8 +822,8 @@ def model_kinship_graph(nodeid, meta=False):
         if meta:
             meta_query = """
             MATCH (n:DataModel)
-            WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
-            MATCH p = (n)-[:meta]->(meta:DataMeta)
+            WHERE id(n) = $nodeId
+            MATCH p = (n)-[:INCLUDES]->(meta:DataMeta)
             RETURN meta
             """
             meta_result = session.run(meta_query, nodeId=nodeid)
@@ -816,7 +839,7 @@ def model_kinship_graph(nodeid, meta=False):
                     meta_node = {
                         "id": meta_id,
                         "text": meta_name,
-                        "type": "meta"
+                        "type": "DataMeta"
                     }
                     nodes.append(meta_node)
                     
@@ -824,7 +847,7 @@ def model_kinship_graph(nodeid, meta=False):
                     tag_line = {
                         "from": str(nodeid),
                         "to": meta_id,
-                        "text": "component"
+                        "text": "INCLUDES"
                     }
                     lines.append(tag_line)
 
@@ -864,40 +887,63 @@ def model_impact_graph(nodeid, meta=False):
         if not start_record:
             return {"nodes": [], "lines": []}
         
-        # 查询影响模型的数据资源
-        resource_query = """
+        # 查询指向当前模型的影响关系（包括数据资源和其他数据模型），表示哪些节点受到当前节点影响
+        impact_query = """
         MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:DataResource)
-        RETURN resource
+        OPTIONAL MATCH (resource:DataResource)-[:DERIVED_FROM]->(n)
+        OPTIONAL MATCH (model:DataModel)-[:DERIVED_FROM]->(n)
+        RETURN resource, model
         """
         
-        resource_result = session.run(resource_query, nodeId=nodeid)
+        impact_result = session.run(impact_query, nodeId=nodeid)
         
         nodes = [{"id": str(nodeid), "text": start_record['name'], "type": "model"}]
         lines = []
         
-        # 处理资源节点
-        for record in resource_result:
-            if 'resource' in record:
+        # 处理影响节点（数据资源和数据模型）
+        for record in impact_result:
+            # 处理数据资源节点
+            if record['resource']:
                 resource = record['resource']
                 resource_id = str(resource.id)
                 resource_name = resource.get('name', '')
-                resource_en_name = resource.get('en_name', '')
                 
                 # 创建资源节点
                 resource_node = {
                     "id": resource_id,
                     "text": resource_name,
-                    "type": "resource"
+                    "type": "DataResource"
                 }
                 nodes.append(resource_node)
                 
                 # 创建资源到模型的关系
                 line = {
-                    "from": str(nodeid),
-                    "to": resource_id,
-                    "text": "resource"
+                    "from": resource_id,
+                    "to": str(nodeid),
+                    "text": "DERIVED_FROM"
+                }
+                lines.append(line)
+            
+            # 处理数据模型节点
+            if record['model']:
+                model = record['model']
+                model_id = str(model.id)
+                model_name = model.get('name', '')
+                
+                # 创建模型节点
+                model_node = {
+                    "id": model_id,
+                    "text": model_name,
+                    "type": "DataModel"
+                }
+                nodes.append(model_node)
+                
+                # 创建模型到模型的关系
+                line = {
+                    "from": model_id,
+                    "to": str(nodeid),
+                    "text": "DERIVED_FROM"
                 }
                 lines.append(line)
 
@@ -905,8 +951,8 @@ def model_impact_graph(nodeid, meta=False):
         if meta:
             meta_query = """
             MATCH (n:DataModel)
-            WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
-            MATCH p = (n)-[:meta]->(meta:DataMeta)
+            WHERE id(n) = $nodeId
+            MATCH p = (n)-[:INCLUDES]->(meta:DataMeta)
             RETURN meta
             """
             meta_result = session.run(meta_query, nodeId=nodeid)
@@ -916,13 +962,12 @@ def model_impact_graph(nodeid, meta=False):
                     meta_node = record['meta']
                     meta_id = str(meta.id)
                     meta_name = meta.get('name', '')
-                    meta_en_name = meta.get('en_name', '')
                     
                     # 创建元数据节点
                     meta_node = {
                         "id": meta_id,
                         "text": meta_name,
-                        "type": "meta"
+                        "type": "DataMeta"
                     }
                     nodes.append(meta_node)
                     
@@ -930,7 +975,7 @@ def model_impact_graph(nodeid, meta=False):
                     tag_line = {
                         "from": str(nodeid),
                         "to": meta_id,
-                        "text": "component"
+                        "text": "INCLUDES"
                     }
                     lines.append(tag_line)
 
@@ -970,53 +1015,125 @@ def model_all_graph(nodeid, meta=False):
         if not start_record:
             return {"nodes": [], "lines": []}
         
-        # 查询与模型关联的数据资源
-        resource_query = """
+        # 查询与模型关联的所有DERIVED_FROM关系（双向，包括数据资源和其他数据模型）
+        all_relations_query = """
         MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:DataResource)
-        RETURN resource
-        """
         
-        resource_result = session.run(resource_query, nodeId=nodeid)
+        // 查询当前节点指向的节点（血缘关系）
+        OPTIONAL MATCH (n)-[:DERIVED_FROM]->(outbound_resource:DataResource)
+        OPTIONAL MATCH (n)-[:DERIVED_FROM]->(outbound_model:DataModel)
         
-        # 查询与模型关联的元数据
-        meta_query = """
-        MATCH (n:DataModel)
-        WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
-        MATCH p = (n)-[:meta]->(meta:DataMeta)
-        RETURN meta
+        // 查询指向当前节点的节点（影响关系）
+        OPTIONAL MATCH (inbound_resource:DataResource)-[:DERIVED_FROM]->(n)
+        OPTIONAL MATCH (inbound_model:DataModel)-[:DERIVED_FROM]->(n)
+        
+        RETURN outbound_resource, outbound_model, inbound_resource, inbound_model
         """
         
-        nodes = [{"id": str(nodeid), "text": start_record['name'], "type": "model"}]
+        relations_result = session.run(all_relations_query, nodeId=nodeid)
+        
+        nodes = [{"id": str(nodeid), "text": start_record['name'], "type": "DataModel"}]
         lines = []
         
-        # 处理资源节点
-        for record in resource_result:
-            if 'resource' in record:
-                resource = record['resource']
+        # 处理所有DERIVED_FROM关系节点
+        for record in relations_result:
+            # 处理当前节点指向的数据资源（血缘关系）
+            if record['outbound_resource']:
+                resource = record['outbound_resource']
                 resource_id = str(resource.id)
                 resource_name = resource.get('name', '')
-                resource_en_name = resource.get('en_name', '')
                 
                 # 创建资源节点
                 resource_node = {
                     "id": resource_id,
                     "text": resource_name,
-                    "type": "resource"
+                    "type": "DataResource"
                 }
                 nodes.append(resource_node)
                 
-                # 创建资源到模型的关系
+                # 创建当前模型到资源的关系
                 line = {
                     "from": str(nodeid),
                     "to": resource_id,
-                    "text": "resource"
+                    "text": "DERIVED_FROM"
+                }
+                lines.append(line)
+            
+            # 处理当前节点指向的数据模型（血缘关系）
+            if record['outbound_model']:
+                model = record['outbound_model']
+                model_id = str(model.id)
+                model_name = model.get('name', '')
+                
+                # 创建模型节点
+                model_node = {
+                    "id": model_id,
+                    "text": model_name,
+                    "type": "DataModel"
+                }
+                nodes.append(model_node)
+                
+                # 创建当前模型到模型的关系
+                line = {
+                    "from": str(nodeid),
+                    "to": model_id,
+                    "text": "DERIVED_FROM"
+                }
+                lines.append(line)
+            
+            # 处理指向当前节点的数据资源（影响关系）
+            if record['inbound_resource']:
+                resource = record['inbound_resource']
+                resource_id = str(resource.id)
+                resource_name = resource.get('name', '')
+                
+                # 创建资源节点
+                resource_node = {
+                    "id": resource_id,
+                    "text": resource_name,
+                    "type": "DataResource"
+                }
+                nodes.append(resource_node)
+                
+                # 创建资源到当前模型的关系
+                line = {
+                    "from": resource_id,
+                    "to": str(nodeid),
+                    "text": "DERIVED_FROM"
+                }
+                lines.append(line)
+            
+            # 处理指向当前节点的数据模型（影响关系）
+            if record['inbound_model']:
+                model = record['inbound_model']
+                model_id = str(model.id)
+                model_name = model.get('name', '')
+                
+                # 创建模型节点
+                model_node = {
+                    "id": model_id,
+                    "text": model_name,
+                    "type": "DataModel"
+                }
+                nodes.append(model_node)
+                
+                # 创建模型到当前模型的关系
+                line = {
+                    "from": model_id,
+                    "to": str(nodeid),
+                    "text": "DERIVED_FROM"
                 }
                 lines.append(line)
 
         # 处理元数据节点
         if meta:
+            meta_query = """
+            MATCH (n:DataModel)
+            WHERE id(n) = $nodeId
+            MATCH p = (n)-[:INCLUDES]->(meta:DataMeta)
+            RETURN meta
+            """
             meta_result = session.run(meta_query, nodeId=nodeid)
             
             for record in meta_result:
@@ -1024,21 +1141,20 @@ def model_all_graph(nodeid, meta=False):
                     meta_node = record['meta']
                     meta_id = str(meta.id)
                     meta_name = meta.get('name', '')
-                    meta_en_name = meta.get('en_name', '')
                     
                     # 创建元数据节点
                     meta_node = {
                         "id": meta_id,
                         "text": meta_name,
-                        "type": "meta"
+                        "type": "DataMeta"
                     }
                     nodes.append(meta_node)
                     
-                    # 创建模型到元数据的标签关系
+                    # 创建模型到元数据的关系
                     tag_line = {
                         "from": str(nodeid),
                         "to": meta_id,
-                        "text": "component"
+                        "text": "INCLUDES"
                     }
                     lines.append(tag_line)