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

from flask import jsonify, request, make_response, Blueprint, current_app, send_file
from datetime import datetime
import json
from app.core.data_parse.time_utils import get_east_asia_time_naive, get_east_asia_time_str, get_east_asia_timestamp, get_east_asia_isoformat, get_east_asia_date_str
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,
    web_url_crawl
)
# 导入酒店管理相关函数
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 delete_business_card, batch_process_business_card_images
# 导入网页文本解析函数
from app.core.data_parse.parse_web import 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.core.data_parse.calendar import get_calendar_by_date
# 导入微信认证相关函数
from app.core.data_parse.calendar import (
    register_wechat_user,
    login_wechat_user,
    logout_wechat_user,
    get_wechat_user_info,
    update_wechat_user_info,
    save_calendar_record,
    get_calendar_record
)
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
from app.models.parse_models import ParseTaskRepository
from app.core.data_parse.parse_system import db

# 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-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_zh: 标签名称
            - category: 标签分类
            - description: 标签描述
            - status: 启用状态，默认为'active'
        
    返回:
        - JSON: 包含创建结果和标签信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        if not data:
            return jsonify({
                'success': False,
                'message': '请求数据为空',
                'data': None
            }), 400
        
        # 验证必要字段
        if 'name_zh' not in data or not data['name_zh']:
            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_zh: 标签名称
            - 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





