替换DataResource和DataMeta的标签为DataResource和DataMeta。

修改DataResource和DataMeta的属性名。

app/api/data_resource/routes.py

@@ -227,7 +227,7 @@ def data_resource_delete():
         with neo4j_driver.get_session() as session:
             # 删除数据资源节点及其关系
             cypher = """
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $resource_id
             DETACH DELETE n
             """
@@ -471,7 +471,7 @@ def id_data_save():
         with neo4j_driver.get_session() as session:
             # 获取数据资源名称
             resource_query = """
-            MATCH (n:data_resource) 
+            MATCH (n:DataResource) 
             WHERE id(n) = $resource_id
             RETURN n.name as resource_name
             """
@@ -485,7 +485,7 @@ def id_data_save():
             
             # 先删除现有关系
             cypher_delete = """
-            MATCH (n:data_resource)-[r:contain]->()
+            MATCH (n:DataResource)-[r:contain]->()
             WHERE id(n) = $resource_id
             DELETE r
             """
@@ -495,7 +495,7 @@ def id_data_save():
             for meta in metadata_list:
                 # 创建元数据节点
                 meta_cypher = """
-                MERGE (m:meta_data {name: $name})
+                MERGE (m:DataMeta {name: $name})
                 ON CREATE SET m.en_name = $en_name, 
                             m.createTime = $create_time,
                             m.data_type = $type
@@ -520,7 +520,7 @@ def id_data_save():
                 
                 # 使用明确的属性名匹配而不是ID
                 rel_cypher = """
-                MATCH (a:data_resource {name: $r_name}), (m:meta_data {name: $m_name})
+                MATCH (a:DataResource {name: $r_name}), (m:DataMeta {name: $m_name})
                 MERGE (a)-[r:contain]->(m)
                 RETURN r
                 """
@@ -539,7 +539,7 @@ def id_data_save():
 
                 # 额外验证关系是否创建
                 verify_cypher = """
-                MATCH (a:data_resource {name: $r_name})-[r:contain]->(m:meta_data {name: $m_name})
+                MATCH (a:DataResource {name: $r_name})-[r:contain]->(m:DataMeta {name: $m_name})
                 RETURN count(r) as rel_count
                 """
                 
@@ -630,7 +630,7 @@ def ddl_identify():
                     with neo4j_driver.get_session() as session:
                         table_query = """
                         UNWIND $names AS name
-                        OPTIONAL MATCH (n:data_resource {en_name: name})
+                        OPTIONAL MATCH (n:DataResource {en_name: name})
                         RETURN name, n IS NOT NULL AS exists
                         """
                         table_results = session.run(table_query, names=table_names)

app/api/meta_data/routes.py

@@ -217,20 +217,20 @@ def meta_node_add():
         with neo4j_driver.get_session() as session:
             cypher = """
             MERGE (n:DataMeta {name: $name})
-            ON CREATE SET n.data_type = $type,
+            ON CREATE SET n.type = $type,
                          n.category = $category,
                          n.alias = $alias,
                          n.affiliation = $affiliation,
-                         n.desc = $desc,
+                         n.describe = $describe,
                          n.createTime = $create_time,
                          n.updateTime = $update_time,
                          n.status = $status,
                          n.en_name = $en_name
-            ON MATCH SET n.data_type = $type,
+            ON MATCH SET n.type = $type,
                         n.category = $category,
                         n.alias = $alias,
                         n.affiliation = $affiliation,
-                        n.desc = $desc,
+                        n.describe = $describe,
                         n.updateTime = $update_time,
                         n.status = $status,
                         n.en_name = $en_name
@@ -244,7 +244,7 @@ def meta_node_add():
                 category=node_category,
                 alias=node_alias,
                 affiliation=node_affiliation,
-                desc=node_desc,
+                describe=node_desc,
                 create_time=create_time,
                 update_time=update_time,
                 status=str(node_status),

app/core/data_resource/resource.py

@@ -720,7 +720,7 @@ def resource_impact_all_graph(resource_id, include_meta=True):
                 resource_id_int = int(resource_id)
             except (ValueError, TypeError):
                 logger.error(f"资源ID不是有效的整数: {resource_id}")
