修改元数据模块里管理元数据的一系列问题。

app/api/meta_data/routes.py

@@ -124,39 +124,71 @@ def meta_node_delete():
 @bp.route('/node/edit', methods=['POST'])
 def meta_node_edit():
     try:
-        # 从请求中获取节点信息
+        # 从请求中获取节点ID
         node_id = request.json.get('id')
-        node_name = request.json.get('name')
-        node_type = request.json.get('type')
-        node_desc = request.json.get('desc', '')
-        node_properties = request.json.get('properties', {})
         
+        if not node_id:
+            return jsonify(failed("节点ID不能为空"))
+        
+        # 获取节点
         with neo4j_driver.get_session() as session:
-            # 更新节点属性
+            # 查询节点信息
             cypher = """
-            MATCH (n) WHERE id(n) = $node_id 
-            SET n.name = $name, n.data_type = $type, n.desc = $desc, 
-                n.properties = $properties, n.updateTime = $update_time
+            MATCH (n:meta_data)
+            WHERE id(n) = $node_id
             RETURN n
             """
-            update_time = get_formatted_time()
-            result = session.run(
-                cypher, 
-                node_id=int(node_id), 
-                name=node_name, 
-                type=node_type, 
-                desc=node_desc,
-                properties=node_properties,
-                update_time=update_time
-            )
+            result = session.run(cypher, node_id=int(node_id))
             
             node = result.single()
-            if node:
-                return jsonify(success(dict(node["n"])))
-            else:
+            if not node or not node["n"]:
                 return jsonify(failed("节点不存在"))
+            
+            # 获取节点数据
+            node_data = dict(node["n"])
+            node_data["id"] = node["n"].id
+            
+            # 获取标签信息
+            tag_cypher = """
+            MATCH (n:meta_data)-[:label]->(t:data_label)
+            WHERE id(n) = $node_id
+            RETURN t
+            """
+            tag_result = session.run(tag_cypher, node_id=int(node_id))
+            tag = tag_result.single()
+            
+            # 获取主数据信息
+            master_data_cypher = """
+            MATCH (n:meta_data)-[:master_data]->(m:master_data)
+            WHERE id(n) = $node_id
+            RETURN m
+            """
+            master_data_result = session.run(master_data_cypher, node_id=int(node_id))
+            master_data = master_data_result.single()
+            
+            # 构建返回数据
+            response_data = [{
+                "master_data": master_data["m"].id if master_data and master_data["m"] else None,
+                "name": node_data.get("name", ""),
+                "en_name": node_data.get("en_name", ""),
+                "time": node_data.get("updateTime", ""),
+                "status": node_data.get("status", "true") == "true",
+                "type": node_data.get("type", ""),
+                "tag": {
+                    "name": tag["t"].get("name", "") if tag and tag["t"] else None,
+                    "id": tag["t"].id if tag and tag["t"] else None
+                },
+                "affiliation": node_data.get("affiliation"),
+                "category": node_data.get("category"),
+                "alias": node_data.get("alias"),
+                "describe": node_data.get("describe")
+            }]
+            
+            logger.info(f"成功获取元数据节点: ID={node_data['id']}")
+            return jsonify(success(response_data))
+            
     except Exception as e:
-        logger.error(f"编辑元数据失败: {str(e)}")
+        logger.error(f"获取元数据节点失败: {str(e)}")
         return jsonify(failed(str(e)))
 
 # 增加元数据
@@ -166,30 +198,79 @@ def meta_node_add():
         # 从请求中获取节点信息
         node_name = request.json.get('name')
         node_type = request.json.get('type')
-        node_desc = request.json.get('desc', '')
-        node_properties = request.json.get('properties', {})
+        node_category = request.json.get('category')
+        node_alias = request.json.get('alias')
+        node_affiliation = request.json.get('affiliation')
+        node_tag = request.json.get('tag')
+        node_desc = request.json.get('describe')
+        node_status = request.json.get('status', 1)
+        
+        if not node_name:
+            return jsonify(failed("节点名称不能为空"))
+            
+        if not node_type:
+            return jsonify(failed("节点类型不能为空"))
+        
+        node_en_name = translate_and_parse(node_name)
         
         # 创建节点
         with neo4j_driver.get_session() as session:
             cypher = """
-            CREATE (n:meta_data {name: $name, data_type: $type, desc: $desc, 
-                               properties: $properties, createTime: $create_time, 
-                               updateTime: $update_time})
+            MERGE (n:meta_data {name: $name})
+            ON CREATE SET n.data_type = $type,
+                         n.category = $category,
+                         n.alias = $alias,
+                         n.affiliation = $affiliation,
+                         n.desc = $desc,
+                         n.createTime = $create_time,
+                         n.updateTime = $update_time,
+                         n.status = $status,
+                         n.en_name = $en_name
+            ON MATCH SET n.data_type = $type,
+                        n.category = $category,
+                        n.alias = $alias,
+                        n.affiliation = $affiliation,
+                        n.desc = $desc,
+                        n.updateTime = $update_time,
+                        n.status = $status,
+                        n.en_name = $en_name
             RETURN n
             """
             create_time = update_time = get_formatted_time()
             result = session.run(
                 cypher, 
-                name=node_name, 
-                type=node_type, 
+                name=node_name,
+                type=node_type,
+                category=node_category,
+                alias=node_alias,
+                affiliation=node_affiliation,
                 desc=node_desc,
-                properties=node_properties,
                 create_time=create_time,
-                update_time=update_time
+                update_time=update_time,
+                status=str(node_status),
+                en_name=node_en_name
             )
             
             node = result.single()
