1628 lines
54 KiB
Python
1628 lines
54 KiB
Python
"""直播账号履约作业服务:订单同步、映射、选号、绑码和人工完成。"""
|
||
|
||
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",
|
||
]
|