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_system 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_duplicate_records, 
    process_duplicate_record, 
    get_duplicate_record_detail, 
    fix_broken_duplicate_records
)
# 导入解析任务相关函数
from app.core.data_parse.parse_task import (
    get_parse_tasks, 
    get_parse_task_detail,
    add_parse_task,
    add_parsed_talents
)
# 导入酒店管理相关函数
from app.core.data_parse.hotel_management import (
    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
)
# 导入新的名片图片解析函数和添加名片函数
from app.core.data_parse.parse_card import process_business_card_image, add_business_card, delete_business_card, batch_process_business_card_images
# 导入网页文本解析函数
from app.core.data_parse.parse_web import process_webpage_with_QWen, add_webpage_talent, batch_process_md
# 导入简历解析函数
from app.core.data_parse.parse_resume import batch_parse_resumes
# 导入门墩儿数据处理函数
from app.core.data_parse.parse_menduner import batch_process_menduner_data
# 导入图片批量处理函数
from app.core.data_parse.parse_pic import batch_process_images
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

# 添加网页人才信息接口
@bp.route('/add-webpage-talent', methods=['POST'])
def add_webpage_talent_route():
    """
    添加网页人才信息的API接口，包括保存网页内容和创建名片记录
    
    请求参数:
        - talent_list: 人才信息列表，每个item包含业务卡片格式的数据 (JSON数组)
        - web_md: 网页markdown文本内容 (JSON字符串)
        
    请求体示例:
        {
            "talent_list": [
                {
                    "name_zh": "张三",
                    "name_en": "Zhang San",
                    "title_zh": "总经理",
                    "title_en": "General Manager",
                    "hotel_zh": "北京万豪酒店",
                    "hotel_en": "Beijing Marriott Hotel",
                    "brand_group": "万豪",
                    "mobile": "13800138000",
                    "email": "zhangsan@example.com"
                },
                {
                    "name_zh": "李四",
                    "name_en": "Li Si",
                    "title_zh": "市场总监",
                    "title_en": "Marketing Director",
                    "hotel_zh": "上海希尔顿酒店",
                    "hotel_en": "Shanghai Hilton Hotel",
                    "brand_group": "希尔顿",
                    "mobile": "13900139000",
                    "email": "lisi@example.com"
                }
            ],
            "web_md": "# 人事任命公告\n\n**1** 张三被任命为北京万豪酒店总经理...\n\n**2** 李四被任命为上海希尔顿酒店市场总监..."
        }
        
    返回:
        - JSON: 包含处理结果，包括成功和失败的记录统计
        
    功能说明:
        - 将网页markdown内容保存到MinIO
        - 循环处理talent_list中的每个人才记录
        - 为每个人才创建business_card记录
        - 使用与名片上传相同的重复检查逻辑
        - 在business_card记录的updated_by字段中记录MinIO路径
        
    状态码:
        - 200: 所有记录处理成功
        - 206: 部分记录处理成功
        - 400: 请求参数错误
        - 500: 处理失败
    """
    try:
        # 检查请求是否为 JSON 格式
        if not request.is_json:
            return jsonify({
                'success': False,
                'message': '请求必须是 JSON 格式',
                'data': None
            }), 400
        
        # 获取请求数据
        data = request.get_json()
        
        # 检查是否提供了 talent_list 参数
        if 'talent_list' not in data:
            return jsonify({
                'success': False,
                'message': '缺少必填参数: talent_list',
                'data': None
            }), 400
        
        # 检查是否提供了 web_md 参数
        if 'web_md' not in data:
            return jsonify({
                'success': False,
                'message': '缺少必填参数: web_md',
                'data': None
            }), 400
        
        talent_list = data['talent_list']
        web_md = data['web_md']
        
        # 验证 talent_list 是否为数组
        if not isinstance(talent_list, list):
            return jsonify({
                'success': False,
                'message': 'talent_list 必须是数组类型',
                'data': None
            }), 400
        
        # 验证 web_md 是否为字符串
        if not isinstance(web_md, str):
            return jsonify({
                'success': False,
                'message': 'web_md 必须是字符串类型',
                'data': None
            }), 400
        
        # 验证数组不能为空
        if len(talent_list) == 0:
            return jsonify({
                'success': False,
                'message': 'talent_list 不能为空数组',
                'data': None
            }), 400
        
        # 验证文本内容不能为空
        if not web_md.strip():
            return jsonify({
                'success': False,
                'message': 'web_md 内容不能为空',
                'data': None
            }), 400
        
        # 验证文本长度（防止过长的文本）
        if len(web_md) > 100000:  # 限制最大100KB
            return jsonify({
                'success': False,
                'message': 'web_md 内容过长，最大支持100KB',
                'data': None
            }), 400
        
        # 验证数组长度（防止过多记录）
        if len(talent_list) > 50:  # 限制最大50条记录
            return jsonify({
                'success': False,
                'message': 'talent_list 记录过多，最大支持50条记录',
                'data': None
            }), 400
        
        # 基本的数据格式验证
        for index, talent_data in enumerate(talent_list):
            if not isinstance(talent_data, dict):
                return jsonify({
                    'success': False,
                    'message': f'talent_list 第{index + 1}项必须是对象类型',
                    'data': None
                }), 400
            
            # 检查必要的字段
            if not talent_data.get('name_zh'):
                return jsonify({
                    'success': False,
                    'message': f'talent_list 第{index + 1}项缺少必填字段: name_zh',
                    'data': None
                }), 400
        
        # 记录处理请求
        logger.info(f"开始处理网页人才信息，人才数量: {len(talent_list)}, 网页内容长度: {len(web_md)} 字符")
        
        # 调用网页人才处理函数
        result = add_webpage_talent(talent_list, web_md)
        
        # 根据处理结果设置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'] == 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': None
        }), 500