-            return jsonify(success(dict(node["n"])))
+            if node and node["n"]:
+                node_data = dict(node["n"])
+                node_data["id"] = node["n"].id
+                
+                # 如果提供了标签ID，创建标签关系
+                if node_tag:
+                    tag_cypher = """
+                    MATCH (n:meta_data), (t:data_label)
+                    WHERE id(n) = $node_id AND id(t) = $tag_id
+                    MERGE (n)-[r:label]->(t)
+                    RETURN r
+                    """
+                    session.run(tag_cypher, node_id=node["n"].id, tag_id=int(node_tag))
+                
+                logger.info(f"成功创建或更新元数据节点: ID={node_data['id']}, name={node_name}")
+                return jsonify(success(node_data))
+            else:
+                logger.error(f"创建元数据节点失败: {node_name}")
+                return jsonify(failed("创建元数据节点失败"))
     except Exception as e:
         logger.error(f"添加元数据失败: {str(e)}")
         return jsonify(failed(str(e)))
@@ -613,4 +694,114 @@ def get_meta_config():
         'bucket_name': config['bucket_name'],
         'prefix': config['prefix'],
         'allowed_extensions': list(config['allowed_extensions'])
-    }) 
+    })
+
+# 更新元数据
+@bp.route('/node/update', methods=['POST'])
+def meta_node_update():
+    try:
+        # 从请求中获取节点ID和更新数据
+        node_id = request.json.get('id')
+        
+        if not node_id:
+            return jsonify(failed("节点ID不能为空"))
+        
+        # 更新节点
+        with neo4j_driver.get_session() as session:
+            # 检查节点是否存在并获取当前值
+            check_cypher = """
+            MATCH (n:meta_data)
+            WHERE id(n) = $node_id
+            RETURN n
+            """
+            result = session.run(check_cypher, node_id=int(node_id))
+            node = result.single()
+            
+            if not node or not node["n"]:
+                return jsonify(failed("节点不存在"))
+            
+            # 获取当前节点的所有属性
+            current_node = node["n"]
+            current_properties = dict(current_node)
+            
+            # 构建更新语句，只更新提供的属性
+            update_cypher = """
+            MATCH (n:meta_data)
+            WHERE id(n) = $node_id
+            SET n.updateTime = $update_time
+            """
+            
+            # 准备更新参数
+            update_params = {
+                'node_id': int(node_id),
+                'update_time': get_formatted_time()
+            }
+            
+            # 处理每个可能的更新字段
+            fields_to_update = {
+                'name': request.json.get('name'),
+                'category': request.json.get('category'),
+                'alias': request.json.get('alias'),
+                'affiliation': request.json.get('affiliation'),
+                'type': request.json.get('type'),
+                'describe': request.json.get('describe'),
+                'status': request.json.get('status')
+            }
+            
+            # 只更新提供了新值的字段
+            for field, new_value in fields_to_update.items():
+                if new_value is not None:
+                    update_cypher += f", n.{field} = ${field}\n"
+                    update_params[field] = new_value
+                else:
+                    # 如果字段没有提供新值，使用当前值
+                    update_params[field] = current_properties.get(field)
+                    update_cypher += f", n.{field} = ${field}\n"
+            
+            # 处理英文名称
+            if request.json.get('name'):
+                update_cypher += ", n.en_name = $en_name\n"
+                update_params['en_name'] = translate_and_parse(request.json.get('name'))
+            else:
+                update_cypher += ", n.en_name = $en_name\n"
+                update_params['en_name'] = current_properties.get('en_name')
+            
+            update_cypher += "RETURN n"
+            
+            result = session.run(update_cypher, **update_params)
+            
+            updated_node = result.single()
+            if updated_node and updated_node["n"]:
+                node_data = dict(updated_node["n"])
+                node_data["id"] = updated_node["n"].id
+                
+                # 如果更新了标签，处理标签关系
+                tag = request.json.get('tag')
+                if tag is not None:
+                    # 先删除现有标签关系
+                    delete_tag_cypher = """
+                    MATCH (n:meta_data)-[r:label]->(t:data_label)
+                    WHERE id(n) = $node_id
+                    DELETE r
+                    """
+                    session.run(delete_tag_cypher, node_id=int(node_id))
+                    
+                    # 创建新的标签关系
+                    if tag and isinstance(tag, dict) and 'id' in tag:
+                        create_tag_cypher = """
+                        MATCH (n:meta_data), (t:data_label)
+                        WHERE id(n) = $node_id AND id(t) = $tag_id
+                        MERGE (n)-[r:label]->(t)
+                        RETURN r
+                        """
+                        session.run(create_tag_cypher, node_id=int(node_id), tag_id=int(tag['id']))
+                
+                logger.info(f"成功更新元数据节点: ID={node_data['id']}")
+                return jsonify(success(node_data))
+            else:
+                logger.error(f"更新元数据节点失败: ID={node_id}")
+                return jsonify(failed("更新元数据节点失败"))
+                
+    except Exception as e:
+        logger.error(f"更新元数据失败: {str(e)}")
+        return jsonify(failed(str(e)))