DataOps-platform/app/api/data_parse/routes.py

from flask import jsonify, request, make_response, Blueprint, current_app, send_file
from app.api.data_parse import bp
from app.core.data_parse.parse import update_business_card, get_business_cards, update_business_card_status, create_talent_tag, get_talent_tag_list, update_talent_tag, delete_talent_tag, query_neo4j_graph, talent_get_tags, talent_update_tags, get_business_card, search_business_cards_by_mobile, get_hotel_positions_list, add_hotel_positions, update_hotel_positions, query_hotel_positions, delete_hotel_positions, get_hotel_group_brands_list, add_hotel_group_brands, update_hotel_group_brands, query_hotel_group_brands, delete_hotel_group_brands, get_duplicate_records, process_duplicate_record, get_duplicate_record_detail, fix_broken_duplicate_records
# 导入新的名片图片解析函数和添加名片函数
from app.core.data_parse.parse_card import process_business_card_image, add_business_card, delete_business_card
# 导入网页文本解析函数
from app.core.data_parse.parse_web import process_webpage_with_QWen
from app.config.config import DevelopmentConfig, ProductionConfig
import logging
import boto3
from botocore.config import Config
from botocore.exceptions import ClientError
from io import BytesIO
import base64
import os
import urllib.parse
from minio import Minio

# Define logger
logger = logging.getLogger(__name__)

# For failure responses
def failed(message, code=500):
    return {
        'success': False,
        'message': message,
        'data': None
    }, code

# 根据环境选择配置
if os.environ.get('FLASK_ENV') == 'production':
    config = ProductionConfig()
else:
    config = DevelopmentConfig()

# 使用配置变量
minio_url = f"{'https' if config.MINIO_SECURE else 'http'}://{config.MINIO_HOST}"
minio_access_key = config.MINIO_USER
minio_secret_key = config.MINIO_PASSWORD
minio_bucket = config.MINIO_BUCKET
use_ssl = config.MINIO_SECURE

def get_minio_client():
    """获取 MinIO 客户端实例"""
    return Minio(
        '192.168.3.143:9000',
        access_key=config.MINIO_USER,
        secret_key=config.MINIO_PASSWORD,
        secure=config.MINIO_SECURE
    )

# 名片解析接口
@bp.route('/business-card-parse', methods=['POST'])
def parse_business_card_route():
    """
    解析名片图片并提取信息的API接口（仅解析，不保存到数据库）
    
    请求参数:
        - image: 名片图片文件 (multipart/form-data)
        
    返回:
        - JSON: 包含提取的名片信息和处理状态
        
    注意：此接口仅负责图片解析和信息提取，不会将数据保存到数据库
    """
    # 检查是否上传了文件
    if 'image' not in request.files:
        return jsonify({
            'success': False,
            'message': '未上传图片',
            'data': None
        }), 400
    
    image_file = request.files['image']
    
    # 检查文件是否为空
    if image_file.filename == '':
        return jsonify({
            'success': False,
            'message': '未选择文件',
            'data': None
        }), 400
    
    # 检查文件类型是否为图片
    if not image_file.content_type.startswith('image/'):
        return jsonify({
            'success': False,
            'message': '上传的文件不是图片',
            'data': None
        }), 400
    
    # 处理名片图片
    result = process_business_card_image(image_file)
    
    if result['success']:
        return jsonify(result), 200
    else:
        return jsonify(result), 500