# 获取单个名片记录的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: 包含处理结果和状态信息
        
    返回格式:
        {
            'success': true/false,
            'message': '处理结果描述'
        }
        
    功能说明:
        - 接收包含人才数据的请求体
        - 严格按照样例格式处理 results 数组中的人才数据
        - 调用 add_single_talent 函数将人才信息写入 business_cards 表
        - 提供详细的处理统计和结果追踪
    """
    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({
            'success': result['success'],
            'message': result['message']
        }), 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('/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字段)
        - data: 数据内容 (form-data字段，招聘类型必填)
        - publish_time: 发布时间 (form-data字段，新任命类型必填)
        
    返回:
        - JSON: 包含任务创建结果和状态信息
        
    返回格式:
        {
            'success': true/false,
            'message': '处理结果描述'
        }
        
    功能说明:
        - 根据任务类型处理不同格式的文件
        - 名片任务：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参数'
            }), 400
        
        if task_type not in ['名片', '简历', '新任命', '招聘', '杂项']:
            return jsonify({
                'success': False,
                'message': 'task_type参数必须是以下值之一：名片、简历、新任命、招聘、杂项'
            }), 400
        
        # 获取创建者信息（可选参数）
        created_by = request.form.get('created_by', 'api_user')
        
        # 获取数据内容和发布时间参数
        data = request.form.get('data')
        publish_time = request.form.get('publish_time')
        
        # 对于招聘类型，不需要文件上传
        if task_type == '招聘':
            # 检查是否误传了文件
            if 'files' in request.files and request.files.getlist('files'):
                return jsonify({
                    'success': False,
                    'message': '招聘类型任务不需要上传文件'
                }), 400
            
            # 检查data参数是否有内容
            if not data:
                return jsonify({
                    'success': False,
                    'message': '招聘类型任务需要提供data参数'
                }), 400
            
            # 记录请求日志
            logger.info(f"新增招聘任务请求: 创建者={created_by}, data长度={len(data) if data else 0}")
            
            # 调用核心业务逻辑
            result = add_parse_task(None, task_type, created_by, data, publish_time)
            
            # 如果任务创建成功，继续执行批量处理
            if result['success']:
                # 招聘任务创建成功，不需要进一步处理
                logger.info(f"招聘任务创建成功")
            else:
                logger.error(f"招聘任务创建失败: {result.get('message', '未知错误')}")
        else:
            # 其他类型需要文件上传
            if 'files' not in request.files:
                return jsonify({
                    'success': False,
                    'message': f'{task_type}任务需要上传文件，请使用files字段上传文件'
                }), 400
            
            # 获取上传的文件列表
            uploaded_files = request.files.getlist('files')
            
            # 检查文件列表是否为空
            if not uploaded_files or len(uploaded_files) == 0:
                return jsonify({
                    'success': False,
                    'message': '文件数组不能为空'
                }), 400
            
            # 验证所有文件
            valid_files = []
            for i, file in enumerate(uploaded_files):
                # 检查文件是否为空
                if not file or file.filename == '':
                    return jsonify({
                        'success': False,
                        'message': f'第{i+1}个文件为空或未选择'
                    }), 400
                
                valid_files.append(file)
            
            # 对于新任命类型，检查publish_time参数
            if task_type == '新任命':
                if not publish_time:
                    return jsonify({
                        'success': False,
                        'message': '新任命类型任务需要提供publish_time参数'
                    }), 400
            
            # 记录请求日志
            logger.info(f"新增{task_type}任务请求: 文件数量={len(valid_files)}, 创建者={created_by}")
            
            # 调用核心业务逻辑
            result = add_parse_task(valid_files, task_type, created_by, data, publish_time)
        
        # 根据处理结果设置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']
        }), 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
        }), 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
    - 招聘: 已在add-parse-task接口中自动处理，此处不再支持
    - 杂项: batch_process_images
    
    请求参数:
    - data (dict): 包含完整任务信息的对象，格式如下：
        {
            "id": 123,
            "task_name": "parse_task_20241201_a1b2c3d4",
            "task_status": "待解析",
            "task_type": "名片",
            "task_source": [
                {
                    "original_filename": "张三名片.jpg",
                    "minio_path": "https://192.168.3.143:9000/dataops-platform/talent_photos/20241201_001234_张三名片.jpg",
                    "status": "正常"
                }
            ],
            "collection_count": 2,
            "parse_count": 0,
            "parse_result": null,
            "created_at": "2024-12-01 10:30:45",
            "created_by": "api_user",
            "updated_at": "2024-12-01 10:30:45",
            "updated_by": "api_user"
        }
        
    对于新任命类型，task_source中的每个对象还需要包含publish_time字段：
        {
            "publish_time": "20250731",
            "original_filename": "张三任命.md",
            "minio_path": "https://192.168.3.143:9000/dataops-platform/appointment_files/20241201_001234_张三任命.md",
            "status": "正常"
        }
    """
    try:
        # 获取请求数据
        request_data = request.get_json()
        
        if not request_data:
            return jsonify({
                'success': False,
                'message': '请求数据不能为空',
                'data': None
            }), 400
        
        # 验证请求数据格式
        if not isinstance(request_data, dict) or 'data' not in request_data:
            return jsonify({
                'success': False,
                'message': '请求数据格式错误，必须包含data字段',
                'data': None
            }), 400
        
        # 获取任务数据
        task_data = request_data.get('data')
        if not task_data:
            return jsonify({
                'success': False,
                'message': '任务数据不能为空',
                'data': None
            }), 400
        
        # 验证任务数据格式
        if not isinstance(task_data, dict):
            return jsonify({
                'success': False,
                'message': '任务数据必须是对象格式',
                'data': None
            }), 400
        
        # 获取任务类型
        task_type = task_data.get('task_type', '').strip()
        if not task_type:
            return jsonify({
                'success': False,
                'message': '任务类型不能为空',
                'data': None
            }), 400
        
        # 获取任务源数据
        task_source = task_data.get('task_source', [])
        if not task_source:
            return jsonify({
                'success': False,
                'message': '任务源数据不能为空',
                'data': None
            }), 400
        
        # 验证任务源数据格式
        if not isinstance(task_source, list):
            return jsonify({
                'success': False,
                'message': '任务源数据必须是数组格式',
                'data': None
            }), 400
        
        # 获取任务ID
        task_id = task_data.get('id')
        
        # 更新parse_task_repository数据库表中的task_source
        if task_id:
            try:
                from app.models.parse_models import ParseTaskRepository
                from app.core.data_parse.parse_system import db
                task_record = ParseTaskRepository.query.get(task_id)
                if task_record:
                    task_record.task_source = task_source
                    task_record.updated_at = get_east_asia_time_naive()
                    task_record.updated_by = 'admin'
                    db.session.commit()
                    logging.info(f"已更新task_id为{task_id}的任务记录的task_source")
                else:
                    logging.warning(f"未找到task_id为{task_id}的任务记录")
            except Exception as update_error:
                logging.error(f"更新任务记录失败: {str(update_error)}")
                db.session.rollback()
        
        # 根据任务类型执行相应的处理函数
        try:
            if task_type == '名片':
                # 调用名片批量处理函数
                result = batch_process_business_card_images(task_source, task_id, task_type)
                
            elif task_type == '简历':
                # 调用简历批量处理函数
                result = batch_parse_resumes(task_source, task_id, task_type)
                
            elif task_type == '新任命':
                # 验证新任命任务的publish_time字段
                for source_item in task_source:
                    if not isinstance(source_item, dict) or 'publish_time' not in source_item:
                        return jsonify({
                            'success': False,
                            'message': '新任命任务的每个源数据必须包含publish_time字段',
                            'data': None
                        }), 400
                
                # 调用新任命批量处理函数
                result = batch_process_md(task_source, task_id=task_id, task_type=task_type)
                
            elif task_type == '招聘':
                result = batch_process_menduner_data(task_source, task_id, task_type)
                
            elif task_type == '杂项':
                # 调用图片批量处理函数（表格类型）
                process_type = request_data.get('process_type', 'table')
                result = batch_process_images(task_source, process_type, task_id, task_type)
                
            else:
                return jsonify({
                    'success': False,
                    'message': f'不支持的任务类型: {task_type}，支持的类型：名片、简历、新任命、招聘、杂项',
                    'data': None
                }), 400
            
            # 记录处理结果日志并更新任务状态
            from app.models.parse_models import ParseTaskRepository
            from app.core.data_parse.parse_system import db
            task_obj = None
            
            if task_id:
                task_obj = ParseTaskRepository.query.filter_by(id=task_id).first()
            
            # 根据解析结果确定任务状态和返回数据
            if result.get('success'):
                logging.info(f"执行{task_type}解析任务成功: {result.get('message', '')}")
                
                # 获取解析结果数据
                result_data = result.get('data', {})
                success_count = result_data.get('success_count', 0)
                failed_count = result_data.get('failed_count', 0)
                # 对于新任命类型，parsed_record_ids在process_single_markdown_file中已经处理
                parsed_record_ids = result_data.get('parsed_record_ids', [])
                
                # 确定任务状态
                if failed_count == 0:
                    task_status = '解析成功'
                elif success_count > 0:
                    task_status = '部分解析成功'
                else:
                    task_status = '不成功'
                
                # 更新任务记录
                if task_obj:
                    task_obj.task_status = task_status
                    task_obj.parse_count = success_count
                    # 对于新任命类型，需要从数据库中查询实际的记录ID
                    if task_type == '新任命':
                        try:
                            from app.core.data_parse.parse_system import ParsedTalent
                            # 查询该任务相关的所有记录
                            parsed_records = ParsedTalent.query.filter_by(task_id=str(task_id), task_type=task_type).all()
                            record_ids = [str(record.id) for record in parsed_records]
                            task_obj.parse_result = ','.join(record_ids) if record_ids else ''
                        except Exception as e:
                            logging.error(f"查询新任命记录ID失败: {str(e)}")
                            task_obj.parse_result = ''
                    else:
                        task_obj.parse_result = ','.join(parsed_record_ids) if parsed_record_ids else ''
                    task_obj.updated_at = get_east_asia_time_naive()
                    task_obj.updated_by = 'admin'
                    db.session.commit()
                    logging.info(f"已更新解析任务记录: id={getattr(task_obj, 'id', None)}, 状态={task_obj.task_status}")
                
                # 构建返回数据，按照请求参数格式返回
                return_data = task_data.copy() if task_data else {}
                
                # 对于新任命类型，需要从数据库中查询实际的记录ID
                if task_type == '新任命':
                    try:
                        from app.core.data_parse.parse_system import ParsedTalent
                        # 查询该任务相关的所有记录
                        parsed_records = ParsedTalent.query.filter_by(task_id=str(task_id), task_type=task_type).all()
                        record_ids = [str(record.id) for record in parsed_records]
                        parse_result = ','.join(record_ids) if record_ids else ''
                    except Exception as e:
                        logging.error(f"查询新任命记录ID失败: {str(e)}")
                        parse_result = ''
                else:
                    parse_result = ','.join(parsed_record_ids) if parsed_record_ids else ''
                
                return_data.update({
                    'task_status': task_status,
                    'parse_count': success_count,
                    'parse_result': parse_result,
                    'updated_at': get_east_asia_isoformat(),
                    'updated_by': 'admin'
                })
                
                # 确定HTTP状态码
                if failed_count == 0:
                    status_code = 200  # 完全成功
                elif success_count > 0:
                    status_code = 206  # 部分成功
                else:
                    status_code = 500  # 完全失败
                
                return jsonify({
                    'success': True,
                    'message': result.get('message', '解析完成'),
                    'data': return_data
                }), status_code
                
            else:
                logging.error(f"执行{task_type}解析任务失败: {result.get('message', '')}")
                
                # 设置任务状态为不成功
                if task_obj:
                    task_obj.task_status = '不成功'
                    task_obj.parse_count = 0
                    task_obj.parse_result = ''
                    task_obj.updated_at = get_east_asia_time_naive()
                    task_obj.updated_by = 'admin'
                    db.session.commit()
                    logging.info(f"已更新解析任务记录: id={getattr(task_obj, 'id', None)}, 状态=不成功")
                
                # 构建返回数据，按照请求参数格式返回
                return_data = task_data.copy() if task_data else {}
                return_data.update({
                    'task_status': '不成功',
                    'parse_count': 0,
                    'parse_result': '',
                    'updated_at': get_east_asia_isoformat(),
                    'updated_by': 'admin'
                })
                
                return jsonify({
                    'success': False,
                    'message': result.get('message', '解析失败'),
                    'data': return_data
                }), 500
            
        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():
    """
    处理解析任务响应数据并写入人才信息接口
    
    请求参数:
        - 请求体: 包含任务ID和人才数据的JSON对象 (JSON格式)
          - task_id: 任务ID，用于更新任务状态（可选）
          - task_type: 任务类型（可选）
          - data: 包含人才解析结果的数据对象
        
    请求体格式（严格按照样例格式）:
        {
           "task_id": "119",
           "task_type": "名片",
           "data": {
               "results": [
                    {
                        "name_zh": "王仁",
                        "name_en": "Owen Wang",
                        "title_zh": "总经理",
                        "title_en": "General Manager",
                        "mobile": "+86 138 1685 0647",
                        "phone": null,
                        "email": "rwang5@urcove-hotels.com",
                        "hotel_zh": "上海静安逸扉酒店",
                        "hotel_en": "UrCove by HYATT Shanghai Jing'an",
                        "brand_zh": null,
                        "brand_en": null,
                        "affiliation_zh": null,
                        "affiliation_en": null,
                        "brand_group": "UrCove, HYATT",
                        "address_zh": "中国上海市静安区武定西路1185号",
                        "address_en": "No.1185 West Wuding Road, Jing'an District",
                        "postal_code_zh": "200042",
                        "postal_code_en": "200042",
                        "birthday": null,
                        "residence": null,
                        "age": 0,
                        "native_place": null,
                        "image_path": "",
                        "talent_profile": "测试用名片",
                        "career_path": [
                            {
                                "date": "2025-08-01",
                                "hotel_en": "UrCove by HYATT Shanghai Jing'an",
                                "hotel_zh": "上海静安逸扉酒店",
                                "image_path": "",
                                "source": "business_card_creation",
                                "title_en": "General Manager",
                                "title_zh": "总经理"
                            }
                        ],
                        "origin_source": [
                            {
                                "task_type": "招聘",
                                "minio_path": "http://example.com/path/to/image.jpg",
                                "source_date": "2025-08-01"
                            }
                        ],
                        "minio_path": "http://example.com/path/to/image.jpg"  // 可选字段
                    }
                ]
            }
        }
        
    返回:
        - JSON: 包含批量处理结果和状态信息
        
    功能说明:
        - 接收包含人才数据的请求体
        - 严格按照样例格式处理 results 数组中的人才数据
        - 调用 add_single_talent 函数将人才信息写入 business_cards 表
        - 提供详细的处理统计和结果追踪
        
    状态码:
        - 200: 全部处理成功
        - 206: 部分处理成功
        - 400: 请求参数错误
        - 500: 服务器内部错误
    """
    try:
        # 检查请求是否为 JSON 格式
        if not request.is_json:
            return jsonify({
                'success': False,
                'message': '请求必须是 JSON 格式'
            }), 400
        
        # 获取请求数据
        api_response_data = request.get_json()
        
        # 基本参数验证
        if not api_response_data:
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400
        
        # 验证数据格式
        if not isinstance(api_response_data, dict):
            return jsonify({
                'success': False,
                'message': '请求数据必须是JSON对象格式'
            }), 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', '处理完成')
        }), 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
        }), 500