# 获取解析任务列表接口
@bp.route('/get-parse-tasks', methods=['GET'])
def get_parse_tasks_route():
    """
    获取解析任务列表的API接口，支持分页
    
    查询参数:
        - page: 页码，从1开始，默认为1
        - per_page: 每页记录数，默认为10，最大100
        - task_type: 任务类型过滤，可选
        - task_status: 任务状态过滤，可选
        
    返回:
        - JSON: 包含解析任务列表和分页信息
        
    功能说明:
        - 支持分页查询，每页默认10条记录
        - 支持按任务类型和状态过滤
        - 按创建时间倒序排列
        - 返回总记录数和分页信息
        
    状态码:
        - 200: 查询成功
        - 400: 请求参数错误
        - 500: 查询失败
    """
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        task_type = request.args.get('task_type', type=str)
        task_status = request.args.get('task_status', type=str)
        
        # 记录请求日志
        logger.info(f"获取解析任务列表请求: page={page}, per_page={per_page}, task_type={task_type}, task_status={task_status}")
        
        # 调用核心业务逻辑
        result = get_parse_tasks(page, per_page, task_type, task_status)
        
        # 返回结果
        return jsonify({
            'success': result['success'],
            'message': result['message'],
            'data': result['data']
        }), result['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-parse-task-detail', methods=['GET'])