# 添加名片记录接口
@bp.route('/add-business-card', methods=['POST'])
def add_business_card_route():
    """
    添加名片记录的API接口（解析图片并保存到数据库）
    
    请求参数:
        - card_data: 名片信息数据 (JSON格式，可以通过form-data或JSON body传递)
        - image: 名片图片文件 (multipart/form-data，可选)
        
    返回:
        - JSON: 包含保存结果和处理状态
        
    注意：此接口负责业务逻辑处理，包括重复检查、MinIO上传和数据库保存
    """
    try:
        # 获取名片数据 - 支持两种方式
        card_data = None
        
        # 方式1：通过JSON body传递
        if request.is_json:
            card_data = request.get_json()
        # 方式2：通过form-data传递card_data字段
        elif 'card_data' in request.form:
            import json
            try:
                card_data = json.loads(request.form['card_data'])
            except json.JSONDecodeError:
                return jsonify({
                    'success': False,
                    'message': 'card_data格式错误，必须是有效的JSON字符串',
                    'data': None
                }), 400
        
        # 检查是否提供了名片数据
        if not card_data:
            return jsonify({
                'success': False,
                'message': '未提供名片数据，请通过JSON body或form-data的card_data字段传递',
                'data': None
            }), 400
        
        # 获取可选的图片文件
        image_file = None
        if 'image' in request.files:
            image_file = request.files['image']
            
            # 检查文件是否为空
            if image_file.filename == '':
                image_file = None
            # 检查文件类型是否为图片
            elif not image_file.content_type.startswith('image/'):
                return jsonify({
                    'success': False,
                    'message': '上传的文件不是图片',
                    'data': None
                }), 400
        
        # 调用业务逻辑函数处理名片数据
        result = add_business_card(card_data, image_file)
        
        # 根据处理结果设置HTTP状态码
        if result['success']:
            if result['code'] == 200:
                status_code = 200
            elif result['code'] == 202:
                status_code = 202  # Accepted - 创建成功但有疑似重复记录
            else:
                status_code = 200
        else:
            if result['code'] == 400:
                status_code = 400
            else:
                status_code = 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"添加名片记录失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'添加名片记录失败: {str(e)}',
            'data': None
        }), 500

# 更新名片信息接口
@bp.route('/business-cards/<int:card_id>', methods=['PUT'])
def update_business_card_route(card_id):
    """
    更新名片信息的API接口
    
    路径参数:
        - card_id: 名片记录ID
    
    请求参数:
        - JSON格式的名片信息
        
    返回:
        - JSON: 包含更新后的名片信息和处理状态
    """
    # 获取请求数据
    data = request.json
    
    if not data:
        return jsonify({
            'success': False,
            'message': '请求数据为空',
            'data': None
        }), 400
    
    # 调用业务逻辑函数处理更新
    result = update_business_card(card_id, data)
    
    # 根据处理结果设置HTTP状态码
    status_code = 200 if result['success'] else 500
    if 'not found' in result.get('message', '').lower() or '未找到' in result.get('message', ''):
        status_code = 404
    
    return jsonify(result), status_code

# 获取所有名片记录的API接口
@bp.route('/get-business-cards', methods=['GET'])
def get_business_cards_route():
    """
    获取所有名片记录的API接口
    
    返回:
        - JSON: 包含名片记录列表和处理状态
    """
    # 调用业务逻辑函数获取名片列表
    result = get_business_cards()
    
    # 根据处理结果设置HTTP状态码
    status_code = 200 if result['success'] else 500
    
    return jsonify(result), status_code


@bp.route('/update-business-cards/<int:card_id>/status', methods=['PUT'])
def update_business_card_status_route(card_id):
    """
    更新名片状态的API接口
    
    路径参数:
        - card_id: 名片记录ID
    
    请求参数:
        - JSON格式，包含status字段
        
    返回:
        - JSON: 包含更新后的名片信息和处理状态
    """
    # 获取请求数据
    data = request.json
    
    if not data or 'status' not in data:
        return jsonify({
            'success': False,
            'message': '请求数据为空或缺少status字段',
            'data': None
        }), 400
    
    status = data['status']
    
    # 调用业务逻辑函数处理状态更新
    result = update_business_card_status(card_id, status)
    
    # 根据处理结果设置HTTP状态码
    status_code = 200 if result['success'] else 500
    if 'not found' in result.get('message', '').lower() or '未找到' in result.get('message', ''):
        status_code = 404
    
    return jsonify(result), status_code

