"""直播账号履约作业服务:订单同步、映射、选号、绑码和人工完成。""" from __future__ import annotations import os import time import uuid from datetime import UTC, datetime, timedelta from threading import Lock from typing import Any from fastapi import HTTPException from sqlalchemy import or_ from sqlalchemy.orm import Session from ...models import ( Account, AccountLease, DouyuGoodsSnapshot, DouyuTask, PlatformCommodityMapping, PlatformFulfillmentEvent, PlatformFulfillmentSetting, PlatformFulfillmentTask, User, ) from ..douyu_account_state import DouyuLiveAccountState, refresh_douyu_account_state from ..douyu_activity_query import activity_client, query_exchange_eligibility from ..douyu_batch_launcher import start_douyu_batch, stop_douyu_batches from ..douyu_service import douyu_config_value, ensure_douyu_config from ..external_order_source import ( OrderLookupUnavailable, list_pending_manual_fulfillments, ) from .account_selector import ( AccountCandidate, has_recent_exchange, lease_account, live_candidate_accounts, release_lease, renew_lease, ) from .order_site_notifier import enqueue_order_site_binding_state TARGET_PLATFORM = "douyu" SCOPE_ELITE = "elite" ACTIVE_STATUSES = { "ready", "allocated", "waiting_bind", "role_ready", "binding_confirming", "bound", "manual_required", } BINDING_QR_TTL_SECONDS = int(os.getenv("PLATFORM_BINDING_QR_TTL_SECONDS", "600")) AUTO_SYNC_INTERVAL_SECONDS = 900.0 _SYNC_LOCK = Lock() _AUTO_SYNC_LOCK = Lock() _AUTO_SYNC_LAST_ATTEMPT = float("-inf") def _now() -> datetime: return datetime.now(UTC) def _jsonable(value: Any) -> Any: if isinstance(value, datetime): return value.isoformat() if isinstance(value, dict): return {str(key): _jsonable(item) for key, item in value.items()} if isinstance(value, (list, tuple)): return [_jsonable(item) for item in value] if isinstance(value, (str, int, float, bool)) or value is None: return value return str(value) def _mapping_for_sku( db: Session, internal_sku_key: str ) -> PlatformCommodityMapping | None: return ( db.query(PlatformCommodityMapping) .filter( PlatformCommodityMapping.target_platform == TARGET_PLATFORM, PlatformCommodityMapping.internal_sku_key == internal_sku_key, PlatformCommodityMapping.enabled.is_(True), ) .first() ) def get_settings(db: Session) -> dict[str, Any]: row = ( db.query(PlatformFulfillmentSetting) .filter(PlatformFulfillmentSetting.id == 1) .first() ) if row is None: row = PlatformFulfillmentSetting(id=1, lease_duration_minutes=None) db.add(row) db.commit() db.refresh(row) return { "leaseDurationMinutes": row.lease_duration_minutes, "updatedAt": _jsonable(row.updated_at), } def update_settings( db: Session, *, lease_duration_minutes: int | None, current: User, ) -> dict[str, Any]: row = ( db.query(PlatformFulfillmentSetting) .filter(PlatformFulfillmentSetting.id == 1) .first() ) if row is None: row = PlatformFulfillmentSetting(id=1) db.add(row) now = _now() row.lease_duration_minutes = lease_duration_minutes row.updated_by = current.id row.updated_at = now active_leases = ( db.query(AccountLease) .filter( AccountLease.purpose == "platform_fulfillment", AccountLease.status == "active", ) .all() ) for lease in active_leases: lease.expires_at = ( None if lease_duration_minutes is None else now + timedelta(minutes=lease_duration_minutes) ) db.commit() return { "leaseDurationMinutes": row.lease_duration_minutes, "updatedAt": _jsonable(row.updated_at), } def _lease_duration_minutes(db: Session) -> int | None: return get_settings(db)["leaseDurationMinutes"] def _integration_actor(db: Session) -> User: raw_user_id = os.getenv("PLATFORM_FULFILLMENT_INTEGRATION_ACTOR_ID", "").strip() query = db.query(User).filter(User.is_active.is_(True)) if raw_user_id: try: user = query.filter(User.id == int(raw_user_id)).first() except ValueError: user = None else: user = query.filter(User.role == "super_admin").order_by(User.id.asc()).first() if user is None: raise HTTPException( status_code=503, detail="未配置可用的直播账号履约集成操作人", ) return user def _find_customer_task( db: Session, *, source_order_item_id: str, platform_order_id: str = "", ) -> PlatformFulfillmentTask | None: item_id = str(source_order_item_id or "").strip() if not item_id: return None query = db.query(PlatformFulfillmentTask).filter( PlatformFulfillmentTask.source_system == "order_site", PlatformFulfillmentTask.source_order_item_id == item_id, ) order_no = str(platform_order_id or "").strip() if order_no: query = query.filter(PlatformFulfillmentTask.platform_order_id == order_no) return query.first() def _binding_qr_expired(bind_task: DouyuTask, now: datetime | None = None) -> bool: result = bind_task.result or {} raw_expires_at = str(result.get("qr_expires_at") or "").strip() if raw_expires_at: try: expires_at = datetime.fromisoformat(raw_expires_at) except ValueError: expires_at = None if expires_at is not None: if expires_at.tzinfo is None: expires_at = expires_at.replace(tzinfo=UTC) return expires_at <= (now or _now()) created_at = bind_task.created_at if created_at.tzinfo is None: created_at = created_at.replace(tzinfo=UTC) return created_at + timedelta(seconds=BINDING_QR_TTL_SECONDS) <= (now or _now()) def _append_event( db: Session, task_id: int, event_type: str, *, actor_type: str = "system", actor_id: int | str | None = None, detail: dict[str, Any] | None = None, ) -> None: db.add( PlatformFulfillmentEvent( task_id=task_id, event_type=event_type, actor_type=actor_type, actor_id=str(actor_id or ""), detail_json=detail or {}, created_at=_now(), ) ) def _emit_order_site_binding_state( db: Session, task_id: int, *, extra: dict[str, Any] | None = None, ) -> bool: """当前事务内写 Outbox;HTTP 投递由独立 worker 完成。""" payload = customer_binding_out(db, task_id) if extra: payload.update(extra) return enqueue_order_site_binding_state( db, payload, ) def _load_task(db: Session, task_id: int) -> PlatformFulfillmentTask: task = ( db.query(PlatformFulfillmentTask) .filter(PlatformFulfillmentTask.id == int(task_id)) .first() ) if task is None: raise HTTPException(status_code=404, detail="直播账号履约任务不存在") return task def _apply_mapping( task: PlatformFulfillmentTask, mapping: PlatformCommodityMapping | None, ) -> None: if mapping is None: task.commodity_mapping_id = None task.commodity_id = "" task.required_points = None task.execution_status = "pending_mapping" task.issue_code = "mapping_missing" task.last_error = "内部 SKU 尚未配置斗鱼商品映射" return task.commodity_mapping_id = mapping.id task.commodity_id = mapping.commodity_id task.required_points = mapping.required_points task.execution_status = "ready" task.issue_code = "" task.last_error = "" def _sync_pending_tasks( db: Session, *, limit: int = 100, commit: bool = True, ) -> dict[str, Any]: """只拉取已配置商品映射的人工待履约订单项并生成本地作业。""" mappings = ( db.query(PlatformCommodityMapping) .filter( PlatformCommodityMapping.target_platform == TARGET_PLATFORM, PlatformCommodityMapping.enabled.is_(True), ) .all() ) mappings_by_sku = { str(mapping.internal_sku_key or "").strip(): mapping for mapping in mappings if str(mapping.internal_sku_key or "").strip() } if not mappings_by_sku: if commit: db.commit() return { "fetched": 0, "created": 0, "updated": 0, "skippedUnmapped": 0, "configuredSkuCount": 0, } try: rows = list_pending_manual_fulfillments( limit=limit, internal_sku_keys=list(mappings_by_sku), ) except OrderLookupUnavailable as exc: raise HTTPException(status_code=503, detail=f"订单源不可用:{exc}") from exc created = 0 updated = 0 skipped_unmapped = 0 for row in rows: item_id = str(row.get("source_order_item_id") or "") if not item_id: continue internal_sku_key = str(row.get("internal_sku_key") or "").strip() mapping = mappings_by_sku.get(internal_sku_key) if mapping is None: skipped_unmapped += 1 continue task = ( db.query(PlatformFulfillmentTask) .filter( PlatformFulfillmentTask.source_system == "order_site", PlatformFulfillmentTask.source_order_item_id == item_id, ) .first() ) if task is None: task = PlatformFulfillmentTask( source_system="order_site", source_order_id=str(row.get("source_order_id") or ""), source_order_item_id=item_id, source_fulfillment_id=str(row.get("source_fulfillment_id") or ""), created_at=_now(), updated_at=_now(), ) db.add(task) db.flush() created += 1 _append_event( db, task.id, "task_created", detail={"platformOrderId": row.get("platform_order_id")}, ) else: updated += 1 if task.execution_status in {"completed", "cancelled"}: continue task.platform_order_id = str(row.get("platform_order_id") or "") task.provider = str(row.get("provider") or "") task.shop_id = str(row.get("shop_id") or "") task.shop_name = str(row.get("shop_name") or "") task.sku_code = str(row.get("sku_code") or "") task.sku_name = str(row.get("sku_name") or "") task.internal_sku_key = internal_sku_key task.quantity = 1 task.order_amount_fen = int( row.get("revenue_amount_fen") or row.get("total_amount") or 0 ) task.target_platform = TARGET_PLATFORM task.scope = SCOPE_ELITE task.source_snapshot_json = _jsonable(row) task.updated_at = _now() if task.execution_status in {"pending_mapping", "ready"}: _apply_mapping(task, mapping) _emit_order_site_binding_state(db, task.id) if commit: db.commit() return { "fetched": len(rows), "created": created, "updated": updated, "skippedUnmapped": skipped_unmapped, "configuredSkuCount": len(mappings_by_sku), } def sync_pending_tasks( db: Session, *, limit: int = 100, commit: bool = True, ) -> dict[str, Any]: """串行同步订单,避免自动同步与人工同步并发创建重复任务。""" with _SYNC_LOCK: return _sync_pending_tasks(db, limit=limit, commit=commit) def sync_pending_tasks_if_due( db: Session, *, limit: int = 100, now: float | None = None, ) -> dict[str, Any] | None: """工作台读取时自动同步;按进程节流,不阻塞每 5 秒一次的列表轮询。""" global _AUTO_SYNC_LAST_ATTEMPT if not _AUTO_SYNC_LOCK.acquire(blocking=False): return None try: current = time.monotonic() if now is None else now if current - _AUTO_SYNC_LAST_ATTEMPT < AUTO_SYNC_INTERVAL_SECONDS: return None _AUTO_SYNC_LAST_ATTEMPT = current try: return sync_pending_tasks(db, limit=limit) except Exception: _AUTO_SYNC_LAST_ATTEMPT = float("-inf") raise finally: _AUTO_SYNC_LOCK.release() def list_tasks( db: Session, *, status: str = "", keyword: str = "", page: int = 1, page_size: int = 20, ) -> dict[str, Any]: query = db.query(PlatformFulfillmentTask) query = query.filter( or_( PlatformFulfillmentTask.commodity_mapping_id.isnot(None), PlatformFulfillmentTask.commodity_id != "", ) ) if status: if status == "unfinished": query = query.filter( PlatformFulfillmentTask.execution_status.notin_( ["completed", "cancelled"] ) ) else: query = query.filter(PlatformFulfillmentTask.execution_status == status) text = keyword.strip() if text: pattern = f"%{text}%" query = query.filter( or_( PlatformFulfillmentTask.platform_order_id.ilike(pattern), PlatformFulfillmentTask.sku_name.ilike(pattern), PlatformFulfillmentTask.sku_code.ilike(pattern), PlatformFulfillmentTask.internal_sku_key.ilike(pattern), PlatformFulfillmentTask.commodity_id.ilike(pattern), ) ) total = query.count() rows = ( query.order_by( PlatformFulfillmentTask.updated_at.desc(), PlatformFulfillmentTask.id.desc(), ) .offset((max(1, page) - 1) * max(1, page_size)) .limit(max(1, min(page_size, 100))) .all() ) return { "items": [_task_out(db, row) for row in rows], "pagination": { "page": max(1, page), "pageSize": max(1, page_size), "total": total, }, } def _task_out( db: Session, task: PlatformFulfillmentTask, *, include_qr: bool = False, ) -> dict[str, Any]: account = ( db.query(Account).filter(Account.id == task.account_id).first() if task.account_id else None ) lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) bind_task = ( db.query(DouyuTask).filter(DouyuTask.id == task.bind_task_id).first() if task.bind_task_id else None ) bind_result = (bind_task.result or {}) if bind_task else {} return { "id": task.id, "sourceSystem": task.source_system, "sourceOrderId": task.source_order_id, "sourceOrderItemId": task.source_order_item_id, "sourceFulfillmentId": task.source_fulfillment_id, "platformOrderId": task.platform_order_id, "provider": task.provider, "shopId": task.shop_id, "shopName": task.shop_name, "skuCode": task.sku_code, "skuName": task.sku_name, "internalSkuKey": task.internal_sku_key, "quantity": task.quantity, "orderAmountFen": task.order_amount_fen, "targetPlatform": task.target_platform, "scope": task.scope, "commodityMappingId": task.commodity_mapping_id, "commodityId": task.commodity_id, "requiredPoints": task.required_points, "bindingStatus": task.binding_status, "executionStatus": task.execution_status, "exchangeStatus": task.exchange_status, "issueCode": task.issue_code, "lastError": task.last_error, "operatorId": task.operator_id, "completedAt": task.completed_at, "createdAt": task.created_at, "updatedAt": task.updated_at, "account": ( { "id": account.id, "username": account.username, "nickname": account.nickname or "", "points": account.points, "goldBalance": account.gold_balance, "eliteOpened": account.elite_opened, "ckCheckStatus": account.ck_check_status, "roleBindStatus": account.role_bind_status, "gameName": account.game_name, "gameChannel": account.game_channel, "roleChangeAvailableAt": account.role_change_available_at, } if account else None ), "lease": ( { "id": lease.id, "status": lease.status, "expiresAt": lease.expires_at, } if lease else None ), "bindTask": ( { "id": bind_task.id, "taskType": bind_task.task_type, "status": bind_task.status, "message": bind_task.message, "qrUrl": str(bind_result.get("url") or "") if include_qr else "", "roleName": str( bind_result.get("role_name") or bind_result.get("current_role_name") or "" ), "areaName": str(bind_result.get("area_name") or ""), "platName": str(bind_result.get("plat_name") or ""), "bindPhase": str(bind_result.get("bind_phase") or ""), "bindReadyForConfirm": bool(bind_result.get("bind_ready_for_confirm")), "bindConfirmed": bool(bind_result.get("bind_confirmed")), } if bind_task else None ), } def get_task_detail(db: Session, task_id: int) -> dict[str, Any]: task = _load_task(db, task_id) events = ( db.query(PlatformFulfillmentEvent) .filter(PlatformFulfillmentEvent.task_id == task.id) .order_by(PlatformFulfillmentEvent.id.desc()) .limit(200) .all() ) return { "task": _task_out(db, task, include_qr=True), "events": [ { "id": event.id, "eventType": event.event_type, "actorType": event.actor_type, "actorId": event.actor_id, "detail": event.detail_json or {}, "createdAt": event.created_at, } for event in events ], } def _customer_task_message(task: PlatformFulfillmentTask) -> str: messages = { "mapping_missing": "商品正在准备中,请稍后重试", "no_eligible_account": "正在准备可用账号,请稍后重试", "elite_not_opened": "账号正在准备精英宝典,请稍后重试", "points_short": "账号正在补充积分,请稍后重试", "commodity_limit_reached": "当前商品暂时无法兑换,请联系客服", "binding_failed": "暂未识别到绑定角色,请继续使用当前二维码完成扫码", "account_role_cooldown": "当前绑定账号暂不可换绑,请截图本页面并联系客服处理", "customer_role_cooldown": "该游戏角色仍在换绑冷却期,请截图本页面并联系客服处理", "eligibility_check_failed": "状态查询异常,请稍后刷新", "manual_required": "当前需要人工处理,请联系客服", } return messages.get(task.issue_code, "") if task.issue_code else "" def _binding_failure_issue(bind_task: DouyuTask, result: dict[str, Any]) -> str: phase = str(result.get("bind_phase") or "") message = str(bind_task.message or "") if phase == "change_waiting" or "暂不能换绑" in message: task_issue = "account_role_cooldown" elif ( phase == "confirm_failed" or "待绑定游戏账号" in message or "未到换绑时间" in message ): task_issue = "customer_role_cooldown" else: return "binding_failed" messages = { "account_role_cooldown": "当前绑定账号暂不可换绑,请截图本页面并联系客服处理", "customer_role_cooldown": "该游戏角色仍在换绑冷却期,请截图本页面并联系客服处理", } return task_issue if messages.get(task_issue) else "binding_failed" def customer_binding_out(db: Session, task_id: int) -> dict[str, Any]: """面向前端客户页的安全绑定快照,不包含账号、CK、积分和租约。""" task = _load_task(db, task_id) bind_task = ( db.query(DouyuTask).filter(DouyuTask.id == task.bind_task_id).first() if task.bind_task_id else None ) bind_result = (bind_task.result or {}) if bind_task else {} lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) lease_ready = bool(task.account_id and lease and lease.status == "active") binding_failed = task.binding_status == "failed" binding_confirmed = task.binding_status == "bound" return { "sessionId": task.id, "platformOrderId": task.platform_order_id, "sourceOrderItemId": task.source_order_item_id, "productName": task.sku_name, "quantity": task.quantity, "executionStatus": task.execution_status, "bindingStatus": task.binding_status, "exchangeStatus": task.exchange_status, "issueCode": task.issue_code, "message": _customer_task_message(task), "accountReady": lease_ready, "bindTaskId": bind_task.id if bind_task else None, "bindTaskStatus": bind_task.status if bind_task else "", "bindPhase": str(bind_result.get("bind_phase") or ""), "qrUrl": str(bind_result.get("url") or ""), "qrGeneratedAt": str(bind_result.get("qr_generated_at") or ""), "qrExpiresAt": str(bind_result.get("qr_expires_at") or ""), "roleName": str( bind_result.get("role_name") or bind_result.get("current_role_name") or "" ), "areaName": str(bind_result.get("area_name") or ""), "platName": str(bind_result.get("plat_name") or ""), "bindReadyForConfirm": ( bool(bind_result.get("bind_ready_for_confirm")) and not binding_failed ), "bindConfirmed": bool(bind_result.get("bind_confirmed")) and binding_confirmed, "completedAt": _jsonable(task.completed_at), "updatedAt": _jsonable(task.updated_at), } def ensure_customer_session( db: Session, *, source_order_item_id: str, platform_order_id: str = "", ) -> dict[str, Any]: """按订单项幂等准备客户绑定会话;必要时同步订单并自动分配账号。""" task = _find_customer_task( db, source_order_item_id=source_order_item_id, platform_order_id=platform_order_id, ) if task is None: sync_pending_tasks(db, limit=500) task = _find_customer_task( db, source_order_item_id=source_order_item_id, platform_order_id=platform_order_id, ) if task is None: raise HTTPException(status_code=404, detail="订单尚未进入直播账号履约队列") if task.execution_status in {"completed", "cancelled"}: return customer_binding_out(db, task.id) if task.execution_status in {"pending_mapping", "ready", "manual_required"}: if task.issue_code == "mapping_missing": return customer_binding_out(db, task.id) actor = _integration_actor(db) allocate_task(db, task_id=task.id, current=actor) return customer_binding_out(db, task.id) async def customer_start_binding( db: Session, *, task_id: int, force_refresh: bool = False, ) -> dict[str, Any]: task = _load_task(db, task_id) actor = _integration_actor(db) if task.execution_status not in {"completed", "cancelled"} and ( not task.account_id or not task.lease_id ): allocate_task(db, task_id=task.id, current=actor) await start_binding( db, task_id=task.id, current=actor, force_refresh=force_refresh, ) return customer_binding_out(db, task.id) def customer_refresh_binding(db: Session, *, task_id: int) -> dict[str, Any]: refresh_binding(db, task_id=task_id) return customer_binding_out(db, task_id) def customer_refresh_bindings(db: Session, *, task_ids: list[int]) -> dict[str, Any]: items: list[dict[str, Any]] = [] for task_id in dict.fromkeys(task_ids): task = ( db.query(PlatformFulfillmentTask) .filter(PlatformFulfillmentTask.id == task_id) .first() ) if task is None: continue refresh_binding(db, task_id=task.id) items.append(customer_binding_out(db, task.id)) return {"items": items} async def customer_confirm_binding(db: Session, *, task_id: int) -> dict[str, Any]: refresh_binding(db, task_id=task_id) await confirm_binding(db, task_id=task_id, current=_integration_actor(db)) return customer_binding_out(db, task_id) def list_mappings(db: Session, *, keyword: str = "") -> list[dict[str, Any]]: query = db.query(PlatformCommodityMapping) text = keyword.strip() if text: pattern = f"%{text}%" query = query.filter( or_( PlatformCommodityMapping.internal_sku_key.ilike(pattern), PlatformCommodityMapping.commodity_id.ilike(pattern), PlatformCommodityMapping.goods_name.ilike(pattern), ) ) rows = query.order_by(PlatformCommodityMapping.updated_at.desc()).limit(300).all() return [ { "id": row.id, "targetPlatform": row.target_platform, "internalSkuKey": row.internal_sku_key, "commodityId": row.commodity_id, "goodsName": row.goods_name, "requiredPoints": row.required_points, "scope": row.scope, "enabled": row.enabled, "updatedAt": row.updated_at, } for row in rows ] def upsert_mapping( db: Session, *, internal_sku_key: str, commodity_id: str, goods_name: str, required_points: int | None, enabled: bool, current: User, ) -> dict[str, Any]: sku_key = internal_sku_key.strip() commodity = commodity_id.strip() if not sku_key or not commodity: raise HTTPException(status_code=400, detail="内部 SKU 和斗鱼商品 ID 不能为空") goods = ( db.query(DouyuGoodsSnapshot) .filter(DouyuGoodsSnapshot.commodity_id == commodity) .order_by(DouyuGoodsSnapshot.id.desc()) .first() ) row = ( db.query(PlatformCommodityMapping) .filter( PlatformCommodityMapping.target_platform == TARGET_PLATFORM, PlatformCommodityMapping.internal_sku_key == sku_key, ) .first() ) if row is None: row = PlatformCommodityMapping( target_platform=TARGET_PLATFORM, internal_sku_key=sku_key, created_by=current.id, created_at=_now(), ) db.add(row) row.commodity_id = commodity row.goods_name = (goods_name or (goods.name if goods else "")).strip() row.required_points = ( int(required_points) if required_points is not None else (int(goods.score) if goods and goods.score is not None else None) ) row.scope = SCOPE_ELITE row.enabled = bool(enabled) row.updated_at = _now() db.flush() pending = ( db.query(PlatformFulfillmentTask) .filter( PlatformFulfillmentTask.internal_sku_key == sku_key, PlatformFulfillmentTask.execution_status.in_( ["pending_mapping", "ready", "manual_required"] ), ) .all() ) for task in pending: _apply_mapping(task, row if row.enabled else None) task.updated_at = _now() _append_event( db, task.id, "mapping_updated", actor_type="user", actor_id=current.id, detail={"commodityId": row.commodity_id, "enabled": row.enabled}, ) db.commit() return next( item for item in list_mappings(db, keyword=sku_key) if item["id"] == row.id ) def allocate_task(db: Session, *, task_id: int, current: User) -> dict[str, Any]: task = _load_task(db, task_id) if task.execution_status in {"completed", "cancelled"}: raise HTTPException(status_code=409, detail="已结束任务不能重新分配账号") if not task.commodity_id or not task.required_points: raise HTTPException(status_code=409, detail="请先完成商品映射") required_points = int(task.required_points) if task.account_id and task.lease_id: lease = db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if lease and lease.status == "active": return get_task_detail(db, task.id) config = ensure_douyu_config(db) lease_duration_minutes = _lease_duration_minutes(db) manual_id = str(douyu_config_value("manual_id", config.manual_id)) rid = str(douyu_config_value("rid", config.rid)) act_alias = str(douyu_config_value("bind_act_alias", config.bind_act_alias)) # 单次最多实时检测 5 个,避免一次选号请求被外部接口拖到超时。 # 检测时间会写回 ck_checked_at,下一次点击自动轮到下一批。 candidates = live_candidate_accounts(db, limit=5) diagnostics: list[dict[str, Any]] = [] qualified: list[tuple[Account, DouyuLiveAccountState]] = [] selected: AccountCandidate | None = None selected_state: DouyuLiveAccountState | None = None lease = None for account in candidates: live_state = refresh_douyu_account_state( db, account, manual_id=manual_id, rid=rid, act_alias=act_alias, ) reasons = live_state.blocking_reasons(commodity_id=task.commodity_id) if has_recent_exchange( db, account_id=int(account.id), commodity_id=task.commodity_id, ): reasons.append("365 天内已有该商品兑换事件") if reasons: diagnostics.append( { "accountId": int(account.id), "accountName": live_state.account_name, "ck": live_state.ck_verdict, "eliteOpened": live_state.elite_opened, "points": live_state.points, "reasons": reasons, } ) continue qualified.append((account, live_state)) # 积分和宝典开通不淘汰账号,只影响后续处理成本。优先选已经可直接兑换的账号, # 其次是只需充值、只需开通、两者都需要的账号。 qualified.sort( key=lambda item: ( item[1].readiness_rank(required_points=required_points), int(item[1].points or 0), int(item[0].id), ) ) for account, live_state in qualified: candidate = AccountCandidate( account_id=int(account.id), username=str(account.username or ""), nickname=str(account.nickname or ""), points=int(live_state.points or 0), gold_balance=account.gold_balance, points_expire_at=account.points_expire_at, role_change_available_at=live_state.role_change_available_at, ) lease = lease_account( db, candidate=candidate, holder_user_id=current.id, task_id=task.id, commodity_id=task.commodity_id, ttl_minutes=lease_duration_minutes, ) if lease is not None: selected = candidate selected_state = live_state break diagnostics.append( { "accountId": int(account.id), "accountName": live_state.account_name, "ck": live_state.ck_verdict, "eliteOpened": live_state.elite_opened, "points": live_state.points, "reasons": ["账号刚被其他任务占用"], } ) if selected is None or selected_state is None or lease is None: task.execution_status = "ready" task.issue_code = "no_eligible_account" if not candidates: task.last_error = "没有带 CK、允许自动管理且未停用的斗鱼账号" else: summary = ";".join( f"{item['accountName']}: {', '.join(item['reasons'][:3])}" for item in diagnostics[:5] ) task.last_error = ( f"已实时检测 {len(diagnostics)} 个账号,当前没有可用账号" + (f"。{summary}" if summary else "") )[:500] task.updated_at = _now() _append_event( db, task.id, "account_allocation_failed", detail={ "candidateCount": len(candidates), "diagnostics": diagnostics, }, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) task.account_id = selected.account_id task.lease_id = lease.id task.operator_id = current.id task.execution_status = "allocated" task.binding_status = "not_started" soft_reasons = selected_state.soft_requirement_reasons( required_points=required_points ) if task.commodity_id in selected_state.limited_ids: task.exchange_status = "limited" task.issue_code = "commodity_limit_reached" task.last_error = "该账号已达到此商品兑换上限" elif selected_state.elite_opened is not True: task.exchange_status = "not_opened" task.issue_code = "elite_not_opened" task.last_error = "账号尚未开通精英宝典,可开通后继续" elif selected_state.points is None or selected_state.points < required_points: task.exchange_status = "points_short" task.issue_code = "points_short" task.last_error = "账号积分不足,可充值后继续" else: task.exchange_status = "eligible" task.issue_code = "" task.last_error = "" task.updated_at = _now() _append_event( db, task.id, "account_allocated", actor_type="user", actor_id=current.id, detail={ "accountId": selected.account_id, "accountName": selected.display_name, "points": selected.points, "eliteOpened": selected_state.elite_opened, "softReasons": soft_reasons, "exchangeStatus": task.exchange_status, }, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def release_task_account( db: Session, *, task_id: int, current: User, reason: str = "manual_release", ) -> dict[str, Any]: task = _load_task(db, task_id) lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) release_lease(db, lease, reason=reason) task.account_id = None task.lease_id = None task.bind_task_id = None task.execution_status = "ready" task.binding_status = "not_started" task.exchange_status = "not_started" task.issue_code = "" task.last_error = "" task.updated_at = _now() _append_event( db, task.id, "account_released", actor_type="user", actor_id=current.id, detail={"reason": reason}, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def reset_task_binding( db: Session, *, task_id: int, current: User, reason: str = "客服重置角色绑定", ) -> dict[str, Any]: """清空本单旧绑定与客户资料,保留账号租约供客户重新扫码。""" task = _load_task(db, task_id) if task.execution_status in {"completed", "cancelled"}: raise HTTPException(status_code=409, detail="已结束任务不能重置绑定") if task.binding_status != "failed": raise HTTPException( status_code=409, detail="只有绑定失败的任务可以重置角色资料" ) if not task.account_id or not task.lease_id: raise HTTPException(status_code=409, detail="当前任务没有可保留的履约账号") lease = db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if lease is None or lease.status != "active": raise HTTPException( status_code=409, detail="账号租约已失效,请释放账号后重新选号" ) previous_bind_task_id = task.bind_task_id previous_bind_task = ( db.query(DouyuTask).filter(DouyuTask.id == previous_bind_task_id).first() if previous_bind_task_id else None ) if previous_bind_task and previous_bind_task.status in { "planned", "pending", "running", }: raise HTTPException(status_code=409, detail="当前绑定任务仍在执行,不能重置") previous_binding_status = task.binding_status previous_issue_code = task.issue_code task.bind_task_id = None task.binding_status = "not_started" task.execution_status = "allocated" task.exchange_status = "not_started" task.issue_code = "" task.last_error = "" task.operator_id = current.id task.updated_at = _now() renew_lease(db, lease, ttl_minutes=_lease_duration_minutes(db)) _append_event( db, task.id, "binding_reset", actor_type="user", actor_id=current.id, detail={ "reason": reason.strip()[:1000], "previousBindTaskId": previous_bind_task_id, "previousBindingStatus": previous_binding_status, "previousIssueCode": previous_issue_code, "customerProfileReset": True, }, ) _emit_order_site_binding_state( db, task.id, extra={ "customerProfileReset": True, "resetReason": reason.strip()[:1000], }, ) db.commit() return get_task_detail(db, task.id) async def start_binding( db: Session, *, task_id: int, current: User, force_refresh: bool = False, ) -> dict[str, Any]: task = _load_task(db, task_id) if not task.account_id or not task.lease_id: raise HTTPException(status_code=409, detail="请先分配账号") lease = db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if lease is None or lease.status != "active": raise HTTPException(status_code=409, detail="账号租约已失效,请重新分配") if task.bind_task_id: existing = db.query(DouyuTask).filter(DouyuTask.id == task.bind_task_id).first() if existing: result = existing.result or {} if bool(result.get("bind_confirmed")) or bool( result.get("bind_ready_for_confirm") ): return get_task_detail(db, task.id) if existing.status in {"planned", "pending", "running"}: return get_task_detail(db, task.id) if existing.status == "success" and not _binding_qr_expired(existing): return get_task_detail(db, task.id) if not force_refresh and existing.status not in { "success", "failed", "error", "stopped", }: return get_task_detail(db, task.id) batch_id = f"pfbind-{task.id}-{uuid.uuid4().hex[:8]}" bind_task = DouyuTask( batch_id=batch_id, account_id=task.account_id, account_assigned_to=current.id, task_type="get_bind_qr", handbook_scope="elite", status="planned", message="等待生成绑定二维码", result={"payload": {}}, created_by=current.id, ) db.add(bind_task) db.flush() task.bind_task_id = bind_task.id task.binding_status = "preparing" task.execution_status = "waiting_bind" task.issue_code = "" task.last_error = "" task.operator_id = current.id task.updated_at = _now() renew_lease( db, lease, ttl_minutes=_lease_duration_minutes(db), ) _append_event( db, task.id, "binding_started", actor_type="user", actor_id=current.id, detail={"bindTaskId": bind_task.id}, ) _emit_order_site_binding_state(db, task.id) db.commit() start_douyu_batch( batch_id=batch_id, task_type="get_bind_qr", payload={}, concurrency=1, ) return get_task_detail(db, task.id) def refresh_binding(db: Session, *, task_id: int) -> dict[str, Any]: task = _load_task(db, task_id) if task.execution_status in {"completed", "cancelled"}: return get_task_detail(db, task.id) if not task.bind_task_id: return get_task_detail(db, task.id) bind_task = db.query(DouyuTask).filter(DouyuTask.id == task.bind_task_id).first() if bind_task is None: return get_task_detail(db, task.id) before = ( task.binding_status, task.execution_status, task.exchange_status, task.issue_code, task.last_error, ) result = bind_task.result or {} if bind_task.status in {"failed", "error", "stopped"}: task.binding_status = "failed" task.execution_status = "manual_required" task.issue_code = _binding_failure_issue(bind_task, result) task.last_error = _customer_task_message(task) elif bool(result.get("bind_confirmed")): task.binding_status = "bound" task.execution_status = "bound" task.issue_code = "" task.last_error = "" elif bool(result.get("bind_ready_for_confirm")) or result.get("role_name"): task.binding_status = "role_ready" task.execution_status = "role_ready" task.issue_code = "" task.last_error = "" elif result.get("url"): task.binding_status = "qr_pending" task.execution_status = "waiting_bind" task.issue_code = "" task.last_error = "" after = ( task.binding_status, task.execution_status, task.exchange_status, task.issue_code, task.last_error, ) if after != before: task.updated_at = _now() if task.binding_status == "failed": _append_event( db, task.id, "binding_failed", detail={ "issueCode": task.issue_code, "bindTaskId": bind_task.id, "bindPhase": str(result.get("bind_phase") or ""), "rawError": str(bind_task.message or "")[:1000], }, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def sync_task_from_binding_runner(db: Session, *, douyu_task_id: int) -> int: """斗鱼绑定任务落库后,把关联履约任务和 Outbox 一并刷新。""" task_ids = [ int(row.id) for row in ( db.query(PlatformFulfillmentTask.id) .filter(PlatformFulfillmentTask.bind_task_id == int(douyu_task_id)) .all() ) ] for task_id in task_ids: refresh_binding(db, task_id=task_id) return len(task_ids) def reconcile_binding_state_outbox(db: Session, *, limit: int = 500) -> int: """低频补齐 active 任务当前快照;只会在缺失或 dead 时重新入队。""" task_ids = [ int(row.id) for row in ( db.query(PlatformFulfillmentTask.id) .filter( PlatformFulfillmentTask.execution_status.notin_( ["completed", "cancelled"] ) ) .order_by(PlatformFulfillmentTask.updated_at.asc()) .limit(max(1, min(limit, 500))) .all() ) ] queued = sum( 1 for task_id in task_ids if _emit_order_site_binding_state(db, task_id) ) db.commit() return queued async def confirm_binding( db: Session, *, task_id: int, current: User ) -> dict[str, Any]: task = _load_task(db, task_id) task = _load_task(db, refresh_binding(db, task_id=task.id)["task"]["id"]) if task.binding_status != "role_ready": raise HTTPException(status_code=409, detail="当前没有待确认的游戏角色") if not task.account_id or not task.lease_id: raise HTTPException(status_code=409, detail="账号租约不存在") lease = db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if lease is None or lease.status != "active": raise HTTPException(status_code=409, detail="账号租约已失效") current_bind_task = ( db.query(DouyuTask).filter(DouyuTask.id == task.bind_task_id).first() if task.bind_task_id else None ) current_bind_result = (current_bind_task.result or {}) if current_bind_task else {} expected_role_name = str(current_bind_result.get("role_name") or "").strip() baseline_role_name = str(current_bind_result.get("current_role_name") or "").strip() batch_id = f"pfconfirm-{task.id}-{uuid.uuid4().hex[:8]}" confirm_task = DouyuTask( batch_id=batch_id, account_id=task.account_id, account_assigned_to=current.id, task_type="confirm_bind", handbook_scope="elite", status="planned", message="等待确认角色绑定", result={ "payload": {}, "expected_role_name": expected_role_name, "baseline_role_name": baseline_role_name, }, created_by=current.id, ) db.add(confirm_task) db.flush() task.bind_task_id = confirm_task.id task.binding_status = "confirming" task.execution_status = "binding_confirming" task.operator_id = current.id task.updated_at = _now() renew_lease(db, lease, ttl_minutes=_lease_duration_minutes(db)) _append_event( db, task.id, "binding_confirm_started", actor_type="user", actor_id=current.id, detail={"confirmTaskId": confirm_task.id}, ) _emit_order_site_binding_state(db, task.id) db.commit() start_douyu_batch( batch_id=batch_id, task_type="confirm_bind", payload={}, concurrency=1, ) return get_task_detail(db, task.id) def refresh_exchange_eligibility( db: Session, *, task_id: int, current: User ) -> dict[str, Any]: task = _load_task(db, task_id) if task.binding_status != "bound": raise HTTPException(status_code=409, detail="请先确认游戏角色绑定") account = db.query(Account).filter(Account.id == task.account_id).first() if account is None or not account.cookie: raise HTTPException(status_code=409, detail="账号 CK 不可用") config = ensure_douyu_config(db) try: cookie = str(account.cookie) client = activity_client(cookie) eligibility = query_exchange_eligibility( client, cookie=cookie, manual_id=str(douyu_config_value("manual_id", config.manual_id)), rid=str(douyu_config_value("rid", config.rid)), uid=str(account.uid or ""), ) account.elite_opened = bool(eligibility.elite_user_info.get("manual_type")) account.points = eligibility.points except Exception as exc: # noqa: BLE001 外部接口错误要落成可重试的检查失败 task.execution_status = "manual_required" task.exchange_status = "check_failed" task.issue_code = "eligibility_check_failed" task.last_error = str(exc) task.updated_at = _now() _append_event( db, task.id, "eligibility_check_failed", actor_type="user", actor_id=current.id, detail={"error": str(exc)}, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) if task.commodity_id in eligibility.limited_ids: task.exchange_status = "limited" task.issue_code = "commodity_limit_reached" task.last_error = "该账号已达到此商品兑换上限" elif not account.elite_opened: task.exchange_status = "not_opened" task.issue_code = "elite_not_opened" task.last_error = "该账号精英宝典未开通" elif task.required_points and int(account.points or 0) < int(task.required_points): task.exchange_status = "points_short" task.issue_code = "points_short" task.last_error = "该账号精英积分不足,需人工充值" else: task.exchange_status = "eligible" task.issue_code = "" task.last_error = "" # 积分不足、未开通和限兑都不是流程终点:角色已经绑定,账号继续保留, # 后续充值/开通/解除限兑后刷新资格即可。 task.execution_status = "bound" task.updated_at = _now() account.updated_at = _now() _append_event( db, task.id, "exchange_eligibility_checked", actor_type="user", actor_id=current.id, detail={ "exchangeStatus": task.exchange_status, "limitedCount": len(eligibility.limited_ids), }, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def complete_manual_exchange( db: Session, *, task_id: int, current: User, note: str = "", ) -> dict[str, Any]: task = _load_task(db, task_id) if task.binding_status != "bound": raise HTTPException(status_code=409, detail="游戏角色尚未确认绑定") if task.exchange_status not in {"eligible", "manual_done"}: raise HTTPException( status_code=409, detail="当前兑换资格不是可兑换状态,请先刷新检查结果", ) lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) task.exchange_status = "manual_done" task.execution_status = "completed" task.completed_at = _now() task.operator_id = current.id task.last_error = "" task.issue_code = "" task.updated_at = _now() release_lease(db, lease, reason="manual_exchange_completed") _append_event( db, task.id, "manual_exchange_completed", actor_type="user", actor_id=current.id, detail={"note": note[:1000]}, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def mark_manual_required( db: Session, *, task_id: int, current: User, reason: str, ) -> dict[str, Any]: task = _load_task(db, task_id) task.execution_status = "manual_required" task.operator_id = current.id task.last_error = reason.strip()[:2000] task.issue_code = task.issue_code or "manual_required" task.updated_at = _now() _append_event( db, task.id, "marked_manual_required", actor_type="user", actor_id=current.id, detail={"reason": task.last_error}, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) def cancel_task( db: Session, *, task_id: int, current: User, reason: str, ) -> dict[str, Any]: task = _load_task(db, task_id) if task.execution_status == "cancelled": return get_task_detail(db, task.id) if task.execution_status == "completed": raise HTTPException(status_code=409, detail="已完成任务不能取消") account_id = task.account_id lease_id = task.lease_id lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) linked_tasks = ( db.query(DouyuTask) .filter( DouyuTask.id.in_( [value for value in [task.bind_task_id, task.exchange_task_id] if value] ) ) .all() if task.bind_task_id or task.exchange_task_id else [] ) stopped_batches = stop_douyu_batches( [str(linked_task.batch_id or "") for linked_task in linked_tasks] ) for linked_task in linked_tasks: if linked_task.status in {"planned", "pending", "running"}: linked_task.status = "stopped" linked_task.message = "履约任务已取消" linked_task.finished_at = _now() release_lease(db, lease, reason="platform_fulfillment_cancelled") task.account_id = None task.lease_id = None task.bind_task_id = None task.exchange_task_id = None task.binding_status = "not_started" task.execution_status = "cancelled" task.exchange_status = "not_started" task.issue_code = "" task.operator_id = current.id task.last_error = reason.strip()[:2000] task.updated_at = _now() _append_event( db, task.id, "task_cancelled", actor_type="user", actor_id=current.id, detail={ "reason": task.last_error, "releasedAccountId": account_id, "releasedLeaseId": lease_id, "stoppedBatches": stopped_batches, }, ) _emit_order_site_binding_state(db, task.id) db.commit() return get_task_detail(db, task.id) __all__ = [ "allocate_task", "cancel_task", "complete_manual_exchange", "confirm_binding", "customer_refresh_bindings", "get_task_detail", "list_mappings", "list_tasks", "mark_manual_required", "reconcile_binding_state_outbox", "refresh_binding", "refresh_exchange_eligibility", "release_task_account", "reset_task_binding", "start_binding", "sync_pending_tasks", "sync_pending_tasks_if_due", "sync_task_from_binding_runner", "upsert_mapping", ]