"""直播账号履约作业服务:订单同步、映射、选号、绑码和人工完成。""" from __future__ import annotations import uuid from datetime import UTC, datetime, timedelta 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 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, ) TARGET_PLATFORM = "douyu" SCOPE_ELITE = "elite" ACTIVE_STATUSES = { "ready", "allocated", "waiting_bind", "role_ready", "binding_confirming", "bound", "manual_required", } 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 _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 _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) -> dict[str, Any]: """从 order_site 拉取人工待履约订单项并幂等生成本地作业。""" try: rows = list_pending_manual_fulfillments(limit=limit) except OrderLookupUnavailable as exc: raise HTTPException(status_code=503, detail=f"订单源不可用:{exc}") from exc created = 0 updated = 0 for row in rows: item_id = str(row.get("source_order_item_id") or "") if not item_id: 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 = str(row.get("internal_sku_key") or "") 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_for_sku(db, task.internal_sku_key)) db.commit() return {"fetched": len(rows), "created": created, "updated": updated} def list_tasks( db: Session, *, status: str = "", keyword: str = "", page: int = 1, page_size: int = 20, ) -> dict[str, Any]: query = db.query(PlatformFulfillmentTask) 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 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, }, ) 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, }, ) 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}, ) db.commit() return get_task_detail(db, task.id) async def start_binding(db: Session, *, task_id: int, current: User) -> 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 and existing.status in {"planned", "pending", "running", "success"}: 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.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}, ) 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 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) 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_failed" task.last_error = bind_task.message or "绑定任务失败" 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.updated_at = _now() db.commit() return get_task_detail(db, task.id) 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="账号租约已失效") 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": {}}, 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}, ) 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)}, ) 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), }, ) 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]}, ) 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}, ) 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) lease = ( db.query(AccountLease).filter(AccountLease.id == task.lease_id).first() if task.lease_id else None ) release_lease(db, lease, reason="platform_fulfillment_cancelled") task.execution_status = "cancelled" 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}, ) db.commit() return get_task_detail(db, task.id) __all__ = [ "allocate_task", "cancel_task", "complete_manual_exchange", "confirm_binding", "get_task_detail", "list_mappings", "list_tasks", "mark_manual_required", "refresh_binding", "refresh_exchange_eligibility", "release_task_account", "start_binding", "sync_pending_tasks", "upsert_mapping", ]