修改data_model为DataModel

修改data_metric为DataMetric
修改data_resource为DataResource
修改data_meta为DataMeta
修改data_label为DataLabel
修改dataflow上传参数结构，基于a：b的格式，a为节点名称，b为表名

app/api/data_interface/routes.py

@@ -148,7 +148,7 @@ def data_standard_graph_all():
         return json.dumps(res, ensure_ascii=False, cls=MyEncoder)
 
 
-# 数据标签新增 data_label
+# 数据标签新增 DataLabel
 @bp.route('/data/label/add', methods=['POST'])
 def data_label_add():
     try:
@@ -158,7 +158,7 @@ def data_label_add():
         en_name = translate_and_parse(name)  # 英文名
         receiver['en_name'] = en_name[0]
         receiver['time'] = get_formatted_time()
-        create_or_get_node('data_label', **receiver)
+        create_or_get_node('DataLabel', **receiver)
 
         res = success('', "success")
         return json.dumps(res, ensure_ascii=False, cls=MyEncoder)
@@ -168,7 +168,7 @@ def data_label_add():
         return json.dumps(res, ensure_ascii=False, cls=MyEncoder)
 
 
-# 数据标签详情 data_label
+# 数据标签详情 DataLabel
 @bp.route('/data/label/detail', methods=['POST'])
 def data_label_detail():
     try:
@@ -176,7 +176,7 @@ def data_label_detail():
         receiver = request.get_json()
         nodeid = receiver['id']  # id
 
-        cql = """MATCH (n:data_label) where id(n) = $nodeId 
+        cql = """MATCH (n:DataLabel) where id(n) = $nodeId 
                   RETURN properties(n) as property"""
         with connect_graph().session() as session:
             property = session.run(cql, nodeId=nodeid).evaluate()

app/api/data_metric/routes.py

@@ -94,7 +94,7 @@ def data_metric_code():
     try:
         id_list = [item["id"] for item in relation]
         cql = """
-        MATCH (n:meta_node) WHERE id(n) IN $Id_list
+        MATCH (n:DataMetric) WHERE id(n) IN $Id_list
         WITH n.en_name AS en_name, n.name AS name
         WITH collect({en_name: en_name, name: name}) AS res
         WITH reduce(acc = {}, item IN res | apoc.map.setKey(acc, item.en_name, item.name)) AS result
@@ -235,7 +235,7 @@ def data_metric_list_graph():
             where_clause = "MATCH (n)-[:label]->(la) WHERE id(la) = $nodeId"
             params['nodeId'] = nodeid
         query = f"""
-        MATCH (n:data_metric)
+        MATCH (n:DataMetric)
         OPTIONAL MATCH (n)-[:child]->(child)
         {where_clause}
         WITH 

app/api/data_model/routes.py

@@ -173,7 +173,7 @@ def data_model_delete():
         # 首先删除数据模型节点
         from app.services.neo4j_driver import neo4j_driver
         query = """
-        MATCH (n:data_model) where id(n) = $nodeId
+        MATCH (n:DataModel) where id(n) = $nodeId
         detach delete n
         """
         with neo4j_driver.get_session() as session:
@@ -260,7 +260,7 @@ def data_model_list_graph():
 
         from app.services.neo4j_driver import neo4j_driver
         query = f"""
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         OPTIONAL MATCH (n)-[:child]->(child)
         {where_clause}
         WITH 

app/api/meta_data/routes.py

@@ -150,7 +150,7 @@ def meta_node_edit():
             
             # 获取标签信息
             tag_cypher = """
-            MATCH (n:meta_data)-[:label]->(t:data_label)
+            MATCH (n:meta_data)-[:label]->(t:DataLabel)
             WHERE id(n) = $node_id
             RETURN t
             """
@@ -259,7 +259,7 @@ def meta_node_add():
                 # 如果提供了标签ID，创建标签关系
                 if node_tag:
                     tag_cypher = """
-                    MATCH (n:meta_data), (t:data_label)
+                    MATCH (n:meta_data), (t:DataLabel)
                     WHERE id(n) = $node_id AND id(t) = $tag_id
                     MERGE (n)-[r:label]->(t)
                     RETURN r
@@ -780,7 +780,7 @@ def meta_node_update():
                 if tag is not None:
                     # 先删除现有标签关系
                     delete_tag_cypher = """
-                    MATCH (n:meta_data)-[r:label]->(t:data_label)
+                    MATCH (n:meta_data)-[r:label]->(t:DataLabel)
                     WHERE id(n) = $node_id
                     DELETE r
                     """
@@ -789,7 +789,7 @@ def meta_node_update():
                     # 创建新的标签关系
                     if tag and isinstance(tag, dict) and 'id' in tag:
                         create_tag_cypher = """
-                        MATCH (n:meta_data), (t:data_label)
+                        MATCH (n:meta_data), (t:DataLabel)
                         WHERE id(n) = $node_id AND id(t) = $tag_id
                         MERGE (n)-[r:label]->(t)
                         RETURN r

app/api/production_line/README.md

@@ -32,7 +32,7 @@
         {
           "id": 123,
           "name": "样例生产线",
-          "type": "data_model"
+          "type": "DataModel"
         }
         // 更多记录...
       ],
@@ -89,4 +89,8 @@
 
 ```python
 from app.core.production_line import production_draw_graph
-``` 
+```
+
+- 数据资源(DataResource)：处理数据资源与元数据节点及数据标准之间的关系
+
+graph_data = production_draw_graph(resource_id, "DataResource") 

app/api/production_line/routes.py

@@ -40,7 +40,7 @@ def production_line_list():
             where_clause = "TRUE"
         cql = f"""
         MATCH (n)
-        WHERE (n:data_model OR n:data_resource OR n:data_metric) AND {where_clause}
+                 WHERE (n:DataModel OR n:DataResource OR n:DataMetric) AND {where_clause}
         WITH id(n) AS id, n.name AS name, labels(n)[0] AS type,n
         RETURN  {{
             id: id,
@@ -65,9 +65,9 @@ def production_line_list():
             for item in data:
                 records.append(item['result'])
 
-            # 获取总量
-            total_query = f"MATCH (n) WHERE (n:data_model OR n:data_resource OR n:data_metric) AND {where_clause}" \
-                        f" RETURN COUNT(n) AS total"
+                          # 获取总量
+            total_query = f"MATCH (n) WHERE (n:DataModel OR n:DataResource OR n:DataMetric) AND {where_clause}" \
+                          f" RETURN COUNT(n) AS total"
             total_result = session.run(total_query).single()["total"]
         
         response_data = {'records': records, 'total': total_result, 'size': page_size, 'current': page}

app/core/data_flow/dataflows.py

@@ -95,33 +95,63 @@ class DataFlowService:
             数据流详情字典，如果不存在则返回None
         """
         try:
-            query = """
+            # 从Neo4j获取基本信息
+            neo4j_query = """
             MATCH (n:DataFlow)
             WHERE id(n) = $dataflow_id
-            OPTIONAL MATCH (n)-[:label]-(la:data_label)
-            OPTIONAL MATCH (n)-[:child]-(child)
-            OPTIONAL MATCH (parent)-[:child]-(n)
+            OPTIONAL MATCH (n)-[:label]-(la:DataLabel)
             RETURN n, id(n) as node_id,
-                   collect(DISTINCT {id: id(la), name: la.name}) as tags,
-                   collect(DISTINCT {id: id(child), name: child.name}) as children,
-                   collect(DISTINCT {id: id(parent), name: parent.name}) as parents
+                   collect(DISTINCT {id: id(la), name: la.name}) as tags
             """
             
             with connect_graph().session() as session:
-                result = session.run(query, dataflow_id=dataflow_id).data()
+                neo4j_result = session.run(neo4j_query, dataflow_id=dataflow_id).data()
                 
-                if not result:
+                if not neo4j_result:
                     return None
                 
-                record = result[0]
+                record = neo4j_result[0]
                 node = record['n']
                 dataflow = dict(node)
-                dataflow['id'] = record['node_id']  # 使用查询返回的node_id
+                dataflow['id'] = record['node_id']
                 dataflow['tags'] = record['tags']
-                dataflow['children'] = record['children']
-                dataflow['parents'] = record['parents']
+            
+            # 从PostgreSQL获取额外信息
+            pg_query = """
+            SELECT 
+                source_table,
+                target_table,
+                script_name,
+                script_type,
+                script_requirement,
+                script_content,
+                user_name,
+                create_time,
+                update_time,
+                target_dt_column
+            FROM dags.data_transform_scripts
+            WHERE script_name = :script_name
+            """
+            
+            with db.engine.connect() as conn:
+                pg_result = conn.execute(text(pg_query), {"script_name": dataflow.get('name_zh')}).fetchone()
                 
-                return dataflow
+                if pg_result:
+                    # 将PostgreSQL数据添加到结果中
+                    dataflow.update({
+                        'source_table': pg_result.source_table,
+                        'target_table': pg_result.target_table,
+                        'script_type': pg_result.script_type,
+                        'script_requirement': pg_result.script_requirement,
+                        'script_content': pg_result.script_content,
+                        'created_by': pg_result.user_name,
+                        'pg_created_at': pg_result.create_time,
+                        'pg_updated_at': pg_result.update_time,
+                        'target_dt_column': pg_result.target_dt_column
+                    })
+            
+            return dataflow
+            
         except Exception as e:
             logger.error(f"获取数据流详情失败: {str(e)}")
             raise e
@@ -139,12 +169,12 @@ class DataFlowService:
         """
         try:
             # 验证必填字段
-            required_fields = ['name', 'describe']
+            required_fields = ['name_zh', 'describe']
             for field in required_fields:
                 if field not in data:
                     raise ValueError(f"缺少必填字段: {field}")
             
-            dataflow_name = data['name']
+            dataflow_name = data['name_zh']
             
             # 使用LLM翻译名称生成英文名
             try:
@@ -165,6 +195,7 @@ class DataFlowService:
                 'tag': data.get('tag', ''),
                 'describe': data.get('describe', ''),
                 'status': data.get('status', 'inactive'),
+                'update_mode': data.get('update_mode', 'append'),
                 'created_at': get_formatted_time(),
                 'updated_at': get_formatted_time()
             }  
@@ -203,9 +234,9 @@ class DataFlowService:
                 
             # 返回创建的数据流信息
             # 查询创建的节点获取完整信息
-            query = "MATCH (n:DataFlow {name: $name}) RETURN n, id(n) as node_id"
+            query = "MATCH (n:DataFlow {name_zh: $name_zh}) RETURN n, id(n) as node_id"
             with connect_graph().session() as session:
-                id_result = session.run(query, name=dataflow_name).single()
+                id_result = session.run(query, name_zh=dataflow_name).single()
                 if id_result:
                     dataflow_node = id_result['n']
                     node_id = id_result['node_id']
@@ -217,7 +248,7 @@ class DataFlowService:
                     # 如果查询失败，返回基本信息
                     result = {
                         'id': dataflow_id if isinstance(dataflow_id, int) else None,
-                        'name': dataflow_name,
+                        'name_zh': dataflow_name,
                         'name_en': name_en,
                         'created_at': get_formatted_time()
                     }
@@ -237,14 +268,14 @@ class DataFlowService:
         Args:
             data: 包含脚本信息的数据
             script_name: 脚本名称
-            en_name: 英文名称
+            name_en: 英文名称
         """
         try:
             # 提取脚本相关信息
             script_requirement = data.get('script_requirement', '')
             script_content = data.get('script_content', '')
-            source_table = data.get('source_table', '')
-            target_table = data.get('target_table', name_en)  # 如果没有指定目标表，使用英文名
+            source_table = data.get('source_table', '').split(':')[-1] if ':' in data.get('source_table', '') else data.get('source_table', '')
+            target_table = data.get('target_table', '').split(':')[-1] if ':' in data.get('target_table', '') else data.get('target_table', name_en)  # 如果没有指定目标表，使用英文名
             script_type = data.get('script_type', 'python')
             user_name = data.get('created_by', 'system')
             target_dt_column = data.get('target_dt_column', '')
@@ -345,7 +376,7 @@ class DataFlowService:
         """处理标签关系"""
         try:
             # 查找标签节点
-            query = "MATCH (n:data_label) WHERE id(n) = $tag_id RETURN n"
+            query = "MATCH (n:DataLabel) WHERE id(n) = $tag_id RETURN n"
             with connect_graph().session() as session:
                 result = session.run(query, tag_id=tag_id).data()
                 
@@ -639,10 +670,16 @@ class DataFlowService:
             script_name = dataflow_name,
             script_type = data.get('script_type', 'sql')
             schedule_status = data.get('status', 'inactive')
-            source_table = data.get('source_table', '')
-            target_table = data.get('target_table', '')
+            source_table_full = data.get('source_table', '')
+            target_table_full = data.get('target_table', '')
             update_mode = data.get('update_mode', 'full')
             
+            # 处理source_table和target_table的格式
+            source_table = source_table_full.split(':')[-1] if ':' in source_table_full else source_table_full
+            target_table = target_table_full.split(':')[-1] if ':' in target_table_full else target_table_full
+            source_label = source_table_full.split(':')[0] if ':' in source_table_full else source_table_full
+            target_label = target_table_full.split(':')[0] if ':' in target_table_full else target_table_full
+            
             # 验证必要字段
             if not source_table or not target_table:
                 logger.warning(f"source_table或target_table为空，跳过关系创建: source_table={source_table}, target_table={target_table}")
@@ -651,71 +688,53 @@ class DataFlowService:
             logger.info(f"开始创建脚本关系: {source_table} -> {target_table}")
             
             with connect_graph().session() as session:
-                # 创建或获取source_table节点
-                source_node_query = """
-                MERGE (source:table {name: $source_table})
+                # 创建或获取source和target节点
+                create_nodes_query = f"""
+                MERGE (source:{source_label} {{name: $source_table}})
                 ON CREATE SET source.created_at = $created_at,
                              source.type = 'source'
-                RETURN source, id(source) as source_id
-                """
-                
-                # 创建或获取target_table节点
-                target_node_query = """
-                MERGE (target:table {name: $target_table})
+                WITH source
+                MERGE (target:{target_label} {{name: $target_table}})
                 ON CREATE SET target.created_at = $created_at,
                              target.type = 'target'
-                RETURN target, id(target) as target_id
+                RETURN source, target, id(source) as source_id, id(target) as target_id
                 """
                 
-                current_time = get_formatted_time()
-                
                 # 执行创建节点的查询
-                source_result = session.run(source_node_query, 
-                                          source_table=source_table, 
-                                          created_at=current_time).single()
-                target_result = session.run(target_node_query, 
-                                          target_table=target_table, 
-                                          created_at=current_time).single()
+                result = session.run(create_nodes_query,
+                                   source_table=source_table,
+                                   target_table=target_table,
+                                   created_at=get_formatted_time()).single()
                 
-                if source_result and target_result:
-                    source_id = source_result['source_id']
-                    target_id = target_result['target_id']
+                if result:
+                    source_id = result['source_id']
+                    target_id = result['target_id']
                     
-                    # 检查关系是否已存在
-                    relationship_check_query = """
-                    MATCH (source:table)-[r:DERIVED_FROM]-(target:table)
+                    # 检查并创建关系
+                    create_relationship_query = f"""
+                    MATCH (source:{source_label}), (target:{target_label})
                     WHERE id(source) = $source_id AND id(target) = $target_id
+                    AND NOT EXISTS((target)-[:DERIVED_FROM]->(source))
+                    CREATE (target)-[r:DERIVED_FROM]->(source)
+                    SET r.script_name = $script_name,
+                        r.script_type = $script_type,
+                        r.schedule_status = $schedule_status,
+                        r.update_mode = $update_mode,
+                        r.created_at = $created_at,
+                        r.updated_at = $created_at
                     RETURN r
                     """
                     
-                    existing_relationship = session.run(relationship_check_query, 
-                                                      source_id=source_id, 
-                                                      target_id=target_id).single()
+                    relationship_result = session.run(create_relationship_query,
+                                                   source_id=source_id,
+                                                   target_id=target_id,
+                                                   script_name=script_name,
+                                                   script_type=script_type,
+                                                   schedule_status=schedule_status,
+                                                   update_mode=update_mode,
+                                                   created_at=get_formatted_time()).single()
                     
-                    if not existing_relationship:
-                        # 创建DERIVED_FROM关系，从source_table到target_table
-                        create_relationship_query = """
-                        MATCH (source:table), (target:table)
-                        WHERE id(source) = $source_id AND id(target) = $target_id
-                        CREATE (target)-[r:DERIVED_FROM]->(source)
-                        SET r.script_name = $script_name,
-                            r.script_type = $script_type,
-                            r.schedule_status = $schedule_status,
-                            r.update_mode = $update_mode,
-                            r.created_at = $created_at,
-                            r.updated_at = $created_at
-                        RETURN r
-                        """
-                        
-                        session.run(create_relationship_query,
-                                  source_id=source_id,
-                                  target_id=target_id,
-                                  script_name=script_name,
-                                  script_type=script_type,
-                                  schedule_status=schedule_status,
-                                  update_mode=update_mode,
-                                  created_at=current_time)
-                        
+                    if relationship_result:
                         logger.info(f"成功创建DERIVED_FROM关系: {target_table} -> {source_table} (script: {script_name})")
                     else:
                         logger.info(f"DERIVED_FROM关系已存在: {target_table} -> {source_table}")

app/core/data_interface/README.md

@@ -50,7 +50,7 @@
 - `input`：输入参数（可选）
 - `output`：输出参数（可选）
 
-### 数据标签（data_label）
+### 数据标签（DataLabel）
 
 数据标签节点具有以下主要属性：
 - `name`：标签名称

app/core/data_interface/interface.py

@@ -3,7 +3,7 @@
 
 本模块包含了数据接口相关的所有核心业务逻辑函数，包括：
 - 数据标准(data_standard)相关功能
-- 数据标签(data_label)相关功能
+- 数据标签(DataLabel)相关功能
 - 图谱生成
 - 动态标签识别等功能
 """
@@ -109,8 +109,8 @@ def standard_kinship_graph(nodeid):
     cql = """
     MATCH(da:data_standard)
     WHERE id(da)=$nodeId
-    OPTIONAL MATCH(a:data_resource)-[:clean_resource]-(da)
-    OPTIONAL MATCH(b:data_model)-[:clean_model]-(da)
+    OPTIONAL MATCH(a:DataResource)-[:clean_resource]-(da)
+    OPTIONAL MATCH(b:DataModel)-[:clean_model]-(da)
     WITH 
         collect({id:toString(id(a)),text:a.name,type:split(labels(a)[0],'_')[1]})+
         collect({id:toString(id(b)),text:b.name,type:split(labels(b)[0],'_')[1]})+
@@ -156,8 +156,8 @@ def standard_impact_graph(nodeid):
     cql = """
         MATCH(da:data_standard)
         WHERE id(da)=$nodeId
-        OPTIONAL MATCH(da)-[:clean_model]-(m1:meta_node)
-        OPTIONAL MATCH(da)-[:clean_model]-(m2:meta_node)
+        OPTIONAL MATCH(da)-[:clean_model]-(m1:DataMeta)-[:clean_model]-(da)
+        OPTIONAL MATCH(da)-[:clean_model]-(m2:DataMeta)-[:clean_model]-(da)
         WITH 
             collect({id:toString(id(da)),text:da.name,type:split(labels(da)[0],'_')[1]})+
             collect({id:toString(id(m1)),text:m1.name})+
@@ -203,10 +203,10 @@ def standard_all_graph(nodeid):
     cql = """
     MATCH(da:data_standard)
     WHERE id(da)=$nodeId
-    OPTIONAL MATCH(a:data_resource)-[:clean_resource]-(da)
-    OPTIONAL MATCH(b:data_model)-[:clean_model]-(da)
-    OPTIONAL MATCH(da)-[:clean_model]-(m1:meta_node)
-    OPTIONAL MATCH(da)-[:clean_model]-(m2:meta_node)
+    OPTIONAL MATCH(a:DataResource)-[:clean_resource]-(da)
+    OPTIONAL MATCH(b:DataModel)-[:clean_model]-(da)
+    OPTIONAL MATCH(da)-[:clean_model]-(m1:DataMeta)-[:clean_model]-(da)
+    OPTIONAL MATCH(da)-[:clean_model]-(m2:DataMeta)-[:clean_model]-(da)
     WITH 
         collect({id:toString(id(a)),text:a.name,type:split(labels(a)[0],'_')[1]})+
         collect({id:toString(id(b)),text:b.name,type:split(labels(b)[0],'_')[1]})+
@@ -281,7 +281,7 @@ def label_list(skip_count, page_size, en_name_filter=None,
 
     # 构建完整的查询语句
     cql = f"""
-    MATCH (n:data_label)
+    MATCH (n:DataLabel)
     WHERE {where_str}
     WITH n, properties(n) as properties, n.time as time, id(n) as nodeid
     OPTIONAL MATCH (n)<-[r]-()
@@ -318,7 +318,7 @@ def label_list(skip_count, page_size, en_name_filter=None,
             data.append(properties)
 
         # 获取总量
-        total_query = f"MATCH (n:data_label) WHERE {where_str} RETURN COUNT(n) AS total"
+        total_query = f"MATCH (n:DataLabel) WHERE {where_str} RETURN COUNT(n) AS total"
         total_result = session.run(total_query, **params).single()["total"]
         
     return data, total_result
@@ -336,7 +336,7 @@ def id_label_graph(id):
         图谱数据
     """
     query = """
-    MATCH (n:data_label)
+    MATCH (n:DataLabel)
     WHERE id(n) = $nodeId
     OPTIONAL MATCH (a)-[:label]-(n)
     WITH 
@@ -378,13 +378,13 @@ def label_kinship_graph(nodeid):
     """
     # 查询语句
     cql = """
-    MATCH(la:data_label)
+    MATCH(la:DataLabel)
     WHERE id(la)=$nodeId
-    OPTIONAL MATCH(a:data_resource)-[:label]-(la)
-    OPTIONAL MATCH(b:data_model)-[:label]-(la)
-    OPTIONAL MATCH(meta:meta_node)-[:label]-(la)
+    OPTIONAL MATCH(a:DataResource)-[:label]-(la)
+    OPTIONAL MATCH(b:DataModel)-[:label]-(la)
+    OPTIONAL MATCH(meta:DataMeta)-[:label]-(la)
     OPTIONAL MATCH(d:data_standard)-[:label]-(la)
-    OPTIONAL MATCH(e:data_metric)-[:label]-(la)
+          OPTIONAL MATCH(e:DataMetric)-[:label]-(la)
     WITH 
         collect({id:toString(id(a)),text:a.name,type:split(labels(a)[0],'_')[1]})+
         collect({id:toString(id(b)),text:b.name,type:split(labels(b)[0],'_')[1]})+
@@ -433,7 +433,7 @@ def label_impact_graph(nodeid):
     """
     # 查询语句
     cql = """
-        MATCH(n:data_label)
+        MATCH(n:DataLabel)
         WHERE id(n)=$nodeId
         RETURN {id:toString(id(n)),text:(n.name),type:"label"} AS nodes,
                toString(id(n)) as rootId
@@ -468,7 +468,7 @@ def dynamic_label_list(name_filter=None):
     """
     # 构建完整的查询语句
     cql = f"""
-    MATCH (n:data_label)
+    MATCH (n:DataLabel)
     WITH n, apoc.text.levenshteinSimilarity(n.group, "{name_filter}") AS similarity
     WHERE similarity > 0.1 // 设置相似度阈值
     RETURN DISTINCT n.group as name, id(n) as nodeid

app/core/data_metric/metric_interface.py

@@ -65,9 +65,9 @@ def metric_list(skip_count, page_size, en_name_filter=None,
 
     # 构建完整的查询语句
     cql = f"""
-    MATCH (n:data_metric)-[:label]->(la:data_label)
+    MATCH (n:DataMetric)-[:label]->(la:DataLabel)
     WHERE {where_str}
-    OPTIONAL MATCH (n)-[:origin]->(m:data_model)
+    OPTIONAL MATCH (n)-[:origin]->(m:DataModel)
     WITH n, la, CASE WHEN m IS NULL THEN null ELSE {{id: id(m), name: m.name}}
     END AS data_model,properties(n) as properties,
            n.time as time,id(n) as nodeid,{{id:id(la),name:la.name}} as tag
@@ -103,7 +103,7 @@ def metric_list(skip_count, page_size, en_name_filter=None,
             data.append(properties)
 
         # 获取总量
-        total_query = f"MATCH (n:data_metric) " \
+        total_query = f"MATCH (n:DataMetric) " \
                       f"WHERE {where_str} RETURN COUNT(n) AS total"
         total_result = session.run(total_query, **params).single()["total"]
     
@@ -121,7 +121,7 @@ def handle_metric_relation(model_ids):
         list: 血缘关系数据
     """
     query = """
-            MATCH (search:data_model)-[:connection]->(common_node:meta_node)<-[:connection]-(connect:data_model)
+            MATCH (search:DataModel)-[:connection]->(common_node:meta_node)<-[:connection]-(connect:DataModel)
             WHERE id(search) = $model_Ids
             WITH search, connect, common_node
             MATCH (search)-[:connection]->(search_node:meta_node)
@@ -154,15 +154,15 @@ def id_mertic_graph(id):
         dict: 图谱数据，包含节点、连线和根节点ID
     """
     query = """
-    MATCH (n:data_metric)
+    MATCH (n:DataMetric)
     WHERE id(n) = $nodeId
     WITH n, apoc.convert.fromJsonList(n.model_id) AS id_lists
     UNWIND id_lists AS id_list
     WITH n, id_list.id AS model_id, id_list.metaData AS meta_ids
-    OPTIONAL MATCH (t:data_label) WHERE id(t) = n.tag
+    OPTIONAL MATCH (t:DataLabel) WHERE id(t) = n.tag
     UNWIND meta_ids AS meta_id
-    MATCH (d:data_model) WHERE id(d) = model_id
-    MATCH (a:meta_node) WHERE id(a) = meta_id
+    MATCH (d:DataModel) WHERE id(d) = model_id
+    MATCH (a:DataMeta) WHERE id(a) = meta_id
     with 
        collect({from:toString(id(n)),to:toString(id(d)),text:"来源"})+
        collect({from:toString(id(n)),to:toString(id(a)),text:"包含"})+
@@ -213,7 +213,7 @@ def handle_data_metric(metric_name, result_list, receiver):
         'en_name': data_metric_en
     })
 
-    data_metric_node = get_node('data_metric', name=metric_name) or create_or_get_node('data_metric', **receiver)
+    data_metric_node = get_node('DataMetric', name=metric_name) or create_or_get_node('DataMetric', **receiver)
 
     child_list = receiver['childrenId']
     for child_id in child_list:
@@ -228,7 +228,7 @@ def handle_data_metric(metric_name, result_list, receiver):
                 connect_graph.create(Relationship(data_metric_node, 'child', child))
 
     if receiver.get('tag'):
-        tag = get_node_by_id('data_label', receiver['tag'])
+        tag = get_node_by_id('DataLabel', receiver['tag'])
         if tag:
             # 获取节点ID
             dm_id = data_metric_node.id if hasattr(data_metric_node, 'id') else data_metric_node.identity if hasattr(data_metric_node, 'identity') else None
@@ -253,25 +253,25 @@ def handle_meta_data_metric(data_metric_node_id, id_list):
     metric_ids = [item['id'] for item in id_list if item['type'] == 'metric']
     
     with connect_graph().session() as session:
-        # 创建与data_model的关系
+        # 创建与DataModel的关系
         if model_ids:
             cql_resource = """
-                MATCH (n:data_metric)
+                MATCH (n:DataMetric)
                 WHERE id(n) = $data_metric_node_id
                 UNWIND $model_ids AS model_id
-                MATCH (d:data_model)
+                MATCH (d:DataModel)
                 WHERE id(d) = model_id
                 MERGE (n)-[:origin]->(d)
             """
             session.run(cql_resource, data_metric_node_id=data_metric_node_id, model_ids=model_ids)
             
-        # 创建与data_metric的关系
+        # 创建与DataMetric的关系
         if metric_ids:
             cql_resource = """
-                MATCH (n:data_metric)
+                MATCH (n:DataMetric)
                 WHERE id(n) = $data_metric_node_id
                 UNWIND $metric_ids AS metric_id
-                MATCH (d:data_metric)
+                MATCH (d:DataMetric)
                 WHERE id(d) = metric_id
                 MERGE (n)-[:origin]->(d)
             """
@@ -281,10 +281,10 @@ def handle_meta_data_metric(data_metric_node_id, id_list):
         for record in id_list:
             if "metaData" in record and record['metaData'] != []:
                 cql_meta = """
-                            MATCH (n:data_metric)
+                            MATCH (n:DataMetric)
                             WHERE id(n) = $data_metric_node_id
                             UNWIND $meta_ids AS meta_id
-                            MATCH (d:meta_node)
+                            MATCH (d:DataMeta)
                             WHERE id(d) = meta_id
                             MERGE (n)-[:connection]->(d)
                         """
@@ -302,23 +302,23 @@ def handle_id_metric(id):
         dict: 指标详情数据
     """
     query = """
-    MATCH (n:data_metric)
+    MATCH (n:DataMetric)
     WHERE id(n) = $nodeId
     WITH apoc.convert.fromJsonList(n.id_list) AS info, n
     UNWIND info AS item
     WITH n, item.id AS model_or_metric_id, item.metaData AS meta_ids, item.type AS type
     
     // 数据模型或者数据指标
-    OPTIONAL MATCH (n)-[:origin]->(m1:data_model)
+    OPTIONAL MATCH (n)-[:origin]->(m1:DataModel)
     WHERE type = 'model' AND id(m1) = model_or_metric_id
     WITH n, model_or_metric_id, meta_ids, type, m1
-    OPTIONAL MATCH (n)-[:origin]->(m2:data_metric)
+    OPTIONAL MATCH (n)-[:origin]->(m2:DataMetric)
     WHERE type = 'metric' AND id(m2) = model_or_metric_id
     WITH n, model_or_metric_id, meta_ids, type, m1, m2
     // 元数据
-    OPTIONAL MATCH (n)-[:connection]-(meta:meta_node)
+    OPTIONAL MATCH (n)-[:connection]-(meta:DataMeta)
     // 数据标签
-    OPTIONAL MATCH (n)-[:label]-(la:data_label)
+    OPTIONAL MATCH (n)-[:label]-(la:DataLabel)
     OPTIONAL MATCH (parent)-[:child]-(n)
     WITH properties(n) AS properties,collect(DISTINCT id(meta)) AS meta_list,parent,
         {id: id(la), name: la.name} AS tag,
@@ -382,8 +382,8 @@ def metric_kinship_graph(nodeid, meta):
         id: toString(id(n)),
         text: n.name+'-测试',
         type: CASE 
-            WHEN 'data_metric' IN labels(n) THEN 'metric'
-            WHEN 'data_model' IN labels(n) THEN 'model'
+            WHEN 'DataMetric' IN labels(n) THEN 'metric'
+            WHEN 'DataModel' IN labels(n) THEN 'model'
             ELSE split(labels(n)[0],'_')[1]
         END
     }) as nodes, paths
@@ -429,11 +429,11 @@ def metric_impact_graph(nodeid, meta):
     if meta:
         # 查询语句
         cql = """
-        MATCH(mc2:data_metric)
+        MATCH(mc2:DataMetric)
         WHERE id(mc2)=$nodeId
-        OPTIONAL MATCH(mc4:data_metric)-[:origin]-(mc2)
-        OPTIONAL MATCH(mc2)-[:connection]-(meta:meta_node)
-        OPTIONAL MATCH(mc2)-[:label]-(la:data_label)
+        OPTIONAL MATCH(mc4:DataMetric)-[:origin]-(mc2)
+        OPTIONAL MATCH(mc2)-[:connection]-(meta:DataMeta)
+        OPTIONAL MATCH(mc2)-[:label]-(la:DataLabel)
         OPTIONAL MATCH(mc2)-[:child]-(child)
         WITH 
             collect({id:toString(id(mc2)),text:mc2.name,type:split(labels(mc2)[0],'_')[1]})+
@@ -454,10 +454,10 @@ def metric_impact_graph(nodeid, meta):
     else:
         # 查询语句
         cql = """
-            MATCH(mc2:data_metric)
+            MATCH(mc2:DataMetric)
             WHERE id(mc2)=$nodeId
-            OPTIONAL MATCH(mc4:data_metric)-[:origin]-(mc2)
-            OPTIONAL MATCH(mc2)-[:label]-(la:data_label)
+            OPTIONAL MATCH(mc4:DataMetric)-[:origin]-(mc2)
+            OPTIONAL MATCH(mc2)-[:label]-(la:DataLabel)
             OPTIONAL MATCH(mc2)-[:child]-(child)
             WITH 
                 collect({id:toString(id(mc2)),text:mc2.name,type:split(labels(mc2)[0],'_')[1]})+
@@ -499,13 +499,13 @@ def metric_all_graph(nodeid, meta):
     if meta:
         # 查询语句
         cql = """
-        MATCH(mc2:data_metric)
+        MATCH(mc2:DataMetric)
         WHERE id(mc2)=$nodeId
-        OPTIONAL MATCH(mc2)-[:origin]-(mo:data_model)
-        OPTIONAL MATCH(mc2)-[:origin]-(mc1:data_metric)
-        OPTIONAL MATCH(mc4:data_metric)-[:origin]-(mc2)
-        OPTIONAL MATCH(mc2)-[:connection]-(meta:meta_node)
-        OPTIONAL MATCH(mc2)-[:label]-(la:data_label)
+        OPTIONAL MATCH(mc2)-[:origin]-(mo:DataModel)
+        OPTIONAL MATCH(mc2)-[:origin]-(mc1:DataMetric)
+        OPTIONAL MATCH(mc4:DataMetric)-[:origin]-(mc2)
+        OPTIONAL MATCH(mc2)-[:connection]-(meta:DataMeta)
+        OPTIONAL MATCH(mc2)-[:label]-(la:DataLabel)
         OPTIONAL MATCH(mc2)-[:child]-(child)
         WITH 
             collect({id:toString(id(mc2)),text:mc2.name,type:split(labels(mc2)[0],'_')[1]})+
@@ -530,12 +530,12 @@ def metric_all_graph(nodeid, meta):
     else:
         # 查询语句
         cql = """
-            MATCH(mc2:data_metric)
+            MATCH(mc2:DataMetric)
             WHERE id(mc2)=$nodeId
-            OPTIONAL MATCH(mc2)-[:origin]-(mo:data_model)
-            OPTIONAL MATCH(mc2)-[:origin]-(mc1:data_metric)
-            OPTIONAL MATCH(mc4:data_metric)-[:origin]-(mc2)
-            OPTIONAL MATCH(mc2)-[:label]-(la:data_label)
+            OPTIONAL MATCH(mc2)-[:origin]-(mo:DataModel)
+            OPTIONAL MATCH(mc2)-[:origin]-(mc1:DataMetric)
+            OPTIONAL MATCH(mc4:DataMetric)-[:origin]-(mc2)
+            OPTIONAL MATCH(mc2)-[:label]-(la:DataLabel)
             OPTIONAL MATCH(mc2)-[:child]-(child)
             WITH 
                 collect({id:toString(id(mc2)),text:mc2.name,type:split(labels(mc2)[0],'_')[1]})+
@@ -574,7 +574,7 @@ def data_metric_edit(data):
     Args:
         data: 数据指标数据
     """
-    node_a = get_node_by_id('data_metric', data["id"])
+    node_a = get_node_by_id('DataMetric', data["id"])
     if node_a:
         delete_relationships(data["id"])
 
@@ -601,7 +601,7 @@ def data_metric_edit(data):
 
     # 处理数据标签及其关系
     if data.get("tag"):
-        tag_node = get_node_by_id('data_label', data["tag"])
+        tag_node = get_node_by_id('DataLabel', data["tag"])
         if tag_node:
             relationship_label = Relationship(node_a, "label", tag_node)
             connect_graph.merge(relationship_label)
@@ -628,7 +628,7 @@ def create_metric_node(name, description, category, id_list):
     Returns:
         tuple: (节点ID, ID列表)
     """
-    data_metric_node = create_or_get_node('data_metric', 
+    data_metric_node = create_or_get_node('DataMetric', 
                                         name=name,
                                         description=description,
                                         category=category,
@@ -637,4 +637,4 @@ def create_metric_node(name, description, category, id_list):
     if not hasattr(data_metric_node, 'id'):
         raise ValueError("Failed to create valid metric node")
         
-    return data_metric_node.id, id_list 
+    return data_metric_node.id, id_list 

app/core/data_model/README.md

@@ -12,9 +12,9 @@
 
 2. **数据模型关系管理**
    - 数据模型与元数据（meta_node）的关系处理
-   - 数据模型与数据资源（data_resource）的关系处理
+   - 数据模型与数据资源（DataResource）的关系处理
    - 数据模型与其他数据模型的关系处理
-   - 数据模型与标签（data_label）的关系处理
+   - 数据模型与标签（DataLabel）的关系处理
 
 3. **数据模型层级管理**
    - 计算并设置数据模型层级（level）属性
@@ -48,7 +48,7 @@
 
 ## 数据模型
 
-数据模型（data_model）节点具有以下主要属性：
+数据模型（DataModel）节点具有以下主要属性：
 - `name`：数据模型名称（中文）
 - `en_name`：数据模型英文名称
 - `category`：数据模型分类

app/core/data_model/model.py

@@ -43,7 +43,7 @@ def calculate_model_level(id):
     node_id = int(id) if id is not None else None
     
     cql = """
-    MATCH (start_node:data_model)
+    MATCH (start_node:DataModel)
     WHERE id(start_node) = $nodeId
     CALL {
         WITH start_node
@@ -61,7 +61,7 @@ def calculate_model_level(id):
         
     # 更新level属性
     update_query = """
-    MATCH (n:data_model)
+    MATCH (n:DataModel)
     WHERE id(n) = $nodeId
     SET n.level = $level
     RETURN n
@@ -83,7 +83,7 @@ def handle_model_relation(resource_ids):
         血缘关系数据
     """
     query = """
-            MATCH (search:data_resource)-[:connection]->(common_node:meta_node)<-[:connection]-(connect:data_resource)
+            MATCH (search:DataResource)-[:connection]->(common_node:meta_node)<-[:connection]-(connect:DataResource)
             WHERE id(search) = $resource_Ids
             WITH search, connect, common_node
             MATCH (search)-[:connection]->(search_node:meta_node)
@@ -129,7 +129,7 @@ def handle_data_model(data_model, result_list, result, receiver):
             'en_name': data_model_en
         }
         receiver.update(add_attribute)
-        data_model_node = get_node('data_model', name=data_model) or create_or_get_node('data_model', **receiver)
+        data_model_node = get_node('DataModel', name=data_model) or create_or_get_node('DataModel', **receiver)
 
         logger.info(f"通过查询或创建节点获得节点ID111，data_model_node: {data_model_node}")
         # 获取节点ID，确保我们能安全地访问节点ID
@@ -141,7 +141,7 @@ def handle_data_model(data_model, result_list, result, receiver):
             logger.info(f"通过查询节点名称获取节点ID333，data_model_node: {data_model_node}")
             # 如果节点没有id属性，尝试通过查询获取
             query = """
-            MATCH (n:data_model {name: $name})
+            MATCH (n:DataModel {name: $name})
             RETURN id(n) as node_id
             """
             with connect_graph().session() as session:
@@ -179,7 +179,7 @@ def handle_data_model(data_model, result_list, result, receiver):
 
         # 根据传入参数id，和数据标签建立关系
         if receiver.get('tag'):
-            tag = get_node_by_id('data_label', receiver['tag'])
+            tag = get_node_by_id('DataLabel', receiver['tag'])
             if tag:
                 # 直接使用Cypher查询检查关系是否存在
                 with connect_graph().session() as session:
@@ -233,7 +233,7 @@ def resource_handle_meta_data_model(id_lists, data_model_node_id):
         if meta_ids:
             logger.info("开始创建数据模型与元数据的关系")
             query = """
-            MATCH (source:data_model), (target:meta_data)
+            MATCH (source:DataModel), (target:DataMeta)
             WHERE id(source)=$source_id AND id(target) IN $target_ids
             MERGE (source)-[:INCLUDE]->(target)
             RETURN count(*) as count
@@ -243,11 +243,11 @@ def resource_handle_meta_data_model(id_lists, data_model_node_id):
                 count = result.single()["count"]
                 logger.info(f"成功创建 {count} 个数据模型与元数据的关系")
 
-        # 创建与data_resource的关系 资源关系
+        # 创建与DataResource的关系 资源关系
         if resouce_ids:
             logger.info("开始创建数据模型与数据资源的关系")
             query = """
-            MATCH (source:data_model), (target:data_resource)
+            MATCH (source:DataModel), (target:DataResource)
             WHERE id(source)=$source_id AND id(target) IN $target_ids
             MERGE (source)-[:DERIVES_FROM]->(target)
             RETURN count(*) as count
@@ -281,7 +281,7 @@ def model_handle_meta_data_model(id_lists, data_model_node_id):
     # 创建与meta_node的关系 组成关系
     if meta_ids:
         query = """
-        MATCH (source:data_model), (target:meta_node)
+        MATCH (source:DataModel), (target:DataMeta)
         WHERE id(source)=$source_id AND id(target) IN $target_ids
         MERGE (source)-[:component]->(target)
         """
@@ -291,7 +291,7 @@ def model_handle_meta_data_model(id_lists, data_model_node_id):
     # 创建与data_model的关系 模型关系
     if model_ids:
         query = """
-        MATCH (source:data_model), (target:data_model)
+        MATCH (source:DataModel), (target:DataModel)
         WHERE id(source)=$source_id AND id(target) IN $target_ids
         MERGE (source)-[:use]->(target)
         """
@@ -323,7 +323,7 @@ def handle_no_meta_data_model(id_lists, receiver, data_model_node):
     else:
         # 如果节点没有id属性，尝试通过查询获取
         query = """
-        MATCH (n:data_model {name: $name})
+        MATCH (n:DataModel {name: $name})
         RETURN id(n) as node_id
         """
         with connect_graph().session() as session:
@@ -335,10 +335,10 @@ def handle_no_meta_data_model(id_lists, receiver, data_model_node):
     if not data_model_node_id:
         return
     
-    # 创建与data_resource的关系 资源关系
+    # 创建与DataResource的关系 资源关系
     if resouce_ids:
         query = """
-        MATCH (source:data_model), (target:data_resource)
+        MATCH (source:DataModel), (target:DataResource)
         WHERE id(source)=$source_id AND id(target) IN $target_ids
         MERGE (source)-[:resource]->(target)
         """
@@ -383,7 +383,7 @@ def handle_no_meta_data_model(id_lists, receiver, data_model_node):
                 }
                 
                 # 创建meta_node节点
-                meta_node = create_or_get_node('meta_node', **meta_params)
+                meta_node = create_or_get_node('DataMeta', **meta_params)
                 
                 # 获取数据模型节点ID
                 dm_id = data_model_node_id if data_model_node_id is not None else data_model_node
@@ -439,10 +439,10 @@ def handle_id_model(id):
     """
     node_id = id
     cql = """
-        MATCH (n:data_model) WHERE id(n) = $nodeId
-        OPTIONAL MATCH (n)-[:INCLUDE]->(meta:meta_data)  
-        OPTIONAL MATCH (n)-[:DERIVES_FROM]->(resource:data_resource)
-        OPTIONAL MATCH (n)-[:label]->(tag:data_label)
+        MATCH (n:DataModel) WHERE id(n) = $nodeId
+        OPTIONAL MATCH (n)-[:INCLUDE]->(meta:DataMeta)  
+        OPTIONAL MATCH (n)-[:DERIVES_FROM]->(resource:DataResource)
+        OPTIONAL MATCH (n)-[:label]->(tag:DataLabel)
         OPTIONAL MATCH (uses:model_use)-[:use]->(n)
         OPTIONAL MATCH (n)-[:has_component]->(component)
         WITH n, 
@@ -586,7 +586,7 @@ def model_list(skip_count, page_size, en_name_filter=None, name_filter=None,
         with connect_graph().session() as session:
             # 计算总数量
             count_query = f"""
-            MATCH (n:data_model)
+            MATCH (n:DataModel)
             OPTIONAL MATCH (n)-[:label]->(t)
             {where_str}
             RETURN COUNT(DISTINCT n) AS count
@@ -597,7 +597,7 @@ def model_list(skip_count, page_size, en_name_filter=None, name_filter=None,
 
             # 查询数据
             query = f"""
-            MATCH (n:data_model)
+            MATCH (n:DataModel)
             OPTIONAL MATCH (n)-[:label]->(t)
             {where_str}
             RETURN DISTINCT 
@@ -670,9 +670,9 @@ def model_resource_list(skip_count, page_size, name_filter=None, id=None,
     try:
         # 构建基础查询
         base_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH (n)-[:children]->(m:data_resource)
+        MATCH (n)-[:children]->(m:DataResource)
         """
         
         # 计算总数量
@@ -689,7 +689,7 @@ def model_resource_list(skip_count, page_size, name_filter=None, id=None,
             # 使用分页和筛选条件构建主查询
             main_query = base_query + """
             MATCH (m)-[:label]->(l)
-            WHERE id(n) = $nodeId and labels(m) <> ['meta_node']
+            WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
             RETURN m.name as name, 
                    m.en_name as en_name,
                    id(m) as id,
@@ -743,7 +743,7 @@ def model_kinship_graph(nodeid, meta=False):
     with connect_graph().session() as session:
         # 查询起始模型节点
         start_node_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
         RETURN n.name as name, n.en_name as en_name
         """
@@ -756,9 +756,9 @@ def model_kinship_graph(nodeid, meta=False):
         
         # 查询与模型关联的数据资源
         resource_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:data_resource)
+        MATCH p = (n)-[:children]->(resource:DataResource)
         RETURN resource
         """
         
@@ -794,9 +794,9 @@ def model_kinship_graph(nodeid, meta=False):
         # 处理元数据节点
         if meta:
             meta_query = """
-            MATCH (n:data_model)
-            WHERE id(n) = $nodeId and labels(m) <> ['meta_node']
-            MATCH p = (n)-[:meta]->(meta:meta_node)
+            MATCH (n:DataModel)
+            WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
+            MATCH p = (n)-[:meta]->(meta:DataMeta)
             RETURN meta
             """
             meta_result = session.run(meta_query, nodeId=nodeid)
@@ -849,7 +849,7 @@ def model_impact_graph(nodeid, meta=False):
     with connect_graph().session() as session:
         # 查询起始模型节点
         start_node_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
         RETURN n.name as name, n.en_name as en_name
         """
@@ -862,9 +862,9 @@ def model_impact_graph(nodeid, meta=False):
         
         # 查询影响模型的数据资源
         resource_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:data_resource)
+        MATCH p = (n)-[:children]->(resource:DataResource)
         RETURN resource
         """
         
@@ -900,9 +900,9 @@ def model_impact_graph(nodeid, meta=False):
         # 处理元数据节点
         if meta:
             meta_query = """
-            MATCH (n:data_model)
-            WHERE id(n) = $nodeId and labels(m) <> ['meta_node']
-            MATCH p = (n)-[:meta]->(meta:meta_node)
+            MATCH (n:DataModel)
+            WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
+            MATCH p = (n)-[:meta]->(meta:DataMeta)
             RETURN meta
             """
             meta_result = session.run(meta_query, nodeId=nodeid)
@@ -955,7 +955,7 @@ def model_all_graph(nodeid, meta=False):
     with connect_graph().session() as session:
         # 查询起始模型节点
         start_node_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
         RETURN n.name as name, n.en_name as en_name
         """
@@ -968,9 +968,9 @@ def model_all_graph(nodeid, meta=False):
         
         # 查询与模型关联的数据资源
         resource_query = """
-        MATCH (n:data_model)
+        MATCH (n:DataModel)
         WHERE id(n) = $nodeId
-        MATCH p = (n)-[:children]->(resource:data_resource)
+        MATCH p = (n)-[:children]->(resource:DataResource)
         RETURN resource
         """
         
@@ -978,9 +978,9 @@ def model_all_graph(nodeid, meta=False):
         
         # 查询与模型关联的元数据
         meta_query = """
-        MATCH (n:data_model)
-        WHERE id(n) = $nodeId and labels(m) <> ['meta_node']
-        MATCH p = (n)-[:meta]->(meta:meta_node)
+        MATCH (n:DataModel)
+        WHERE id(n) = $nodeId and labels(m) <> ['DataMeta']
+        MATCH p = (n)-[:meta]->(meta:DataMeta)
         RETURN meta
         """
         
@@ -1066,7 +1066,7 @@ def data_model_edit(receiver):
     
     # 更新数据模型节点
     query = """
-    MATCH (n:data_model) WHERE id(n) = $id
+    MATCH (n:DataModel) WHERE id(n) = $id
     SET n.name = $name, n.en_name = $en_name, n.category = $category, n.describe = $describe
     RETURN n
     """
@@ -1079,14 +1079,14 @@ def data_model_edit(receiver):
     if tag:
         # 先删除所有标签关系
         delete_query = """
-        MATCH (n:data_model)-[r:label]->() WHERE id(n) = $id
+        MATCH (n:DataModel)-[r:label]->() WHERE id(n) = $id
         DELETE r
         """
         with connect_graph().session() as session:
             session.run(delete_query, id=id)
         
         # 再创建新的标签关系
-        tag_node = get_node_by_id('data_label', tag)
+        tag_node = get_node_by_id('DataLabel', tag)
         if tag_node:
             model_node = get_node_by_id_no_label(id)
             if model_node:

app/core/data_parse/parse.py

@@ -294,7 +294,7 @@ def create_main_card_with_duplicates(extracted_data, minio_path, suspected_dupli
     try:
         # 1. 先创建主记录
         # 准备初始职业轨迹，包含当前名片信息和图片路径
-        initial_career_path = extracted_data.get('career_path', [])
+        # initial_career_path = extracted_data.get('career_path', [])
         if extracted_data.get('hotel_zh') or extracted_data.get('hotel_en') or extracted_data.get('title_zh') or extracted_data.get('title_en'):
             initial_entry = {
                 'date': datetime.now().strftime('%Y-%m-%d'),
@@ -305,7 +305,7 @@ def create_main_card_with_duplicates(extracted_data, minio_path, suspected_dupli
                 'image_path': minio_path or '',  # 当前名片的图片路径
                 'source': 'business_card_creation'
             }
-            initial_career_path.append(initial_entry)
+        initial_career_path = [initial_entry]
         
         main_card = BusinessCard(
             name_zh=extracted_data.get('name_zh', ''),
@@ -1155,7 +1155,7 @@ def create_talent_tag(tag_data):
                 tag_properties['en_name'] = ''
                 
         # 创建节点
-        node_id = create_or_get_node('data_label', **tag_properties)
+        node_id = create_or_get_node('DataLabel', **tag_properties)
         
         if node_id:
             return {
@@ -1196,7 +1196,7 @@ def get_talent_tag_list():
         
         # 构建Cypher查询语句，获取分类为talent的标签
         query = """
-        MATCH (n:data_label)
+        MATCH (n:DataLabel)
         WHERE n.category CONTAINS 'talent' OR n.category CONTAINS '人才'
         RETURN id(n) as id, n.name as name, n.en_name as en_name, 
                n.category as category, n.describe as description, 
@@ -1306,7 +1306,7 @@ def update_talent_tag(tag_id, tag_data):
         set_clause = ", ".join(set_clauses)
         
         query = f"""
-        MATCH (n:data_label)
+        MATCH (n:DataLabel)
         WHERE id(n) = $nodeId
         SET {set_clause}
         RETURN id(n) as id, n.name as name, n.en_name as en_name, 
@@ -1371,7 +1371,7 @@ def delete_talent_tag(tag_id):
         
         # 首先获取要删除的标签信息，以便在成功后返回
         get_query = """
-        MATCH (n:data_label)
+        MATCH (n:DataLabel)
         WHERE id(n) = $nodeId
         RETURN id(n) as id, n.name as name, n.en_name as en_name, 
                n.category as category, n.describe as description, 
@@ -1380,7 +1380,7 @@ def delete_talent_tag(tag_id):
         
         # 构建删除节点和关系的Cypher查询
         delete_query = """
-        MATCH (n:data_label)
+        MATCH (n:DataLabel)
         WHERE id(n) = $nodeId
         OPTIONAL MATCH (n)-[r]-()
         DELETE r, n
@@ -1466,7 +1466,7 @@ def query_neo4j_graph(query_requirement):
         # 步骤1: 从Neo4j获取所有标签列表
         logging.info("第一步：从Neo4j获取人才类别的标签列表")
         all_labels_query = """
-        MATCH (dl:data_label)
+        MATCH (dl:DataLabel)
         WHERE dl.category CONTAINS '人才' OR dl.category CONTAINS 'talent'
         RETURN dl.name as name
         """
@@ -1586,11 +1586,11 @@ def query_neo4j_graph(query_requirement):
            属性: pg_id(PostgreSQL数据库ID), name_zh(中文姓名), name_en(英文姓名), 
                 mobile(手机号码), email(电子邮箱), updated_at(更新时间)
         
-        2. data_label - 人才标签节点
+        2. DataLabel - 人才标签节点
                       
         ### 关系
         BELONGS_TO - 从属关系
-           (talent)-[BELONGS_TO]->(data_label) - 人才属于某标签
+           (talent)-[BELONGS_TO]->(DataLabel) - 人才属于某标签
         
         ## 匹配的标签列表
         [{matched_labels_str}]
@@ -1610,7 +1610,7 @@ def query_neo4j_graph(query_requirement):
         假设匹配的标签是 ['五星级酒店', '新开酒店经验', '总经理']
         
         生成的Cypher查询语句应该是：
-        MATCH (t:talent)-[:BELONGS_TO]->(dl:data_label)  
+        MATCH (t:talent)-[:BELONGS_TO]->(dl:DataLabel)  
         WHERE dl.name IN ['五星级酒店', '新开酒店经验', '总经理']  
         WITH t, COLLECT(DISTINCT dl.name) AS labels  
         WHERE size(labels) = 3  
@@ -1713,7 +1713,7 @@ def talent_get_tags(talent_id):
         
         # 构建Cypher查询语句，获取人才节点关联的标签
         cypher_query = """
-        MATCH (t:talent)-[r:BELONGS_TO]->(tag:data_label)
+        MATCH (t:talent)-[r:BELONGS_TO]->(tag:DataLabel)
         WHERE t.pg_id = $talent_id
         RETURN t.pg_id as talent_id, tag.name as tag_name
         """
@@ -1831,7 +1831,7 @@ def talent_update_tags(data):
                 
                 # 首先清除所有现有的BELONGS_TO关系
                 clear_relations_query = """
-                MATCH (t:talent)-[r:BELONGS_TO]->(:data_label)
+                MATCH (t:talent)-[r:BELONGS_TO]->(:DataLabel)
                 WHERE t.pg_id = $talent_id
                 DELETE r
                 RETURN count(r) as deleted_count
@@ -1846,7 +1846,7 @@ def talent_update_tags(data):
                         # 1. 查找或创建标签节点
                         # 先查找是否存在该标签
                         find_tag_query = """
-                        MATCH (tag:data_label)
+                        MATCH (tag:DataLabel)
                         WHERE tag.name = $tag_name
                         RETURN id(tag) as tag_id
                         """
@@ -1858,7 +1858,7 @@ def talent_update_tags(data):
                         else:
                             # 创建新标签
                             create_tag_query = """
-                            CREATE (tag:data_label {name: $name, category: $category, updated_at: $updated_at})
+                            CREATE (tag:DataLabel {name: $name, category: $category, updated_at: $updated_at})
                             RETURN id(tag) as tag_id
                             """
                             tag_result = session.run(
@@ -1872,7 +1872,7 @@ def talent_update_tags(data):
                         
                         # 2. 创建人才与标签的BELONGS_TO关系
                         create_relation_query = """
-                        MATCH (t:talent), (tag:data_label)
+                        MATCH (t:talent), (tag:DataLabel)
                         WHERE t.pg_id = $talent_id AND tag.name = $tag_name
                         CREATE (t)-[r:BELONGS_TO]->(tag)
                         SET r.created_at = $current_time

app/core/data_parse/parse_card.py

@@ -263,7 +263,7 @@ def add_business_card(card_data, image_file=None):
             else:
                 # 创建新记录
                 # 准备初始职业轨迹，包含当前名片信息和图片路径
-                initial_career_path = card_data.get('career_path', [])
+                # initial_career_path = card_data.get('career_path', [])
                 if card_data.get('hotel_zh') or card_data.get('hotel_en') or card_data.get('title_zh') or card_data.get('title_en'):
                     initial_entry = {
                         'date': datetime.now().strftime('%Y-%m-%d'),
@@ -274,7 +274,7 @@ def add_business_card(card_data, image_file=None):
                         'image_path': minio_path or '',  # 当前名片的图片路径
                         'source': 'business_card_creation'
                     }
-                    initial_career_path.append(initial_entry)
+                initial_career_path = [initial_entry]
                 
                 business_card = BusinessCard(
                     name_zh=card_data.get('name_zh', ''),

app/core/data_resource/resource.py

@@ -125,11 +125,11 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
         tag_list = receiver.get('tag')
         receiver.update(update_attributes)
 
-        # 创建或获取 data_resource 节点
+        # 创建或获取 DataResource 节点
         with neo4j_driver.get_session() as session:
             props_str = ", ".join([f"{k}: ${k}" for k in receiver.keys()])
             cypher = f"""
-            MERGE (n:data_resource {{name: $name}})
+            MERGE (n:DataResource {{name: $name}})
             ON CREATE SET n = {{{props_str}}}
             ON MATCH SET {", ".join([f"n.{k} = ${k}" for k in receiver.keys()])}
             RETURN n
@@ -143,11 +143,11 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
 
             # 处理标签关系
             if tag_list:
-                tag_node = get_node_by_id('data_label', tag_list)
+                tag_node = get_node_by_id('DataLabel', tag_list)
                 if tag_node:
                     # 检查关系是否存在
                     rel_check = """
-                    MATCH (a:data_resource)-[r:label]->(b:data_label) 
+                    MATCH (a:DataResource)-[r:label]->(b:DataLabel) 
                     WHERE id(a) = $resource_id AND id(b) = $tag_id
                     RETURN r
                     """
@@ -156,7 +156,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                     # 如果关系不存在则创建
                     if not rel_result.single():
                         rel_create = """
-                        MATCH (a:data_resource), (b:data_label)
+                        MATCH (a:DataResource), (b:DataLabel)
                         WHERE id(a) = $resource_id AND id(b) = $tag_id
                         CREATE (a)-[r:label]->(b)
                         RETURN r
@@ -169,7 +169,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                 for item in head_data:
                     # 创建元数据节点
                     meta_cypher = """
-                    MERGE (m:meta_data {name: $name})
+                    MERGE (m:DataMeta {name: $name})
                     ON CREATE SET m.en_name = $en_name, 
                                 m.create_time = $create_time,
                                 m.data_type = $type,
@@ -198,7 +198,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                         
                         # 确认数据资源节点是否可以正确查询到
                         check_resource_cypher = """
-                        MATCH (n:data_resource) 
+                        MATCH (n:DataResource) 
                         WHERE id(n) = $resource_id 
                         RETURN n
                         """
@@ -211,7 +211,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                         
                         # 创建关系
                         rel_cypher = """
-                        MATCH (a:data_resource), (m:meta_data)
+                        MATCH (a:DataResource), (m:DataMeta)
                         WHERE id(a) = $resource_id AND id(m) = $meta_id
                         MERGE (a)-[r:contain]->(m)
                         RETURN r
@@ -242,7 +242,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                     if data_source_en_name:
                         # 创建 originates_from 关系
                         rel_data_source_cypher = """
-                        MATCH (a:data_resource), (b:DataSource)
+                        MATCH (a:DataResource), (b:DataSource)
                         WHERE id(a) = $resource_id AND b.en_name = $ds_en_name
                         MERGE (a)-[r:originates_from]->(b)
                         RETURN r
@@ -268,7 +268,7 @@ def handle_node(receiver, head_data, data_source=None, resource_type=None):
                                 logger.error(f"数据源节点不存在: en_name={data_source_en_name}")
                             
                             # 检查数据资源节点是否存在
-                            check_res_cypher = "MATCH (a:data_resource) WHERE id(a) = $resource_id RETURN a"
+                            check_res_cypher = "MATCH (a:DataResource) WHERE id(a) = $resource_id RETURN a"
                             check_res_result = session.run(check_res_cypher, resource_id=resource_id)
                             if not check_res_result.single():
                                 logger.error(f"数据资源节点不存在: id={resource_id}")
@@ -299,7 +299,7 @@ def handle_id_resource(resource_id):
             
             # 使用数值ID查询
             cypher = """
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $resource_id
             RETURN n
             """
@@ -327,7 +327,7 @@ def handle_id_resource(resource_id):
             
             # 查询关联的标签
             tag_cypher = """
-            MATCH (n:data_resource)-[r:label]->(t:data_label)
+            MATCH (n:DataResource)-[r:label]->(t:DataLabel)
             WHERE id(n) = $resource_id
             RETURN t
             """
@@ -349,9 +349,9 @@ def handle_id_resource(resource_id):
             
             # 查询关联的元数据 - 支持meta_data和Metadata两种标签
             meta_cypher = """
-            MATCH (n:data_resource)-[:contain]->(m)
+            MATCH (n:DataResource)-[:contain]->(m)
             WHERE id(n) = $resource_id
-            AND (m:meta_data OR m:Metadata)
+            AND (m:DataMeta OR m:Metadata)
             RETURN m
             """
             meta_result = session.run(meta_cypher, resource_id=resource_id_int)
@@ -407,7 +407,7 @@ def id_resource_graph(resource_id):
         with neo4j_driver.get_session() as session:
             # 查询数据资源节点及其关系
             cypher = """
-            MATCH (n:data_resource)-[r]-(m)
+            MATCH (n:DataResource)-[r]-(m)
             WHERE id(n) = $resource_id
             RETURN n, r, m
             """
@@ -452,7 +452,7 @@ def resource_list(page, page_size, en_name_filter=None, name_filter=None,
     try:
         with neo4j_driver.get_session() as session:
             # 构建查询条件
-            match_clause = "MATCH (n:data_resource)"
+            match_clause = "MATCH (n:DataResource)"
             where_conditions = []
             
             if en_name_filter:
@@ -469,7 +469,7 @@ def resource_list(page, page_size, en_name_filter=None, name_filter=None,
                 
             # 标签过滤需要额外的匹配
             if tag_filter:
-                match_clause += "-[:label]->(t:data_label)"
+                match_clause += "-[:label]->(t:DataLabel)"
                 where_conditions.append(f"t.name = '{tag_filter}'")
             
             where_clause = " WHERE " + " AND ".join(where_conditions) if where_conditions else ""
@@ -497,7 +497,7 @@ def resource_list(page, page_size, en_name_filter=None, name_filter=None,
                 
                 # 查询关联的标签
                 tag_cypher = """
-                MATCH (n:data_resource)-[r:label]->(t:data_label)
+                MATCH (n:DataResource)-[r:label]->(t:DataLabel)
                 WHERE id(n) = $resource_id
                 RETURN t
                 """
@@ -530,9 +530,9 @@ def id_data_search_list(resource_id, page, page_size, en_name_filter=None,
             
             # 基本匹配语句 - 支持meta_data和Metadata标签
             match_clause = """
-            MATCH (n:data_resource)-[:contain]->(m)
+            MATCH (n:DataResource)-[:contain]->(m)
             WHERE id(n) = $resource_id
-            AND (m:meta_data OR m:Metadata)
+            AND (m:DataMeta OR m:Metadata)
             """
             
             where_conditions = []
@@ -604,13 +604,13 @@ def resource_kinship_graph(resource_id, include_meta=True):
             
             # 基本查询
             cypher_parts = [
-                f"MATCH (n:data_resource) WHERE id(n) = $resource_id",
-                "OPTIONAL MATCH (n)-[:label]->(l:data_label)",
+                f"MATCH (n:DataResource) WHERE id(n) = $resource_id",
+                "OPTIONAL MATCH (n)-[:label]->(l:DataLabel)",
             ]
             
             # 是否包含元数据 - 支持meta_data和Metadata两种标签
             if include_meta:
-                cypher_parts.append("OPTIONAL MATCH (n)-[:contain]->(m) WHERE (m:meta_data OR m:Metadata)")
+                cypher_parts.append("OPTIONAL MATCH (n)-[:contain]->(m) WHERE (m:DataMeta OR m:Metadata)")
                 
             cypher_parts.append("RETURN n, l, collect(m) as metadata")
             
@@ -688,15 +688,15 @@ def resource_impact_all_graph(resource_id, include_meta=True):
             # 根据meta参数决定查询深度
             if include_meta:
                 cypher = """
-                MATCH path = (n:data_resource)-[*1..3]-(m)
+                MATCH path = (n:DataResource)-[*1..3]-(m)
                 WHERE id(n) = $resource_id
                 RETURN path
                 """
             else:
                 cypher = """
-                MATCH path = (n:data_resource)-[*1..2]-(m)
+                MATCH path = (n:DataResource)-[*1..2]-(m)
                 WHERE id(n) = $resource_id
-                AND NOT (m:meta_data) AND NOT (m:Metadata)
+                AND NOT (m:DataMeta) AND NOT (m:Metadata)
                 RETURN path
                 """
                 
@@ -1061,9 +1061,9 @@ def table_sql(sql):
 def status_query(key_list):
     query = """
     unwind $Key_list as name
-    OPTIONAL MATCH (n:data_model {en_name: name})
-    OPTIONAL MATCH (n:data_resource {en_name: name})
-    OPTIONAL MATCH (n:data_metric {en_name: name})
+    OPTIONAL MATCH (n:DataModel {en_name: name})
+    OPTIONAL MATCH (n:DataResource {en_name: name})
+         OPTIONAL MATCH (n:DataMetric {en_name: name})
     WITH name, CASE 
         WHEN n IS NOT NULL THEN True
         ELSE False
@@ -1220,7 +1220,7 @@ def data_resource_edit(data):
             # 构建更新语句
             set_clause = ", ".join([f"n.{k} = ${k}" for k in update_fields.keys()])
             cypher = f"""
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $resource_id
             SET {set_clause}
             RETURN n
@@ -1240,7 +1240,7 @@ def data_resource_edit(data):
             if tag_id:
                 # 删除旧的标签关系
                 delete_rel_cypher = """
-                MATCH (n:data_resource)-[r:label]->()
+                MATCH (n:DataResource)-[r:label]->()
                 WHERE id(n) = $resource_id
                 DELETE r
                 """
@@ -1248,7 +1248,7 @@ def data_resource_edit(data):
                 
                 # 创建新的标签关系
                 create_rel_cypher = """
-                MATCH (n:data_resource), (t:data_label)
+                MATCH (n:DataResource), (t:DataLabel)
                 WHERE id(n) = $resource_id AND id(t) = $tag_id
                 CREATE (n)-[r:label]->(t)
                 RETURN r
@@ -1260,7 +1260,7 @@ def data_resource_edit(data):
             if parsed_data:
                 # 删除旧的元数据关系
                 delete_meta_cypher = """
-                MATCH (n:data_resource)-[r:contain]->()
+                MATCH (n:DataResource)-[r:contain]->()
                 WHERE id(n) = $resource_id
                 DELETE r
                 """
@@ -1268,7 +1268,7 @@ def data_resource_edit(data):
                 
                 # 删除旧的清洗资源关系
                 delete_clean_cypher = """
-                MATCH (n:data_resource)-[r:clean_resource]->()
+                MATCH (n:DataResource)-[r:clean_resource]->()
                 WHERE id(n) = $resource_id
                 DELETE r
                 """
@@ -1280,7 +1280,7 @@ def data_resource_edit(data):
                     if meta_id:
                         # 创建元数据关系
                         create_meta_cypher = """
-                        MATCH (n:data_resource), (m:meta_data)
+                        MATCH (n:DataResource), (m:DataMeta)
                         WHERE id(n) = $resource_id AND id(m) = $meta_id
                         CREATE (n)-[r:contain]->(m)
                         RETURN r
@@ -1292,7 +1292,7 @@ def data_resource_edit(data):
                         if master_data:
                             # 创建主数据关系
                             create_master_cypher = """
-                            MATCH (master), (meta:meta_data)
+                            MATCH (master), (meta:DataMeta)
                             WHERE id(master) = $master_id AND id(meta) = $meta_id
                             MERGE (master)-[r:master]->(meta)
                             RETURN r
@@ -1305,7 +1305,7 @@ def data_resource_edit(data):
                             standard_id = data_standard.get("id")
                             # 创建数据标准与元数据的关系
                             create_standard_meta_cypher = """
-                            MATCH (standard), (meta:meta_data)
+                            MATCH (standard), (meta:DataMeta)
                             WHERE id(standard) = $standard_id AND id(meta) = $meta_id
                             MERGE (standard)-[r:clean_resource]->(meta)
                             RETURN r
@@ -1314,7 +1314,7 @@ def data_resource_edit(data):
                             
                             # 创建数据资源与数据标准的关系
                             create_resource_standard_cypher = """
-                            MATCH (resource:data_resource), (standard)
+                            MATCH (resource:DataResource), (standard)
                             WHERE id(resource) = $resource_id AND id(standard) = $standard_id
                             MERGE (resource)-[r:clean_resource]->(standard)
                             RETURN r

app/core/production_line/README.md

@@ -11,9 +11,9 @@
 ### 生产线图谱绘制 (production_draw_graph)
 
 根据节点ID和类型绘制生产线图谱，支持以下三种类型的节点：
-- 数据模型(data_model)：处理数据模型与元数据节点及数据标准之间的关系
-- 数据资源(data_resource)：处理数据资源与元数据节点及数据标准之间的关系
-- 数据指标(data_metric)：处理数据指标与元数据节点之间的关系
+- 数据模型(DataModel)：处理数据模型与元数据节点及数据标准之间的关系
+- 数据资源(DataResource)：处理数据资源与元数据节点及数据标准之间的关系
+- 数据指标(DataMetric)：处理数据指标与元数据节点之间的关系
 
 ## 技术实现
 
@@ -29,13 +29,13 @@
 from app.core.production_line import production_draw_graph
 
 # 获取数据模型的图谱
-graph_data = production_draw_graph(model_id, "data_model")
+graph_data = production_draw_graph(model_id, "DataModel")
 
 # 获取数据资源的图谱
-graph_data = production_draw_graph(resource_id, "data_resource")
+graph_data = production_draw_graph(resource_id, "DataResource")
 
 # 获取数据指标的图谱
-graph_data = production_draw_graph(metric_id, "data_metric")
+graph_data = production_draw_graph(metric_id, "DataMetric")
 ```
 
 ## 返回数据结构

app/core/production_line/production_line.py

@@ -18,7 +18,7 @@ def production_draw_graph(id, type):
     
     Args:
         id: 节点ID
-        type: 节点类型(data_model, data_resource, data_metric)
+        type: 节点类型(DataModel, DataResource, DataMetric)
         
     Returns:
         dict: 包含节点、连线和根节点ID的图谱数据
@@ -52,9 +52,9 @@ def production_draw_graph(id, type):
                 type = actual_type
         
         # 数据模型
-        if type.lower() == "data_model":
+        if type.lower() == "DataModel":
             cql = """
-            MATCH (n:data_model)
+            MATCH (n:DataModel)
             WHERE id(n) = $nodeId
             OPTIONAL MATCH (n)-[r:connection]-(m:meta_node)
             OPTIONAL MATCH (n)-[r2:clean_model]-(d:data_standard)
@@ -72,9 +72,9 @@ def production_draw_graph(id, type):
             RETURN lines,nodes,res
             """
         # 数据资源
-        elif type.lower() == "data_resource":
+        elif type.lower() == "DataResource":
             cql = """
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $nodeId
             OPTIONAL MATCH (n)-[r:connection]-(m:meta_node)
             OPTIONAL MATCH (n)-[r2:clean_resource]-(d:data_standard)
@@ -93,9 +93,9 @@ def production_draw_graph(id, type):
             RETURN lines, nodes, res
             """
         # 数据指标
-        elif type.lower() == "data_metric":
+        elif type.lower() == "DataMetric":
             cql = """
-            MATCH (n:data_metric)
+            MATCH (n:DataMetric)
             WHERE id(n) = $nodeId
             OPTIONAL MATCH (n)-[r:connection]-(m:meta_node)
             WITH collect({from: toString(id(n)), to: toString(id(m)), text: "处理"}) AS line1,
@@ -202,7 +202,7 @@ def get_resource_storage_info(resource_id):
         with neo4j_driver.get_session() as session:
             # 获取资源基本信息
             resource_query = """
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $resource_id
             RETURN n.storage_location as storage_location, 
                    n.name as cn_name,
@@ -219,7 +219,7 @@ def get_resource_storage_info(resource_id):
                 
             # 查询元数据节点
             metadata_query = """
-            MATCH (n:data_resource)-[:contain]->(m:meta_data)
+            MATCH (n:DataResource)-[:contain]->(m:DataMeta)
             WHERE id(n) = $resource_id
             RETURN m.name as name, m.en_name as en_name, m.data_type as data_type
             """
@@ -647,7 +647,7 @@ def get_resource_type(resource_id):
         with neo4j_driver.get_session() as session:
             # 查询资源类型
             cypher = """
-            MATCH (n:data_resource)
+            MATCH (n:DataResource)
             WHERE id(n) = $resource_id
             RETURN n.type as type
             """
@@ -914,7 +914,7 @@ def get_resource_data_source(resource_id):
         with neo4j_driver.get_session() as session:
             # 查询数据资源节点连接的数据源节点
             cypher = """
-            MATCH (n:data_resource)-[:originates_from]->(ds:DataSource)
+            MATCH (n:DataResource)-[:originates_from]->(ds:DataSource)
             WHERE id(n) = $resource_id
             RETURN ds
             """