@bp.route('/get-parsed-talents', methods=['GET'])
def get_parsed_talents_route():
    """
    获取解析人才记录列表接口
    
    请求参数:
        - status (str, optional): 状态过滤参数，如果为空则查询所有记录
        
    请求示例:
        GET /get-parsed-talents?status=待审核
        GET /get-parsed-talents (查询所有记录)
        
    返回:
        - JSON: 包含人才记录列表和状态信息
        - 200: 成功获取数据
        - 500: 服务器内部错误
    """
    try:
        # 获取查询参数
        status = request.args.get('status', '').strip()
        
        # 调用核心业务逻辑
        from app.core.data_parse.parse_system import get_parsed_talents
        result = get_parsed_talents(status)
        
        # 根据处理结果设置HTTP状态码
        if result.get('success', False):
            status_code = result.get('code', 200)
        else:
            status_code = result.get('code', 500)
        
        # 记录处理结果日志
        if result.get('success'):
            count = result.get('count', 0)
            if status:
                logging.info(f"成功获取状态为 '{status}' 的解析人才记录: {count} 条")
            else:
                logging.info(f"成功获取所有解析人才记录: {count} 条")
        else:
            logging.error(f"获取解析人才记录失败: {result.get('message', '未知错误')}")
        
        # 返回结果
        return jsonify({
            'success': result.get('success', False),
            'message': result.get('message', '处理完成'),
            'data': result.get('data', []),
            'count': result.get('count', 0)
        }), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"获取解析人才记录接口失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': [],
            'count': 0
        }), 500