def get_parse_task_detail_route():
    """
    获取解析任务详情的API接口
    
    查询参数:
        - task_name: 任务名称，必填
        
    返回:
        - JSON: 包含任务详细信息
        
    功能说明:
        - 根据任务名称查询指定任务的详细信息
        - 返回任务的所有字段信息
        - 包含解析结果的完整数据
        
    状态码:
        - 200: 查询成功
        - 400: 请求参数错误
        - 404: 任务不存在
        - 500: 查询失败
    """
    try:
        # 获取查询参数
        task_name = request.args.get('task_name', type=str)
        
        # 参数验证
        if not task_name:
            return jsonify({
                'success': False,
                'message': '任务名称参数不能为空',
                'data': None
            }), 400
        
        # 记录请求日志
        logger.info(f"获取解析任务详情请求: task_name={task_name}")
        
        # 调用核心业务逻辑
        result = get_parse_task_detail(task_name)
        
        # 返回结果
        return jsonify({
            'success': result['success'],
            'message': result['message'],
            'data': result['data']
        }), result['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('/add-parse-task', methods=['POST'])
def add_parse_task_route():
    """
    新增解析任务的API接口
    
    请求参数:
        - task_type: 任务类型 (form-data字段，必填)
                    可选值：'名片', '简历', '新任命', '招聘', '杂项'
        - files: 文件数组 (multipart/form-data，对于招聘类型可选)
        - created_by: 创建者 (可选，form-data字段)
        
    返回:
        - JSON: 包含任务创建结果和上传摘要
        
    功能说明:
        - 根据任务类型处理不同格式的文件
        - 名片任务：JPG/PNG格式图片 → talent_photos目录
        - 简历任务：PDF格式文件 → resume_files目录
        - 新任命任务：MD格式文件 → appointment_files目录
        - 招聘任务：数据库记录处理，无需文件上传
        - 杂项任务：任意格式文件 → misc_files目录
        - 使用timestamp+uuid自动生成文件名
        - 在parse_task_repository表中创建待解析任务记录
        
    状态码:
        - 200: 所有文件上传成功，任务创建成功
        - 206: 部分文件上传成功，任务创建成功
        - 400: 请求参数错误
        - 500: 服务器内部错误
    """
    try:
        # 获取任务类型参数
        task_type = request.form.get('task_type')
        
        # 验证任务类型
        if not task_type:
            return jsonify({
                'success': False,
                'message': '缺少task_type参数',
                'data': None
            }), 400
        
        if task_type not in ['名片', '简历', '新任命', '招聘', '杂项']:
            return jsonify({
                'success': False,
                'message': 'task_type参数必须是以下值之一：名片、简历、新任命、招聘、杂项',
                'data': None
            }), 400
        
        # 获取创建者信息（可选参数）
        created_by = request.form.get('created_by', 'api_user')
        
        # 对于招聘类型，不需要文件上传
        if task_type == '招聘':
            # 检查是否误传了文件
            if 'files' in request.files and request.files.getlist('files'):
                return jsonify({
                    'success': False,
                    'message': '招聘类型任务不需要上传文件',
                    'data': None
                }), 400
            
            # 记录请求日志
            logger.info(f"新增招聘任务请求: 创建者={created_by}")
            
            # 调用核心业务逻辑
            result = add_parse_task(None, task_type, created_by)
        else:
            # 其他类型需要文件上传
            if 'files' not in request.files:
                return jsonify({
                    'success': False,
                    'message': f'{task_type}任务需要上传文件，请使用files字段上传文件',
                    'data': None
                }), 400
            
            # 获取上传的文件列表
            uploaded_files = request.files.getlist('files')
            
            # 检查文件列表是否为空
            if not uploaded_files or len(uploaded_files) == 0:
                return jsonify({
                    'success': False,
                    'message': '文件数组不能为空',
                    'data': None
                }), 400
            
            # 验证所有文件
            valid_files = []
            for i, file in enumerate(uploaded_files):
                # 检查文件是否为空
                if not file or file.filename == '':
                    return jsonify({
                        'success': False,
                        'message': f'第{i+1}个文件为空或未选择',
                        'data': None
                    }), 400
                
                valid_files.append(file)
            
            # 记录请求日志
            logger.info(f"新增{task_type}任务请求: 文件数量={len(valid_files)}, 创建者={created_by}")
            
            # 调用核心业务逻辑
            result = add_parse_task(valid_files, task_type, created_by)
        
        # 根据处理结果设置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'] == 400:
                status_code = 400
            else:
                status_code = 500
        
        # 返回结果
        return jsonify({
            'success': result['success'],
            'message': result['message'],
            'data': result['data']
        }), 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('/execute-parse-task', methods=['POST'])
def execute_parse_task():
    """
    执行解析任务接口
    
    根据task_type参数调用相应的批量处理函数：
    - 名片: batch_process_business_card_images
    - 简历: batch_parse_resumes  
    - 新任命: batch_process_md
    - 招聘: batch_process_menduner_data
    - 杂项: batch_process_images
    
    请求参数:
    - task_type (str): 任务类型，可选值：'名片', '简历', '新任命', '招聘', '杂项'
    - data (list): 数据列表，根据task_type不同，数据格式不同
    - publish_time (str, optional): 发布时间，仅新任命任务需要
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据不能为空',
                'data': None
            }), 400
        
        # 获取任务类型
        task_type = data.get('task_type', '').strip()
        if not task_type:
            return jsonify({
                'success': False,
                'message': 'task_type参数不能为空',
                'data': None
            }), 400
        
        # 获取数据列表
        task_data = data.get('data')
        if not task_data:
            return jsonify({
                'success': False,
                'message': 'data参数不能为空',
                'data': None
            }), 400
        
        # 根据任务类型执行相应的处理函数
        try:
            if task_type == '名片':
                # 调用名片批量处理函数
                result = batch_process_business_card_images(task_data)
                
            elif task_type == '简历':
                # 调用简历批量处理函数
                result = batch_parse_resumes(task_data)
                
            elif task_type == '新任命':
                # 获取发布时间参数
                publish_time = data.get('publish_time', '')
                if not publish_time:
                    return jsonify({
                        'success': False,
                        'message': '新任命任务需要提供publish_time参数',
                        'data': None
                    }), 400
                
                # 调用新任命批量处理函数
                result = batch_process_md(task_data, publish_time)
                
            elif task_type == '招聘':
                # 调用招聘数据批量处理函数
                result = batch_process_menduner_data(task_data)
                
            elif task_type == '杂项':
                # 调用图片批量处理函数（表格类型）
                process_type = data.get('process_type', 'table')
                result = batch_process_images(task_data, process_type)
                
            else:
                return jsonify({
                    'success': False,
                    'message': f'不支持的任务类型: {task_type}，支持的类型：名片、简历、新任命、招聘、杂项',
                    'data': None
                }), 400
            
            # 记录处理结果日志
            if result.get('success'):
                logging.info(f"执行{task_type}解析任务成功: {result.get('message', '')}")
                # ===== 精简：只根据id字段唯一定位任务记录 =====
                from app.core.data_parse.parse_system import db, ParseTaskRepository
                task_id = data.get('id')
                if task_id:
                    task_obj = ParseTaskRepository.query.filter_by(id=task_id).first()
                    if task_obj:
                        task_obj.task_status = '成功'
                        task_obj.parse_result = result.get('data')
                        db.session.commit()
                        logging.info(f"已更新解析任务记录: id={getattr(task_obj, 'id', None)}, 状态=成功")
            else:
                logging.error(f"执行{task_type}解析任务失败: {result.get('message', '')}")
            
            # 确定HTTP状态码
            if result.get('success'):
                # 检查是否有部分成功的情况
                if 'code' in result:
                    status_code = result['code']
                elif 'summary' in result.get('data', {}):
                    # 检查处理摘要
                    summary = result['data']['summary']
                    if summary.get('failed_count', 0) > 0 and summary.get('success_count', 0) > 0:
                        status_code = 206  # 部分成功
                    else:
                        status_code = 200  # 完全成功
                else:
                    status_code = 200
            else:
                status_code = 500
            
            return jsonify({
                'success': result.get('success', False),
                'message': result.get('message', '处理完成'),
                'data': result.get('data')
            }), status_code
            
        except Exception as process_error:
            error_msg = f"执行{task_type}解析任务时发生错误: {str(process_error)}"
            logging.error(error_msg, exc_info=True)
            
            return jsonify({
                'success': False,
                'message': error_msg,
                'data': None
            }), 500
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"执行解析任务接口失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': None
        }), 500


@bp.route('/add-parsed-talents', methods=['POST'])
def add_parsed_talents_route():
    """
    处理解析任务响应数据并写入人才信息接口
    
    请求参数:
        - api_response_data: execute-parse-task API的完整返回数据 (JSON格式)
        
    请求体示例:
        {
            "success": true,
            "message": "处理完成",
            "data": {
                "summary": {
                    "total_files": 5,
                    "success_count": 4,
                    "failed_count": 1,
                    "success_rate": 80.0
                },
                "results": [
                    {
                        "index": 0,
                        "success": true,
                        "data": {
                            "name_zh": "张三",
                            "title_zh": "经理",
                            "hotel_zh": "某酒店"
                        }
                    }
                ],
                "processed_time": "2025-01-18T10:30:00"
            }
        }
        
    返回:
        - JSON: 包含批量处理结果和状态信息
        
    功能说明:
        - 接收 execute-parse-task API 的完整返回数据
        - 自动识别和处理不同格式的人才数据（单人/批量）
        - 调用 add_single_talent 函数将人才信息写入 business_cards 表
        - 支持新任命等包含多个人员信息的批量数据
        - 提供详细的处理统计和结果追踪
        - 保留原始API响应数据用于调试
        
    状态码:
        - 200: 全部处理成功
        - 206: 部分处理成功
        - 400: 请求参数错误
        - 500: 服务器内部错误
    """
    try:
        # 检查请求是否为 JSON 格式
        if not request.is_json:
            return jsonify({
                'success': False,
                'message': '请求必须是 JSON 格式',
                'data': None
            }), 400
        
        # 获取请求数据
        api_response_data = request.get_json()
        
        # 基本参数验证
        if not api_response_data:
            return jsonify({
                'success': False,
                'message': '请求数据不能为空',
                'data': None
            }), 400
        
        # 验证数据格式
        if not isinstance(api_response_data, dict):
            return jsonify({
                'success': False,
                'message': '请求数据必须是JSON对象格式',
                'data': None
            }), 400
        
        # 记录请求日志
        total_results = 0
        if api_response_data.get('data') and api_response_data['data'].get('results'):
            total_results = len(api_response_data['data']['results'])
        
        logger.info(f"收到处理解析任务响应数据请求，包含 {total_results} 条结果记录")
        
        # 调用核心业务逻辑
        result = add_parsed_talents(api_response_data)
        
        # 根据处理结果设置HTTP状态码
        if result.get('success', False):
            if result.get('code') == 200:
                status_code = 200  # 全部成功
            elif result.get('code') == 206:
                status_code = 206  # 部分成功
            else:
                status_code = 200  # 默认成功
        else:
            if result.get('code') == 400:
                status_code = 400  # 参数错误
            else:
                status_code = 500  # 服务器错误
        
        # 记录处理结果日志
        if result.get('success'):
            data_summary = result.get('data', {}).get('summary', {})
            success_count = data_summary.get('success_count', 0)
            failed_count = data_summary.get('failed_count', 0)
            logger.info(f"处理解析任务响应数据完成: 成功 {success_count} 条，失败 {failed_count} 条")
        else:
            logger.error(f"处理解析任务响应数据失败: {result.get('message', '未知错误')}")
        
        # 返回结果
        return jsonify({
            'success': result.get('success', False),
            'message': result.get('message', '处理完成'),
            'data': result.get('data')
        }), 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