# 从MinIO获取名片图片的API接口
@bp.route('/business-cards/image/<path:image_path>', methods=['GET'])
def get_business_card_image(image_path):
    """
    从MinIO获取名片图片的API接口
    
    路径参数:
        - image_path: MinIO中的图片路径
        
    返回:
        - 图片数据流
    """
    try:
        # 记录下载请求信息，便于调试
        logger.info(f"获取名片图片请求: {image_path}")
        
        # 获取 MinIO 客户端
        minio_client = get_minio_client()
        
        if not minio_client:
            return jsonify(failed("MinIO客户端初始化失败")), 500
        
        try:
            # 使用正确的MinIO客户端方法
            data = minio_client.get_object(minio_bucket, image_path)
            
            # 创建内存文件流
            file_stream = BytesIO(data.read())
            
            # 获取文件名
            file_name = image_path.split('/')[-1]
            
            # 返回文件
            return send_file(
                file_stream,
                as_attachment=False,  # 设置为False，让浏览器直接显示图片
                download_name=file_name,
                mimetype='image/jpeg'  # 根据实际图片类型设置
            )
        except Exception as e:
            logger.error(f"MinIO获取文件失败: {str(e)}")
            return jsonify(failed(f"文件获取失败: {str(e)}")), 404
        
    except Exception as e:
        logger.error(f"文件下载失败: {str(e)}")
        return jsonify(failed(str(e))), 500
    finally:
        # 确保关闭数据流
        if 'data' in locals():
            data.close()

# 创建人才标签接口
@bp.route('/create-talent-tag', methods=['POST'])
def create_talent_tag_route():
    """
    创建人才标签的API接口
    
    请求参数:
        - JSON格式，包含以下字段:
            - name: 标签名称
            - category: 标签分类
            - description: 标签描述
            - status: 启用状态，默认为'active'
        
    返回:
        - JSON: 包含创建结果和标签信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 验证必要字段
        if 'name' not in data or not data['name']:
            return jsonify({
                'success': False,
                'message': '标签名称不能为空',
                'data': None
            }), 400
        
        # 处理分类字段，如果未提供则设置默认值
        if 'category' not in data or not data['category']:
            data['category'] = '未分类'
            
        # 调用业务逻辑函数处理创建
        result = create_talent_tag(data)
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"创建人才标签失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'创建人才标签失败: {str(e)}',
            'data': None
        }), 500

# 获取人才标签列表接口
@bp.route('/get-talent-tag-list', methods=['GET'])
def get_talent_tag_list_route():
    """
    获取人才标签列表的API接口
    
    返回:
        - JSON: 包含人才标签列表和处理状态
    """
    try:
        # 调用业务逻辑函数获取人才标签列表
        result = get_talent_tag_list()
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"获取人才标签列表失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'获取人才标签列表失败: {str(e)}',
            'data': []
        }), 500

# 更新人才标签接口
@bp.route('/update-talent-tag/<int:tag_id>', methods=['PUT'])
def update_talent_tag_route(tag_id):
    """
    更新人才标签的API接口
    
    路径参数:
        - tag_id: 标签节点ID
    
    请求参数:
        - JSON格式，可能包含以下字段:
            - name: 标签名称
            - category: 标签分类
            - description: 标签描述
            - status: 启用状态
        
    返回:
        - JSON: 包含更新结果和标签信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理更新
        result = update_talent_tag(tag_id, data)
        
        # 根据处理结果设置HTTP状态码
        if not result['success']:
            if result['code'] == 404:
                status_code = 404
            elif result['code'] == 400:
                status_code = 400
            else:
                status_code = 500
        else:
            status_code = 200
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"更新人才标签失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'更新人才标签失败: {str(e)}',
            'data': None
        }), 500

# 删除人才标签接口
@bp.route('/delete-talent-tag/<int:tag_id>', methods=['DELETE'])
def delete_talent_tag_route(tag_id):
    """
    删除人才标签的API接口
    
    路径参数:
        - tag_id: 标签节点ID
        
    返回:
        - JSON: 包含删除结果和被删除的标签信息
    """
    try:
        # 调用业务逻辑函数执行删除
        result = delete_talent_tag(tag_id)
        
        # 根据处理结果设置HTTP状态码
        if not result['success']:
            if result['code'] == 404:
                status_code = 404
            else:
                status_code = 500
        else:
            status_code = 200
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"删除人才标签失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'删除人才标签失败: {str(e)}',
            'data': None
        }), 500

@bp.route('/query-kg', methods=['POST'])
def query_kg():
    """
    查询知识图谱API接口
    
    请求参数:
        - query_requirement: 查询需求描述（JSON格式）
        
    返回:
        - JSON: 包含查询结果和处理状态
    """
    try:
        # 获取请求数据
        data = request.json
        
        if not data or 'query_requirement' not in data:
            return jsonify({
                'code': 400,
                'success': False,
                'message': '请求数据为空或缺少query_requirement字段',
                'data': []
            }), 400
        
        query_requirement = data['query_requirement']
        
        # 调用业务逻辑函数执行查询
        result = query_neo4j_graph(query_requirement)
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"查询知识图谱失败: {str(e)}")
        return jsonify({
            'code': 500,
            'success': False,
            'message': f"查询知识图谱失败: {str(e)}",
            'data': []
        }), 500

