Files
live-hub-py/web/backend/services/platform_fulfillment/service.py
T
yml 0220ef995f refactor(douyu): 统一活动查询与直播商品映射
- 收口斗鱼活动、商品、绑定信息和兑换资格查询
- 工作台改为复用统一客户端、快照与实时商品目录
- 补充活动查询与商品映射测试
2026-11-18 10:59:20 +08:00

904 lines
28 KiB
Python

"""直播账号履约作业服务:订单同步、映射、选号、绑码和人工完成。"""
from __future__ import annotations
import uuid
from datetime import UTC, datetime
from typing import Any
from fastapi import HTTPException
from sqlalchemy import or_
from sqlalchemy.orm import Session
from core.douyu import DouyuActivityError
from ...models import (
Account,
AccountLease,
DouyuGoodsSnapshot,
DouyuTask,
PlatformCommodityMapping,
PlatformFulfillmentEvent,
PlatformFulfillmentTask,
User,
)
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 (
BINDING_LEASE_MINUTES,
VALIDATION_LEASE_MINUTES,
eligible_accounts,
lease_account,
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 _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="请先完成商品映射")
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)
candidates = eligible_accounts(
db,
commodity_id=task.commodity_id,
required_points=task.required_points,
limit=20,
)
selected = None
lease = None
for candidate in candidates:
lease = lease_account(
db,
candidate=candidate,
holder_user_id=current.id,
task_id=task.id,
commodity_id=task.commodity_id,
ttl_minutes=VALIDATION_LEASE_MINUTES,
)
if lease is not None:
selected = candidate
break
if selected is None or lease is None:
task.execution_status = "ready"
task.issue_code = "no_eligible_account"
task.last_error = "当前没有满足 CK、积分、限兑和换绑条件的斗鱼账号"
task.updated_at = _now()
_append_event(db, task.id, "account_allocation_failed")
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"
task.exchange_status = "not_started"
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,
},
)
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=BINDING_LEASE_MINUTES,
)
_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=BINDING_LEASE_MINUTES)
_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 DouyuActivityError as exc:
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 = (
"manual_required" if task.exchange_status != "eligible" else "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",
]