DataOps-platform/app/core/data_parse/parse.py

from typing import Dict, Any
from app import db
from datetime import datetime
import os
import boto3
from botocore.config import Config
import logging
import requests
import json
import re
import uuid
from PIL import Image
from io import BytesIO
import pytesseract
import base64
from openai import OpenAI


# 测试用的解析数据接口。没有实际使用。      
def parse_data(data: Dict[str, Any]) -> Dict[str, Any]:
    """
    解析数据的主函数
    
    Args:
        data: 要解析的数据
        
    Returns:
        解析后的数据
    """
    # TODO: 实现数据解析逻辑
    return {
        'status': 'success',
        'message': 'Data parsed successfully',
        'data': data
    } 

# 名片解析数据模型
class BusinessCard(db.Model):
    __tablename__ = 'business_cards'
    
    id = db.Column(db.Integer, primary_key=True)
    name_zh = db.Column(db.String(100), nullable=False)
    name_en = db.Column(db.String(100))
    title_zh = db.Column(db.String(100))
    title_en = db.Column(db.String(100))
    mobile = db.Column(db.String(50))
    phone = db.Column(db.String(50))
    email = db.Column(db.String(100))
    hotel_zh = db.Column(db.String(200))
    hotel_en = db.Column(db.String(200))
    address_zh = db.Column(db.Text)
    address_en = db.Column(db.Text)
    postal_code_zh = db.Column(db.String(20))
    postal_code_en = db.Column(db.String(20))
    brand_zh = db.Column(db.String(100))
    brand_en = db.Column(db.String(100))
    affiliation_zh = db.Column(db.String(200))
    affiliation_en = db.Column(db.String(200))
    image_path = db.Column(db.String(255))  # MinIO中存储的路径
    created_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
    updated_at = db.Column(db.DateTime, onupdate=datetime.now)
    updated_by = db.Column(db.String(50))
    status = db.Column(db.String(20), default='active')
    
    def to_dict(self):
        return {
            'id': self.id,
            'name_zh': self.name_zh,
            'name_en': self.name_en,
            'title_zh': self.title_zh,
            'title_en': self.title_en,
            'mobile': self.mobile,
            'phone': self.phone,
            'email': self.email,
            'hotel_zh': self.hotel_zh,
            'hotel_en': self.hotel_en,
            'address_zh': self.address_zh,
            'address_en': self.address_en,
            'postal_code_zh': self.postal_code_zh,
            'postal_code_en': self.postal_code_en,
            'brand_zh': self.brand_zh,
            'brand_en': self.brand_en,
            'affiliation_zh': self.affiliation_zh,
            'affiliation_en': self.affiliation_en,
            'image_path': self.image_path,
            'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S') if self.created_at else None,
            'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S') if self.updated_at else None,
            'updated_by': self.updated_by,
            'status': self.status
        }


# 名片解析功能模块

# MinIO配置
MINIO_URL = os.environ.get('MINIO_URL', 'localhost:19000')
MINIO_ACCESS_KEY = os.environ.get('MINIO_ACCESS_KEY', 'miniomxl')
MINIO_SECRET_KEY = os.environ.get('MINIO_SECRET_KEY', 'minio2357!')
MINIO_BUCKET = os.environ.get('MINIO_BUCKET', 'business-cards')
USE_SSL = os.environ.get('MINIO_USE_SSL', 'false').lower() == 'true'

# DeepSeek API配置
DEEPSEEK_API_KEY = os.environ.get('DEEPSEEK_API_KEY', 'sk-2aea6e8b159b448aa3c1e29acd6f4349')
DEEPSEEK_API_URL = os.environ.get('DEEPSEEK_API_URL', 'https://api.deepseek.com/v1/chat/completions')
# 备用API端点
DEEPSEEK_API_URL_BACKUP = 'https://api.deepseek.com/v1/completions'