@bp.route('/process-urls', methods=['POST'])
def process_urls_route():
    """
    处理网页URL爬取接口
    
    请求参数:
        - JSON格式，包含以下字段:
            - urlArr: 字符串数组，每个元素为一个网页URL地址
        
    请求示例:
        POST /process-urls
        Content-Type: application/json
        
        {
            "urlArr": [
                "https://example.com/page1",
                "https://example.com/page2",
                "https://mp.weixin.qq.com/s/4yz-kNAWAlF36aeQ_cgQQg"
            ]
        }
        
    返回:
        - JSON: 包含网页爬取结果的字典
        
    返回格式:
        {
            "success": true/false,
            "message": "处理结果描述",
            "data": {
                "total_urls": 总URL数量,
                "success_count": 成功爬取的URL数量,
                "failed_count": 失败的URL数量,
                "contents": [
                    {
                        "url": "URL地址",
                        "data": "网页内容",
                        "status": "success",
                        "content_length": 内容长度,
                        "original_length": 原始内容长度,
                        "status_code": HTTP状态码,
                        "encoding": 编码格式
                    }
                ],
                "failed_items": [
                    {
                        "url": "URL地址",
                        "error": "错误信息",
                        "status": "failed"
                    }
                ]
            }
        }
        
    功能说明:
        - 接收包含URL数组的POST请求
        - 调用web_url_crawl函数进行网页内容爬取
        - 返回结构化的爬取结果
        - 支持批量处理多个URL
        - 提供详细的成功/失败统计信息
        
    状态码:
        - 200: 完全成功，所有URL都成功爬取
        - 206: 部分成功，部分URL成功爬取
        - 400: 请求参数错误
        - 500: 服务器内部错误
    """
    try:
        # 检查请求是否为JSON格式
        if not request.is_json:
            return jsonify({
                'success': False,
                'message': '请求必须是JSON格式'
            }), 400
        
        # 获取请求数据
        request_data = request.get_json()
        
        # 基本参数验证
        if not request_data:
            return jsonify({
                'success': False,
                'message': '请求数据不能为空'
            }), 400
        
        # 验证urlArr字段
        if 'urlArr' not in request_data:
            return jsonify({
                'success': False,
                'message': '缺少必填字段: urlArr'
            }), 400
        
        url_arr = request_data.get('urlArr')
        
        # 验证urlArr是否为数组
        if not isinstance(url_arr, list):
            return jsonify({
                'success': False,
                'message': 'urlArr字段必须是数组格式'
            }), 400
        
        # 验证urlArr是否为空
        if len(url_arr) == 0:
            return jsonify({
                'success': False,
                'message': 'urlArr数组不能为空'
            }), 400
        
        # 验证每个URL是否为字符串
        for i, url in enumerate(url_arr):
            if not isinstance(url, str):
                return jsonify({
                    'success': False,
                    'message': f'urlArr[{i}]必须是字符串格式，当前类型: {type(url).__name__}'
                }), 400
        
        # 记录请求日志
        logger.info(f"收到网页URL爬取请求，包含 {len(url_arr)} 个URL")
        
        # 调用核心业务逻辑 - web_url_crawl函数
        result = web_url_crawl(url_arr)
        
        # 根据处理结果设置HTTP状态码
        if result.get('success', False):
            success_count = result.get('data', {}).get('success_count', 0)
            failed_count = result.get('data', {}).get('failed_count', 0)
            
            if failed_count == 0:
                status_code = 200  # 完全成功
            elif success_count > 0:
                status_code = 206  # 部分成功
            else:
                status_code = 500  # 完全失败
        else:
            status_code = 500  # 服务器错误
        
        # 记录处理结果日志
        if result.get('success'):
            data = result.get('data', {})
            success_count = data.get('success_count', 0)
            failed_count = data.get('failed_count', 0)
            total_urls = data.get('total_urls', 0)
            
            if failed_count == 0:
                logger.info(f"网页URL爬取完全成功: 共 {total_urls} 个URL，全部成功")
            else:
                logger.info(f"网页URL爬取部分成功: 共 {total_urls} 个URL，成功 {success_count} 个，失败 {failed_count} 个")
        else:
            logger.error(f"网页URL爬取失败: {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"网页URL爬取接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'success': False,
            'message': error_msg,
            'data': {
                'total_urls': 0,
                'success_count': 0,
                'failed_count': 0,
                'contents': [],
                'failed_items': []
            }
        }), 500