@bp.route('/talent-get-tags/<int:talent_id>', methods=['GET'])
def talent_get_tags_route(talent_id):
    """
    获取人才标签的API接口
    
    路径参数:
        - talent_id: 人才节点ID
        
    返回:
        - JSON: 包含人才关联的标签列表和处理状态
    """
    try:
        # 调用业务逻辑函数获取人才标签
        result = talent_get_tags(talent_id)
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"获取人才标签失败: {str(e)}")
        return jsonify({
            'code': 500,
            'success': False,
            'message': f"获取人才标签失败: {str(e)}",
            'data': []
        }), 500

@bp.route('/talent-update-tags', methods=['POST'])
def talent_update_tags_route():
    """
    更新人才标签关系的API接口
    
    请求参数:
        - JSON数组，包含talent和tag字段的对象列表
          例如: [
              {"talent": 12345, "tag": "市场营销"},
              {"talent": 12345, "tag": "酒店管理"}
          ]
        
    返回:
        - JSON: 包含更新结果的状态信息
    """
    try:
        # 获取请求数据
        data = request.json
        
        if not data:
            return jsonify({
                'code': 400,
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理标签关系更新
        result = talent_update_tags(data)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200
        elif result['code'] == 206:
            status_code = 206  # Partial Content
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"更新人才标签关系失败: {str(e)}")
        return jsonify({
            'code': 500,
            'success': False,
            'message': f"更新人才标签关系失败: {str(e)}",
            'data': None
        }), 500

# 测试MinIO连接
def test_minio_connection():
    """测试MinIO连接是否正常"""
    try:
        client = get_minio_client()
        if client.bucket_exists(minio_bucket):
            return {
                'success': True,
                'message': f'连接MinIO服务器成功，存储桶 {minio_bucket} 存在',
                'config': {
                    'host': config.MINIO_HOST,
                    'bucket': minio_bucket,
                    'secure': use_ssl
                }
            }
        else:
            return {
                'success': False,
                'message': f'连接MinIO服务器成功，但存储桶 {minio_bucket} 不存在',
                'config': {
                    'host': config.MINIO_HOST,
                    'bucket': minio_bucket,
                    'secure': use_ssl
                }
            }
    except Exception as e:
        return {
            'success': False,
            'message': f'连接MinIO服务器失败: {str(e)}',
            'config': {
                'host': config.MINIO_HOST,
                'bucket': minio_bucket,
                'secure': use_ssl
            }
        }

# MinIO测试接口
@bp.route('/test-minio-connection', methods=['GET'])
def test_minio_connection_route():
    """
    测试MinIO连接的API接口
    
    返回:
        - JSON: 包含连接测试结果
    """
    try:
        result = test_minio_connection()
        status_code = 200 if result['success'] else 500
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"测试MinIO连接失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'测试MinIO连接失败: {str(e)}',
            'config': {
                'host': config.MINIO_HOST,
                'bucket': minio_bucket,
                'secure': use_ssl
            }
        }), 500

# 获取单个名片记录的API接口
@bp.route('/get-business-card/<int:card_id>', methods=['GET'])
def get_business_card_route(card_id):
    """
    获取单个名片记录的API接口
    
    路径参数:
        - card_id: 名片记录ID
        
    返回:
        - JSON: 包含名片记录信息和处理状态
    """
    # 调用业务逻辑函数获取名片记录
    result = get_business_card(card_id)
    
    # 根据处理结果设置HTTP状态码
    if not result['success']:
        if result['code'] == 404:
            status_code = 404
        else:
            status_code = 500
    else:
        status_code = 200
    
    return jsonify(result), status_code

