|
|
@@ -0,0 +1,3453 @@
|
|
|
+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
|
|
|
+from app.config.config import DevelopmentConfig, ProductionConfig
|
|
|
+
|
|
|
+# 名片解析数据模型
|
|
|
+class BusinessCard(db.Model):
|
|
|
+ __tablename__ = 'business_cards'
|
|
|
+
|
|
|
+ id = db.Column(db.Integer, primary_key=True, autoincrement=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(100))
|
|
|
+ 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))
|
|
|
+ birthday = db.Column(db.Date) # 生日，存储年月日
|
|
|
+ age = db.Column(db.Integer) # 年龄字段
|
|
|
+ native_place = db.Column(db.Text) # 籍贯字段
|
|
|
+ residence = db.Column(db.Text) # 居住地
|
|
|
+ image_path = db.Column(db.String(255)) # MinIO中存储的路径
|
|
|
+ career_path = db.Column(db.JSON) # 职业轨迹，JSON格式
|
|
|
+ brand_group = db.Column(db.String(200)) # 品牌组合
|
|
|
+ origin_source = db.Column(db.JSON) # 原始资料记录，JSON格式
|
|
|
+ talent_profile = db.Column(db.Text) # 人才档案，文本格式
|
|
|
+ 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,
|
|
|
+ 'birthday': self.birthday.strftime('%Y-%m-%d') if self.birthday else None,
|
|
|
+ 'age': self.age,
|
|
|
+ 'native_place': self.native_place,
|
|
|
+ 'residence': self.residence,
|
|
|
+ 'image_path': self.image_path,
|
|
|
+ 'career_path': self.career_path,
|
|
|
+ 'brand_group': self.brand_group,
|
|
|
+ 'origin_source': self.origin_source,
|
|
|
+ 'talent_profile': self.talent_profile,
|
|
|
+ '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
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+# 重复名片处理数据模型
|
|
|
+class DuplicateBusinessCard(db.Model):
|
|
|
+ __tablename__ = 'duplicate_business_cards'
|
|
|
+
|
|
|
+ id = db.Column(db.Integer, primary_key=True, autoincrement=True)
|
|
|
+ main_card_id = db.Column(db.Integer, db.ForeignKey('business_cards.id'), nullable=False) # 新创建的主记录ID
|
|
|
+ suspected_duplicates = db.Column(db.JSON, nullable=False) # 疑似重复记录列表，JSON格式
|
|
|
+ duplicate_reason = db.Column(db.String(200), nullable=False) # 重复原因
|
|
|
+ processing_status = db.Column(db.String(20), default='pending') # 处理状态：pending/processed/ignored
|
|
|
+ created_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
|
|
|
+ processed_at = db.Column(db.DateTime) # 处理时间
|
|
|
+ processed_by = db.Column(db.String(50)) # 处理人
|
|
|
+ processing_notes = db.Column(db.Text) # 处理备注
|
|
|
+
|
|
|
+ # 关联主记录
|
|
|
+ main_card = db.relationship('BusinessCard', backref=db.backref('as_main_duplicate_records', lazy=True))
|
|
|
+
|
|
|
+ def to_dict(self):
|
|
|
+ return {
|
|
|
+ 'id': self.id,
|
|
|
+ 'main_card_id': self.main_card_id,
|
|
|
+ 'suspected_duplicates': self.suspected_duplicates,
|
|
|
+ 'duplicate_reason': self.duplicate_reason,
|
|
|
+ 'processing_status': self.processing_status,
|
|
|
+ 'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S') if self.created_at else None,
|
|
|
+ 'processed_at': self.processed_at.strftime('%Y-%m-%d %H:%M:%S') if self.processed_at else None,
|
|
|
+ 'processed_by': self.processed_by,
|
|
|
+ 'processing_notes': self.processing_notes
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+# 解析任务存储库数据模型
|
|
|
+class ParseTaskRepository(db.Model):
|
|
|
+ __tablename__ = 'parse_task_repository'
|
|
|
+
|
|
|
+ id = db.Column(db.Integer, primary_key=True, autoincrement=True)
|
|
|
+ task_name = db.Column(db.String(100), nullable=False)
|
|
|
+ task_status = db.Column(db.String(10), nullable=False)
|
|
|
+ task_type = db.Column(db.String(50), nullable=False)
|
|
|
+ task_source = db.Column(db.String(300), nullable=False)
|
|
|
+ collection_count = db.Column(db.Integer, nullable=False, default=0)
|
|
|
+ parse_count = db.Column(db.Integer, nullable=False, default=0)
|
|
|
+ parse_result = db.Column(db.JSON)
|
|
|
+ created_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
|
|
|
+ created_by = db.Column(db.String(50), nullable=False)
|
|
|
+ updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now, nullable=False)
|
|
|
+ updated_by = db.Column(db.String(50), nullable=False)
|
|
|
+
|
|
|
+ def to_dict(self):
|
|
|
+ return {
|
|
|
+ 'id': self.id,
|
|
|
+ 'task_name': self.task_name,
|
|
|
+ 'task_status': self.task_status,
|
|
|
+ 'task_type': self.task_type,
|
|
|
+ 'task_source': self.task_source,
|
|
|
+ 'collection_count': self.collection_count,
|
|
|
+ 'parse_count': self.parse_count,
|
|
|
+ 'parse_result': self.parse_result,
|
|
|
+ 'created_at': self.created_at.strftime('%Y-%m-%d %H:%M:%S') if self.created_at else None,
|
|
|
+ 'created_by': self.created_by,
|
|
|
+ 'updated_at': self.updated_at.strftime('%Y-%m-%d %H:%M:%S') if self.updated_at else None,
|
|
|
+ 'updated_by': self.updated_by
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+# 名片解析功能模块
|
|
|
+
|
|
|
+def normalize_mobile_numbers(mobile_str):
|
|
|
+ """
|
|
|
+ 标准化手机号码字符串，去重并限制最多3个
|
|
|
+
|
|
|
+ Args:
|
|
|
+ mobile_str (str): 手机号码字符串，可能包含多个手机号码，用逗号分隔
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: 标准化后的手机号码字符串，最多3个，用逗号分隔
|
|
|
+ """
|
|
|
+ if not mobile_str or not mobile_str.strip():
|
|
|
+ return ''
|
|
|
+
|
|
|
+ # 按逗号分割并清理每个手机号码
|
|
|
+ mobiles = []
|
|
|
+ for mobile in mobile_str.split(','):
|
|
|
+ mobile = mobile.strip()
|
|
|
+ if mobile and mobile not in mobiles: # 去重
|
|
|
+ mobiles.append(mobile)
|
|
|
+
|
|
|
+ # 限制最多3个手机号码
|
|
|
+ return ','.join(mobiles[:3])
|
|
|
+
|
|
|
+
|
|
|
+def mobile_numbers_overlap(mobile1, mobile2):
|
|
|
+ """
|
|
|
+ 检查两个手机号码字符串是否有重叠
|
|
|
+
|
|
|
+ Args:
|
|
|
+ mobile1 (str): 第一个手机号码字符串
|
|
|
+ mobile2 (str): 第二个手机号码字符串
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ bool: 是否有重叠的手机号码
|
|
|
+ """
|
|
|
+ if not mobile1 or not mobile2:
|
|
|
+ return False
|
|
|
+
|
|
|
+ mobiles1 = set(mobile.strip() for mobile in mobile1.split(',') if mobile.strip())
|
|
|
+ mobiles2 = set(mobile.strip() for mobile in mobile2.split(',') if mobile.strip())
|
|
|
+
|
|
|
+ return bool(mobiles1 & mobiles2) # 检查交集
|
|
|
+
|
|
|
+
|
|
|
+def merge_mobile_numbers(existing_mobile, new_mobile):
|
|
|
+ """
|
|
|
+ 合并手机号码，去重并限制最多3个
|
|
|
+
|
|
|
+ Args:
|
|
|
+ existing_mobile (str): 现有手机号码字符串
|
|
|
+ new_mobile (str): 新手机号码字符串
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: 合并后的手机号码字符串，最多3个，用逗号分隔
|
|
|
+ """
|
|
|
+ mobiles = []
|
|
|
+
|
|
|
+ # 添加现有手机号码
|
|
|
+ if existing_mobile:
|
|
|
+ for mobile in existing_mobile.split(','):
|
|
|
+ mobile = mobile.strip()
|
|
|
+ if mobile and mobile not in mobiles:
|
|
|
+ mobiles.append(mobile)
|
|
|
+
|
|
|
+ # 添加新手机号码
|
|
|
+ if new_mobile:
|
|
|
+ for mobile in new_mobile.split(','):
|
|
|
+ mobile = mobile.strip()
|
|
|
+ if mobile and mobile not in mobiles:
|
|
|
+ mobiles.append(mobile)
|
|
|
+
|
|
|
+ # 限制最多3个手机号码
|
|
|
+ return ','.join(mobiles[:3])
|
|
|
+
|
|
|
+
|
|
|
+def check_duplicate_business_card(extracted_data):
|
|
|
+ """
|
|
|
+ 检查是否存在重复的名片记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ extracted_data (dict): 提取的名片信息
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含检查结果的字典，格式为：
|
|
|
+ {
|
|
|
+ 'is_duplicate': bool,
|
|
|
+ 'action': str, # 'update', 'create_with_duplicates' 或 'create_new'
|
|
|
+ 'existing_card': BusinessCard 或 None,
|
|
|
+ 'suspected_duplicates': list, # 疑似重复记录列表
|
|
|
+ 'reason': str
|
|
|
+ }
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 获取提取的中文姓名和手机号码
|
|
|
+ name_zh = extracted_data.get('name_zh', '').strip()
|
|
|
+ mobile = normalize_mobile_numbers(extracted_data.get('mobile', ''))
|
|
|
+
|
|
|
+ if not name_zh:
|
|
|
+ return {
|
|
|
+ 'is_duplicate': False,
|
|
|
+ 'action': 'create_new',
|
|
|
+ 'existing_card': None,
|
|
|
+ 'suspected_duplicates': [],
|
|
|
+ 'reason': '无中文姓名，创建新记录'
|
|
|
+ }
|
|
|
+
|
|
|
+ # 查找具有相同中文姓名的记录
|
|
|
+ existing_cards = BusinessCard.query.filter_by(name_zh=name_zh).all()
|
|
|
+
|
|
|
+ if not existing_cards:
|
|
|
+ return {
|
|
|
+ 'is_duplicate': False,
|
|
|
+ 'action': 'create_new',
|
|
|
+ 'existing_card': None,
|
|
|
+ 'suspected_duplicates': [],
|
|
|
+ 'reason': '未找到同名记录，创建新记录'
|
|
|
+ }
|
|
|
+
|
|
|
+ # 如果找到同名记录，进一步检查手机号码
|
|
|
+ if mobile:
|
|
|
+ # 有手机号码的情况，检查是否有重叠的手机号码
|
|
|
+ for existing_card in existing_cards:
|
|
|
+ existing_mobile = existing_card.mobile if existing_card.mobile else ''
|
|
|
+
|
|
|
+ if mobile_numbers_overlap(existing_mobile, mobile):
|
|
|
+ # 手机号码有重叠，更新现有记录
|
|
|
+ return {
|
|
|
+ 'is_duplicate': True,
|
|
|
+ 'action': 'update',
|
|
|
+ 'existing_card': existing_card,
|
|
|
+ 'suspected_duplicates': [],
|
|
|
+ 'reason': f'姓名相同且手机号码有重叠：{name_zh} - 现有手机号:{existing_mobile}, 新手机号:{mobile}'
|
|
|
+ }
|
|
|
+
|
|
|
+ # 有手机号码但与现有记录无重叠，创建新记录并标记疑似重复
|
|
|
+ suspected_list = []
|
|
|
+ for card in existing_cards:
|
|
|
+ suspected_list.append({
|
|
|
+ 'id': card.id,
|
|
|
+ 'name_zh': card.name_zh,
|
|
|
+ 'name_en': card.name_en,
|
|
|
+ 'mobile': card.mobile,
|
|
|
+ 'hotel_zh': card.hotel_zh,
|
|
|
+ 'hotel_en': card.hotel_en,
|
|
|
+ 'title_zh': card.title_zh,
|
|
|
+ 'title_en': card.title_en,
|
|
|
+ 'created_at': card.created_at.strftime('%Y-%m-%d %H:%M:%S') if card.created_at else None
|
|
|
+ })
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'is_duplicate': True,
|
|
|
+ 'action': 'create_with_duplicates',
|
|
|
+ 'existing_card': None,
|
|
|
+ 'suspected_duplicates': suspected_list,
|
|
|
+ 'reason': f'姓名相同但手机号码无重叠：{name_zh}，新手机号：{mobile}，发现{len(suspected_list)}条疑似重复记录'
|
|
|
+ }
|
|
|
+ else:
|
|
|
+ # 无手机号码的情况，创建新记录并标记疑似重复
|
|
|
+ suspected_list = []
|
|
|
+ for card in existing_cards:
|
|
|
+ suspected_list.append({
|
|
|
+ 'id': card.id,
|
|
|
+ 'name_zh': card.name_zh,
|
|
|
+ 'name_en': card.name_en,
|
|
|
+ 'mobile': card.mobile,
|
|
|
+ 'hotel_zh': card.hotel_zh,
|
|
|
+ 'hotel_en': card.hotel_en,
|
|
|
+ 'title_zh': card.title_zh,
|
|
|
+ 'title_en': card.title_en,
|
|
|
+ 'created_at': card.created_at.strftime('%Y-%m-%d %H:%M:%S') if card.created_at else None
|
|
|
+ })
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'is_duplicate': True,
|
|
|
+ 'action': 'create_with_duplicates',
|
|
|
+ 'existing_card': None,
|
|
|
+ 'suspected_duplicates': suspected_list,
|
|
|
+ 'reason': f'姓名相同但新记录无手机号码可比较：{name_zh}，发现{len(suspected_list)}条疑似重复记录'
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"检查重复记录时发生错误: {str(e)}", exc_info=True)
|
|
|
+ return {
|
|
|
+ 'is_duplicate': False,
|
|
|
+ 'action': 'create_new',
|
|
|
+ 'existing_card': None,
|
|
|
+ 'suspected_duplicates': [],
|
|
|
+ 'reason': f'检查过程出错，创建新记录: {str(e)}'
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+def update_career_path(existing_card, new_data, image_path=None):
|
|
|
+ """
|
|
|
+ 更新职业轨迹信息
|
|
|
+
|
|
|
+ Args:
|
|
|
+ existing_card (BusinessCard): 现有名片记录
|
|
|
+ new_data (dict): 新的名片信息
|
|
|
+ image_path (str, optional): 对应的图片路径
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ list: 更新后的职业轨迹
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 获取现有的职业轨迹
|
|
|
+ career_path = existing_card.career_path if existing_card.career_path else []
|
|
|
+
|
|
|
+ # 准备新的职业轨迹条目
|
|
|
+ new_entry = {
|
|
|
+ 'date': datetime.now().strftime('%Y-%m-%d'),
|
|
|
+ 'hotel_zh': new_data.get('hotel_zh', ''),
|
|
|
+ 'hotel_en': new_data.get('hotel_en', ''),
|
|
|
+ 'title_zh': new_data.get('title_zh', ''),
|
|
|
+ 'title_en': new_data.get('title_en', ''),
|
|
|
+ 'image_path': image_path or '', # 添加图片路径
|
|
|
+ 'source': 'business_card_update'
|
|
|
+ }
|
|
|
+
|
|
|
+ # 检查是否已存在相似的条目（避免重复添加）
|
|
|
+ is_duplicate_entry = False
|
|
|
+ for entry in career_path:
|
|
|
+ if (entry.get('hotel_zh') == new_entry['hotel_zh'] and
|
|
|
+ entry.get('title_zh') == new_entry['title_zh'] and
|
|
|
+ entry.get('date') == new_entry['date']):
|
|
|
+ is_duplicate_entry = True
|
|
|
+ break
|
|
|
+
|
|
|
+ if not is_duplicate_entry:
|
|
|
+ career_path.append(new_entry)
|
|
|
+ logging.info(f"为名片ID {existing_card.id} 添加了新的职业轨迹条目，包含图片路径: {image_path}")
|
|
|
+ else:
|
|
|
+ logging.info(f"名片ID {existing_card.id} 的职业轨迹条目已存在，跳过添加")
|
|
|
+
|
|
|
+ return career_path
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"更新职业轨迹时发生错误: {str(e)}", exc_info=True)
|
|
|
+ return existing_card.career_path if existing_card.career_path else []
|
|
|
+
|
|
|
+
|
|
|
+def create_main_card_with_duplicates(extracted_data, minio_path, suspected_duplicates, reason):
|
|
|
+ """
|
|
|
+ 创建新的主记录并保存疑似重复记录信息
|
|
|
+
|
|
|
+ Args:
|
|
|
+ extracted_data (dict): 提取的新名片信息
|
|
|
+ minio_path (str): 新图片的MinIO路径
|
|
|
+ suspected_duplicates (list): 疑似重复记录列表
|
|
|
+ reason (str): 重复原因
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ tuple: (main_card, duplicate_record) 主记录和重复记录信息
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 1. 先创建主记录
|
|
|
+ # 准备初始职业轨迹，包含当前名片信息和图片路径
|
|
|
+ # initial_career_path = extracted_data.get('career_path', [])
|
|
|
+ if extracted_data.get('hotel_zh') or extracted_data.get('hotel_en') or extracted_data.get('title_zh') or extracted_data.get('title_en'):
|
|
|
+ initial_entry = {
|
|
|
+ 'date': datetime.now().strftime('%Y-%m-%d'),
|
|
|
+ 'hotel_zh': extracted_data.get('hotel_zh', ''),
|
|
|
+ 'hotel_en': extracted_data.get('hotel_en', ''),
|
|
|
+ 'title_zh': extracted_data.get('title_zh', ''),
|
|
|
+ 'title_en': extracted_data.get('title_en', ''),
|
|
|
+ 'image_path': minio_path or '', # 当前名片的图片路径
|
|
|
+ 'source': 'business_card_creation'
|
|
|
+ }
|
|
|
+ initial_career_path = [initial_entry]
|
|
|
+
|
|
|
+ # 处理年龄字段，确保是有效的整数或None
|
|
|
+ age_value = None
|
|
|
+ if extracted_data.get('age'):
|
|
|
+ try:
|
|
|
+ age_value = int(extracted_data.get('age'))
|
|
|
+ if age_value <= 0 or age_value > 150: # 合理的年龄范围检查
|
|
|
+ age_value = None
|
|
|
+ except (ValueError, TypeError):
|
|
|
+ age_value = None
|
|
|
+
|
|
|
+ main_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=normalize_mobile_numbers(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', ''),
|
|
|
+ birthday=datetime.strptime(extracted_data.get('birthday'), '%Y-%m-%d').date() if extracted_data.get('birthday') else None,
|
|
|
+ age=age_value,
|
|
|
+ native_place=extracted_data.get('native_place', ''),
|
|
|
+ residence=extracted_data.get('residence', ''),
|
|
|
+ image_path=minio_path, # 最新的图片路径
|
|
|
+ career_path=initial_career_path, # 包含图片路径的职业轨迹
|
|
|
+ brand_group=extracted_data.get('brand_group', ''),
|
|
|
+ origin_source=extracted_data.get('origin_source'), # 原始资料记录
|
|
|
+ talent_profile=extracted_data.get('talent_profile', ''), # 人才档案
|
|
|
+ status='active',
|
|
|
+ updated_by='system'
|
|
|
+ )
|
|
|
+
|
|
|
+ db.session.add(main_card)
|
|
|
+ db.session.flush() # 获取主记录的ID
|
|
|
+
|
|
|
+ # 2. 创建重复记录信息
|
|
|
+ duplicate_record = DuplicateBusinessCard(
|
|
|
+ main_card_id=main_card.id,
|
|
|
+ suspected_duplicates=suspected_duplicates,
|
|
|
+ duplicate_reason=reason,
|
|
|
+ processing_status='pending'
|
|
|
+ )
|
|
|
+
|
|
|
+ db.session.add(duplicate_record)
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"已创建主记录(ID: {main_card.id})并保存{len(suspected_duplicates)}条疑似重复记录信息(重复记录ID: {duplicate_record.id})")
|
|
|
+ return main_card, duplicate_record
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ logging.error(f"创建主记录和重复记录信息失败: {str(e)}", exc_info=True)
|
|
|
+ raise e
|
|
|
+
|
|
|
+
|
|
|
+# 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')
|
|
|
+
|
|
|
+
|
|
|
+# 根据环境选择配置
|
|
|
+"""
|
|
|
+if os.environ.get('FLASK_ENV') == 'production':
|
|
|
+ config = ProductionConfig()
|
|
|
+else:
|
|
|
+ config = DevelopmentConfig()
|
|
|
+"""
|
|
|
+
|
|
|
+# 使用配置变量,缺省认为在生产环境运行
|
|
|
+config = ProductionConfig()
|
|
|
+# 使用配置变量
|
|
|
+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客户端连接"""
|
|
|
+ try:
|
|
|
+ # 使用全局配置变量
|
|
|
+ global minio_url, minio_access_key, minio_secret_key, minio_bucket, use_ssl
|
|
|
+
|
|
|
+ logging.info(f"尝试连接MinIO服务器: {minio_url}")
|
|
|
+
|
|
|
+ minio_client = boto3.client(
|
|
|
+ 's3',
|
|
|
+ endpoint_url=minio_url,
|
|
|
+ aws_access_key_id=minio_access_key,
|
|
|
+ aws_secret_access_key=minio_secret_key,
|
|
|
+ config=Config(
|
|
|
+ signature_version='s3v4',
|
|
|
+ retries={'max_attempts': 3, 'mode': 'standard'},
|
|
|
+ connect_timeout=10,
|
|
|
+ read_timeout=30
|
|
|
+ )
|
|
|
+ )
|
|
|
+
|
|
|
+ # 确保存储桶存在
|
|
|
+ buckets = minio_client.list_buckets()
|
|
|
+ bucket_names = [bucket['Name'] for bucket in buckets.get('Buckets', [])]
|
|
|
+ logging.info(f"成功连接到MinIO服务器，现有存储桶: {bucket_names}")
|
|
|
+
|
|
|
+ if minio_bucket not in bucket_names:
|
|
|
+ logging.info(f"创建存储桶: {minio_bucket}")
|
|
|
+ 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: 英文地址
|
|
|
+- brand_group: 品牌组合（如有多个品牌，以逗号分隔）
|
|
|
+- career_path: 职业轨迹（如果能从文本中推断出，以JSON数组格式返回，包含公司名称和职位）
|
|
|
+
|
|
|
+名片文本：
|
|
|
+{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', 'brand_group', 'career_path']
|
|
|
+ for field in required_fields:
|
|
|
+ if field not in extracted_data:
|
|
|
+ extracted_data[field] = "" if field != 'career_path' else []
|
|
|
+
|
|
|
+ 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': '',
|
|
|
+ 'birthday': '',
|
|
|
+ 'age': 0,
|
|
|
+ 'native_place': '',
|
|
|
+ 'residence': ''
|
|
|
+ }
|
|
|
+
|
|
|
+ # 提取中文姓名
|
|
|
+ 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 VL Max 模型解析图像中的名片信息
|
|
|
+
|
|
|
+ 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) - 如有多个手机号码，使用逗号分隔，最多提取3个
|
|
|
+8. 固定电话 (phone) - 如有多个，使用逗号分隔
|
|
|
+9. 电子邮箱 (email)
|
|
|
+10. 中文地址 (address_zh)
|
|
|
+11. 英文地址 (address_en)
|
|
|
+12. 中文邮政编码 (postal_code_zh)
|
|
|
+13. 英文邮政编码 (postal_code_en)
|
|
|
+14. 生日 (birthday) - 格式为YYYY-MM-DD，如1990-01-01
|
|
|
+15. 年龄 (age) - 数字格式，如30
|
|
|
+16. 籍贯 (native_place) - 出生地或户籍所在地信息
|
|
|
+17. 居住地 (residence) - 个人居住地址信息
|
|
|
+18. 品牌组合 (brand_group) - 如有多个品牌，使用逗号分隔
|
|
|
+19. 职业轨迹 (career_path) - 如能从名片中推断，以JSON数组格式返回，包含当前日期，公司名称和职位。自动生成当前日期。
|
|
|
+20. 隶属关系 (affiliation) - 如能从名片中推断，以JSON数组格式返回，包含公司名称和隶属集团名称
|
|
|
+## 输出格式
|
|
|
+请以严格的JSON格式返回结果，不要添加任何额外解释文字。JSON格式如下：
|
|
|
+```json
|
|
|
+{
|
|
|
+ "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": "",
|
|
|
+ "birthday": "",
|
|
|
+ "age": 0,
|
|
|
+ "native_place": "",
|
|
|
+ "residence": "",
|
|
|
+ "brand_group": "",
|
|
|
+ "career_path": [],
|
|
|
+ "affiliation": []
|
|
|
+}
|
|
|
+```"""
|
|
|
+
|
|
|
+ # 调用 Qwen VL Max API
|
|
|
+ logging.info("发送请求到 Qwen VL Max 模型")
|
|
|
+ completion = client.chat.completions.create(
|
|
|
+ # model="qwen-vl-plus",
|
|
|
+ model="qwen-vl-max-latest",
|
|
|
+ messages=[
|
|
|
+ {
|
|
|
+ "role": "user",
|
|
|
+ "content": [
|
|
|
+ {"type": "text", "text": prompt},
|
|
|
+ {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ ],
|
|
|
+ temperature=0.1, # 降低温度增加精确性
|
|
|
+ response_format={"type": "json_object"} # 要求输出JSON格式
|
|
|
+ )
|
|
|
+
|
|
|
+ # 解析响应
|
|
|
+ response_content = completion.choices[0].message.content
|
|
|
+ logging.info(f"成功从 Qwen 模型获取响应: {response_content}")
|
|
|
+
|
|
|
+ # 尝试从响应中提取 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', 'birthday', 'age', 'native_place', 'residence',
|
|
|
+ 'brand_group', 'career_path'
|
|
|
+ ]
|
|
|
+
|
|
|
+ for field in required_fields:
|
|
|
+ if field not in extracted_data:
|
|
|
+ if field == 'career_path':
|
|
|
+ extracted_data[field] = []
|
|
|
+ elif field == 'age':
|
|
|
+ extracted_data[field] = 0
|
|
|
+ else:
|
|
|
+ extracted_data[field] = ""
|
|
|
+
|
|
|
+ # 为career_path增加一条记录
|
|
|
+ if extracted_data.get('hotel_zh') or extracted_data.get('hotel_en') or extracted_data.get('title_zh') or extracted_data.get('title_en'):
|
|
|
+ career_entry = {
|
|
|
+ 'date': datetime.now().strftime('%Y-%m-%d'),
|
|
|
+ 'hotel_en': extracted_data.get('hotel_en', ''),
|
|
|
+ 'hotel_zh': extracted_data.get('hotel_zh', ''),
|
|
|
+ 'image_path': '',
|
|
|
+ 'source': 'business_card_creation',
|
|
|
+ 'title_en': extracted_data.get('title_en', ''),
|
|
|
+ 'title_zh': extracted_data.get('title_zh', '')
|
|
|
+ }
|
|
|
+
|
|
|
+ # 直接清空原有的career_path内容，用career_entry写入
|
|
|
+ extracted_data['career_path'] = [career_entry]
|
|
|
+ logging.info(f"为解析结果设置了career_path记录: {career_entry}")
|
|
|
+
|
|
|
+ return extracted_data
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"Qwen VL Max 模型解析失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+ raise Exception(error_msg)
|
|
|
+
|
|
|
+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 {
|
|
|
+ 'code': 500,
|
|
|
+ '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)
|
|
|
+
|
|
|
+ # 处理手机号码字段，支持多个手机号码
|
|
|
+ if 'mobile' in data:
|
|
|
+ new_mobile = normalize_mobile_numbers(data.get('mobile', ''))
|
|
|
+ if new_mobile:
|
|
|
+ # 如果有新的手机号码，合并到现有手机号码中
|
|
|
+ card.mobile = merge_mobile_numbers(card.mobile, new_mobile)
|
|
|
+ elif 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)
|
|
|
+ # 处理生日字段，支持字符串转日期
|
|
|
+ if 'birthday' in data:
|
|
|
+ if data['birthday']:
|
|
|
+ try:
|
|
|
+ card.birthday = datetime.strptime(data['birthday'], '%Y-%m-%d').date()
|
|
|
+ except ValueError:
|
|
|
+ # 如果日期格式不正确，设置为None
|
|
|
+ card.birthday = None
|
|
|
+ else:
|
|
|
+ card.birthday = None
|
|
|
+
|
|
|
+ # 处理年龄字段
|
|
|
+ if 'age' in data:
|
|
|
+ try:
|
|
|
+ if data['age'] is not None and str(data['age']).strip():
|
|
|
+ card.age = int(data['age'])
|
|
|
+ else:
|
|
|
+ card.age = None
|
|
|
+ except (ValueError, TypeError):
|
|
|
+ # 如果年龄格式不正确，保持原值
|
|
|
+ pass
|
|
|
+
|
|
|
+ card.native_place = data.get('native_place', card.native_place)
|
|
|
+ card.residence = data.get('residence', card.residence)
|
|
|
+ card.career_path = data.get('career_path', card.career_path) # 更新职业轨迹
|
|
|
+ card.brand_group = data.get('brand_group', card.brand_group) # 更新品牌组合
|
|
|
+ card.origin_source = data.get('origin_source', card.origin_source) # 更新原始资料记录
|
|
|
+ card.talent_profile = data.get('talent_profile', card.talent_profile) # 更新人才档案
|
|
|
+ card.updated_by = data.get('updated_by', 'user') # 可以根据实际情况修改为当前用户
|
|
|
+
|
|
|
+ # 保存更新
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ # 更新成功后，更新Neo4j图数据库中的人才-酒店关系
|
|
|
+ try:
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+ from app.core.graph.graph_operations import create_or_get_node
|
|
|
+
|
|
|
+ # 获取当前时间
|
|
|
+ current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
|
+
|
|
|
+ # 创建或更新人才节点
|
|
|
+ talent_properties = {
|
|
|
+ 'pg_id': card_id, # PostgreSQL数据库中的ID
|
|
|
+ 'name_zh': card.name_zh, # 中文姓名
|
|
|
+ 'name_en': card.name_en, # 英文姓名
|
|
|
+ 'mobile': card.mobile, # 手机号码
|
|
|
+ 'email': card.email, # 电子邮箱
|
|
|
+ 'updated_at': current_time # 更新时间
|
|
|
+ }
|
|
|
+
|
|
|
+ talent_node_id = create_or_get_node('talent', **talent_properties)
|
|
|
+
|
|
|
+ # 如果有酒店信息，创建或更新酒店节点
|
|
|
+ if card.hotel_zh or card.hotel_en:
|
|
|
+ hotel_properties = {
|
|
|
+ 'hotel_zh': card.hotel_zh, # 酒店中文名称
|
|
|
+ 'hotel_en': card.hotel_en, # 酒店英文名称
|
|
|
+ 'updated_at': current_time # 更新时间
|
|
|
+ }
|
|
|
+
|
|
|
+ hotel_node_id = create_or_get_node('hotel', **hotel_properties)
|
|
|
+
|
|
|
+ # 创建或更新人才与酒店之间的WORK_FOR关系
|
|
|
+ if talent_node_id and hotel_node_id:
|
|
|
+ # 构建Cypher查询以创建或更新关系
|
|
|
+ cypher_query = """
|
|
|
+ MATCH (t:talent), (h:hotel)
|
|
|
+ WHERE id(t) = $talent_id AND id(h) = $hotel_id
|
|
|
+ MERGE (t)-[r:WORKS_FOR]->(h)
|
|
|
+ SET r.title_zh = $title_zh,
|
|
|
+ r.title_en = $title_en,
|
|
|
+ r.updated_at = $updated_at
|
|
|
+ RETURN r
|
|
|
+ """
|
|
|
+
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ session.run(
|
|
|
+ cypher_query,
|
|
|
+ talent_id=talent_node_id,
|
|
|
+ hotel_id=hotel_node_id,
|
|
|
+ title_zh=card.title_zh,
|
|
|
+ title_en=card.title_en,
|
|
|
+ updated_at=current_time
|
|
|
+ )
|
|
|
+
|
|
|
+ logging.info(f"已成功更新人才(ID:{talent_node_id})与酒店(ID:{hotel_node_id})的WORK_FOR关系")
|
|
|
+
|
|
|
+ logging.info(f"Neo4j图数据库关系更新成功")
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"更新Neo4j图数据库关系失败: {str(e)}", exc_info=True)
|
|
|
+ # 不因为图数据库更新失败而影响PostgreSQL数据库的更新结果
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ '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 {
|
|
|
+ 'code': 500,
|
|
|
+ '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 {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取名片列表成功',
|
|
|
+ 'data': cards_data
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取名片列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ '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 {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{card_id}的名片记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 验证状态值
|
|
|
+ if status not in ['active', 'inactive']:
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ '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 {
|
|
|
+ 'code': 200,
|
|
|
+ '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 {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def create_talent_tag(tag_data):
|
|
|
+ """
|
|
|
+ 创建人才标签节点
|
|
|
+
|
|
|
+ Args:
|
|
|
+ tag_data: 包含标签信息的字典，包括:
|
|
|
+ - name: 标签名称
|
|
|
+ - category: 标签分类
|
|
|
+ - description: 标签描述
|
|
|
+ - status: 启用状态
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 操作结果字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 验证必要参数存在
|
|
|
+ if not tag_data or 'name' not in tag_data or not tag_data['name']:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '标签名称为必填项',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 准备节点属性
|
|
|
+ tag_properties = {
|
|
|
+ 'name': tag_data.get('name'),
|
|
|
+ 'category': tag_data.get('category', '未分类'),
|
|
|
+ 'describe': tag_data.get('description', ''), # 使用describe与现有系统保持一致
|
|
|
+ 'status': tag_data.get('status', 'active'),
|
|
|
+ 'time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
|
+ }
|
|
|
+
|
|
|
+ # 生成标签的英文名（可选）
|
|
|
+ from app.core.graph.graph_operations import create_or_get_node
|
|
|
+
|
|
|
+ # 如果提供了名称，尝试获取英文翻译
|
|
|
+ if 'name' in tag_data and tag_data['name']:
|
|
|
+ try:
|
|
|
+ from app.api.data_interface.routes import translate_and_parse
|
|
|
+ en_name = translate_and_parse(tag_data['name'])
|
|
|
+ tag_properties['en_name'] = en_name[0] if en_name and isinstance(en_name, list) else ''
|
|
|
+ except Exception as e:
|
|
|
+ logging.warning(f"获取标签英文名失败: {str(e)}")
|
|
|
+ tag_properties['en_name'] = ''
|
|
|
+
|
|
|
+ # 创建节点
|
|
|
+ node_id = create_or_get_node('DataLabel', **tag_properties)
|
|
|
+
|
|
|
+ if node_id:
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '人才标签创建成功',
|
|
|
+ 'data': {
|
|
|
+ 'id': node_id,
|
|
|
+ **tag_properties
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else:
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '人才标签创建失败',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"创建人才标签失败: {str(e)}", exc_info=True)
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'创建人才标签失败: {str(e)}',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def get_talent_tag_list():
|
|
|
+ """
|
|
|
+ 从Neo4j图数据库获取人才标签列表
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和标签列表的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 构建Cypher查询语句，获取分类为talent的标签
|
|
|
+ query = """
|
|
|
+ MATCH (n:DataLabel)
|
|
|
+ WHERE n.category CONTAINS 'talent' OR n.category CONTAINS '人才'
|
|
|
+ RETURN id(n) as id, n.name as name, n.en_name as en_name,
|
|
|
+ n.category as category, n.describe as description,
|
|
|
+ n.status as status, n.time as time
|
|
|
+ ORDER BY n.time DESC
|
|
|
+ """
|
|
|
+
|
|
|
+ # 执行查询
|
|
|
+ tags = []
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ result = session.run(query)
|
|
|
+
|
|
|
+ # 处理查询结果
|
|
|
+ for record in result:
|
|
|
+ tag = {
|
|
|
+ 'id': record['id'],
|
|
|
+ 'name': record['name'],
|
|
|
+ 'en_name': record['en_name'],
|
|
|
+ 'category': record['category'],
|
|
|
+ 'description': record['description'],
|
|
|
+ 'status': record['status'],
|
|
|
+ 'time': record['time']
|
|
|
+ }
|
|
|
+ tags.append(tag)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取人才标签列表成功',
|
|
|
+ 'data': tags
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取人才标签列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+def update_talent_tag(tag_id, tag_data):
|
|
|
+ """
|
|
|
+ 更新人才标签节点属性
|
|
|
+
|
|
|
+ Args:
|
|
|
+ tag_id: 标签节点ID
|
|
|
+ tag_data: 包含更新信息的字典，可能包括:
|
|
|
+ - name: 标签名称
|
|
|
+ - category: 标签分类
|
|
|
+ - description: 标签描述
|
|
|
+ - status: 启用状态
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 操作结果字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 准备要更新的属性
|
|
|
+ update_properties = {}
|
|
|
+
|
|
|
+ # 检查并添加需要更新的属性
|
|
|
+ if 'name' in tag_data and tag_data['name']:
|
|
|
+ update_properties['name'] = tag_data['name']
|
|
|
+
|
|
|
+ # 如果名称更新了，尝试更新英文名称
|
|
|
+ try:
|
|
|
+ from app.api.data_interface.routes import translate_and_parse
|
|
|
+ en_name = translate_and_parse(tag_data['name'])
|
|
|
+ update_properties['en_name'] = en_name[0] if en_name and isinstance(en_name, list) else ''
|
|
|
+ except Exception as e:
|
|
|
+ logging.warning(f"更新标签英文名失败: {str(e)}")
|
|
|
+
|
|
|
+ if 'category' in tag_data and tag_data['category']:
|
|
|
+ update_properties['category'] = tag_data['category']
|
|
|
+
|
|
|
+ if 'description' in tag_data:
|
|
|
+ update_properties['describe'] = tag_data['description']
|
|
|
+
|
|
|
+ if 'status' in tag_data:
|
|
|
+ update_properties['status'] = tag_data['status']
|
|
|
+
|
|
|
+ # 添加更新时间
|
|
|
+ update_properties['time'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
|
+
|
|
|
+ # 如果没有可更新的属性，返回错误
|
|
|
+ if not update_properties:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '未提供任何可更新的属性',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 构建更新的Cypher查询
|
|
|
+ set_clauses = []
|
|
|
+ params = {'nodeId': tag_id}
|
|
|
+
|
|
|
+ for key, value in update_properties.items():
|
|
|
+ param_name = f"param_{key}"
|
|
|
+ set_clauses.append(f"n.{key} = ${param_name}")
|
|
|
+ params[param_name] = value
|
|
|
+
|
|
|
+ set_clause = ", ".join(set_clauses)
|
|
|
+
|
|
|
+ query = f"""
|
|
|
+ MATCH (n:DataLabel)
|
|
|
+ WHERE id(n) = $nodeId
|
|
|
+ SET {set_clause}
|
|
|
+ RETURN id(n) as id, n.name as name, n.en_name as en_name,
|
|
|
+ n.category as category, n.describe as description,
|
|
|
+ n.status as status, n.time as time
|
|
|
+ """
|
|
|
+
|
|
|
+ # 执行更新查询
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ result = session.run(query, **params)
|
|
|
+ record = result.single()
|
|
|
+
|
|
|
+ if not record:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{tag_id}的标签',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 提取更新后的标签信息
|
|
|
+ updated_tag = {
|
|
|
+ 'id': record['id'],
|
|
|
+ 'name': record['name'],
|
|
|
+ 'en_name': record['en_name'],
|
|
|
+ 'category': record['category'],
|
|
|
+ 'description': record['description'],
|
|
|
+ 'status': record['status'],
|
|
|
+ 'time': record['time']
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '人才标签更新成功',
|
|
|
+ 'data': updated_tag
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"更新人才标签失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def delete_talent_tag(tag_id):
|
|
|
+ """
|
|
|
+ 删除人才标签节点及其相关关系
|
|
|
+
|
|
|
+ Args:
|
|
|
+ tag_id: 标签节点ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 操作结果字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 首先获取要删除的标签信息，以便在成功后返回
|
|
|
+ get_query = """
|
|
|
+ MATCH (n:DataLabel)
|
|
|
+ WHERE id(n) = $nodeId
|
|
|
+ RETURN id(n) as id, n.name as name, n.en_name as en_name,
|
|
|
+ n.category as category, n.describe as description,
|
|
|
+ n.status as status, n.time as time
|
|
|
+ """
|
|
|
+
|
|
|
+ # 构建删除节点和关系的Cypher查询
|
|
|
+ delete_query = """
|
|
|
+ MATCH (n:DataLabel)
|
|
|
+ WHERE id(n) = $nodeId
|
|
|
+ OPTIONAL MATCH (n)-[r]-()
|
|
|
+ DELETE r, n
|
|
|
+ RETURN count(n) AS deleted
|
|
|
+ """
|
|
|
+
|
|
|
+ # 执行查询
|
|
|
+ tag_info = None
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ # 先获取标签信息
|
|
|
+ result = session.run(get_query, nodeId=tag_id)
|
|
|
+ record = result.single()
|
|
|
+
|
|
|
+ if not record:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{tag_id}的标签',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 保存标签信息用于返回
|
|
|
+ tag_info = {
|
|
|
+ 'id': record['id'],
|
|
|
+ 'name': record['name'],
|
|
|
+ 'en_name': record['en_name'],
|
|
|
+ 'category': record['category'],
|
|
|
+ 'description': record['description'],
|
|
|
+ 'status': record['status'],
|
|
|
+ 'time': record['time']
|
|
|
+ }
|
|
|
+
|
|
|
+ # 执行删除操作
|
|
|
+ delete_result = session.run(delete_query, nodeId=tag_id)
|
|
|
+ deleted = delete_result.single()['deleted']
|
|
|
+
|
|
|
+ if deleted > 0:
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '人才标签删除成功',
|
|
|
+ 'data': tag_info
|
|
|
+ }
|
|
|
+ else:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未能删除ID为{tag_id}的标签',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"删除人才标签失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def query_neo4j_graph(query_requirement):
|
|
|
+ """
|
|
|
+ 查询Neo4j图数据库，通过Deepseek API生成Cypher脚本
|
|
|
+
|
|
|
+ Args:
|
|
|
+ query_requirement (str): 查询需求描述
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含查询结果的字典，JSON格式
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 导入必要的模块
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+ import requests
|
|
|
+ import json
|
|
|
+
|
|
|
+ # Deepseek API配置
|
|
|
+ api_key = DEEPSEEK_API_KEY
|
|
|
+ api_url = DEEPSEEK_API_URL
|
|
|
+
|
|
|
+ # 步骤1: 从Neo4j获取所有标签列表
|
|
|
+ logging.info("第一步：从Neo4j获取人才类别的标签列表")
|
|
|
+ all_labels_query = """
|
|
|
+ MATCH (dl:DataLabel)
|
|
|
+ WHERE dl.category CONTAINS '人才' OR dl.category CONTAINS 'talent'
|
|
|
+ RETURN dl.name as name
|
|
|
+ """
|
|
|
+
|
|
|
+ all_labels = []
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ result = session.run(all_labels_query)
|
|
|
+ for record in result:
|
|
|
+ all_labels.append(record['name'])
|
|
|
+
|
|
|
+ logging.info(f"获取到{len(all_labels)}个人才标签: {all_labels}")
|
|
|
+
|
|
|
+ # 步骤2: 使用Deepseek判断查询需求中的关键信息与标签的对应关系
|
|
|
+ logging.info("第二步：调用Deepseek API匹配查询需求与标签")
|
|
|
+
|
|
|
+ # 构建所有标签的JSON字符串
|
|
|
+ labels_json = json.dumps(all_labels, ensure_ascii=False)
|
|
|
+
|
|
|
+ # 构建匹配标签的提示语
|
|
|
+ matching_prompt = f"""
|
|
|
+ 请分析以下查询需求，并从标签列表中找出与查询需求相关的标签。
|
|
|
+
|
|
|
+ ## 查询需求
|
|
|
+ {query_requirement}
|
|
|
+
|
|
|
+ ## 可用标签列表
|
|
|
+ {labels_json}
|
|
|
+
|
|
|
+ ## 输出要求
|
|
|
+ 1. 请以JSON数组格式返回匹配的标签名称列表，格式如: ["标签1", "标签2", "标签3"]
|
|
|
+ 2. 只返回标签名称数组，不要包含任何解释或其他文本
|
|
|
+ 3. 如果没有找到匹配的标签，请返回空数组 []
|
|
|
+ """
|
|
|
+
|
|
|
+ # 调用Deepseek API匹配标签
|
|
|
+ headers = {
|
|
|
+ "Authorization": f"Bearer {api_key}",
|
|
|
+ "Content-Type": "application/json"
|
|
|
+ }
|
|
|
+
|
|
|
+ payload = {
|
|
|
+ "model": "deepseek-chat",
|
|
|
+ "messages": [
|
|
|
+ {"role": "system", "content": "你是一个专业的文本分析和匹配专家。"},
|
|
|
+ {"role": "user", "content": matching_prompt}
|
|
|
+ ],
|
|
|
+ "temperature": 0.1,
|
|
|
+ "response_format": {"type": "json_object"}
|
|
|
+ }
|
|
|
+
|
|
|
+ logging.info("发送请求到Deepseek API匹配标签："+matching_prompt)
|
|
|
+ response = requests.post(api_url, headers=headers, json=payload, timeout=30)
|
|
|
+ response.raise_for_status()
|
|
|
+
|
|
|
+ # 解析API响应
|
|
|
+ result = response.json()
|
|
|
+ matching_content = result.get("choices", [{}])[0].get("message", {}).get("content", "[]")
|
|
|
+
|
|
|
+ # 提取JSON数组
|
|
|
+ try:
|
|
|
+ # 尝试直接解析返回结果，预期格式为 ["新开酒店经验", "五星级酒店", "总经理"]
|
|
|
+ logging.info(f"Deepseek返回的匹配内容: {matching_content}")
|
|
|
+
|
|
|
+ # 如果返回的是JSON字符串，先去除可能的前后缀文本
|
|
|
+ if isinstance(matching_content, str):
|
|
|
+ # 查找JSON数组的开始和结束位置
|
|
|
+ start_idx = matching_content.find('[')
|
|
|
+ end_idx = matching_content.rfind(']') + 1
|
|
|
+
|
|
|
+ if start_idx >= 0 and end_idx > start_idx:
|
|
|
+ json_str = matching_content[start_idx:end_idx]
|
|
|
+ matched_labels = json.loads(json_str)
|
|
|
+ else:
|
|
|
+ matched_labels = []
|
|
|
+ else:
|
|
|
+ matched_labels = []
|
|
|
+
|
|
|
+ # 确保结果是字符串列表
|
|
|
+ if matched_labels and all(isinstance(item, str) for item in matched_labels):
|
|
|
+ logging.info(f"成功解析到标签列表: {matched_labels}")
|
|
|
+ else:
|
|
|
+ logging.warning("解析结果不是预期的字符串列表格式，将使用空列表")
|
|
|
+ matched_labels = []
|
|
|
+ except json.JSONDecodeError as e:
|
|
|
+ logging.error(f"JSON解析错误: {str(e)}")
|
|
|
+ matched_labels = []
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"解析匹配标签时出错: {str(e)}")
|
|
|
+ matched_labels = []
|
|
|
+
|
|
|
+ logging.info(f"匹配到的标签: {matched_labels}")
|
|
|
+
|
|
|
+ # 如果没有匹配到标签，返回空结果
|
|
|
+ if not matched_labels:
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '未找到与查询需求匹配的标签',
|
|
|
+ 'query': '',
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+ # 步骤3: 构建Cypher生成提示文本
|
|
|
+ logging.info("第三步：构建提示文本生成Cypher查询语句")
|
|
|
+
|
|
|
+ # 将匹配的标签转换为字符串
|
|
|
+ matched_labels_str = ", ".join([f"'{label}'" for label in matched_labels])
|
|
|
+
|
|
|
+ # 构建生成Cypher的提示语
|
|
|
+ cypher_prompt = f"""
|
|
|
+ 请根据以下Neo4j图数据库结构和已匹配的标签，生成一个Cypher查询脚本。
|
|
|
+
|
|
|
+ ## 图数据库结构
|
|
|
+
|
|
|
+ ### 节点
|
|
|
+ 1. talent - 人才节点
|
|
|
+ 属性: pg_id(PostgreSQL数据库ID), name_zh(中文姓名), name_en(英文姓名),
|
|
|
+ mobile(手机号码), email(电子邮箱), updated_at(更新时间)
|
|
|
+
|
|
|
+ 2. DataLabel - 人才标签节点
|
|
|
+
|
|
|
+ ### 关系
|
|
|
+ BELONGS_TO - 从属关系
|
|
|
+ (talent)-[BELONGS_TO]->(DataLabel) - 人才属于某标签
|
|
|
+
|
|
|
+ ## 匹配的标签列表
|
|
|
+ [{matched_labels_str}]
|
|
|
+
|
|
|
+ ## 查询需求
|
|
|
+ {query_requirement}
|
|
|
+
|
|
|
+ ## 输出要求
|
|
|
+ 1. 只输出有效的Cypher查询语句，不要包含任何解释或注释
|
|
|
+ 2. 确保return语句中包含talent节点属性
|
|
|
+ 3. 尽量利用图数据库的特性来优化查询效率
|
|
|
+ 4. 使用WITH子句和COLLECT函数收集标签，确保查询到同时拥有所有标签的人才
|
|
|
+
|
|
|
+ 注意：请直接返回Cypher查询语句，无需任何其他文本。
|
|
|
+
|
|
|
+ 以下是一个示例：
|
|
|
+ 假设匹配的标签是 ['五星级酒店', '新开酒店经验', '总经理']
|
|
|
+
|
|
|
+ 生成的Cypher查询语句应该是：
|
|
|
+ MATCH (t:talent)-[:BELONGS_TO]->(dl:DataLabel)
|
|
|
+ WHERE dl.name IN ['五星级酒店', '新开酒店经验', '总经理']
|
|
|
+ WITH t, COLLECT(DISTINCT dl.name) AS labels
|
|
|
+ WHERE size(labels) = 3
|
|
|
+ RETURN t.pg_id as pg_id, t.name_zh as name_zh, t.name_en as name_en, t.mobile as mobile, t.email as email, t.updated_at as updated_at
|
|
|
+ """
|
|
|
+
|
|
|
+ # 调用Deepseek API生成Cypher脚本
|
|
|
+ payload = {
|
|
|
+ "model": "deepseek-chat",
|
|
|
+ "messages": [
|
|
|
+ {"role": "system", "content": "你是一个专业的Neo4j Cypher查询专家。"},
|
|
|
+ {"role": "user", "content": cypher_prompt}
|
|
|
+ ],
|
|
|
+ "temperature": 0.1
|
|
|
+ }
|
|
|
+
|
|
|
+ logging.info("发送请求到Deepseek API生成Cypher脚本")
|
|
|
+ response = requests.post(api_url, headers=headers, json=payload, timeout=30)
|
|
|
+ response.raise_for_status()
|
|
|
+
|
|
|
+ # 解析API响应
|
|
|
+ result = response.json()
|
|
|
+ cypher_script = result.get("choices", [{}])[0].get("message", {}).get("content", "")
|
|
|
+
|
|
|
+ # 清理Cypher脚本，移除不必要的markdown格式或注释
|
|
|
+ cypher_script = cypher_script.strip()
|
|
|
+ if cypher_script.startswith("```cypher"):
|
|
|
+ cypher_script = cypher_script[9:]
|
|
|
+ elif cypher_script.startswith("```"):
|
|
|
+ cypher_script = cypher_script[3:]
|
|
|
+ if cypher_script.endswith("```"):
|
|
|
+ cypher_script = cypher_script[:-3]
|
|
|
+ cypher_script = cypher_script.strip()
|
|
|
+
|
|
|
+ logging.info(f"生成的Cypher脚本: {cypher_script}")
|
|
|
+
|
|
|
+ # 步骤4: 执行Cypher脚本
|
|
|
+ logging.info("第四步：执行Cypher脚本并返回结果")
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ result = session.run(cypher_script)
|
|
|
+ records = [record.data() for record in result]
|
|
|
+
|
|
|
+ # 构建查询结果
|
|
|
+ response_data = {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '查询成功执行',
|
|
|
+ 'query': cypher_script,
|
|
|
+ 'matched_labels': matched_labels,
|
|
|
+ 'data': records
|
|
|
+ }
|
|
|
+
|
|
|
+ return response_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}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"查询Neo4j图数据库失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+def talent_get_tags(talent_id):
|
|
|
+ """
|
|
|
+ 根据talent ID获取人才节点关联的标签
|
|
|
+
|
|
|
+ Args:
|
|
|
+ talent_id (int): 人才节点pg_id
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含人才ID和关联标签的字典，JSON格式
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 导入必要的模块
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 准备查询返回数据
|
|
|
+ response_data = {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取人才标签成功',
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+ # 构建Cypher查询语句，获取人才节点关联的标签
|
|
|
+ cypher_query = """
|
|
|
+ MATCH (t:talent)-[r:BELONGS_TO]->(tag:DataLabel)
|
|
|
+ WHERE t.pg_id = $talent_id
|
|
|
+ RETURN t.pg_id as talent_id, tag.name as tag_name
|
|
|
+ """
|
|
|
+
|
|
|
+ # 执行查询
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ result = session.run(cypher_query, talent_id=int(talent_id))
|
|
|
+ records = list(result)
|
|
|
+
|
|
|
+ # 如果没有查询到标签，返回空数组
|
|
|
+ if not records:
|
|
|
+ response_data['message'] = f'人才pg_id {talent_id} 没有关联的标签'
|
|
|
+ return response_data
|
|
|
+
|
|
|
+ # 处理查询结果
|
|
|
+ for record in records:
|
|
|
+ talent_tag = {
|
|
|
+ 'talent': record['talent_id'],
|
|
|
+ 'tag': record['tag_name']
|
|
|
+ }
|
|
|
+ response_data['data'].append(talent_tag)
|
|
|
+
|
|
|
+ return response_data
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取人才标签失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+def talent_update_tags(data):
|
|
|
+ """
|
|
|
+ 根据传入的JSON数据为人才节点创建与标签的BELONGS_TO关系
|
|
|
+
|
|
|
+ Args:
|
|
|
+ data (list): 包含talent和tag字段的对象列表
|
|
|
+ 例如: [
|
|
|
+ {"talent": 12345, "tag": "市场营销"},
|
|
|
+ {"talent": 12345, "tag": "酒店管理"}
|
|
|
+ ]
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 操作结果和状态信息
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 导入必要的模块
|
|
|
+ from app.services.neo4j_driver import neo4j_driver
|
|
|
+
|
|
|
+ # 验证输入参数
|
|
|
+ if not isinstance(data, list):
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '参数格式错误，需要JSON数组',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ if len(data) == 0:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '数据列表为空',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 获取当前时间
|
|
|
+ current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
|
+
|
|
|
+ # 成功和失败计数
|
|
|
+ success_count = 0
|
|
|
+ failed_items = []
|
|
|
+
|
|
|
+ # 按talent分组处理数据
|
|
|
+ talent_tags = {}
|
|
|
+ for item in data:
|
|
|
+ # 验证每个项目的格式
|
|
|
+ if not isinstance(item, dict) or 'talent' not in item or 'tag' not in item:
|
|
|
+ failed_items.append(item)
|
|
|
+ continue
|
|
|
+
|
|
|
+ talent_id = item.get('talent')
|
|
|
+ tag_name = item.get('tag')
|
|
|
+
|
|
|
+ # 验证talent_id和tag_name的值
|
|
|
+ if not talent_id or not tag_name or not isinstance(tag_name, str):
|
|
|
+ failed_items.append(item)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # 按talent_id分组
|
|
|
+ if talent_id not in talent_tags:
|
|
|
+ talent_tags[talent_id] = []
|
|
|
+
|
|
|
+ talent_tags[talent_id].append(tag_name)
|
|
|
+
|
|
|
+ with neo4j_driver.get_session() as session:
|
|
|
+ # 处理每个talent及其标签
|
|
|
+ for talent_id, tags in talent_tags.items():
|
|
|
+ # 首先验证talent节点是否存在
|
|
|
+ check_talent_query = """
|
|
|
+ MATCH (t:talent)
|
|
|
+ WHERE t.pg_id = $talent_id
|
|
|
+ RETURN t
|
|
|
+ """
|
|
|
+ talent_result = session.run(check_talent_query, talent_id=int(talent_id))
|
|
|
+ if not talent_result.single():
|
|
|
+ # 该talent不存在，记录失败项并继续下一个talent
|
|
|
+ for tag in tags:
|
|
|
+ failed_items.append({'talent_pg_id': talent_id, 'tag': tag})
|
|
|
+ continue
|
|
|
+
|
|
|
+ # 首先清除所有现有的BELONGS_TO关系
|
|
|
+ clear_relations_query = """
|
|
|
+ MATCH (t:talent)-[r:BELONGS_TO]->(:DataLabel)
|
|
|
+ WHERE t.pg_id = $talent_id
|
|
|
+ DELETE r
|
|
|
+ RETURN count(r) as deleted_count
|
|
|
+ """
|
|
|
+ clear_result = session.run(clear_relations_query, talent_id=int(talent_id))
|
|
|
+ deleted_count = clear_result.single()['deleted_count']
|
|
|
+ logging.info(f"已删除talent_id={talent_id}的{deleted_count}个已有标签关系")
|
|
|
+
|
|
|
+ # 处理每个标签
|
|
|
+ for tag_name in tags:
|
|
|
+ try:
|
|
|
+ # 1. 查找或创建标签节点
|
|
|
+ # 先查找是否存在该标签
|
|
|
+ find_tag_query = """
|
|
|
+ MATCH (tag:DataLabel)
|
|
|
+ WHERE tag.name = $tag_name
|
|
|
+ RETURN id(tag) as tag_id
|
|
|
+ """
|
|
|
+ tag_result = session.run(find_tag_query, tag_name=tag_name)
|
|
|
+ tag_record = tag_result.single()
|
|
|
+
|
|
|
+ if tag_record:
|
|
|
+ tag_id = tag_record['tag_id']
|
|
|
+ else:
|
|
|
+ # 创建新标签
|
|
|
+ create_tag_query = """
|
|
|
+ CREATE (tag:DataLabel {name: $name, category: $category, updated_at: $updated_at})
|
|
|
+ RETURN id(tag) as tag_id
|
|
|
+ """
|
|
|
+ tag_result = session.run(
|
|
|
+ create_tag_query,
|
|
|
+ name=tag_name,
|
|
|
+ category='talent',
|
|
|
+ updated_at=current_time
|
|
|
+ )
|
|
|
+ tag_record = tag_result.single()
|
|
|
+ tag_id = tag_record['tag_id']
|
|
|
+
|
|
|
+ # 2. 创建人才与标签的BELONGS_TO关系
|
|
|
+ create_relation_query = """
|
|
|
+ MATCH (t:talent), (tag:DataLabel)
|
|
|
+ WHERE t.pg_id = $talent_id AND tag.name = $tag_name
|
|
|
+ CREATE (t)-[r:BELONGS_TO]->(tag)
|
|
|
+ SET r.created_at = $current_time
|
|
|
+ RETURN r
|
|
|
+ """
|
|
|
+
|
|
|
+ relation_result = session.run(
|
|
|
+ create_relation_query,
|
|
|
+ talent_id=int(talent_id),
|
|
|
+ tag_name=tag_name,
|
|
|
+ current_time=current_time
|
|
|
+ )
|
|
|
+
|
|
|
+ if relation_result.single():
|
|
|
+ success_count += 1
|
|
|
+ else:
|
|
|
+ failed_items.append({'talent_pg_id': talent_id, 'tag': tag_name})
|
|
|
+
|
|
|
+ except Exception as tag_error:
|
|
|
+ logging.error(f"为标签 {tag_name} 创建关系时出错: {str(tag_error)}")
|
|
|
+ failed_items.append({'talent_pg_id': talent_id, 'tag': tag_name})
|
|
|
+
|
|
|
+ # 返回结果
|
|
|
+ total_items = len(data)
|
|
|
+ if success_count == total_items:
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'成功创建或更新了 {success_count} 个标签关系',
|
|
|
+ 'data': {
|
|
|
+ 'success_count': success_count,
|
|
|
+ 'total_count': total_items,
|
|
|
+ 'failed_items': []
|
|
|
+ }
|
|
|
+ }
|
|
|
+ elif success_count > 0:
|
|
|
+ return {
|
|
|
+ 'code': 206, # Partial Content
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'部分成功: 创建或更新了 {success_count}/{total_items} 个标签关系',
|
|
|
+ 'data': {
|
|
|
+ 'success_count': success_count,
|
|
|
+ 'total_count': total_items,
|
|
|
+ 'failed_items': failed_items
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else:
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '无法创建任何标签关系',
|
|
|
+ 'data': {
|
|
|
+ 'success_count': 0,
|
|
|
+ 'total_count': total_items,
|
|
|
+ 'failed_items': failed_items
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"更新人才标签关系失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def search_business_cards_by_mobile(mobile_number):
|
|
|
+ """
|
|
|
+ 根据手机号码搜索名片记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ mobile_number (str): 要搜索的手机号码
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和名片列表的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ if not mobile_number or not mobile_number.strip():
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '手机号码不能为空',
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+ mobile_number = mobile_number.strip()
|
|
|
+
|
|
|
+ # 查询包含该手机号码的名片记录
|
|
|
+ # 使用LIKE查询来匹配逗号分隔的手机号码字段
|
|
|
+ cards = BusinessCard.query.filter(
|
|
|
+ db.or_(
|
|
|
+ BusinessCard.mobile == mobile_number, # 完全匹配
|
|
|
+ BusinessCard.mobile.like(f'{mobile_number},%'), # 开头匹配
|
|
|
+ BusinessCard.mobile.like(f'%,{mobile_number},%'), # 中间匹配
|
|
|
+ BusinessCard.mobile.like(f'%,{mobile_number}') # 结尾匹配
|
|
|
+ )
|
|
|
+ ).all()
|
|
|
+
|
|
|
+ # 将所有记录转换为字典格式
|
|
|
+ cards_data = [card.to_dict() for card in cards]
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'搜索到{len(cards_data)}条包含手机号码{mobile_number}的名片记录',
|
|
|
+ 'data': cards_data
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"根据手机号码搜索名片记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': []
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+def get_business_card(card_id):
|
|
|
+ """
|
|
|
+ 根据ID从PostgreSQL数据库中获取名片记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ card_id (int): 名片记录ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和名片信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查询指定ID的名片记录
|
|
|
+ card = BusinessCard.query.get(card_id)
|
|
|
+
|
|
|
+ if not card:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{card_id}的名片记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 将记录转换为字典格式返回
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取名片记录成功',
|
|
|
+ 'data': card.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取名片记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+# 酒店职位数据模型
|
|
|
+class HotelPosition(db.Model):
|
|
|
+ __tablename__ = 'hotel_positions'
|
|
|
+
|
|
|
+ id = db.Column(db.Integer, primary_key=True, autoincrement=True)
|
|
|
+ department_zh = db.Column(db.String(10), nullable=False)
|
|
|
+ department_en = db.Column(db.String(50), nullable=False)
|
|
|
+ position_zh = db.Column(db.String(20), nullable=False)
|
|
|
+ position_en = db.Column(db.String(100), nullable=False)
|
|
|
+ position_abbr = db.Column(db.String(20), nullable=True)
|
|
|
+ level_zh = db.Column(db.String(10), nullable=False)
|
|
|
+ level_en = db.Column(db.String(30), nullable=False)
|
|
|
+ created_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
|
|
|
+ updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
|
|
|
+ created_by = db.Column(db.String(50), default='system')
|
|
|
+ updated_by = db.Column(db.String(50), default='system')
|
|
|
+ status = db.Column(db.String(20), default='active')
|
|
|
+
|
|
|
+ def to_dict(self):
|
|
|
+ return {
|
|
|
+ 'id': self.id,
|
|
|
+ 'department_zh': self.department_zh,
|
|
|
+ 'department_en': self.department_en,
|
|
|
+ 'position_zh': self.position_zh,
|
|
|
+ 'position_en': self.position_en,
|
|
|
+ 'position_abbr': self.position_abbr,
|
|
|
+ 'level_zh': self.level_zh,
|
|
|
+ 'level_en': self.level_en,
|
|
|
+ '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,
|
|
|
+ 'created_by': self.created_by,
|
|
|
+ 'updated_by': self.updated_by,
|
|
|
+ 'status': self.status
|
|
|
+ }
|
|
|
+
|
|
|
+def get_hotel_positions_list():
|
|
|
+ """
|
|
|
+ 获取酒店职位数据表的全部记录
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和酒店职位列表的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查询所有酒店职位记录，按部门和职位排序
|
|
|
+ positions = HotelPosition.query.order_by(
|
|
|
+ HotelPosition.department_zh,
|
|
|
+ HotelPosition.position_zh
|
|
|
+ ).all()
|
|
|
+
|
|
|
+ # 将所有记录转换为字典格式
|
|
|
+ positions_data = [position.to_dict() for position in positions]
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取酒店职位列表成功',
|
|
|
+ 'data': positions_data,
|
|
|
+ 'count': len(positions_data)
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取酒店职位列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': [],
|
|
|
+ 'count': 0
|
|
|
+ }
|
|
|
+
|
|
|
+def add_hotel_positions(position_data):
|
|
|
+ """
|
|
|
+ 新增酒店职位数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ position_data (dict): 包含职位信息的字典，包括:
|
|
|
+ - department_zh: 部门中文名称 (必填)
|
|
|
+ - department_en: 部门英文名称 (必填)
|
|
|
+ - position_zh: 职位中文名称 (必填)
|
|
|
+ - position_en: 职位英文名称 (必填)
|
|
|
+ - position_abbr: 职位英文缩写 (可选)
|
|
|
+ - level_zh: 职级中文名称 (必填)
|
|
|
+ - level_en: 职级英文名称 (必填)
|
|
|
+ - created_by: 创建者 (可选，默认为'system')
|
|
|
+ - updated_by: 更新者 (可选，默认为'system')
|
|
|
+ - status: 状态 (可选，默认为'active')
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和创建的职位信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 验证必填字段
|
|
|
+ required_fields = ['department_zh', 'department_en', 'position_zh', 'position_en', 'level_zh', 'level_en']
|
|
|
+ missing_fields = []
|
|
|
+
|
|
|
+ for field in required_fields:
|
|
|
+ if field not in position_data or not position_data[field] or not position_data[field].strip():
|
|
|
+ missing_fields.append(field)
|
|
|
+
|
|
|
+ if missing_fields:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'缺少必填字段: {", ".join(missing_fields)}',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 检查是否已存在相同的职位记录（基于部门和职位的中文名称）
|
|
|
+ existing_position = HotelPosition.query.filter_by(
|
|
|
+ department_zh=position_data['department_zh'].strip(),
|
|
|
+ position_zh=position_data['position_zh'].strip()
|
|
|
+ ).first()
|
|
|
+
|
|
|
+ if existing_position:
|
|
|
+ return {
|
|
|
+ 'code': 409,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'职位记录已存在：{position_data["department_zh"]} - {position_data["position_zh"]}',
|
|
|
+ 'data': existing_position.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ # 创建新的职位记录
|
|
|
+ new_position = HotelPosition(
|
|
|
+ department_zh=position_data['department_zh'].strip(),
|
|
|
+ department_en=position_data['department_en'].strip(),
|
|
|
+ position_zh=position_data['position_zh'].strip(),
|
|
|
+ position_en=position_data['position_en'].strip(),
|
|
|
+ position_abbr=position_data.get('position_abbr', '').strip() if position_data.get('position_abbr') else None,
|
|
|
+ level_zh=position_data['level_zh'].strip(),
|
|
|
+ level_en=position_data['level_en'].strip(),
|
|
|
+ created_by=position_data.get('created_by', 'system'),
|
|
|
+ updated_by=position_data.get('updated_by', 'system'),
|
|
|
+ status=position_data.get('status', 'active')
|
|
|
+ )
|
|
|
+
|
|
|
+ # 保存到数据库
|
|
|
+ db.session.add(new_position)
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功创建酒店职位记录，ID: {new_position.id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '酒店职位记录创建成功',
|
|
|
+ 'data': new_position.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"创建酒店职位记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def update_hotel_positions(position_id, position_data):
|
|
|
+ """
|
|
|
+ 修改酒店职位数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ position_id (int): 职位记录ID
|
|
|
+ position_data (dict): 包含要更新的职位信息的字典，可能包括:
|
|
|
+ - department_zh: 部门中文名称
|
|
|
+ - department_en: 部门英文名称
|
|
|
+ - position_zh: 职位中文名称
|
|
|
+ - position_en: 职位英文名称
|
|
|
+ - position_abbr: 职位英文缩写
|
|
|
+ - level_zh: 职级中文名称
|
|
|
+ - level_en: 职级英文名称
|
|
|
+ - updated_by: 更新者
|
|
|
+ - status: 状态
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和更新后的职位信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查找要更新的职位记录
|
|
|
+ position = HotelPosition.query.get(position_id)
|
|
|
+
|
|
|
+ if not position:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{position_id}的职位记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 检查是否有数据需要更新
|
|
|
+ if not position_data:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '请求数据为空',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 如果要更新部门和职位名称，检查是否会与其他记录冲突
|
|
|
+ new_department_zh = position_data.get('department_zh', position.department_zh).strip() if position_data.get('department_zh') else position.department_zh
|
|
|
+ new_position_zh = position_data.get('position_zh', position.position_zh).strip() if position_data.get('position_zh') else position.position_zh
|
|
|
+
|
|
|
+ # 查找是否存在相同的职位记录（排除当前记录）
|
|
|
+ existing_position = HotelPosition.query.filter(
|
|
|
+ HotelPosition.id != position_id,
|
|
|
+ HotelPosition.department_zh == new_department_zh,
|
|
|
+ HotelPosition.position_zh == new_position_zh
|
|
|
+ ).first()
|
|
|
+
|
|
|
+ if existing_position:
|
|
|
+ return {
|
|
|
+ 'code': 409,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'职位记录已存在：{new_department_zh} - {new_position_zh}',
|
|
|
+ 'data': existing_position.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ # 更新职位信息
|
|
|
+ if 'department_zh' in position_data and position_data['department_zh']:
|
|
|
+ position.department_zh = position_data['department_zh'].strip()
|
|
|
+
|
|
|
+ if 'department_en' in position_data and position_data['department_en']:
|
|
|
+ position.department_en = position_data['department_en'].strip()
|
|
|
+
|
|
|
+ if 'position_zh' in position_data and position_data['position_zh']:
|
|
|
+ position.position_zh = position_data['position_zh'].strip()
|
|
|
+
|
|
|
+ if 'position_en' in position_data and position_data['position_en']:
|
|
|
+ position.position_en = position_data['position_en'].strip()
|
|
|
+
|
|
|
+ if 'position_abbr' in position_data:
|
|
|
+ # 处理position_abbr，可能为空字符串或None
|
|
|
+ if position_data['position_abbr'] and position_data['position_abbr'].strip():
|
|
|
+ position.position_abbr = position_data['position_abbr'].strip()
|
|
|
+ else:
|
|
|
+ position.position_abbr = None
|
|
|
+
|
|
|
+ if 'level_zh' in position_data and position_data['level_zh']:
|
|
|
+ position.level_zh = position_data['level_zh'].strip()
|
|
|
+
|
|
|
+ if 'level_en' in position_data and position_data['level_en']:
|
|
|
+ position.level_en = position_data['level_en'].strip()
|
|
|
+
|
|
|
+ if 'updated_by' in position_data:
|
|
|
+ position.updated_by = position_data['updated_by'] or 'system'
|
|
|
+
|
|
|
+ if 'status' in position_data:
|
|
|
+ position.status = position_data['status'] or 'active'
|
|
|
+
|
|
|
+ # 更新时间会自动设置（onupdate=datetime.now）
|
|
|
+
|
|
|
+ # 保存更新
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功更新酒店职位记录，ID: {position.id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '酒店职位记录更新成功',
|
|
|
+ 'data': position.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"更新酒店职位记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def query_hotel_positions(position_id):
|
|
|
+ """
|
|
|
+ 查找指定ID的酒店职位数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ position_id (int): 职位记录ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和职位信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 根据ID查找职位记录
|
|
|
+ position = HotelPosition.query.get(position_id)
|
|
|
+
|
|
|
+ if not position:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{position_id}的职位记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 返回找到的记录
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '查找职位记录成功',
|
|
|
+ 'data': position.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"查找职位记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def delete_hotel_positions(position_id):
|
|
|
+ """
|
|
|
+ 删除指定ID的酒店职位数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ position_id (int): 职位记录ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 根据ID查找要删除的职位记录
|
|
|
+ position = HotelPosition.query.get(position_id)
|
|
|
+
|
|
|
+ if not position:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{position_id}的职位记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 保存被删除记录的信息，用于返回
|
|
|
+ deleted_position_info = position.to_dict()
|
|
|
+
|
|
|
+ # 执行删除操作
|
|
|
+ db.session.delete(position)
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功删除酒店职位记录，ID: {position_id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '职位记录删除成功',
|
|
|
+ 'data': deleted_position_info
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"删除职位记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+# 酒店集团子品牌数据模型
|
|
|
+class HotelGroupBrands(db.Model):
|
|
|
+ __tablename__ = 'hotel_group_brands'
|
|
|
+
|
|
|
+ id = db.Column(db.Integer, primary_key=True, autoincrement=True)
|
|
|
+ group_name_en = db.Column(db.String(60), nullable=False)
|
|
|
+ group_name_zh = db.Column(db.String(20), nullable=False)
|
|
|
+ brand_name_en = db.Column(db.String(40), nullable=False)
|
|
|
+ brand_name_zh = db.Column(db.String(40), nullable=False)
|
|
|
+ positioning_level_en = db.Column(db.String(20), nullable=False)
|
|
|
+ positioning_level_zh = db.Column(db.String(5), nullable=False)
|
|
|
+ created_at = db.Column(db.DateTime, default=datetime.now, nullable=False)
|
|
|
+ updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
|
|
|
+ created_by = db.Column(db.String(50), default='system')
|
|
|
+ updated_by = db.Column(db.String(50), default='system')
|
|
|
+ status = db.Column(db.String(20), default='active')
|
|
|
+
|
|
|
+ def to_dict(self):
|
|
|
+ return {
|
|
|
+ 'id': self.id,
|
|
|
+ 'group_name_en': self.group_name_en,
|
|
|
+ 'group_name_zh': self.group_name_zh,
|
|
|
+ 'brand_name_en': self.brand_name_en,
|
|
|
+ 'brand_name_zh': self.brand_name_zh,
|
|
|
+ 'positioning_level_en': self.positioning_level_en,
|
|
|
+ 'positioning_level_zh': self.positioning_level_zh,
|
|
|
+ '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,
|
|
|
+ 'created_by': self.created_by,
|
|
|
+ 'updated_by': self.updated_by,
|
|
|
+ 'status': self.status
|
|
|
+ }
|
|
|
+
|
|
|
+def get_hotel_group_brands_list():
|
|
|
+ """
|
|
|
+ 获取酒店集团子品牌数据表的全部记录
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和酒店集团品牌列表的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查询所有酒店集团品牌记录，按集团和品牌排序
|
|
|
+ brands = HotelGroupBrands.query.order_by(
|
|
|
+ HotelGroupBrands.group_name_zh,
|
|
|
+ HotelGroupBrands.brand_name_zh
|
|
|
+ ).all()
|
|
|
+
|
|
|
+ # 将所有记录转换为字典格式
|
|
|
+ brands_data = [brand.to_dict() for brand in brands]
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取酒店集团品牌列表成功',
|
|
|
+ 'data': brands_data,
|
|
|
+ 'count': len(brands_data)
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取酒店集团品牌列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': [],
|
|
|
+ 'count': 0
|
|
|
+ }
|
|
|
+
|
|
|
+def add_hotel_group_brands(brand_data):
|
|
|
+ """
|
|
|
+ 新增酒店集团子品牌数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ brand_data (dict): 包含品牌信息的字典，包括:
|
|
|
+ - group_name_en: 集团英文名称 (必填)
|
|
|
+ - group_name_zh: 集团中文名称 (必填)
|
|
|
+ - brand_name_en: 品牌英文名称 (必填)
|
|
|
+ - brand_name_zh: 品牌中文名称 (必填)
|
|
|
+ - positioning_level_en: 定位级别英文名称 (必填)
|
|
|
+ - positioning_level_zh: 定位级别中文名称 (必填)
|
|
|
+ - created_by: 创建者 (可选，默认为'system')
|
|
|
+ - updated_by: 更新者 (可选，默认为'system')
|
|
|
+ - status: 状态 (可选，默认为'active')
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和创建的品牌信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 验证必填字段
|
|
|
+ required_fields = ['group_name_en', 'group_name_zh', 'brand_name_en', 'brand_name_zh', 'positioning_level_en', 'positioning_level_zh']
|
|
|
+ missing_fields = []
|
|
|
+
|
|
|
+ for field in required_fields:
|
|
|
+ if field not in brand_data or not brand_data[field] or not brand_data[field].strip():
|
|
|
+ missing_fields.append(field)
|
|
|
+
|
|
|
+ if missing_fields:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'缺少必填字段: {", ".join(missing_fields)}',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 检查是否已存在相同的品牌记录（基于集团和品牌的中文名称）
|
|
|
+ existing_brand = HotelGroupBrands.query.filter_by(
|
|
|
+ group_name_zh=brand_data['group_name_zh'].strip(),
|
|
|
+ brand_name_zh=brand_data['brand_name_zh'].strip()
|
|
|
+ ).first()
|
|
|
+
|
|
|
+
|
|
|
+ if existing_brand:
|
|
|
+ return {
|
|
|
+ 'code': 409,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'品牌记录已存在：{brand_data["group_name_zh"]} - {brand_data["brand_name_zh"]}',
|
|
|
+ 'data': existing_brand.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ # 创建新的品牌记录
|
|
|
+ new_brand = HotelGroupBrands(
|
|
|
+ group_name_en=brand_data['group_name_en'].strip(),
|
|
|
+ group_name_zh=brand_data['group_name_zh'].strip(),
|
|
|
+ brand_name_en=brand_data['brand_name_en'].strip(),
|
|
|
+ brand_name_zh=brand_data['brand_name_zh'].strip(),
|
|
|
+ positioning_level_en=brand_data['positioning_level_en'].strip(),
|
|
|
+ positioning_level_zh=brand_data['positioning_level_zh'].strip(),
|
|
|
+ created_by=brand_data.get('created_by', 'system'),
|
|
|
+ updated_by=brand_data.get('updated_by', 'system'),
|
|
|
+ status=brand_data.get('status', 'active')
|
|
|
+ )
|
|
|
+
|
|
|
+ # 保存到数据库
|
|
|
+ db.session.add(new_brand)
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功创建酒店集团品牌记录，ID: {new_brand.id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '酒店集团品牌记录创建成功',
|
|
|
+ 'data': new_brand.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"创建酒店集团品牌记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def update_hotel_group_brands(brand_id, brand_data):
|
|
|
+ """
|
|
|
+ 修改酒店集团子品牌数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ brand_id (int): 品牌记录ID
|
|
|
+ brand_data (dict): 包含要更新的品牌信息的字典，可能包括:
|
|
|
+ - group_name_en: 集团英文名称
|
|
|
+ - group_name_zh: 集团中文名称
|
|
|
+ - brand_name_en: 品牌英文名称
|
|
|
+ - brand_name_zh: 品牌中文名称
|
|
|
+ - positioning_level_en: 定位级别英文名称
|
|
|
+ - positioning_level_zh: 定位级别中文名称
|
|
|
+ - updated_by: 更新者
|
|
|
+ - status: 状态
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和更新后的品牌信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查找要更新的品牌记录
|
|
|
+ brand = HotelGroupBrands.query.get(brand_id)
|
|
|
+
|
|
|
+ if not brand:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{brand_id}的品牌记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 检查是否有数据需要更新
|
|
|
+ if not brand_data:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '请求数据为空',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 如果要更新集团和品牌名称，检查是否会与其他记录冲突
|
|
|
+ new_group_name_zh = brand_data.get('group_name_zh', brand.group_name_zh).strip() if brand_data.get('group_name_zh') else brand.group_name_zh
|
|
|
+ new_brand_name_zh = brand_data.get('brand_name_zh', brand.brand_name_zh).strip() if brand_data.get('brand_name_zh') else brand.brand_name_zh
|
|
|
+
|
|
|
+ # 查找是否存在相同的品牌记录（排除当前记录）
|
|
|
+ existing_brand = HotelGroupBrands.query.filter(
|
|
|
+ HotelGroupBrands.id != brand_id,
|
|
|
+ HotelGroupBrands.group_name_zh == new_group_name_zh,
|
|
|
+ HotelGroupBrands.brand_name_zh == new_brand_name_zh
|
|
|
+ ).first()
|
|
|
+
|
|
|
+ if existing_brand:
|
|
|
+ return {
|
|
|
+ 'code': 409,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'品牌记录已存在：{new_group_name_zh} - {new_brand_name_zh}',
|
|
|
+ 'data': existing_brand.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ # 更新品牌信息
|
|
|
+ if 'group_name_en' in brand_data and brand_data['group_name_en']:
|
|
|
+ brand.group_name_en = brand_data['group_name_en'].strip()
|
|
|
+
|
|
|
+ if 'group_name_zh' in brand_data and brand_data['group_name_zh']:
|
|
|
+ brand.group_name_zh = brand_data['group_name_zh'].strip()
|
|
|
+
|
|
|
+ if 'brand_name_en' in brand_data and brand_data['brand_name_en']:
|
|
|
+ brand.brand_name_en = brand_data['brand_name_en'].strip()
|
|
|
+
|
|
|
+ if 'brand_name_zh' in brand_data and brand_data['brand_name_zh']:
|
|
|
+ brand.brand_name_zh = brand_data['brand_name_zh'].strip()
|
|
|
+
|
|
|
+ if 'positioning_level_en' in brand_data and brand_data['positioning_level_en']:
|
|
|
+ brand.positioning_level_en = brand_data['positioning_level_en'].strip()
|
|
|
+
|
|
|
+ if 'positioning_level_zh' in brand_data and brand_data['positioning_level_zh']:
|
|
|
+ brand.positioning_level_zh = brand_data['positioning_level_zh'].strip()
|
|
|
+
|
|
|
+ if 'updated_by' in brand_data:
|
|
|
+ brand.updated_by = brand_data['updated_by'] or 'system'
|
|
|
+
|
|
|
+ if 'status' in brand_data:
|
|
|
+ brand.status = brand_data['status'] or 'active'
|
|
|
+
|
|
|
+ # 更新时间会自动设置（onupdate=datetime.now）
|
|
|
+
|
|
|
+ # 保存更新
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功更新酒店集团品牌记录，ID: {brand.id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '酒店集团品牌记录更新成功',
|
|
|
+ 'data': brand.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"更新酒店集团品牌记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def query_hotel_group_brands(brand_id):
|
|
|
+ """
|
|
|
+ 查找指定ID的酒店集团子品牌数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ brand_id (int): 品牌记录ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和品牌信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 根据ID查找品牌记录
|
|
|
+ brand = HotelGroupBrands.query.get(brand_id)
|
|
|
+
|
|
|
+ if not brand:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{brand_id}的品牌记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 返回找到的记录
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '查找品牌记录成功',
|
|
|
+ 'data': brand.to_dict()
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"查找品牌记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def delete_hotel_group_brands(brand_id):
|
|
|
+ """
|
|
|
+ 删除指定ID的酒店集团子品牌数据表记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ brand_id (int): 品牌记录ID
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 根据ID查找要删除的品牌记录
|
|
|
+ brand = HotelGroupBrands.query.get(brand_id)
|
|
|
+
|
|
|
+ if not brand:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{brand_id}的品牌记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 保存被删除记录的信息，用于返回
|
|
|
+ deleted_brand_info = brand.to_dict()
|
|
|
+
|
|
|
+ # 执行删除操作
|
|
|
+ db.session.delete(brand)
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功删除酒店集团品牌记录，ID: {brand_id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '品牌记录删除成功',
|
|
|
+ 'data': deleted_brand_info
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"删除品牌记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def get_duplicate_records(status=None):
|
|
|
+ """
|
|
|
+ 获取重复记录列表
|
|
|
+
|
|
|
+ Args:
|
|
|
+ status (str, optional): 筛选特定状态的记录 ('pending', 'processed', 'ignored')
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果和重复记录列表
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 构建查询
|
|
|
+ query = DuplicateBusinessCard.query
|
|
|
+ if status:
|
|
|
+ query = query.filter_by(processing_status=status)
|
|
|
+
|
|
|
+ # 按创建时间倒序排列
|
|
|
+ duplicate_records = query.order_by(DuplicateBusinessCard.created_at.desc()).all()
|
|
|
+
|
|
|
+ # 获取详细信息，包括主记录
|
|
|
+ records_data = []
|
|
|
+ for record in duplicate_records:
|
|
|
+ record_dict = record.to_dict()
|
|
|
+ # 添加主记录信息
|
|
|
+ if record.main_card:
|
|
|
+ record_dict['main_card'] = record.main_card.to_dict()
|
|
|
+ records_data.append(record_dict)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取重复记录列表成功',
|
|
|
+ 'data': records_data,
|
|
|
+ 'count': len(records_data)
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取重复记录列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': [],
|
|
|
+ 'count': 0
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+def process_duplicate_record(duplicate_id, action, selected_duplicate_id=None, processed_by=None, notes=None):
|
|
|
+ """
|
|
|
+ 处理重复记录
|
|
|
+
|
|
|
+ Args:
|
|
|
+ duplicate_id (int): 名片记录ID（对应DuplicateBusinessCard表中的main_card_id字段）
|
|
|
+ action (str): 处理动作 ('merge_to_suspected', 'keep_main', 'ignore')
|
|
|
+ selected_duplicate_id (int, optional): 当action为'merge_to_suspected'时，选择的疑似重复记录ID
|
|
|
+ processed_by (str, optional): 处理人
|
|
|
+ notes (str, optional): 处理备注
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含操作结果
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查找重复记录 - 使用main_card_id字段匹配
|
|
|
+ duplicate_record = DuplicateBusinessCard.query.filter_by(main_card_id=duplicate_id).first()
|
|
|
+ if not duplicate_record:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到main_card_id为{duplicate_id}的重复记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ if duplicate_record.processing_status != 'pending':
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'重复记录状态为{duplicate_record.processing_status}，无法处理',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ main_card = duplicate_record.main_card
|
|
|
+ if not main_card:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '未找到对应的主记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ result_data = None
|
|
|
+
|
|
|
+ if action == 'merge_to_suspected':
|
|
|
+ # 合并到选中的疑似重复记录
|
|
|
+ if not selected_duplicate_id:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '执行合并操作时必须提供selected_duplicate_id',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 查找选中的疑似重复记录
|
|
|
+ target_card = BusinessCard.query.get(selected_duplicate_id)
|
|
|
+ if not target_card:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到ID为{selected_duplicate_id}的目标记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 将主记录的信息合并到目标记录，并更新职业轨迹
|
|
|
+ target_card.name_en = main_card.name_en or target_card.name_en
|
|
|
+ target_card.title_zh = main_card.title_zh or target_card.title_zh
|
|
|
+ target_card.title_en = main_card.title_en or target_card.title_en
|
|
|
+
|
|
|
+ # 合并手机号码，避免重复
|
|
|
+ if main_card.mobile:
|
|
|
+ target_card.mobile = merge_mobile_numbers(target_card.mobile, main_card.mobile)
|
|
|
+
|
|
|
+ target_card.phone = main_card.phone or target_card.phone
|
|
|
+ target_card.email = main_card.email or target_card.email
|
|
|
+ target_card.hotel_zh = main_card.hotel_zh or target_card.hotel_zh
|
|
|
+ target_card.hotel_en = main_card.hotel_en or target_card.hotel_en
|
|
|
+ target_card.address_zh = main_card.address_zh or target_card.address_zh
|
|
|
+ target_card.address_en = main_card.address_en or target_card.address_en
|
|
|
+ target_card.postal_code_zh = main_card.postal_code_zh or target_card.postal_code_zh
|
|
|
+ target_card.postal_code_en = main_card.postal_code_en or target_card.postal_code_en
|
|
|
+ target_card.brand_zh = main_card.brand_zh or target_card.brand_zh
|
|
|
+ target_card.brand_en = main_card.brand_en or target_card.brand_en
|
|
|
+ target_card.affiliation_zh = main_card.affiliation_zh or target_card.affiliation_zh
|
|
|
+ target_card.affiliation_en = main_card.affiliation_en or target_card.affiliation_en
|
|
|
+ target_card.birthday = main_card.birthday or target_card.birthday
|
|
|
+ target_card.residence = main_card.residence or target_card.residence
|
|
|
+ target_card.brand_group = main_card.brand_group or target_card.brand_group
|
|
|
+ target_card.image_path = main_card.image_path # 更新为最新的MinIO图片路径
|
|
|
+ target_card.updated_by = processed_by or 'system'
|
|
|
+
|
|
|
+ # 更新职业轨迹，使用主记录的图片路径
|
|
|
+ new_data = {
|
|
|
+ 'hotel_zh': main_card.hotel_zh,
|
|
|
+ 'hotel_en': main_card.hotel_en,
|
|
|
+ 'title_zh': main_card.title_zh,
|
|
|
+ 'title_en': main_card.title_en
|
|
|
+ }
|
|
|
+ target_card.career_path = update_career_path(target_card, new_data, main_card.image_path)
|
|
|
+
|
|
|
+ # 先删除重复记录表中的记录，避免外键约束冲突
|
|
|
+ db.session.delete(duplicate_record)
|
|
|
+
|
|
|
+ # 然后删除主记录
|
|
|
+ db.session.delete(main_card)
|
|
|
+
|
|
|
+ result_data = target_card.to_dict()
|
|
|
+
|
|
|
+ elif action == 'keep_main':
|
|
|
+ # 保留主记录，不做任何合并
|
|
|
+ result_data = main_card.to_dict()
|
|
|
+
|
|
|
+ elif action == 'ignore':
|
|
|
+ # 忽略，不做任何操作
|
|
|
+ result_data = main_card.to_dict()
|
|
|
+
|
|
|
+ # 更新重复记录状态（只有在非merge_to_suspected操作时才更新，因为merge_to_suspected已经删除了记录）
|
|
|
+ if action != 'merge_to_suspected':
|
|
|
+ duplicate_record.processing_status = 'processed'
|
|
|
+ duplicate_record.processed_at = datetime.now()
|
|
|
+ duplicate_record.processed_by = processed_by or 'system'
|
|
|
+ duplicate_record.processing_notes = notes or f'执行操作: {action}'
|
|
|
+
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功处理重复记录，main_card_id: {duplicate_id}，操作: {action}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'重复记录处理成功，操作: {action}',
|
|
|
+ 'data': {
|
|
|
+ 'duplicate_record': duplicate_record.to_dict(),
|
|
|
+ 'result': result_data
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"处理重复记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def get_duplicate_record_detail(duplicate_id):
|
|
|
+ """
|
|
|
+ 获取指定重复记录的详细信息
|
|
|
+
|
|
|
+ Args:
|
|
|
+ duplicate_id (int): 名片记录ID（对应DuplicateBusinessCard表中的main_card_id字段）
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含重复记录详细信息
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查找重复记录 - 使用main_card_id字段匹配
|
|
|
+ duplicate_record = DuplicateBusinessCard.query.filter_by(main_card_id=duplicate_id).first()
|
|
|
+ if not duplicate_record:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到main_card_id为{duplicate_id}的重复记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 构建详细信息
|
|
|
+ record_dict = duplicate_record.to_dict()
|
|
|
+
|
|
|
+ # 添加主记录信息
|
|
|
+ if duplicate_record.main_card:
|
|
|
+ record_dict['main_card'] = duplicate_record.main_card.to_dict()
|
|
|
+ else:
|
|
|
+ record_dict['main_card'] = None
|
|
|
+
|
|
|
+ # 解析suspected_duplicates字段中的JSON信息，并获取详细的名片信息
|
|
|
+ suspected_duplicates_details = []
|
|
|
+ if duplicate_record.suspected_duplicates:
|
|
|
+ try:
|
|
|
+ # 确保suspected_duplicates是列表格式
|
|
|
+ suspected_list = duplicate_record.suspected_duplicates
|
|
|
+ if not isinstance(suspected_list, list):
|
|
|
+ logging.warning(f"suspected_duplicates不是列表格式: {type(suspected_list)}")
|
|
|
+ suspected_list = []
|
|
|
+
|
|
|
+ # 遍历每个疑似重复记录ID
|
|
|
+ for suspected_item in suspected_list:
|
|
|
+ try:
|
|
|
+ # 支持两种格式：直接ID或包含ID的字典
|
|
|
+ if isinstance(suspected_item, dict):
|
|
|
+ card_id = suspected_item.get('id')
|
|
|
+ else:
|
|
|
+ card_id = suspected_item
|
|
|
+
|
|
|
+ if card_id:
|
|
|
+ # 调用get_business_card函数获取详细信息
|
|
|
+ card_result = get_business_card(card_id)
|
|
|
+ if card_result['success'] and card_result['data']:
|
|
|
+ suspected_duplicates_details.append(card_result['data'])
|
|
|
+ logging.info(f"成功获取疑似重复记录详情，ID: {card_id}")
|
|
|
+ else:
|
|
|
+ logging.warning(f"无法获取疑似重复记录详情，ID: {card_id}, 原因: {card_result['message']}")
|
|
|
+ # 添加错误信息记录
|
|
|
+ suspected_duplicates_details.append({
|
|
|
+ 'id': card_id,
|
|
|
+ 'error': card_result['message'],
|
|
|
+ 'success': False
|
|
|
+ })
|
|
|
+ else:
|
|
|
+ logging.warning(f"疑似重复记录项缺少ID信息: {suspected_item}")
|
|
|
+
|
|
|
+ except Exception as item_error:
|
|
|
+ logging.error(f"处理疑似重复记录项时出错: {suspected_item}, 错误: {str(item_error)}")
|
|
|
+ suspected_duplicates_details.append({
|
|
|
+ 'original_item': suspected_item,
|
|
|
+ 'error': f"处理出错: {str(item_error)}",
|
|
|
+ 'success': False
|
|
|
+ })
|
|
|
+
|
|
|
+ except Exception as parse_error:
|
|
|
+ logging.error(f"解析suspected_duplicates JSON时出错: {str(parse_error)}")
|
|
|
+ suspected_duplicates_details = [{
|
|
|
+ 'error': f"解析JSON出错: {str(parse_error)}",
|
|
|
+ 'original_data': duplicate_record.suspected_duplicates,
|
|
|
+ 'success': False
|
|
|
+ }]
|
|
|
+
|
|
|
+ # 将详细的疑似重复记录信息添加到返回数据中
|
|
|
+ record_dict['suspected_duplicates_details'] = suspected_duplicates_details
|
|
|
+ record_dict['suspected_duplicates_count'] = len(suspected_duplicates_details)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '获取重复记录详情成功',
|
|
|
+ 'data': record_dict
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取重复记录详情失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+def fix_broken_duplicate_records():
|
|
|
+ """
|
|
|
+ 修复duplicate_business_cards表中main_card_id为null的损坏记录
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 修复操作的结果
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 查找所有main_card_id为null的记录
|
|
|
+ broken_records = DuplicateBusinessCard.query.filter(
|
|
|
+ DuplicateBusinessCard.main_card_id.is_(None)
|
|
|
+ ).all()
|
|
|
+
|
|
|
+ if not broken_records:
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': '没有发现需要修复的损坏记录',
|
|
|
+ 'data': {
|
|
|
+ 'fixed_count': 0,
|
|
|
+ 'total_broken': 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ # 记录要删除的记录信息
|
|
|
+ broken_info = []
|
|
|
+ for record in broken_records:
|
|
|
+ broken_info.append({
|
|
|
+ 'id': record.id,
|
|
|
+ 'duplicate_reason': record.duplicate_reason,
|
|
|
+ 'processing_status': record.processing_status,
|
|
|
+ 'created_at': record.created_at.strftime('%Y-%m-%d %H:%M:%S') if record.created_at else None,
|
|
|
+ 'processed_at': record.processed_at.strftime('%Y-%m-%d %H:%M:%S') if record.processed_at else None
|
|
|
+ })
|
|
|
+
|
|
|
+ # 删除所有损坏的记录
|
|
|
+ for record in broken_records:
|
|
|
+ db.session.delete(record)
|
|
|
+
|
|
|
+ # 提交事务
|
|
|
+ db.session.commit()
|
|
|
+
|
|
|
+ logging.info(f"成功修复并删除了{len(broken_records)}条损坏的重复记录")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'成功修复并删除了{len(broken_records)}条损坏的重复记录',
|
|
|
+ 'data': {
|
|
|
+ 'fixed_count': len(broken_records),
|
|
|
+ 'total_broken': len(broken_records),
|
|
|
+ 'deleted_records': broken_info
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ db.session.rollback()
|
|
|
+ error_msg = f"修复损坏记录失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+def get_parse_tasks(page=1, per_page=10, task_type=None, task_status=None):
|
|
|
+ """
|
|
|
+ 获取解析任务列表，支持分页和过滤
|
|
|
+
|
|
|
+ Args:
|
|
|
+ page (int): 页码，从1开始，默认为1
|
|
|
+ per_page (int): 每页记录数，默认为10，最大100
|
|
|
+ task_type (str): 任务类型过滤，可选
|
|
|
+ task_status (str): 任务状态过滤，可选
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含查询结果和分页信息的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 参数验证
|
|
|
+ if page < 1:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '页码必须大于0',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ if per_page < 1 or per_page > 100:
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '每页记录数必须在1-100之间',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 构建查询
|
|
|
+ query = db.session.query(ParseTaskRepository)
|
|
|
+
|
|
|
+ # 添加过滤条件
|
|
|
+ if task_type:
|
|
|
+ query = query.filter(ParseTaskRepository.task_type == task_type)
|
|
|
+ if task_status:
|
|
|
+ query = query.filter(ParseTaskRepository.task_status == task_status)
|
|
|
+
|
|
|
+ # 按创建时间倒序排列
|
|
|
+ query = query.order_by(ParseTaskRepository.created_at.desc())
|
|
|
+
|
|
|
+ # 分页查询
|
|
|
+ pagination = query.paginate(
|
|
|
+ page=page,
|
|
|
+ per_page=per_page,
|
|
|
+ error_out=False
|
|
|
+ )
|
|
|
+
|
|
|
+ # 转换为字典格式
|
|
|
+ tasks = [task.to_dict() for task in pagination.items]
|
|
|
+
|
|
|
+ # 构建响应数据
|
|
|
+ response_data = {
|
|
|
+ 'tasks': tasks,
|
|
|
+ 'pagination': {
|
|
|
+ 'page': page,
|
|
|
+ 'per_page': per_page,
|
|
|
+ 'total': pagination.total,
|
|
|
+ 'pages': pagination.pages,
|
|
|
+ 'has_prev': pagination.has_prev,
|
|
|
+ 'has_next': pagination.has_next,
|
|
|
+ 'prev_num': pagination.prev_num,
|
|
|
+ 'next_num': pagination.next_num
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ # 记录查询日志
|
|
|
+ logging.info(f"查询解析任务列表: page={page}, per_page={per_page}, total={pagination.total}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'成功获取解析任务列表，共{pagination.total}条记录',
|
|
|
+ 'data': response_data
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取解析任务列表失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+def get_parse_task_detail(task_name):
|
|
|
+ """
|
|
|
+ 根据任务名称获取解析任务详情
|
|
|
+
|
|
|
+ Args:
|
|
|
+ task_name (str): 任务名称
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含查询结果的字典
|
|
|
+ """
|
|
|
+ try:
|
|
|
+ # 参数验证
|
|
|
+ if not task_name or not isinstance(task_name, str):
|
|
|
+ return {
|
|
|
+ 'code': 400,
|
|
|
+ 'success': False,
|
|
|
+ 'message': '任务名称不能为空',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 查询指定任务名称的记录
|
|
|
+ task = db.session.query(ParseTaskRepository).filter(
|
|
|
+ ParseTaskRepository.task_name == task_name
|
|
|
+ ).first()
|
|
|
+
|
|
|
+ if not task:
|
|
|
+ return {
|
|
|
+ 'code': 404,
|
|
|
+ 'success': False,
|
|
|
+ 'message': f'未找到任务名称为 {task_name} 的记录',
|
|
|
+ 'data': None
|
|
|
+ }
|
|
|
+
|
|
|
+ # 转换为字典格式
|
|
|
+ task_detail = task.to_dict()
|
|
|
+
|
|
|
+ # 记录查询日志
|
|
|
+ logging.info(f"查询解析任务详情: task_name={task_name}, task_id={task.id}")
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 200,
|
|
|
+ 'success': True,
|
|
|
+ 'message': f'成功获取任务 {task_name} 的详细信息',
|
|
|
+ 'data': task_detail
|
|
|
+ }
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ error_msg = f"获取解析任务详情失败: {str(e)}"
|
|
|
+ logging.error(error_msg, exc_info=True)
|
|
|
+
|
|
|
+ return {
|
|
|
+ 'code': 500,
|
|
|
+ 'success': False,
|
|
|
+ 'message': error_msg,
|
|
|
+ 'data': None
|
|
|
+ }
|
maxiaolong