@bp.route('/get-calendar-info', methods=['GET'])
def get_calendar_info_api():
    """
    获取指定日期的黄历信息
    
    GET /api/data_parse/get-calendar-info?date=YYYY-MM-DD
    
    Args:
        date (str): 查询日期，格式为YYYY-MM-DD
        
    Returns:
        JSON: 包含黄历信息的响应数据
    """
    try:
        # 获取查询参数
        date_param = request.args.get('date')
        
        # 验证日期参数
        if not date_param:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: date'
            }), 400
        
        # 验证日期格式
        if not isinstance(date_param, str) or len(date_param) != 10:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '日期格式错误，请使用YYYY-MM-DD格式'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到黄历信息查询请求，日期: {date_param}")
        
        # 调用核心业务逻辑 - get_calendar_by_date函数
        result = get_calendar_by_date(date_param)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"黄历信息查询成功，日期: {date_param}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"黄历信息查询失败，日期: {date_param}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"黄历信息查询接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


# ================================
# 微信认证相关API路由
# ================================

@bp.route('/wechat-register', methods=['POST'])
def wechat_register_api():
    """
    微信用户注册接口
    
    POST /api/parse/wechat-register
    
    Request Body:
    {
        "wechat_code": "wx_code_12345",         // 必填：微信授权码（15分钟有效期）
        "phone_number": "13800138000",          // 可选：手机号码
        "id_card_number": "110101199001011234", // 可选：身份证号码
        "platform": "miniprogram"              // 可选：微信平台类型，默认为小程序
    }
    
    Returns:
        JSON: 包含注册结果的响应数据，成功时返回用户openid等信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        # 验证请求数据
        if not data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '请求体不能为空'
            }), 400
        
        # 验证必填参数
        wechat_code = data.get('wechat_code')
        if not wechat_code:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: wechat_code'
            }), 400
        
        # 获取可选参数
        phone_number = data.get('phone_number')
        id_card_number = data.get('id_card_number')
        platform = data.get('platform', 'miniprogram')
        
        # 记录请求日志
        logger.info(f"收到微信用户注册请求，wechat_code: {wechat_code}, platform: {platform}")
        
        # 调用核心业务逻辑
        result = register_wechat_user(wechat_code, phone_number, id_card_number, platform)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 201:
            logger.info(f"微信用户注册成功，wechat_code: {wechat_code}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"微信用户注册失败，wechat_code: {wechat_code}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"微信用户注册接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


@bp.route('/wechat-login', methods=['POST'])
def wechat_login_api():
    """
    微信用户登录接口
    
    POST /api/parse/wechat-login
    
    Request Body:
    {
        "wechat_code": "wx_code_12345",  // 必填：微信授权码（15分钟有效期）
        "platform": "miniprogram"       // 可选：微信平台类型，默认为小程序
    }
    
    Returns:
        JSON: 包含登录结果的响应数据，成功时返回用户openid等信息
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        # 验证请求数据
        if not data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '请求体不能为空'
            }), 400
        
        # 验证必填参数
        wechat_code = data.get('wechat_code')
        if not wechat_code:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: wechat_code'
            }), 400
        
        # 获取可选参数
        platform = data.get('platform', 'miniprogram')
        
        # 记录请求日志
        logger.info(f"收到微信用户登录请求，wechat_code: {wechat_code}, platform: {platform}")
        
        # 调用核心业务逻辑
        result = login_wechat_user(wechat_code, platform)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"微信用户登录成功，wechat_code: {wechat_code}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"微信用户登录失败，wechat_code: {wechat_code}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"微信用户登录接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


@bp.route('/wechat-logout', methods=['POST'])
def wechat_logout_api():
    """
    微信用户登出接口
    
    POST /api/parse/wechat-logout
    
    Request Body:
    {
        "openid": "wx_openid_abcd1234567890"  // 必填：微信用户openid
    }
    
    Returns:
        JSON: 包含登出结果的响应数据
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        # 验证请求数据
        if not data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '请求体不能为空'
            }), 400
        
        # 验证必填参数
        openid = data.get('openid')
        if not openid:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: openid'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到微信用户登出请求，openid: {openid}")
        
        # 调用核心业务逻辑
        result = logout_wechat_user(openid)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"微信用户登出成功，openid: {openid}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"微信用户登出失败，openid: {openid}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"微信用户登出接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


@bp.route('/wechat-user', methods=['GET'])
def wechat_get_user_info_api():
    """
    获取微信用户信息接口
    
    GET /api/parse/wechat-user?openid=wx_openid_abcd1234567890
    
    Args:
        openid (str): 微信用户openid，作为查询参数
        
    Returns:
        JSON: 包含用户信息的响应数据
    """
    try:
        # 获取查询参数
        openid = request.args.get('openid')
        
        # 验证必填参数
        if not openid:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: openid'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到获取微信用户信息请求，openid: {openid}")
        
        # 调用核心业务逻辑
        result = get_wechat_user_info(openid)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"获取微信用户信息成功，openid: {openid}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"获取微信用户信息失败，openid: {openid}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"获取微信用户信息接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


@bp.route('/wechat-user', methods=['PUT'])
def wechat_update_user_info_api():
    """
    更新微信用户信息接口
    
    PUT /api/parse/wechat-user
    
    Request Body:
    {
        "openid": "wx_openid_abcd1234567890",  // 必填：微信用户openid
        "phone_number": "13900139000",         // 可选：要更新的手机号码
        "id_card_number": "110101199001011234" // 可选：要更新的身份证号码
    }
    
    Returns:
        JSON: 包含更新结果的响应数据
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        # 验证请求数据
        if not data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '请求体不能为空'
            }), 400
        
        # 验证必填参数
        openid = data.get('openid')
        if not openid:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: openid'
            }), 400
        
        # 构建更新数据，排除openid
        update_data = {}
        if 'phone_number' in data:
            update_data['phone_number'] = data['phone_number']
        if 'id_card_number' in data:
            update_data['id_card_number'] = data['id_card_number']
        
        # 检查是否有要更新的数据
        if not update_data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '没有提供要更新的数据'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到更新微信用户信息请求，openid: {openid}, 更新字段: {list(update_data.keys())}")
        
        # 调用核心业务逻辑
        result = update_wechat_user_info(openid, update_data)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"更新微信用户信息成功，openid: {openid}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"更新微信用户信息失败，openid: {openid}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"更新微信用户信息接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