@bp.route('/search-business-cards-by-mobile', methods=['GET'])
def search_business_cards_by_mobile_route():
    """
    根据手机号码搜索名片记录的API接口
    
    查询参数:
        - mobile: 要搜索的手机号码
        
    返回:
        - JSON: 包含搜索到的名片记录列表和处理状态
        
    示例:
        GET /search-business-cards-by-mobile?mobile=13800138000
    """
    try:
        # 获取查询参数
        mobile_number = request.args.get('mobile', '').strip()
        
        if not mobile_number:
            return jsonify({
                'success': False,
                'message': '请提供要搜索的手机号码',
                'data': []
            }), 400
        
        # 调用业务逻辑函数搜索名片记录
        result = search_business_cards_by_mobile(mobile_number)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200
        elif result['code'] == 400:
            status_code = 400
        else:
            status_code = 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"根据手机号码搜索名片时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': []
        }), 500

@bp.route('/get-hotel-positions-list', methods=['GET'])
def get_hotel_positions_list_route():
    """
    获取酒店职位数据表全部记录的API接口
    
    返回:
        - JSON: 包含酒店职位记录列表和处理状态
    """
    try:
        # 调用业务逻辑函数获取酒店职位列表
        result = get_hotel_positions_list()
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"获取酒店职位列表时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': [],
            'count': 0
        }), 500

@bp.route('/add-hotel-positions', methods=['POST'])
def add_hotel_positions_route():
    """
    新增酒店职位数据表记录的API接口
    
    请求参数:
        - JSON格式，包含以下字段:
            - department_zh: 部门中文名称 (必填)
            - department_en: 部门英文名称 (必填)
            - position_zh: 职位中文名称 (必填)
            - position_en: 职位英文名称 (必填)
            - position_abbr: 职位英文缩写 (可选)
            - level_zh: 职级中文名称 (必填)
            - level_en: 职级英文名称 (必填)
            - created_by: 创建者 (可选)
            - updated_by: 更新者 (可选)
            - status: 状态 (可选)
    
    返回:
        - JSON: 包含创建结果和职位信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理创建
        result = add_hotel_positions(data)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 201  # Created
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 409:
            status_code = 409  # Conflict
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"创建酒店职位记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/update-hotel-positions/<int:position_id>', methods=['PUT'])
def update_hotel_positions_route(position_id):
    """
    修改酒店职位数据表记录的API接口
    
    路径参数:
        - position_id: 职位记录ID
    
    请求参数:
        - JSON格式，可能包含以下字段:
            - department_zh: 部门中文名称
            - department_en: 部门英文名称
            - position_zh: 职位中文名称
            - position_en: 职位英文名称
            - position_abbr: 职位英文缩写
            - level_zh: 职级中文名称
            - level_en: 职级英文名称
            - updated_by: 更新者
            - status: 状态
    
    返回:
        - JSON: 包含更新结果和职位信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理更新
        result = update_hotel_positions(position_id, data)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 404:
            status_code = 404  # Not Found
        elif result['code'] == 409:
            status_code = 409  # Conflict
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"更新酒店职位记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/query-hotel-positions/<int:position_id>', methods=['GET'])
def query_hotel_positions_route(position_id):
    """
    查找指定ID的酒店职位数据表记录的API接口
    
    路径参数:
        - position_id: 职位记录ID
    
    返回:
        - JSON: 包含查找结果和职位信息
    """
    try:
        # 调用业务逻辑函数查找职位记录
        result = query_hotel_positions(position_id)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"查找酒店职位记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/delete-hotel-positions/<int:position_id>', methods=['DELETE'])
def delete_hotel_positions_route(position_id):
    """
    删除指定ID的酒店职位数据表记录的API接口
    
    路径参数:
        - position_id: 职位记录ID
    
    返回:
        - JSON: 包含删除结果和被删除的职位信息
    """
    try:
        # 调用业务逻辑函数删除职位记录
        result = delete_hotel_positions(position_id)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"删除酒店职位记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/get-hotel-group-brands-list', methods=['GET'])
def get_hotel_group_brands_list_route():
    """
    获取酒店集团子品牌数据表全部记录的API接口
    
    返回:
        - JSON: 包含酒店集团品牌记录列表和处理状态
    """
    try:
        # 调用业务逻辑函数获取酒店集团品牌列表
        result = get_hotel_group_brands_list()
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"获取酒店集团品牌列表时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': [],
            'count': 0
        }), 500