-                return {"nodes": [], "relationships": []}
+                return {"nodes": [], "lines": []}
             
             # 根据meta参数决定查询深度
             if include_meta:
@@ -741,7 +741,7 @@ def resource_impact_all_graph(resource_id, include_meta=True):
             
             # 收集节点和关系
             nodes = {}
-            relationships = {}
+            lines = {}
             
             for record in result:
                 path = record["path"]
@@ -750,29 +750,29 @@ def resource_impact_all_graph(resource_id, include_meta=True):
                 for node in path.nodes:
                     if node.id not in nodes:
                         node_dict = serialize_node_properties(node)
-                        node_dict["id"] = node.id
-                        node_dict["labels"] = list(node.labels)
+                        node_dict["id"] = str(node.id)
+                        node_dict["node_type"] = list(node.labels)[0] if node.labels else ""
                         nodes[node.id] = node_dict
                 
-                # 处理路径中的所有关系
+                # 处理路径中的所有关系。Neo4j的路径对象(path)中，关系集合的属性名是relationships
                 for rel in path.relationships:
-                    if rel.id not in relationships:
+                    if rel.id not in lines:
                         rel_dict = {
-                            "id": rel.id,
-                            "source": rel.start_node.id,
-                            "target": rel.end_node.id,
+                            "id": str(rel.id),
+                            "from": str(rel.start_node.id),
+                            "to": str(rel.end_node.id),
                             "type": rel.type
                         }
-                        relationships[rel.id] = rel_dict
+                        lines[rel.id] = rel_dict
             
             logger.info(f"成功获取完整图谱，ID: {resource_id_int}, 节点数: {len(nodes)}")
             return {
                 "nodes": list(nodes.values()),
-                "relationships": list(relationships.values())
+                "lines": list(lines.values())
             }
     except Exception as e:
         logger.error(f"获取数据资源影响关系图谱失败: {str(e)}")
-        return {"nodes": [], "relationships": []}
+        return {"nodes": [], "lines": []}
 
 def clean_type(type_str):
     """清洗SQL类型字符串"""

app/core/meta_data/meta_data.py

@@ -22,6 +22,39 @@ from app.core.llm.llm_service import llm_client as llm_call  # 导入core/llm模
 
 logger = logging.getLogger("app")
 
+def serialize_neo4j_object(obj):
+    """
+    将Neo4j对象转换为可JSON序列化的格式
+    
+    Args:
+        obj: Neo4j节点或属性值
+        
+    Returns:
+        序列化后的对象
+    """
+    if hasattr(obj, 'year'):  # DateTime对象
+        # 将Neo4j DateTime转换为字符串
+        return obj.strftime("%Y-%m-%d %H:%M:%S") if hasattr(obj, 'strftime') else str(obj)
+    elif hasattr(obj, '__dict__'):  # 复杂对象
+        return str(obj)
+    else:
+        return obj
+
+def serialize_node_properties(node):
+    """
+    将Neo4j节点属性序列化为可JSON化的字典
+    
+    Args:
+        node: Neo4j节点对象
+        
+    Returns:
+        dict: 序列化后的属性字典
+    """
+    properties = {}
+    for key, value in dict(node).items():
+        properties[key] = serialize_neo4j_object(value)
+    return properties
+
 def get_formatted_time():
     """获取格式化的当前时间"""
     return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