# ================================
# 日历记录相关API路由
# ================================

@bp.route('/save-calendar-record', methods=['POST'])
def save_calendar_record_api():
    """
    保存日历记录接口
    
    POST /api/parse/save-calendar-record
    
    Request Body:
    {
        "openid": "wx_openid_abcd1234567890123456",  // 必填：微信用户openid
        "month_key": "2024-01",                      // 必填：月份标识（YYYY-MM格式）
        "calendar_content": [                        // 必填：日历内容（JSON数组）
            {
                "date": "2024-01-01",
                "events": ["元旦节"],
                "notes": "新年快乐"
            },
            {
                "date": "2024-01-15",
                "events": ["会议", "约会"],
                "notes": "重要日程"
            }
        ]
    }
    
    Returns:
        JSON: 包含保存结果的响应数据
    """
    try:
        # 获取请求数据
        data = request.get_json()
        
        # 验证请求数据
        if not data:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '请求体不能为空'
            }), 400
        
        # 验证必填参数
        openid = data.get('openid')
        month_key = data.get('month_key')
        calendar_content = data.get('calendar_content')
        
        if not openid:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: openid'
            }), 400
        
        if not month_key:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: month_key'
            }), 400
        
        if calendar_content is None:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: calendar_content'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到保存日历记录请求，openid: {openid}, month_key: {month_key}")
        
        # 调用核心业务逻辑
        result = save_calendar_record(data)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            logger.info(f"保存日历记录成功，openid: {openid}, month_key: {month_key}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"保存日历记录失败，openid: {openid}, month_key: {month_key}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"保存日历记录接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500


@bp.route('/get-calendar-record', methods=['GET'])
def get_calendar_record_api():
    """
    获取日历记录接口
    
    GET /api/parse/get-calendar-record?openid=wx_openid_abcd1234567890123456&month_key=2024-01
    
    Args:
        openid (str): 微信用户openid，作为查询参数
        month_key (str): 月份标识（YYYY-MM格式），作为查询参数
        
    Returns:
        JSON: 包含查询结果的响应数据
    """
    try:
        # 获取查询参数
        openid = request.args.get('openid')
        month_key = request.args.get('month_key')
        
        # 验证必填参数
        if not openid:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: openid'
            }), 400
        
        if not month_key:
            return jsonify({
                'reason': 'failed',
                'return_code': 400,
                'result': None,
                'error': '缺少必填参数: month_key'
            }), 400
        
        # 记录请求日志
        logger.info(f"收到获取日历记录请求，openid: {openid}, month_key: {month_key}")
        
        # 调用核心业务逻辑
        result = get_calendar_record(openid, month_key)
        
        # 根据返回结果设置HTTP状态码
        status_code = result.get('return_code', 500)
        
        # 记录处理结果日志
        if result.get('return_code') == 200:
            has_content = result.get('result', {}).get('id') is not None
            logger.info(f"获取日历记录成功，openid: {openid}, month_key: {month_key}, 有记录: {has_content}")
        else:
            error_msg = result.get('error', '未知错误')
            logger.warning(f"获取日历记录失败，openid: {openid}, month_key: {month_key}，错误: {error_msg}")
        
        # 返回结果
        return jsonify(result), status_code
        
    except Exception as e:
        # 记录错误日志
        error_msg = f"获取日历记录接口失败: {str(e)}"
        logger.error(error_msg, exc_info=True)
        
        # 返回错误响应
        return jsonify({
            'reason': 'failed',
            'return_code': 500,
            'result': None,
            'error': error_msg
        }), 500