# OCR配置
# 设置pytesseract路径（如果需要）
# pytesseract.pytesseract.tesseract_cmd = r'/path/to/tesseract'
# OCR语言设置，支持多语言
OCR_LANG = os.environ.get('OCR_LANG', 'chi_sim+eng')

def get_minio_client():
    """获取MinIO客户端连接"""
    try:
        minio_client = boto3.client(
            's3',
            endpoint_url=f'{"https" if USE_SSL else "http"}://{MINIO_URL}',
            aws_access_key_id=MINIO_ACCESS_KEY,
            aws_secret_access_key=MINIO_SECRET_KEY,
            config=Config(signature_version='s3v4'),
            region_name='us-east-1'  # 可选，但某些S3客户端可能需要
        )
        
        # 确保存储桶存在
        if MINIO_BUCKET not in [bucket['Name'] for bucket in minio_client.list_buckets()['Buckets']]:
            minio_client.create_bucket(Bucket=MINIO_BUCKET)
            
        return minio_client
    except Exception as e:
        logging.error(f"MinIO连接错误: {str(e)}")
        return None

def extract_text_from_image(image_data):
    """
    使用OCR从图像中提取文本，然后通过DeepSeek API解析名片信息
    
    Args:
        image_data (bytes): 图像的二进制数据
        
    Returns:
        dict: 提取的信息（姓名、职位、公司等）
    
    Raises:
        Exception: 当OCR或API调用失败或配置错误时抛出异常
    """
    try:
        # 步骤1: 使用OCR从图像中提取文本
        ocr_text = ocr_extract_text(image_data)
        if not ocr_text or ocr_text.strip() == "":
            error_msg = "OCR无法从图像中提取文本"
            logging.error(error_msg)
            raise Exception(error_msg)
        
        logging.info(f"OCR提取的文本: {ocr_text[:200]}..." if len(ocr_text) > 200 else ocr_text)
        
        # 步骤2: 使用DeepSeek API解析文本中的信息
        return parse_text_with_deepseek(ocr_text)
    
    except Exception as e:
        error_msg = f"从图像中提取和解析文本失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        raise Exception(error_msg)


def ocr_extract_text(image_data):
    """
    使用OCR从图像中提取文本
    
    Args:
        image_data (bytes): 图像的二进制数据
        
    Returns:
        str: 提取的文本
    """
    try:
        # 将二进制数据转换为PIL图像
        image = Image.open(BytesIO(image_data))
        
        # 使用pytesseract进行OCR文本提取
        text = pytesseract.image_to_string(image, lang=OCR_LANG)
        
        # 清理提取的文本
        text = text.strip()
        logging.info(f"OCR成功从图像中提取文本，长度: {len(text)}")
        print(text)
        
        return text
    except Exception as e:
        error_msg = f"OCR提取文本失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        raise Exception(error_msg)