@@ -158,7 +191,7 @@ def meta_list(page, page_size, search="", en_name_filter=None,
             # 格式化结果
             result_list = []
             for record in result:
-                node = dict(record["n"])
+                node = serialize_node_properties(record["n"])
                 node["id"] = record["n"].id
                 result_list.append(node)
                 
@@ -170,12 +203,24 @@ def meta_list(page, page_size, search="", en_name_filter=None,
 def handle_id_unstructured(node_id):
     """处理非结构化数据节点"""
     try:
+        # 参数验证
+        if node_id is None:
+            logger.error("node_id参数不能为None")
+            return None
+        
+        # 确保node_id为整数
+        try:
+            node_id_int = int(node_id)
+        except (ValueError, TypeError):
+            logger.error(f"node_id不是有效的整数: {node_id}")
+            return None
+        
         with neo4j_driver.get_session() as session:
             query = "MATCH (n) WHERE id(n) = $node_id RETURN n"
-            result = session.run(query, node_id=int(node_id))
+            result = session.run(query, node_id=node_id_int)
             node = result.single()
             if node:
-                return dict(node["n"])
+                return serialize_node_properties(node["n"])
             else:
                 return None
     except Exception as e:
@@ -265,6 +310,18 @@ def meta_kinship_graph(node_id):
         dict: 图谱数据
     """
     try:
+        # 参数验证
+        if node_id is None:
+            logger.error("node_id参数不能为None")
+            return {"nodes": [], "relationships": []}
+        
+        # 确保node_id为整数
+        try:
+            node_id_int = int(node_id)
+        except (ValueError, TypeError):
+            logger.error(f"node_id不是有效的整数: {node_id}")
+            return {"nodes": [], "relationships": []}
+        
         with neo4j_driver.get_session() as session:
             # 获取节点和直接关系
             cypher = """
@@ -272,7 +329,7 @@ def meta_kinship_graph(node_id):
             WHERE id(n) = $node_id
             RETURN n, r, m
             """
-            result = session.run(cypher, node_id=int(node_id))
+            result = session.run(cypher, node_id=node_id_int)
             
             # 格式化结果为图谱数据
             nodes = {}
@@ -280,12 +337,12 @@ def meta_kinship_graph(node_id):
             
             for record in result:
                 # 处理源节点
-                source_node = dict(record["n"])
+                source_node = serialize_node_properties(record["n"])
                 source_node["id"] = record["n"].id
                 nodes[source_node["id"]] = source_node
                 
                 # 处理目标节点
-                target_node = dict(record["m"])
+                target_node = serialize_node_properties(record["m"])
                 target_node["id"] = record["m"].id
                 nodes[target_node["id"]] = target_node
                 
@@ -321,6 +378,18 @@ def meta_impact_graph(node_id):
         dict: 图谱数据
     """
     try:
+        # 参数验证
+        if node_id is None:
+            logger.error("node_id参数不能为None")
+            return {"nodes": [], "relationships": []}
+        
+        # 确保node_id为整数
+        try:
+            node_id_int = int(node_id)
+        except (ValueError, TypeError):
+            logger.error(f"node_id不是有效的整数: {node_id}")
+            return {"nodes": [], "relationships": []}
+        
         with neo4j_driver.get_session() as session:
             # 获取所有可达节点和关系
             cypher = """
@@ -328,7 +397,7 @@ def meta_impact_graph(node_id):
             WHERE id(n) = $node_id
             RETURN path
             """
-            result = session.run(cypher, node_id=int(node_id))
+            result = session.run(cypher, node_id=node_id_int)
             
             # 格式化结果
             nodes = {}
@@ -339,7 +408,7 @@ def meta_impact_graph(node_id):
                 
                 # 处理路径中的所有节点
                 for node in path.nodes:
-                    node_dict = dict(node)
+                    node_dict = serialize_node_properties(node)
                     node_dict["id"] = node.id
                     nodes[node.id] = node_dict
                 
@@ -400,11 +469,23 @@ def parse_entity_relation(text):
 def handle_txt_graph(node_id, entity, entity_en):
     """处理文本图谱创建"""
     try:
+        # 参数验证
+        if node_id is None:
+            logger.error("node_id参数不能为None")
+            return False
+        
+        # 确保node_id为整数
+        try:
+            node_id_int = int(node_id)
+        except (ValueError, TypeError):
+            logger.error(f"node_id不是有效的整数: {node_id}")
+            return False
+        
         # 创建实体节点
         with neo4j_driver.get_session() as session:
             # 查找源节点
             query = "MATCH (n) WHERE id(n) = $node_id RETURN n"
-            result = session.run(query, node_id=int(node_id))
+            result = session.run(query, node_id=node_id_int)
             source_node = result.single()["n"]
             
             if not source_node: