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

from flask import jsonify, request, make_response, Blueprint, current_app, send_file
from app.api.data_parse import bp
from app.core.data_parse.parse import parse_data, process_business_card, 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, 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.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('/parse', methods=['POST'])
def parse():
    """
    解析数据的接口
    """
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': 'No data provided'}), 400
            
        result = parse_data(data)
        return jsonify(result), 200
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500 
    
# 名片解析接口
@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_file)
    
    if result['success']:
        return jsonify(result), 200
    else:
        return jsonify(result), 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('/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