608 lines
27 KiB
Python
608 lines
27 KiB
Python
|
||
from app.core.crud import CRUDBase
|
||
from app.schemas.weixin import (
|
||
WeixinCustomerCreate,
|
||
WeixinCustomerUpdate,
|
||
WeixinCustomerXingyunCreate,
|
||
)
|
||
from typing import List
|
||
|
||
from app.models.weixin import WeixinCustomer, WeixinUser, CustomerGroup
|
||
from app.schemas.weixin import WeixinUserBindInfo, WeixinOrderBindInfo
|
||
|
||
from some_sdk.services.binder import lintao_client, xy_client, wk_client
|
||
from some_sdk.lintao_sdk.biz.by_order import get_order_relative_user, save_other_memo
|
||
from some_sdk.xingyun_sdk.apis.customer import bind_user_to_xingyun, list_user_order
|
||
from some_sdk.xingyun_sdk.apis.work_external_contact import list_all_contact_by_addtime, list_all_contact_by_addtime_and_tag
|
||
from some_sdk.wk_weixin_sdk.apis.corp_user import from_service_external_userid
|
||
from some_sdk.wk_weixin_sdk.apis.extern_user import get_external_user_chat_info
|
||
|
||
from app.controllers.msg import msg_controller
|
||
from app.schemas.msg import MsgType
|
||
|
||
from app.utils.common import async_split_generator
|
||
import pickle
|
||
import hashlib
|
||
|
||
import re, os
|
||
from datetime import datetime, timedelta
|
||
from app.core.cache import cache_if
|
||
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
EXCLUDE_SHOP_NAMES = ['领淘文具旗舰店']
|
||
XINGYUN_USE_TIME = datetime(2025, 6, 18)
|
||
|
||
class WeixinCustomerController(CRUDBase[WeixinCustomer, WeixinCustomerCreate, WeixinCustomerUpdate]):
|
||
def __init__(self):
|
||
super().__init__(model=WeixinCustomer)
|
||
|
||
async def update_from_group(self, external_members: list[dict]):
|
||
# 同步更新数据库
|
||
member_dict = {}
|
||
for member in external_members:
|
||
member = member.copy()
|
||
userid = member.pop('userid', None)
|
||
|
||
weixin_name = member.pop('name', None)
|
||
weixin_unionid = member.pop('unionid', None)
|
||
|
||
member_info = WeixinCustomer.orm_format(member)
|
||
member_info['weixin_id'] = userid
|
||
member_info['weixin_name'] = weixin_name
|
||
member_info['weixin_unionid'] = weixin_unionid
|
||
member_dict[userid] = member_info
|
||
|
||
member_list = await self.model.filter(weixin_id__in=member_dict.keys())
|
||
|
||
update_list = []
|
||
update_fileds = ['weixin_unionid', 'weixin_id', 'weixin_name', 'order_id', 'taobao_id', 'taobao_name', 'extra', 'need_confirm']
|
||
|
||
history = {}
|
||
for member in member_list:
|
||
member_info = member_dict.pop(member.weixin_id, history.get(member.weixin_id, {}))
|
||
if not member_info: continue
|
||
history[member.weixin_id] = member_info
|
||
|
||
member_info['extra'] = {**(member.extra or {}), **member_info['extra']}
|
||
|
||
updated = {}
|
||
for field in update_fileds:
|
||
old_value = getattr(member, field)
|
||
if field not in member_info:
|
||
continue
|
||
value = member_info.get(field)
|
||
if old_value != value:
|
||
setattr(member, field, value)
|
||
updated[f'{field}:{str(old_value)}'] = value
|
||
if updated:
|
||
logger.info(f'用户 {member.weixin_name} 更新关系为 {updated}')
|
||
update_list.append(member)
|
||
if update_list:
|
||
await self.model.bulk_update(update_list, fields=update_fileds)
|
||
|
||
# 新增用户
|
||
create_list = []
|
||
for userid, member_info in member_dict.items():
|
||
create_list.append(WeixinCustomer(
|
||
**member_info,
|
||
))
|
||
if create_list:
|
||
await self.model.bulk_create(create_list)
|
||
|
||
return {
|
||
'update_count': len(update_list),
|
||
'create_count': len(create_list),
|
||
}
|
||
|
||
async def bind_user(self, user_in: WeixinUserBindInfo):
|
||
if not user_in.taobao_id:
|
||
raise ValueError("淘宝ID不能为空")
|
||
await self.model.filter(taobao_id=user_in.taobao_id).update_from_dict(user_in.model_dump(exclude_unset=True))
|
||
|
||
async def remark_order(self, order: dict, remark: str):
|
||
ctid = order.get("ctid") or order.get("trade_no")
|
||
# if remark in (order.get("remark") or ''):
|
||
if '企微' in (order.get("remark") or ''):
|
||
logger.info(f'订单 {ctid} 备注中已包含 企微 备注，无需重复添加')
|
||
return
|
||
remark_list = [order.get("remark", ""), remark]
|
||
append_remark = '；'.join(filter(lambda x: x, remark_list))
|
||
|
||
if os.getenv("APP_ENV") == "prod":
|
||
result = await save_other_memo(lintao_client, order_id=ctid, other_memo=append_remark)
|
||
assert result["type"] == "success", f"保存备注失败，响应: {result}"
|
||
logger.info(f'成功为订单 {ctid} 打上备注 {append_remark}')
|
||
else:
|
||
logger.info(f'非生产环境，不实际为订单 {ctid} 打上备注 {append_remark}')
|
||
|
||
async def remark_order_by_order_id(self, remark: str, order_id: str=None, orders: list=None):
|
||
if not orders:
|
||
assert order_id, "订单ID不能为空"
|
||
orders = [o async for o in get_order_relative_user(lintao_client, trade_no=order_id)]
|
||
assert orders, f"订单 {order_id} 不存在"
|
||
|
||
# 打上备注
|
||
logger.info(f'即将为以下订单 {[o.get("trade_no") for o in orders]} 打上备注 {remark}')
|
||
need_monitor_order_list = []
|
||
for order in orders:
|
||
if not order.get('title'):
|
||
# 未领单的订单，需要添加到监控列表中进行监控，防止被刷掉
|
||
need_monitor_order_list.append(order)
|
||
logger.info(f'订单 {order.get("trade_no")} 未领单，需要添加到监控列表中进行监控，防止被刷掉')
|
||
|
||
try:
|
||
await self.remark_order(order, remark=remark)
|
||
except Exception as e:
|
||
logger.error(f'为订单 {order.get("trade_no")} 打上备注 {remark} 失败，异常: {e}')
|
||
need_monitor_order_list.append(order)
|
||
|
||
return need_monitor_order_list
|
||
|
||
|
||
async def bind_order(self, bind_in: WeixinOrderBindInfo):
|
||
orders = [o async for o in get_order_relative_user(lintao_client, trade_no=bind_in.order_id)]
|
||
assert orders, f"订单 {bind_in.order_id} 不存在"
|
||
|
||
orders = [o for o in orders if o.get('trade_no') == bind_in.order_id]
|
||
order = orders[0]
|
||
|
||
buyer_ids = []
|
||
for user in order.get('users', []):
|
||
taobao_id = user.get('id', '')
|
||
if not taobao_id or re.match(r'^\d+$', taobao_id): continue
|
||
buyer_ids.append(taobao_id)
|
||
|
||
# 更新还是新建？
|
||
orms = await self.model.filter(weixin_id=bind_in.userid).all()
|
||
logger.info(f'用户 {bind_in.userid} 准备绑定订单 {len(orms)} {[orm.weixin_name for orm in orms]}')
|
||
|
||
update_list = []
|
||
for orm in orms:
|
||
if orm.order_id and orm.order_id != order.get('trade_no'):
|
||
logger.warning(f'用户 {orm.weixin_name} 已绑定订单 {orm.order_id}，即将覆盖为 {order.get("trade_no")}')
|
||
|
||
orm.weixin_id = bind_in.userid
|
||
orm.order_id = order.get('trade_no')
|
||
orm.shop_name = order.get('shop_name', '')
|
||
orm.taobao_id = user.get('id', '')
|
||
orm.taobao_name = user.get('name', '')
|
||
update_list.append(orm)
|
||
|
||
if update_list:
|
||
logger.info(f'更新用户 {bind_in.userid} 绑定订单 {order.get("trade_no")} 中的用户 {user}')
|
||
await self.model.bulk_update(update_list, fields=['order_id', 'weixin_id', 'taobao_id', 'taobao_name'])
|
||
return True, orders
|
||
|
||
if not orms:
|
||
logger.info(f'绑定用户 {bind_in.userid} 绑定订单 {order.get("trade_no")} 中的用户 {user}')
|
||
orm_user = WeixinCustomer(
|
||
weixin_id=bind_in.userid,
|
||
order_id=order.get('trade_no'),
|
||
taobao_id=user.get('id', ''),
|
||
taobao_name=user.get('name', ''),
|
||
)
|
||
await orm_user.save()
|
||
return True, orders
|
||
|
||
return False, orders
|
||
|
||
async def bind_xingyun_user(self, contact_orm: WeixinCustomer):
|
||
assert contact_orm.xingyun_id, "星云用户ID不能为空"
|
||
if contact_orm.shop_name in EXCLUDE_SHOP_NAMES:
|
||
contact_orm.xingyun_sync = True
|
||
contact_orm.extra = contact_orm.extra or {}
|
||
contact_orm.extra['system_remark'] = f'店铺名称: {contact_orm.shop_name}，没有开通星云有客服务，故此跳过。'
|
||
return
|
||
|
||
order_id = contact_orm.order_id.split('_')[-1]
|
||
logger.info(f'同步客户订单信息到星云: {contact_orm.xingyun_id} -》 {order_id}')
|
||
try:
|
||
await bind_user_to_xingyun(xy_client, contact_orm.xingyun_id, order_id)
|
||
except:
|
||
logger.error(f'同步客户订单信息到星云失败: {contact_orm.xingyun_id} -》 {order_id}, 尝试寻找同用户的其他订单来绑定')
|
||
shop_name = ''
|
||
async for order in get_order_relative_user(lintao_client, buyer_nick=contact_orm.taobao_name):
|
||
shop_name = order.get('shop_name', '')
|
||
if shop_name in EXCLUDE_SHOP_NAMES:
|
||
continue
|
||
|
||
if not order.get('create_time'): continue
|
||
create_time = order.get('create_time')
|
||
create_time = datetime.fromisoformat(create_time.replace("Z", "+00:00"))
|
||
if create_time < XINGYUN_USE_TIME:
|
||
continue
|
||
|
||
order_id = order.get('trade_no').split('_')[-1]
|
||
await bind_user_to_xingyun(xy_client, contact_orm.xingyun_id, order_id)
|
||
logger.info(f'通过同用户的其他订单来同步客户订单信息到星云成功: {contact_orm.xingyun_id} -》 {order_id}')
|
||
break
|
||
|
||
if shop_name and not contact_orm.shop_name:
|
||
contact_orm.shop_name = order.get('shop_name', '')
|
||
await contact_orm.save()
|
||
|
||
contact_orm.xingyun_sync = True
|
||
|
||
async def load_all_user_from_xingyun(self, task_id: str, add_time_start: datetime, add_time_end: datetime):
|
||
logger.info(f'从星云加载客户数据，时间范围 {task_id} {add_time_start} - {add_time_end}')
|
||
contact_iter = list_all_contact_by_addtime_and_tag(xy_client, task_id=task_id, keyword='', add_time_start=add_time_start, add_time_end=add_time_end)
|
||
|
||
return await self._load_user_from_xingyun(contact_iter, eager_load=True)
|
||
|
||
async def load_user_from_xingyun(self, add_time_start: datetime, add_time_end: datetime):
|
||
logger.info(f'从星云加载客户数据，时间范围 {add_time_start} - {add_time_end}')
|
||
contact_iter = list_all_contact_by_addtime(xy_client, keyword='', add_time_start=add_time_start, add_time_end=add_time_end)
|
||
|
||
return await self._load_user_from_xingyun(contact_iter)
|
||
|
||
async def _load_user_from_xingyun(self, contact_iter: list, eager_load: bool = False):
|
||
logger.info(f'从星云加载客户数据，开始同步')
|
||
load_result = {"update_count": 0, "add_count": 0}
|
||
async for contact_list in async_split_generator(contact_iter, 10):
|
||
try: result = await self.save_xingyun_contact_info(contact_list)
|
||
except Exception as e:
|
||
logger.error(f'从星云加载客户数据，同步失败 {e}')
|
||
logger.exception(e)
|
||
raise e
|
||
|
||
# 全部都已经同步完了
|
||
if not eager_load and result.get("update_count", 0) + result.get("add_count", 0) == 0:
|
||
logger.info(f'从星云加载客户数据，全部同步完成')
|
||
break
|
||
|
||
load_result['update_count'] += result.get("update_count", 0)
|
||
load_result['add_count'] += result.get("add_count", 0)
|
||
logger.info(f'从星云加载客户数据{eager_load}，更新 {result.get("update_count", 0)} 条，新增 {result.get("add_count", 0)} 条')
|
||
logger.info(f'从星云加载客户数据，总 {load_result["update_count"] + load_result["add_count"]} 条，更新 {load_result["update_count"]} 条，新增 {load_result["add_count"]} 条')
|
||
await self.sync_xingyun_contact_info()
|
||
|
||
return load_result
|
||
|
||
async def save_xingyun_contact_info(self, contact_list: list):
|
||
contact_dict = {contact.get('cid'): contact for contact in contact_list}
|
||
contact_orm_list: List[WeixinCustomer] = await self.model.filter(xingyun_id__in=contact_dict.keys())
|
||
|
||
field_names = set()
|
||
update_list = []
|
||
|
||
async def update(contact_dict, contact_orm_list, key):
|
||
history = {}
|
||
for contact_orm in contact_orm_list:
|
||
value = getattr(contact_orm, key)
|
||
contact = contact_dict.pop(value, history.get(value, {}))
|
||
if not contact: continue
|
||
history[value] = contact
|
||
|
||
try:
|
||
contact_in = WeixinCustomerXingyunCreate(**contact).transform_to_extra()
|
||
except Exception as e:
|
||
logger.error(f'客户数据转换错误，chat_id: {contact}, {e}')
|
||
continue
|
||
# print(type(contact_in), contact_in)
|
||
updated = False
|
||
|
||
contact_in_dict = contact_in.model_dump(exclude_unset=True)
|
||
field_names.update(contact_in_dict.keys())
|
||
|
||
for field_name in field_names:
|
||
|
||
old_value = getattr(contact_orm, field_name)
|
||
value = contact_in_dict.get(field_name)
|
||
if old_value != value:
|
||
setattr(contact_orm, field_name, value)
|
||
updated = True
|
||
|
||
new_extra = {**(contact_orm.extra or {}), **contact_in.extra}
|
||
if contact_in.extra != new_extra:
|
||
if new_extra != contact_orm.extra:
|
||
contact_orm.extra = new_extra
|
||
updated = True
|
||
|
||
# 触发同步信息到星云
|
||
if updated and not contact_orm.xingyun_sync and contact_orm.xingyun_id:
|
||
try:
|
||
await self.bind_xingyun_user(contact_orm)
|
||
update_list.append(contact_orm)
|
||
except Exception as e:
|
||
logger.error(f'客户数据同步错误，xingyun_id: {contact_orm.xingyun_id}, {e}')
|
||
continue
|
||
|
||
if update_list:
|
||
await self.model.bulk_update(update_list, list(field_names) + ['extra', 'xingyun_sync'])
|
||
|
||
await update(contact_dict, contact_orm_list, 'xingyun_id')
|
||
|
||
add_dict = {}
|
||
for contact in contact_dict.values():
|
||
externalUserid = contact.get('externalUserid', None)
|
||
if not externalUserid:
|
||
continue
|
||
try:
|
||
resp = await from_service_external_userid(wk_client, externalUserid)
|
||
except Exception as e:
|
||
logger.error(f'从星云加载客户数据，获取用户ID失败，externalUserid: {externalUserid}, {e}')
|
||
continue
|
||
if not resp or not resp.get('external_userid'):
|
||
continue
|
||
|
||
external_userid = resp.get('external_userid')
|
||
contact['external_userid'] = external_userid
|
||
add_dict[external_userid] = contact
|
||
|
||
contact_orm_list = await self.model.filter(weixin_id__in=add_dict.keys())
|
||
await update(add_dict, contact_orm_list, 'weixin_id')
|
||
|
||
add_list = []
|
||
for contact in add_dict.values():
|
||
contact_in = WeixinCustomerXingyunCreate(**contact).transform_to_extra()
|
||
add_list.append(self.model(**contact_in.model_dump(exclude_unset=True)))
|
||
|
||
if add_list:
|
||
await self.model.bulk_create(add_list)
|
||
|
||
return {
|
||
'update_count': len(update_list),
|
||
'add_count': len(add_list),
|
||
}
|
||
|
||
async def bind_user(self, bind_info: WeixinUserBindInfo):
|
||
return await self.bind_user(bind_info)
|
||
|
||
async def monitor_erp_order(self):
|
||
# 从领淘ERP加载订单相关用户
|
||
# 获取上一个订单的创建时间
|
||
cache_file = 'env/order_cache.pkl'
|
||
newest_order_create_time = None
|
||
today_end = datetime.now().replace(hour=23, minute=59, second=59, microsecond=0)
|
||
try:
|
||
with open(cache_file, 'rb') as f:
|
||
last_order = pickle.load(f)
|
||
newest_order_create_time = last_order.get('create_time')
|
||
logger.info(f'从缓存文件加载最新订单创建时间，{newest_order_create_time}')
|
||
except FileNotFoundError:
|
||
newest_order_create_time = today_end.replace(hour=0, minute=0, second=0, microsecond=0)
|
||
newest_order_create_time = newest_order_create_time.strftime('%Y-%m-%d %H:%M:%S')
|
||
|
||
order_list = [o async for o in get_order_relative_user(lintao_client, start_date=newest_order_create_time, end_date=today_end.strftime('%Y-%m-%d %H:%M:%S'))]
|
||
msg_list, newest_order = await self.find_bind_order(order_list)
|
||
|
||
# 保存最新订单到缓存文件
|
||
if newest_order:
|
||
newest_order['create_time'] = newest_order['create_time'].replace('T', ' ')
|
||
with open(cache_file, 'wb') as f:
|
||
pickle.dump(newest_order, f)
|
||
|
||
return msg_list
|
||
|
||
async def find_bind_order(self, order_list: list):
|
||
|
||
buyer_order_dict = {}
|
||
newest_order = None
|
||
last_erp_id = 0
|
||
|
||
order_id_set = set()
|
||
for order in order_list:
|
||
erp_id = order.get('id')
|
||
if erp_id <= 6368700: break
|
||
|
||
create_time = order.get('create_time')
|
||
if last_erp_id < erp_id:
|
||
if create_time: newest_order = order
|
||
last_erp_id = erp_id
|
||
|
||
order_id = order.get('trade_no')
|
||
if order_id in order_id_set: continue
|
||
order_id_set.add(order_id)
|
||
|
||
users = order.get("users", [])
|
||
buyer_id_set = set()
|
||
for user in users:
|
||
role = user.get('role')
|
||
if role != 'buyer': continue
|
||
buyer_id = user.get('id')
|
||
if not buyer_id: continue
|
||
if buyer_id in buyer_id_set: continue
|
||
buyer_id_set.add(buyer_id)
|
||
|
||
buyer_order_dict.setdefault(buyer_id, []).append(order)
|
||
|
||
customer_list = await self.model.filter(taobao_id__in=buyer_order_dict.keys()).all()
|
||
|
||
# 通知新订单
|
||
# （客户id）-（所属企微客服）刚在（店铺名）下单-（金额）
|
||
msg_set = set()
|
||
msg_list = []
|
||
for customer_orm in customer_list:
|
||
order_list = buyer_order_dict.get(customer_orm.taobao_id, [])
|
||
|
||
order_info = [
|
||
f"在({order.get('shop_name')})下单{order.get('price')}元，单号({order.get('trade_no')})"
|
||
for order in order_list
|
||
]
|
||
chat_info = await get_external_user_chat_info(customer_orm.weixin_id)
|
||
follow_user_list = chat_info.get('follow_user', [])
|
||
|
||
for follow_user in follow_user_list:
|
||
follow_userid = follow_user.get('userid')
|
||
weixin_user_orm: WeixinUser = await WeixinUser.filter(userid=follow_userid).first()
|
||
owner_name = '未知'
|
||
if weixin_user_orm: owner_name = weixin_user_orm.english_name or weixin_user_orm.username
|
||
qiwei_customer_name = customer_orm.taobao_name or customer_orm.weixin_name
|
||
|
||
content = f"({qiwei_customer_name}) -({owner_name})- 刚{', '.join(order_info)}"
|
||
msg_hash_id = hashlib.md5(content.encode('utf-8')).hexdigest()
|
||
if msg_hash_id in msg_set: continue
|
||
msg_set.add(msg_hash_id)
|
||
|
||
# 检查消息是否已存在
|
||
msg_orm = await msg_controller.model.filter(hash_id=msg_hash_id).first()
|
||
if msg_orm: continue
|
||
|
||
msg = msg_controller.model(
|
||
hash_id=msg_hash_id,
|
||
title=qiwei_customer_name,
|
||
content=content,
|
||
detail=order_list,
|
||
type=MsgType.NEW_ORDER,
|
||
owner_id=follow_userid,
|
||
owner_name=owner_name
|
||
)
|
||
logger.info(f'创建新订单通知消息，{msg.content}')
|
||
msg_list.append(msg)
|
||
|
||
if msg_list:
|
||
await msg_controller.model.bulk_create(msg_list)
|
||
|
||
return msg_list, newest_order
|
||
|
||
async def get_customer_by_weixin_id(self, weixin_id: str):
|
||
async with cache_if(f'customer:user_datail_0:{weixin_id}', ttl=3600*24) as cache:
|
||
if cache.hit:
|
||
result = cache.value
|
||
return result
|
||
else:
|
||
result = await self._get_customer_by_weixin_id(weixin_id)
|
||
cache.set(result)
|
||
return result
|
||
|
||
async def _get_customer_by_weixin_id(self, weixin_id: str):
|
||
chat_info = await get_external_user_chat_info(weixin_id)
|
||
follow_user_list = chat_info.get('follow_user', [])
|
||
external_contact = chat_info.get('external_contact', {})
|
||
|
||
if external_contact:
|
||
customer_orm = await self.model.filter(weixin_id=weixin_id).first()
|
||
if customer_orm:
|
||
customer_orm.weixin_avatar = external_contact.get('avatar')
|
||
customer_orm.weixin_unionid = external_contact.get('unionid')
|
||
customer_orm.weixin_name = external_contact.get('name')
|
||
await customer_orm.save()
|
||
|
||
user_ids = [follow_user.get('userid') for follow_user in follow_user_list]
|
||
weixin_user_orm_list = await WeixinUser.filter(userid__in=user_ids).all()
|
||
weixin_user_orm_dict = {weixin_user_orm.userid: weixin_user_orm for weixin_user_orm in weixin_user_orm_list}
|
||
for follow_user in follow_user_list:
|
||
follow_userid = follow_user.get('userid')
|
||
weixin_user_orm = weixin_user_orm_dict.get(follow_userid)
|
||
|
||
if weixin_user_orm:
|
||
follow_user['username'] = weixin_user_orm.english_name or weixin_user_orm.username
|
||
|
||
return {
|
||
**external_contact,
|
||
'follow_user_list': follow_user_list,
|
||
}
|
||
|
||
# for follow_user in follow_user_list:
|
||
# follow_userid = follow_user.get('userid')
|
||
|
||
async def get_user_detail(self, weixin_id: str):
|
||
async with cache_if(f'customer:user_datail:{weixin_id}', ttl=3600) as cache:
|
||
if cache.hit:
|
||
result = cache.value
|
||
return result
|
||
else:
|
||
customer = await weixin_customer_controller.model.get_or_none(weixin_id=weixin_id)
|
||
# if customer: return customer.to_dict()
|
||
print(f'get_user_detail, weixin_id: {weixin_id}, customer: {customer}')
|
||
|
||
# 通过中间表 CustomerGroup 查询其加入的所有群
|
||
memberships = await CustomerGroup.filter(
|
||
customer=customer
|
||
).prefetch_related('group') # 预加载 group 信息
|
||
|
||
group_list = []
|
||
result = {'group_list': group_list}
|
||
for m in memberships:
|
||
data = await m.to_dict()
|
||
# data['group'] = await m.group.to_dict()
|
||
data['chat_name'] = m.group.name
|
||
data['create_time'] = m.group.create_time
|
||
group_list.append(data)
|
||
|
||
chat_info = await self.get_customer_by_weixin_id(weixin_id)
|
||
result['user_detail'] = chat_info
|
||
cache.set(result)
|
||
|
||
return result
|
||
|
||
# 同步星云和数据库中的客户信息: 同步绑定信息到星云、从星云中加载订单信息
|
||
async def sync_xingyun_contact_info(self, eager_load: bool = False):
|
||
# 从星云同步绑定信息到本地
|
||
await self._sync_xingyun_contact_info(eager_load=eager_load, order_id__isnull=False)
|
||
# 从本地同步订单信息到星云
|
||
await self._sync_xingyun_contact_info(eager_load=eager_load, order_id__isnull=True, limit=10)
|
||
|
||
async def _sync_xingyun_contact_info(self, eager_load: bool = False, max_try: int = 2, limit: int = 20, **query_kwargs):
|
||
query_kwargs = query_kwargs or {}
|
||
|
||
last_id = 0
|
||
while eager_load or max_try > 0:
|
||
max_try -= 1
|
||
if last_id:
|
||
contact_orm_list = await self.model.filter(xingyun_sync=False, xingyun_id__isnull=False, id__lt=last_id, **query_kwargs).order_by('-id').limit(limit).all()
|
||
else:
|
||
contact_orm_list = await self.model.filter(xingyun_sync=False, xingyun_id__isnull=False, **query_kwargs).order_by('-id').limit(limit).all()
|
||
|
||
if not contact_orm_list: break
|
||
logger.debug(f'同步客户数据，{len(contact_orm_list)}')
|
||
|
||
has_new = False
|
||
update_list = []
|
||
for contact_orm in contact_orm_list:
|
||
last_id = contact_orm.id
|
||
has_new = True
|
||
|
||
if contact_orm.need_confirm:
|
||
logger.info(f'客户需要确认绑定: {contact_orm}')
|
||
continue
|
||
|
||
if contact_orm.order_id:
|
||
try:
|
||
await self.bind_xingyun_user(contact_orm)
|
||
update_list.append(contact_orm)
|
||
except Exception as e:
|
||
logger.error(f'同步客户订单信息到星云错误，xingyun_id: {contact_orm.xingyun_id}, {e}')
|
||
continue
|
||
else:
|
||
# list_user_order
|
||
try:
|
||
order_list = list_user_order(xy_client, cid=contact_orm.xingyun_id)
|
||
except Exception as e:
|
||
logger.error(f'客户数据同步错误，xingyun_id: {contact_orm.xingyun_id}, {e}')
|
||
logger.exception(e)
|
||
continue
|
||
|
||
shopNameSet, order_id_list = set(), []
|
||
async for order in order_list:
|
||
shopName = order.get('shopName')
|
||
if shopName in shopNameSet:
|
||
continue
|
||
shopNameSet.add(shopName)
|
||
order_id_list.append(order.get('orderId'))
|
||
# 多店铺用的用的名称和ID都一样，所以不区分
|
||
break
|
||
|
||
for order_id in order_id_list:
|
||
try:
|
||
await self.bind_order(WeixinOrderBindInfo(
|
||
userid=contact_orm.weixin_id,
|
||
order_id=order_id,
|
||
))
|
||
except AssertionError as e:
|
||
logger.error(f'同步客户订单信息到本地错误，xingyun_id: {contact_orm.xingyun_id}, {e}')
|
||
logger.exception(e)
|
||
continue
|
||
contact_orm.xingyun_sync = True
|
||
update_list.append(contact_orm)
|
||
logger.info(f'同步客户订单信息到本地: {contact_orm.xingyun_id} -》 {order_id}')
|
||
|
||
if update_list:
|
||
await self.model.bulk_update(update_list, ['xingyun_sync'])
|
||
|
||
if not has_new: break
|
||
|
||
weixin_customer_controller = WeixinCustomerController()
|