@bp.route('/add-hotel-group-brands', methods=['POST'])
def add_hotel_group_brands_route():
    """
    新增酒店集团子品牌数据表记录的API接口
    
    请求参数:
        - JSON格式，包含以下字段:
            - group_name_en: 集团英文名称 (必填)
            - group_name_zh: 集团中文名称 (必填)
            - brand_name_en: 品牌英文名称 (必填)
            - brand_name_zh: 品牌中文名称 (必填)
            - positioning_level_en: 定位级别英文名称 (必填)
            - positioning_level_zh: 定位级别中文名称 (必填)
            - created_by: 创建者 (可选)
            - updated_by: 更新者 (可选)
            - status: 状态 (可选)
    
    返回:
        - JSON: 包含创建结果和品牌信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理创建
        result = add_hotel_group_brands(data)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 201  # Created
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 409:
            status_code = 409  # Conflict
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"创建酒店集团品牌记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/update-hotel-group-brands/<int:brand_id>', methods=['PUT'])
def update_hotel_group_brands_route(brand_id):
    """
    修改酒店集团子品牌数据表记录的API接口
    
    路径参数:
        - brand_id: 品牌记录ID
    
    请求参数:
        - JSON格式，可能包含以下字段:
            - group_name_en: 集团英文名称
            - group_name_zh: 集团中文名称
            - brand_name_en: 品牌英文名称
            - brand_name_zh: 品牌中文名称
            - positioning_level_en: 定位级别英文名称
            - positioning_level_zh: 定位级别中文名称
            - updated_by: 更新者
            - status: 状态
    
    返回:
        - JSON: 包含更新结果和品牌信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理更新
        result = update_hotel_group_brands(brand_id, data)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 404:
            status_code = 404  # Not Found
        elif result['code'] == 409:
            status_code = 409  # Conflict
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"更新酒店集团品牌记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/query-hotel-group-brands/<int:brand_id>', methods=['GET'])
def query_hotel_group_brands_route(brand_id):
    """
    查找指定ID的酒店集团子品牌数据表记录的API接口
    
    路径参数:
        - brand_id: 品牌记录ID
    
    返回:
        - JSON: 包含查找结果和品牌信息
    """
    try:
        # 调用业务逻辑函数查找品牌记录
        result = query_hotel_group_brands(brand_id)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"查找酒店集团品牌记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

@bp.route('/delete-hotel-group-brands/<int:brand_id>', methods=['DELETE'])
def delete_hotel_group_brands_route(brand_id):
    """
    删除指定ID的酒店集团子品牌数据表记录的API接口
    
    路径参数:
        - brand_id: 品牌记录ID
    
    返回:
        - JSON: 包含删除结果和被删除的品牌信息
    """
    try:
        # 调用业务逻辑函数删除品牌记录
        result = delete_hotel_group_brands(brand_id)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"删除酒店集团品牌记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


# ==================================
# 重复记录处理API接口
# ==================================

@bp.route('/get-duplicate-records', methods=['GET'])
def get_duplicate_records_route():
    """
    获取重复记录列表的API接口
    
    查询参数:
        - status: 可选，筛选特定状态的记录 ('pending', 'processed', 'ignored')
    
    返回:
        - JSON: 包含重复记录列表和处理状态
    """
    try:
        # 获取查询参数
        status = request.args.get('status', None)
        
        # 验证status参数的有效性
        if status and status not in ['pending', 'processed', 'ignored']:
            return jsonify({
                'success': False,
                'message': 'status参数无效，必须为 pending、processed 或 ignored',
                'data': None
            }), 400
        
        # 调用业务逻辑函数获取重复记录列表
        result = get_duplicate_records(status)
        
        # 根据处理结果设置HTTP状态码
        status_code = 200 if result['success'] else 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"获取重复记录列表时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': [],
            'count': 0
        }), 500