def parse_text_with_deepseek(text):
    """
    使用DeepSeek API解析文本中的名片信息
    
    Args:
        text (str): 要解析的文本
        
    Returns:
        dict: 解析的名片信息
    """
    # 准备请求DeepSeek API
    if not DEEPSEEK_API_KEY:
        error_msg = "未配置DeepSeek API密钥"
        logging.error(error_msg)
        raise Exception(error_msg)
    
    # 构建API请求的基本信息
    headers = {
        "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
        "Content-Type": "application/json"
    }
    
    # 构建提示语，包含OCR提取的文本
    prompt = f"""请从以下名片文本中提取详细信息，需分别识别中英文内容。
以JSON格式返回，包含以下字段：
- name_zh: 中文姓名
- name_en: 英文姓名
- title_zh: 中文职位/头衔
- title_en: 英文职位/头衔
- hotel_zh: 中文酒店/公司名称
- hotel_en: 英文酒店/公司名称
- mobile: 手机号码
- phone: 固定电话
- email: 电子邮箱
- address_zh: 中文地址
- address_en: 英文地址

名片文本：
{text}
"""
    
    # 使用模型名称
    model_name = 'deepseek-chat'
    
    try:
        # 尝试调用DeepSeek API
        logging.info(f"尝试通过DeepSeek API解析文本")
        payload = {
            "model": model_name,
            "messages": [
                {"role": "system", "content": "你是一个专业的名片信息提取助手。请用JSON格式返回结果，不要有多余的文字说明。"},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.1
        }
        
        logging.info(f"向DeepSeek API发送请求")
        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
        
        # 检查响应状态
        response.raise_for_status()
        
        # 解析API响应
        result = response.json()
        content = result.get("choices", [{}])[0].get("message", {}).get("content", "{}")
        
        # 尝试解析JSON内容
        try:
            # 找到内容中的JSON部分（有时模型会在JSON前后添加额外文本）
            json_content = extract_json_from_text(content)
            extracted_data = json.loads(json_content)
            logging.info(f"成功解析DeepSeek API返回的JSON")
        except json.JSONDecodeError:
            logging.warning(f"无法解析JSON，尝试直接从文本提取信息")
            # 如果无法解析JSON，尝试直接从文本中提取关键信息
            extracted_data = extract_fields_from_text(content)
        
        # 确保所有必要的字段都存在
        required_fields = ['name', 'title', 'company', 'phone', 'email', 'address']
        for field in required_fields:
            if field not in extracted_data:
                extracted_data[field] = ""
        
        logging.info(f"成功从DeepSeek API获取解析结果")
        return extracted_data
        
    except requests.exceptions.HTTPError as e:
        error_msg = f"DeepSeek API调用失败: {str(e)}"
        logging.error(error_msg)
        
        if hasattr(e, 'response') and e.response:
            logging.error(f"错误状态码: {e.response.status_code}")
            logging.error(f"错误内容: {e.response.text}")
        
        raise Exception(error_msg)
    except Exception as e:
        error_msg = f"解析文本过程中发生错误: {str(e)}"
        logging.error(error_msg, exc_info=True)
        raise Exception(error_msg)


def extract_json_from_text(text):
    """
    从文本中提取JSON部分
    
    Args:
        text (str): 包含JSON的文本
        
    Returns:
        str: 提取的JSON字符串
    """
    # 尝试找到最外层的花括号对
    start_idx = text.find('{')
    if start_idx == -1:
        return "{}"
    
    # 使用简单的括号匹配算法找到对应的闭合括号
    count = 0
    for i in range(start_idx, len(text)):
        if text[i] == '{':
            count += 1
        elif text[i] == '}':
            count -= 1
            if count == 0:
                return text[start_idx:i+1]
    
    # 如果没有找到闭合括号，返回从开始位置到文本结尾
    return text[start_idx:]


def extract_fields_from_text(text):
    """
    从文本中直接提取名片字段信息
    
    Args:
        text (str): 要分析的文本
        
    Returns:
        dict: 提取的字段
    """
    # 初始化结果字典
    result = {
        'name_zh': '',
        'name_en': '',
        'title_zh': '',
        'title_en': '',
        'mobile': '',
        'phone': '',
        'email': '',
        'hotel_zh': '',
        'hotel_en': '',
        'address_zh': '',
        'address_en': '',
        'postal_code_zh': '',
        'postal_code_en': '',
        'brand_zh': '',
        'brand_en': '',
        'affiliation_zh': '',
        'affiliation_en': ''
    }
    
    # 提取中文姓名
    name_zh_match = re.search(r'["\'](姓名)["\'][\s\{:]*["\']?(中文)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if name_zh_match:
        result['name_zh'] = name_zh_match.group(3)
    
    # 提取英文姓名
    name_en_match = re.search(r'["\'](姓名)["\'][\s\{:]*["\']?(英文)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if name_en_match:
        result['name_en'] = name_en_match.group(3)
    
    # 提取中文头衔
    title_zh_match = re.search(r'["\'](头衔|职位)["\'][\s\{:]*["\']?(中文)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if title_zh_match:
        result['title_zh'] = title_zh_match.group(3)
    
    # 提取英文头衔
    title_en_match = re.search(r'["\'](头衔|职位)["\'][\s\{:]*["\']?(英文)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if title_en_match:
        result['title_en'] = title_en_match.group(3)
    
    # 提取手机
    mobile_match = re.search(r'["\'](手机)["\'][\s:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if mobile_match:
        result['mobile'] = mobile_match.group(2)
    
    # 提取电话
    phone_match = re.search(r'["\'](电话)["\'][\s:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if phone_match:
        result['phone'] = phone_match.group(2)
    
    # 提取邮箱
    email_match = re.search(r'["\'](邮箱)["\'][\s:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if email_match:
        result['email'] = email_match.group(2)
    
    # 提取中文酒店名称
    hotel_zh_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(中文)["\']?[\s\{:]*["\']?(酒店名称)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if hotel_zh_match:
        result['hotel_zh'] = hotel_zh_match.group(4)
    
    # 提取英文酒店名称
    hotel_en_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(英文)["\']?[\s\{:]*["\']?(酒店名称)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if hotel_en_match:
        result['hotel_en'] = hotel_en_match.group(4)
    
    # 提取中文详细地址
    address_zh_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(中文)["\']?[\s\{:]*["\']?(详细地址)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if address_zh_match:
        result['address_zh'] = address_zh_match.group(4)
    
    # 提取英文详细地址
    address_en_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(英文)["\']?[\s\{:]*["\']?(详细地址)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if address_en_match:
        result['address_en'] = address_en_match.group(4)
    
    # 提取中文邮政编码
    postal_code_zh_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(中文)["\']?[\s\{:]*["\']?(邮政编码)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if postal_code_zh_match:
        result['postal_code_zh'] = postal_code_zh_match.group(4)
    
    # 提取英文邮政编码
    postal_code_en_match = re.search(r'["\'](地址)["\'][\s\{:]*["\']?(英文)["\']?[\s\{:]*["\']?(邮政编码)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if postal_code_en_match:
        result['postal_code_en'] = postal_code_en_match.group(4)
    
    # 提取中文品牌名称
    brand_zh_match = re.search(r'["\'](公司)["\'][\s\{:]*["\']?(中文)["\']?[\s\{:]*["\']?(品牌名称)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if brand_zh_match:
        result['brand_zh'] = brand_zh_match.group(4)
    
    # 提取英文品牌名称
    brand_en_match = re.search(r'["\'](公司)["\'][\s\{:]*["\']?(英文)["\']?[\s\{:]*["\']?(品牌名称)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if brand_en_match:
        result['brand_en'] = brand_en_match.group(4)
    
    # 提取中文隶属关系
    affiliation_zh_match = re.search(r'["\'](公司)["\'][\s\{:]*["\']?(中文)["\']?[\s\{:]*["\']?(隶属关系)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if affiliation_zh_match:
        result['affiliation_zh'] = affiliation_zh_match.group(4)
    
    # 提取英文隶属关系
    affiliation_en_match = re.search(r'["\'](公司)["\'][\s\{:]*["\']?(英文)["\']?[\s\{:]*["\']?(隶属关系)["\']?[\s\}:]*["\']([^"\']+)["\']', text, re.IGNORECASE)
    if affiliation_en_match:
        result['affiliation_en'] = affiliation_en_match.group(4)
    
    return result

def parse_text_with_qwen25VLplus(image_data):
    """
    使用阿里云的 Qwen 2.5 VL Plus 模型解析图像中的名片信息
    
    Args:
        image_data (bytes): 图像的二进制数据
        
    Returns:
        dict: 解析的名片信息
    """
    # 阿里云 Qwen API 配置
    QWEN_API_KEY = os.environ.get('QWEN_API_KEY', 'sk-8f2320dafc9e4076968accdd8eebd8e9')
    
    try:
        # 将图片数据转为 base64 编码
        base64_image = base64.b64encode(image_data).decode('utf-8')
        
        # 初始化 OpenAI 客户端，配置为阿里云 API
        client = OpenAI(
            api_key=QWEN_API_KEY,
            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        )
        
        # 构建提示语
        prompt = """请分析这张名片，提取以下信息，需分别识别中英文内容：
1. 中文姓名 (name_zh)
2. 英文姓名 (name_en)
3. 中文职位/头衔 (title_zh)
4. 英文职位/头衔 (title_en)
5. 中文酒店/公司名称 (hotel_zh)
6. 英文酒店/公司名称 (hotel_en)
7. 手机号码 (mobile)
8. 固定电话 (phone)
9. 电子邮箱 (email)
10. 中文地址 (address_zh)
11. 英文地址 (address_en)
12. 中文邮政编码 (postal_code_zh)
13. 英文邮政编码 (postal_code_en)

请以JSON格式返回结果，不要有多余的文字说明。每个字段如果名片中没有相应信息，返回空字符串。"""
        
        # 调用 Qwen 2.5 VL Plus API
        logging.info("发送请求到 Qwen 2.5 VL Plus 模型")
        completion = client.chat.completions.create(
            model="qwen-vl-plus",
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
                    ]
                }
            ]
        )
        
        # 解析响应
        response_content = completion.choices[0].message.content
        logging.info(f"成功从 Qwen 模型获取响应: {response_content[:100]}...")
        
        # 尝试从响应中提取 JSON
        try:
            json_content = extract_json_from_text(response_content)
            extracted_data = json.loads(json_content)
            logging.info("成功解析 Qwen 响应中的 JSON")
        except json.JSONDecodeError:
            logging.warning("无法解析 JSON，尝试从文本中提取信息")
            extracted_data = extract_fields_from_text(response_content)
        
        # 确保所有必要字段存在
        required_fields = [
            'name_zh', 'name_en', 'title_zh', 'title_en', 
            'hotel_zh', 'hotel_en', 'mobile', 'phone', 
            'email', 'address_zh', 'address_en',
            'postal_code_zh', 'postal_code_en'
        ]
        
        for field in required_fields:
            if field not in extracted_data:
                extracted_data[field] = ""
        
        return extracted_data
        
    except Exception as e:
        error_msg = f"Qwen 2.5 VL Plus 模型解析失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        raise Exception(error_msg)

def process_business_card(image_file):
    """
    处理名片图片并提取信息
    
    Args:
        image_file (FileStorage): 上传的名片图片文件
        
    Returns:
        dict: 处理结果，包含提取的信息和状态
    """
    minio_path = None
    
    try:
        # 读取图片数据
        image_data = image_file.read()
        image_file.seek(0)  # 重置文件指针以便后续读取
        
        try:
            # 优先使用 Qwen 2.5 VL Plus 模型直接从图像提取信息
            try:
                logging.info("尝试使用 Qwen 2.5 VL Plus 模型解析名片")
                extracted_data = parse_text_with_qwen25VLplus(image_data)
                logging.info("成功使用 Qwen 2.5 VL Plus 模型解析名片")
            except Exception as qwen_error:
                logging.warning(f"Qwen 模型解析失败，错误原因: {str(qwen_error)}")
                # extracted_data = extract_text_from_image(image_data)
        except Exception as e:
            return {
                'success': False,
                'message': f"名片解析失败: {str(e)}",
                'data': None
            }
        
        try:
            # 生成唯一的文件名
            file_ext = os.path.splitext(image_file.filename)[1].lower()
            if not file_ext:
                file_ext = '.jpg'  # 默认扩展名
            
            unique_filename = f"{uuid.uuid4().hex}{file_ext}"
            minio_path = f"{unique_filename}"
            
            # 尝试上传到MinIO
            minio_client = get_minio_client()
            if minio_client:
                minio_client.put_object(
                    Bucket=MINIO_BUCKET,
                    Key=minio_path,
                    Body=image_file,
                    ContentType=image_file.content_type
                )
                logging.info(f"图片已上传到MinIO: {minio_path}")
                
                # 只存储相对路径，不存储完整URL
                # 完整URL会由前端通过API代理访问
                logging.info(f"存储图片路径: {minio_path}")
            else:
                minio_path = None
                logging.warning("MinIO客户端未初始化，图片未上传")
        except Exception as e:
            logging.error(f"上传图片到MinIO失败: {str(e)}", exc_info=True)
            minio_path = None
        
        try:
            # 保存到数据库
            business_card = BusinessCard(
                name_zh=extracted_data.get('name_zh', ''),
                name_en=extracted_data.get('name_en', ''),
                title_zh=extracted_data.get('title_zh', ''),
                title_en=extracted_data.get('title_en', ''),
                mobile=extracted_data.get('mobile', ''),
                phone=extracted_data.get('phone', ''),
                email=extracted_data.get('email', ''),
                hotel_zh=extracted_data.get('hotel_zh', ''),
                hotel_en=extracted_data.get('hotel_en', ''),
                address_zh=extracted_data.get('address_zh', ''),
                address_en=extracted_data.get('address_en', ''),
                postal_code_zh=extracted_data.get('postal_code_zh', ''),
                postal_code_en=extracted_data.get('postal_code_en', ''),
                brand_zh=extracted_data.get('brand_zh', ''),
                brand_en=extracted_data.get('brand_en', ''),
                affiliation_zh=extracted_data.get('affiliation_zh', ''),
                affiliation_en=extracted_data.get('affiliation_en', ''),
                image_path=minio_path,  # 存储相对路径
                status='active',
                updated_by='system'
            )
            
            db.session.add(business_card)
            db.session.commit()
            
            logging.info(f"名片信息已保存到数据库，ID: {business_card.id}")
            
            return {
                'success': True,
                'message': '名片解析成功',
                'data': business_card.to_dict()
            }
        except Exception as e:
            db.session.rollback()
            error_msg = f"保存名片信息到数据库失败: {str(e)}"
            logging.error(error_msg, exc_info=True)
            
            # 即使数据库操作失败，仍返回提取的信息
            return {
                'success': False,
                'message': error_msg,
                'data': {
                    'id': None,
                    'name_zh': extracted_data.get('name_zh', ''),
                    'name_en': extracted_data.get('name_en', ''),
                    'title_zh': extracted_data.get('title_zh', ''),
                    'title_en': extracted_data.get('title_en', ''),
                    'mobile': extracted_data.get('mobile', ''),
                    'phone': extracted_data.get('phone', ''),
                    'email': extracted_data.get('email', ''),
                    'hotel_zh': extracted_data.get('hotel_zh', ''),
                    'hotel_en': extracted_data.get('hotel_en', ''),
                    'address_zh': extracted_data.get('address_zh', ''),
                    'address_en': extracted_data.get('address_en', ''),
                    'postal_code_zh': extracted_data.get('postal_code_zh', ''),
                    'postal_code_en': extracted_data.get('postal_code_en', ''),
                    'brand_zh': extracted_data.get('brand_zh', ''),
                    'brand_en': extracted_data.get('brand_en', ''),
                    'affiliation_zh': extracted_data.get('affiliation_zh', ''),
                    'affiliation_en': extracted_data.get('affiliation_en', ''),
                    'image_path': minio_path,  # 返回相对路径
                    'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                    'updated_at': None,
                    'updated_by': 'system',
                    'status': 'active'
                }
            }
            
    except Exception as e:
        db.session.rollback()
        error_msg = f"名片处理失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        return {
            'success': False,
            'message': error_msg,
            'data': None
        }

def update_business_card(card_id, data):
    """
    更新名片信息
    
    Args:
        card_id (int): 名片记录ID
        data (dict): 包含要更新的字段的字典
        
    Returns:
        dict: 包含操作结果和更新后的名片信息
    """
    try:
        # 查找要更新的名片记录
        card = BusinessCard.query.get(card_id)
        
        if not card:
            return {
                'success': False,
                'message': f'未找到ID为{card_id}的名片记录',
                'data': None
            }
        
        # 更新名片信息
        card.name_zh = data.get('name_zh', card.name_zh)
        card.name_en = data.get('name_en', card.name_en)
        card.title_zh = data.get('title_zh', card.title_zh)
        card.title_en = data.get('title_en', card.title_en)
        card.mobile = data.get('mobile', card.mobile)
        card.phone = data.get('phone', card.phone)
        card.email = data.get('email', card.email)
        card.hotel_zh = data.get('hotel_zh', card.hotel_zh)
        card.hotel_en = data.get('hotel_en', card.hotel_en)
        card.address_zh = data.get('address_zh', card.address_zh)
        card.address_en = data.get('address_en', card.address_en)
        card.postal_code_zh = data.get('postal_code_zh', card.postal_code_zh)
        card.postal_code_en = data.get('postal_code_en', card.postal_code_en)
        card.brand_zh = data.get('brand_zh', card.brand_zh)
        card.brand_en = data.get('brand_en', card.brand_en)
        card.affiliation_zh = data.get('affiliation_zh', card.affiliation_zh)
        card.affiliation_en = data.get('affiliation_en', card.affiliation_en)
        card.updated_by = data.get('updated_by', 'user')  # 可以根据实际情况修改为当前用户
        
        # 保存更新
        db.session.commit()
        
        return {
            'success': True,
            'message': '名片信息已更新',
            'data': card.to_dict()
        }
    
    except Exception as e:
        db.session.rollback()
        error_msg = f"更新名片信息失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        return {
            'success': False,
            'message': error_msg,
            'data': None
        }

def get_business_cards():
    """
    获取所有名片记录列表
    
    Returns:
        dict: 包含操作结果和名片列表
    """
    try:
        # 查询所有名片记录
        cards = BusinessCard.query.all()
        
        # 将所有记录转换为字典格式
        cards_data = [card.to_dict() for card in cards]
        
        return {
            'success': True,
            'message': '获取名片列表成功',
            'data': cards_data
        }
    
    except Exception as e:
        error_msg = f"获取名片列表失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        return {
            'success': False,
            'message': error_msg,
            'data': []
        }

def update_business_card_status(card_id, status):
    """
    更新名片状态（激活/禁用）
    
    Args:
        card_id (int): 名片记录ID
        status (str): 新状态，'active'或'inactive'
        
    Returns:
        dict: 包含操作结果和更新后的名片信息
    """
    try:
        # 查找要更新的名片记录
        card = BusinessCard.query.get(card_id)
        
        if not card:
            return {
                'success': False,
                'message': f'未找到ID为{card_id}的名片记录',
                'data': None
            }
        
        # 验证状态值
        if status not in ['active', 'inactive']:
            return {
                'success': False,
                'message': f'无效的状态值: {status}，必须为 active 或 inactive',
                'data': None
            }
        
        # 更新状态
        card.status = status
        card.updated_at = datetime.now()
        card.updated_by = 'system'  # 可以根据实际情况修改为当前用户
        
        # 保存更新
        db.session.commit()
        
        return {
            'success': True,
            'message': f'名片状态已更新为: {status}',
            'data': card.to_dict()
        }
    
    except Exception as e:
        db.session.rollback()
        error_msg = f"更新名片状态失败: {str(e)}"
        logging.error(error_msg, exc_info=True)
        
        return {
            'success': False,
            'message': error_msg,
            'data': None
        }