Files
live-hub-py/web/backend/services/platform_fulfillment/service.py
T

1352 lines
45 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""直播账号履约作业服务:订单同步、映射、选号、绑码和人工完成。"""
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
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 notify_order_site_binding_state_async
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 = 60.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 _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 sync_pending_tasks(db: Session, *, limit: int = 100) -> dict[str, Any]:
"""串行同步订单,避免自动同步与人工同步并发创建重复任务。"""
with _SYNC_LOCK:
return _sync_pending_tasks(db, limit=limit)
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)
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": "绑定失败,请刷新二维码后重试",
"eligibility_check_failed": "状态查询异常,请稍后刷新",
"manual_required": "当前需要人工处理,请联系客服",
}
return messages.get(task.issue_code, "") if task.issue_code else ""
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")
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")),
"bindConfirmed": bool(bind_result.get("bind_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,
},
)
db.commit()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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},
)
db.commit()
notify_order_site_binding_state_async(task.id)
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)
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_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.issue_code = ""
task.last_error = ""
task.updated_at = _now()
db.commit()
after = (
task.binding_status,
task.execution_status,
task.exchange_status,
task.issue_code,
task.last_error,
)
if after != before:
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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()
notify_order_site_binding_state_async(task.id)
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",
"refresh_binding",
"refresh_exchange_eligibility",
"release_task_account",
"start_binding",
"sync_pending_tasks",
"sync_pending_tasks_if_due",
"upsert_mapping",
]