@bp.route('/process-duplicate-record/<int:duplicate_id>', methods=['POST'])
def process_duplicate_record_route(duplicate_id):
    """
    处理重复记录的API接口
    
    路径参数:
        - duplicate_id: 重复记录ID
    
    请求参数:
        - JSON格式，包含以下字段:
            - action: 处理动作 (必填) ('merge_to_suspected', 'keep_main', 'ignore')
            - selected_duplicate_id: 当action为'merge_to_suspected'时，选择的疑似重复记录ID (可选)
            - processed_by: 处理人 (可选)
            - notes: 处理备注 (可选)
    
    返回:
        - JSON: 包含处理结果和状态信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 验证必填字段
        action = data.get('action')
        if not action:
            return jsonify({
                'success': False,
                'message': '缺少必填字段: action',
                'data': None
            }), 400
        
        # 验证action参数的有效性
        if action not in ['merge_to_suspected', 'keep_main', 'ignore']:
            return jsonify({
                'success': False,
                'message': 'action参数无效，必须为 merge_to_suspected、keep_main 或 ignore',
                'data': None
            }), 400
        
        # 提取其他参数
        selected_duplicate_id = data.get('selected_duplicate_id')
        processed_by = data.get('processed_by')
        notes = data.get('notes')
        
        # 特殊验证：如果action为merge_to_suspected，必须提供selected_duplicate_id
        if action == 'merge_to_suspected' and not selected_duplicate_id:
            return jsonify({
                'success': False,
                'message': '执行merge_to_suspected操作时必须提供selected_duplicate_id',
                'data': None
            }), 400
        
        # 调用业务逻辑函数处理重复记录
        result = process_duplicate_record(
            duplicate_id=duplicate_id,
            action=action,
            selected_duplicate_id=selected_duplicate_id,
            processed_by=processed_by,
            notes=notes
        )
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 400:
            status_code = 400  # Bad Request
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"处理重复记录时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


@bp.route('/get-duplicate-record-detail/<int:duplicate_id>', methods=['GET'])
def get_duplicate_record_detail_route(duplicate_id):
    """
    获取指定重复记录详细信息的API接口
    
    路径参数:
        - duplicate_id: 重复记录ID
    
    返回:
        - JSON: 包含重复记录详细信息
    """
    try:
        # 调用业务逻辑函数获取重复记录详情
        result = get_duplicate_record_detail(duplicate_id)
        
        # 根据处理结果设置HTTP状态码
        if result['code'] == 200:
            status_code = 200  # OK
        elif result['code'] == 404:
            status_code = 404  # Not Found
        else:
            status_code = 500  # Internal Server Error
        
        return jsonify(result), status_code
        
    except Exception as e:
        # 处理未预期的异常
        error_msg = f"获取重复记录详情时发生错误: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500

# 删除名片记录接口
@bp.route('/delete-business-card/<int:card_id>', methods=['DELETE'])
def delete_business_card_route(card_id):
    """
    删除名片记录的API接口
    
    路径参数:
        - card_id: 名片记录ID (必填)
        
    功能说明:
        - 删除PostgreSQL数据库中business_cards表的指定记录
        - 删除PostgreSQL数据库中duplicate_business_cards表的相关记录  
        - 删除MinIO存储中的名片图片文件
        - 删除Neo4j图数据库中talent节点及其关联关系
        
    返回:
        - JSON: 包含删除操作的结果状态和被删除的记录信息
        
    状态码:
        - 200: 完全成功删除所有相关数据
        - 206: 部分成功 (PostgreSQL删除成功，但Neo4j删除失败)
        - 404: 未找到指定ID的名片记录
        - 500: 删除操作失败
    """
    try:
        # 验证card_id参数
        if not card_id or card_id <= 0:
            return jsonify({
                'success': False,
                'message': '无效的名片记录ID',
                'data': None
            }), 400
        
        # 调用删除函数
        result = delete_business_card(card_id)
        
        # 根据处理结果设置HTTP状态码和返回响应
        if result['success']:
            if result['code'] == 200:
                status_code = 200  # 完全成功
            elif result['code'] == 206:
                status_code = 206  # 部分成功
            else:
                status_code = 200  # 默认成功
        else:
            if result['code'] == 404:
                status_code = 404  # 未找到记录
            elif result['code'] == 400:
                status_code = 400  # 参数错误
            else:
                status_code = 500  # 服务器错误
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"删除名片记录失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'删除名片记录失败: {str(e)}',
            'data': None
        }), 500

# 修复损坏的重复记录接口
@bp.route('/fix-broken-duplicate-records', methods=['POST'])
def fix_broken_duplicate_records_route():
    """
    修复duplicate_business_cards表中main_card_id为null的损坏记录
    
    功能说明:
        - 查找所有main_card_id为null的损坏记录
        - 删除这些损坏的记录以维护数据完整性
        - 返回修复操作的详细结果
        
    返回:
        - JSON: 包含修复操作的结果和被删除记录的信息
        
    状态码:
        - 200: 修复成功
        - 500: 修复失败
        
    注意:
        - 此操作会永久删除损坏的记录
        - 建议在系统维护时执行此操作
    """
    try:
        # 调用修复函数
        result = fix_broken_duplicate_records()
        
        # 根据结果设置状态码
        if result['success']:
            status_code = 200
        else:
            status_code = 500
        
        return jsonify(result), status_code
        
    except Exception as e:
        logger.error(f"修复损坏记录接口调用失败: {str(e)}")
        return jsonify({
            'success': False,
            'message': f'修复损坏记录接口调用失败: {str(e)}',
            'data': None
        }), 500


# 网页文本解析接口
@bp.route('/webpage-parse', methods=['POST'])
def webpage_parse_route():
    """
    解析网页 Markdown 文本并提取人员信息的API接口
    
    请求参数:
        - markdown_text: 网页的 Markdown 格式文本内容 (JSON格式)
        - publish_time: 发布时间，用于career_path中的date字段 (JSON格式)
        
    请求体示例:
        {
            "markdown_text": "# 张三\n\n职位：高级经理\n\n公司：XX酒店\n\n![照片](http://example.com/photo.jpg)",
            "publish_time": "2025-01-15"
        }
        
    返回:
        - JSON: 包含提取的人员信息和处理状态
        
    功能说明:
        - 接收 Markdown 格式的网页文本
        - 进行必要的格式和内容验证
        - 使用 Qwen VL Max 模型提取人员信息
        - 支持提取照片链接 (pic_url)
        - 返回标准化的人员信息数据
        
    状态码:
        - 200: 解析成功
        - 400: 请求参数错误
        - 500: 解析失败
    """
    try:
        # 检查请求是否为 JSON 格式
        if not request.is_json:
            return jsonify({
                'success': False,
                'message': '请求必须是 JSON 格式',
                'data': None
            }), 400
        
        # 获取请求数据
        data = request.get_json()
        
        # 检查是否提供了 markdown_text 参数
        if 'markdown_text' not in data:
            return jsonify({
                'success': False,
                'message': '缺少必填参数: markdown_text',
                'data': None
            }), 400
        
        # 检查是否提供了 publish_time 参数
        if 'publish_time' not in data:
            return jsonify({
                'success': False,
                'message': '缺少必填参数: publish_time',
                'data': None
            }), 400
        
        markdown_text = data['markdown_text']
        publish_time = data['publish_time']
        
        # 验证 markdown_text 是否为字符串
        if not isinstance(markdown_text, str):
            return jsonify({
                'success': False,
                'message': 'markdown_text 必须是字符串类型',
                'data': None
            }), 400
        
        # 验证 publish_time 是否为字符串
        if not isinstance(publish_time, str):
            return jsonify({
                'success': False,
                'message': 'publish_time 必须是字符串类型',
                'data': None
            }), 400
        
        # 验证文本内容不能为空
        if not markdown_text.strip():
            return jsonify({
                'success': False,
                'message': 'markdown_text 内容不能为空',
                'data': None
            }), 400
        
        # 验证文本长度（防止过长的文本）
        if len(markdown_text) > 50000:  # 限制最大50KB
            return jsonify({
                'success': False,
                'message': 'markdown_text 内容过长，最大支持50KB',
                'data': None
            }), 400
        
        # 基本的 Markdown 格式验证（可选）
        # 检查是否包含一些基本的文本内容
        if len(markdown_text.strip()) < 10:
            return jsonify({
                'success': False,
                'message': 'markdown_text 内容过短，无法进行有效解析',
                'data': None
            }), 400
        
        # 记录解析请求
        logger.info(f"开始解析网页文本，内容长度: {len(markdown_text)} 字符")
        
        # 调用网页文本解析函数
        extracted_data = process_webpage_with_QWen(markdown_text, publish_time)
        
        # 返回成功结果
        return jsonify({
            'success': True,
            'message': '网页文本解析成功',
            'data': extracted_data
        }), 200
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"网页文本解析失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500