From 1a49bcd481e4d57e93e5365c73a18de57bf320f6 Mon Sep 17 00:00:00 2001 From: yml Date: Fri, 20 Nov 2026 01:55:25 +0800 Subject: [PATCH] feat(douyu): unify account probes and lifecycle writes Centralize Douyu client creation, CK session probing, identity refresh, role alias resolution, capability persistence, cache and batch throttling across collaboration, fulfillment, tasks and cookie management. Add the account-name copy action in the collaboration table. --- .env.example | 2 + docker-compose.yml | 2 + tests/test_douyu_account_probe.py | 225 ++++ tests/test_douyu_activity_query.py | 83 +- tests/test_platform_fulfillment.py | 58 +- web/backend/routers/cookies.py | 63 +- web/backend/routers/douyu_collab.py | 15 +- web/backend/schemas.py | 2 + .../services/automation/jobs/ck_health.py | 52 +- web/backend/services/cookie_check_service.py | 2 + web/backend/services/douyu_account_probe.py | 1035 +++++++++++++++++ web/backend/services/douyu_account_state.py | 239 +--- web/backend/services/douyu_activity_query.py | 134 +-- web/backend/services/douyu_collab_service.py | 295 +++-- web/backend/services/douyu_runner.py | 40 +- web/backend/services/douyu_runner_bind.py | 261 +++-- web/backend/services/douyu_runner_core.py | 5 +- web/backend/services/douyu_runner_overview.py | 103 +- web/backend/services/douyu_runner_xpd.py | 21 +- web/backend/services/douyu_service.py | 9 +- web/backend/services/login_service.py | 46 +- .../services/platform_fulfillment/service.py | 65 +- web/frontend/src/api/douyuCollab.ts | 2 + web/frontend/src/pages/DouyuCollabPage.tsx | 42 +- 24 files changed, 2162 insertions(+), 639 deletions(-) create mode 100644 tests/test_douyu_account_probe.py create mode 100644 web/backend/services/douyu_account_probe.py diff --git a/.env.example b/.env.example index 79fd62d..fd8cf19 100644 --- a/.env.example +++ b/.env.example @@ -74,6 +74,8 @@ DB_LOCK_WAIT_TIMEOUT=10 DOUYU_BATCH_CREATE_CONCURRENCY=2 DOUYU_MAX_ACTIVE_BATCHES=20 DOUYU_MAX_ACTIVE_TASKS=250 +DOUYU_PROBE_CACHE_SECONDS=30 +DOUYU_COLLAB_VERIFY_BATCH_INTERVAL_SECONDS=0.2 # Cookie 安全标志(生产环境 HTTPS 部署时设为 true) COOKIE_SECURE=false diff --git a/docker-compose.yml b/docker-compose.yml index 59a1cb7..95fff68 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -44,6 +44,8 @@ services: - DOUYU_BATCH_CREATE_CONCURRENCY=${DOUYU_BATCH_CREATE_CONCURRENCY:-2} - DOUYU_MAX_ACTIVE_BATCHES=${DOUYU_MAX_ACTIVE_BATCHES:-20} - DOUYU_MAX_ACTIVE_TASKS=${DOUYU_MAX_ACTIVE_TASKS:-250} + - DOUYU_PROBE_CACHE_SECONDS=${DOUYU_PROBE_CACHE_SECONDS:-30} + - DOUYU_COLLAB_VERIFY_BATCH_INTERVAL_SECONDS=${DOUYU_COLLAB_VERIFY_BATCH_INTERVAL_SECONDS:-0.2} # JWT 密钥(生产环境务必修改,可用 python -c "import secrets; print(secrets.token_urlsafe(32))" 生成) - JWT_SECRET_KEY=${JWT_SECRET_KEY:-} # 后台登录滑动会话:24h 空闲过期,7d 绝对上限。 diff --git a/tests/test_douyu_account_probe.py b/tests/test_douyu_account_probe.py new file mode 100644 index 0000000..6287153 --- /dev/null +++ b/tests/test_douyu_account_probe.py @@ -0,0 +1,225 @@ +"""斗鱼统一账号探针:能力分离、alias 选择和写回保护。""" + +from __future__ import annotations + +from datetime import UTC, datetime + +from web.backend.models import Account, AccountEvent +from web.backend.services.douyu_account_probe import ( + ROLE_BOUND, + ROLE_ERROR, + ROLE_PENDING, + ROLE_UNBOUND, + ROLE_UNKNOWN, + persist_probe_result, + probe_account, + resolve_elite_role, +) + +CONFIG = { + "manual_id": "manual-id", + "rid": "room-id", + "bind_act_alias": "current-alias", + "confirm_act_alias": "current-alias", + "legacy_act_alias": "cjm", +} + + +class RoleClient: + def __init__(self, responses, errors=None): + self.responses = responses + self.errors = errors or {} + self.calls: list[str] = [] + + def bind_info(self, act_alias: str, *, v2: bool = False): + self.calls.append(act_alias) + if act_alias in self.errors: + raise RuntimeError(self.errors[act_alias]) + return self.responses.get(act_alias, {}) + + +def _bind( + role: str = "", + *, + bound_act: bool = False, + bound_role: bool = False, + need_act: bool = True, + need_role: bool = True, +): + return { + "is_bound_act": bound_act, + "is_bound_role": bound_role, + "need_bind_act": need_act, + "need_bind_role": need_role, + "role_name": role, + "area_name": "微信" if role else "", + "plat_name": "安卓" if role else "", + } + + +def test_role_resolver_prefers_current_bound_and_reports_pending_legacy(): + client = RoleClient( + { + "current-alias": _bind("当前角色", bound_act=True, bound_role=True), + "cjm": _bind("新角色", bound_role=True), + } + ) + + result = resolve_elite_role(client, CONFIG) + + assert result["status"] == ROLE_BOUND + assert result["role_name"] == "当前角色" + assert result["source_alias"] == "current-alias" + assert result["pending_role_name"] == "新角色" + assert client.calls == ["current-alias", "cjm"] + + +def test_role_resolver_uses_legacy_pending_role_when_current_is_empty(): + client = RoleClient( + { + "current-alias": _bind(""), + "cjm": _bind("待确认角色", bound_role=True, need_act=False), + } + ) + + result = resolve_elite_role(client, CONFIG) + + assert result["status"] == ROLE_PENDING + assert result["role_name"] == "待确认角色" + assert result["source_alias"] == "cjm" + + +def test_role_resolver_partial_failure_does_not_claim_unbound(): + client = RoleClient( + { + "current-alias": _bind(""), + "cjm": _bind(""), + }, + errors={"current-alias": "登录已失效"}, + ) + + result = resolve_elite_role(client, CONFIG) + + assert result["status"] == ROLE_UNKNOWN + assert result["errors"] + + +def test_role_resolver_official_empty_is_explicitly_unbound(): + client = RoleClient( + { + "current-alias": _bind(""), + "cjm": _bind(""), + } + ) + + result = resolve_elite_role(client, CONFIG) + + assert result["status"] == ROLE_UNBOUND + assert result["role_name"] == "" + + +class ProbeClient: + def __init__(self): + self.calls = 0 + + def elite_user_info(self, **_kwargs): + self.calls += 1 + return { + "manual_type": 1, + "manual_score": 100, + "expire_time": 0, + "user_info": {"nickname": "精英昵称"}, + } + + def bind_info(self, act_alias: str, *, v2: bool = False): + self.calls += 1 + return _bind("角色A", bound_act=True, bound_role=True) + + +def test_probe_account_reads_identity_and_does_not_call_activity_for_invalid_ck(): + account = Account( + id=1, + username="douyu-user", + password="p", + email="u@example.com", + email_password="ep", + cookie="acf_uid=100; acf_nickname=cookie-name", + ) + valid_client = ProbeClient() + valid = probe_account( + account, + CONFIG, + client=valid_client, + session_checker=lambda _cookie: { + "valid": True, + "message": "有效", + "nickname": "会话昵称", + "checked_at": datetime.now(UTC), + }, + ) + + assert valid["session"]["status"] == "valid" + assert valid["identity"]["nickname"] == "精英昵称" + assert valid["identity"]["nickname_source"] == "elite" + assert valid["roles"]["elite"]["status"] == ROLE_BOUND + + invalid_client = ProbeClient() + invalid = probe_account( + account, + CONFIG, + client=invalid_client, + session_checker=lambda _cookie: { + "valid": False, + "message": "未登录", + "checked_at": datetime.now(UTC), + }, + ) + assert invalid["session"]["status"] == "invalid" + assert invalid_client.calls == 0 + + +def test_persist_probe_error_preserves_last_known_role(db): + account = Account( + username="preserve-role", + password="p", + email="preserve@example.com", + email_password="ep", + status="active", + cookie="acf_uid=100", + game_name="保留角色", + game_channel="微信 · 安卓", + role_bind_status=ROLE_BOUND, + ) + db.add(account) + db.commit() + + persist_probe_result( + db, + account, + { + "probe_id": "probe-error", + "identity": {"uid": "100", "username": account.username}, + "session": {}, + "elite": {}, + "eligibility": {}, + "roles": { + "elite": { + "status": ROLE_ERROR, + "errors": ["接口超时"], + } + }, + "gold": {}, + "goods": {}, + "errors": {"elite_role": "接口超时"}, + }, + source="test.role_error", + record_event=True, + commit=True, + ) + + db.refresh(account) + assert account.game_name == "保留角色" + assert account.role_bind_status == ROLE_BOUND + event = db.query(AccountEvent).filter_by(event_type="account_probe").one() + assert event.detail["probe_id"] == "probe-error" + assert event.detail["role"] == ROLE_ERROR diff --git a/tests/test_douyu_activity_query.py b/tests/test_douyu_activity_query.py index 7deb13e..c7d58ad 100644 --- a/tests/test_douyu_activity_query.py +++ b/tests/test_douyu_activity_query.py @@ -7,9 +7,9 @@ from pathlib import Path from typing import cast from core.douyu import DouyuActivityClient -from web.backend.models import User +from web.backend.models import Account, User from web.backend.routers import douyu as douyu_api -from web.backend.services import douyu_activity_query as query +from web.backend.services.douyu_account_probe import probe_account READ_METHODS = { "acf_ccn", @@ -70,19 +70,33 @@ class FakeActivityClient: } -def test_exchange_eligibility_is_normalized_once(): +def test_account_probe_normalizes_exchange_eligibility_once(): client = FakeActivityClient() - - result = query.query_exchange_eligibility( - cast(DouyuActivityClient, client), + account = Account( + id=1, + username="probe-account", + password="p", + email="probe@example.com", + email_password="ep", + uid="100", cookie="acf_uid=100; acf_nickname=test", - manual_id="manual-1", - rid="room-1", ) - assert result.elite_user_info["manual_type"] == 1 - assert result.points == 5200 - assert result.limited_ids == frozenset({"limited-1"}) + result = probe_account( + account, + { + "manual_id": "manual-1", + "rid": "room-1", + }, + client=cast(DouyuActivityClient, client), + session_checker=None, + with_elite_role=False, + with_eligibility=True, + ) + + assert result["elite"]["raw"]["manual_type"] == 1 + assert result["eligibility"]["points"] == 5200 + assert result["eligibility"]["limited_ids"] == ["limited-1"] assert client.calls == [ "acf_ccn", "elite_user_info", @@ -141,3 +155,50 @@ def test_douyu_read_queries_only_call_client_from_shared_module(): ) assert violations == [] + + +def test_douyu_client_factory_and_role_query_stay_centralized(): + backend = Path(__file__).parents[1] / "web" / "backend" + client_factory = backend / "services" / "douyu_activity_query.py" + role_probe = backend / "services" / "douyu_account_probe.py" + constructor_violations: list[str] = [] + role_query_violations: list[str] = [] + lifecycle_write_violations: list[str] = [] + + for path in [ + *backend.glob("services/douyu_*.py"), + *backend.glob("routers/douyu*.py"), + ]: + tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path)) + for node in ast.walk(tree): + if not isinstance(node, ast.Call): + continue + func = node.func + if ( + isinstance(func, ast.Name) + and func.id == "DouyuActivityClient" + and path != client_factory + ): + constructor_violations.append( + f"{path.relative_to(backend)}:{node.lineno}" + ) + if ( + isinstance(func, ast.Name) + and func.id == "query_bind_info" + and path != role_probe + ): + role_query_violations.append( + f"{path.relative_to(backend)}:{node.lineno}" + ) + if ( + isinstance(func, ast.Name) + and func.id == "on_ck_verdict" + and path != role_probe + ): + lifecycle_write_violations.append( + f"{path.relative_to(backend)}:{node.lineno}" + ) + + assert constructor_violations == [] + assert role_query_violations == [] + assert lifecycle_write_violations == [] diff --git a/tests/test_platform_fulfillment.py b/tests/test_platform_fulfillment.py index 862370e..f50aa0b 100644 --- a/tests/test_platform_fulfillment.py +++ b/tests/test_platform_fulfillment.py @@ -34,7 +34,6 @@ from web.backend.services.automation.jobs import ( platform_fulfillment_lease_reaper as reaper, ) from web.backend.services.douyu_account_state import DouyuLiveAccountState -from web.backend.services.douyu_activity_query import DouyuEligibilityResult from web.backend.services.platform_fulfillment import account_selector, service NOW = datetime.now(UTC).replace(microsecond=0) @@ -2145,14 +2144,26 @@ class TestBindingAndCompletion(_Base): self.session.commit() monkeypatch.setattr( service, - "query_exchange_eligibility", - lambda *_args, **_kwargs: DouyuEligibilityResult( - elite_user_info={"manual_type": 1}, - points=100, - points_response={"points": 100}, - limited_goods=[], - limited_ids=frozenset(), - ), + "probe_account", + lambda *_args, **_kwargs: { + "probe_id": "points-short", + "session": {"status": "valid", "message": "有效"}, + "elite": { + "status": "ok", + "raw": {"manual_type": 1}, + "manual_type": 1, + "manual_score": 100, + "opened": True, + }, + "eligibility": { + "points": 100, + "points_response": {"points": 100}, + "limited_ids": [], + "limited_goods": [], + }, + "roles": {}, + "errors": {}, + }, ) detail = service.refresh_exchange_eligibility( @@ -2175,14 +2186,27 @@ class TestBindingAndCompletion(_Base): self.session.commit() monkeypatch.setattr( service, - "query_exchange_eligibility", - lambda *_args, **_kwargs: DouyuEligibilityResult( - elite_user_info={"manual_type": 1, "expire_time": 1}, - points=2000, - points_response={"points": 2000}, - limited_goods=[], - limited_ids=frozenset(), - ), + "probe_account", + lambda *_args, **_kwargs: { + "probe_id": "expired-elite", + "session": {"status": "valid", "message": "有效"}, + "elite": { + "status": "ok", + "raw": {"manual_type": 1, "expire_time": 1}, + "manual_type": 1, + "manual_score": 2000, + "expire_time": 1, + "opened": False, + }, + "eligibility": { + "points": 2000, + "points_response": {"points": 2000}, + "limited_ids": [], + "limited_goods": [], + }, + "roles": {}, + "errors": {}, + }, ) detail = service.refresh_exchange_eligibility( diff --git a/web/backend/routers/cookies.py b/web/backend/routers/cookies.py index d47cef7..c30cc65 100644 --- a/web/backend/routers/cookies.py +++ b/web/backend/routers/cookies.py @@ -33,8 +33,9 @@ from ..models import Account, AuditLog, LoginTask, User from ..models import ProxyConfig as ProxyConfigModel from ..permissions import get_user_permissions, user_has_permission from ..schemas import CookieReloginRequest -from ..services.account_lifecycle import on_ck_cleared, on_ck_verdict +from ..services.account_lifecycle import on_ck_cleared from ..services.cookie_check_service import check_douyu_cookie +from ..services.douyu_account_probe import persist_probe_result, probe_session from ..services.douyu_service import ( LOGIN_ATTEMPT_IN_FLIGHT_STATUSES, cookie_holding_filter, @@ -117,9 +118,13 @@ def _relogin_display(account: Account, in_flight_batch_id: str = "") -> dict: def _check_one_cookie(account: Account) -> dict: """将共享检测结果补充为 CK 记录的接口返回格式。""" - result = check_douyu_cookie(account.cookie or "") + session = probe_session(account.cookie or "", checker=check_douyu_cookie) + result = dict(session.get("detail") or {}) result["id"] = account.id - result["checked_at"] = result["checked_at"].isoformat() + result["valid"] = session["status"] == "valid" + result["message"] = session["message"] + result["checked_at"] = session["checked_at"] + result["_session_probe"] = session return result @@ -502,6 +507,12 @@ def _check_cookies(ids: str, db: Session, current: User, *, detailed: bool) -> d "nickname": None, "level": None, "checked_at": datetime.now(UTC).isoformat(), + "_session_probe": { + "status": "error", + "message": f"检测异常: {exc}", + "checked_at": datetime.now(UTC).isoformat(), + "detail": {}, + }, } ) results.sort(key=lambda item: item["id"]) @@ -513,15 +524,47 @@ def _check_cookies(ids: str, db: Session, current: User, *, detailed: bool) -> d acc = accounts_by_id.get(item["id"]) if not acc: continue - # 人工检测结论同样走统一入口(写结论 + 由好变坏记事件 + 重算状态) - on_ck_verdict( + session_probe = item.pop("_session_probe", None) + if not isinstance(session_probe, dict): + session_probe = { + "status": "valid" if item.get("valid") else "invalid", + "message": item.get("message") or "", + "checked_at": item.get("checked_at") or checked_at.isoformat(), + "detail": { + "valid": bool(item.get("valid")), + "message": item.get("message") or "", + "fish_ball": item.get("fish_ball"), + "nickname": item.get("nickname"), + "level": item.get("level"), + "checked_at": item.get("checked_at") or checked_at, + }, + } + # 人工检测走统一探针落库:CK 能力、生命周期与账号时间线一次完成。 + persist_probe_result( db, acc, - "valid" if item["valid"] else "invalid", - detail=item, - occurred_at=checked_at, - actor_type="user", - actor_id=current.id, + { + "probe_id": f"ck-check:{checked_at.timestamp()}:{acc.id}", + "identity": { + "uid": acc.uid, + "username": acc.username, + "nickname": ( + (session_probe.get("detail") or {}).get("nickname") or "" + ), + "nickname_source": "session", + }, + "session": session_probe, + "elite": {}, + "eligibility": {}, + "roles": {}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + current=current, + source="account.ck_check", + record_event=True, + commit=False, ) # 审计带上账号:单个检测时可直接反查(批量时只能落到 target 文本里) db.add( diff --git a/web/backend/routers/douyu_collab.py b/web/backend/routers/douyu_collab.py index 6ea2b5d..ab146c8 100644 --- a/web/backend/routers/douyu_collab.py +++ b/web/backend/routers/douyu_collab.py @@ -7,6 +7,8 @@ from __future__ import annotations import asyncio +import os +import time from fastapi import ( APIRouter, @@ -57,6 +59,14 @@ from ..services.douyu_collab_events import collab_events router = APIRouter(prefix="/api/douyu", tags=["斗鱼外部单协作"]) +def _verify_batch_interval() -> float: + try: + value = float(os.getenv("DOUYU_COLLAB_VERIFY_BATCH_INTERVAL_SECONDS", "0.2")) + except ValueError: + value = 0.2 + return max(0.0, min(value, 5.0)) + + def _http_error(exc: collab.CollabError) -> ApiError: return ApiError( status_code=exc.status_code, @@ -356,7 +366,10 @@ def verify_external_orders_batch( current: User = Depends(require_permission("douyu:collab:edit")), ): results: list[dict] = [] - for order_id in ids: + interval = _verify_batch_interval() + for index, order_id in enumerate(ids): + if index and interval: + time.sleep(interval) try: order = collab.get_order(db, order_id) result = collab.verify_order(db, current, order) diff --git a/web/backend/schemas.py b/web/backend/schemas.py index 0dbb125..64fa807 100644 --- a/web/backend/schemas.py +++ b/web/backend/schemas.py @@ -2535,6 +2535,8 @@ class DouyuCollabAccountLookupOut(BaseModel): account_nickname: str = "" ck_status: str = "" ck_status_label: str = "" + auth_status: str = "" + role_status: str = "" manual_type: int | None = None manual_score: int | None = None expire_time: int | None = None diff --git a/web/backend/services/automation/jobs/ck_health.py b/web/backend/services/automation/jobs/ck_health.py index c61ecbb..a707f32 100644 --- a/web/backend/services/automation/jobs/ck_health.py +++ b/web/backend/services/automation/jobs/ck_health.py @@ -17,7 +17,7 @@ from sqlalchemy import and_, func, or_ from sqlalchemy.orm import Session from ....models import Account, AutomationJob -from ...account_lifecycle import MANUAL_STATES, on_ck_verdict +from ...account_lifecycle import MANUAL_STATES from ...account_value import ( HIGH_VALUE_TIER_MAX, high_value_recheck_seconds, @@ -27,7 +27,11 @@ from ...cookie_check_service import ( check_douyu_cookie, ) from ...cookie_check_service import ( - classify_douyu_cookie_result as classify_result, + classify_douyu_cookie_result as classify_result, # noqa: F401 - 兼容诊断入口 +) +from ...douyu_account_probe import ( + persist_probe_result, + probe_session, ) from ...douyu_service import cookie_holding_filter, cookie_operable_filter @@ -109,15 +113,16 @@ def count_remaining(db: Session, job: AutomationJob, now: datetime) -> int: def _detect(account: Account) -> dict[str, Any]: try: - return check_douyu_cookie(account.cookie or "") + return probe_session( + account.cookie or "", + checker=check_douyu_cookie, + ) except Exception as exc: # noqa: BLE001 单个账号失败不影响整轮 return { - "valid": False, + "status": "error", "message": f"检测异常: {exc}", - "fish_ball": None, - "nickname": None, - "level": None, - "checked_at": datetime.now(UTC), + "checked_at": datetime.now(UTC).isoformat(), + "detail": {}, } @@ -153,16 +158,39 @@ def run_ck_health(db: Session, job: AutomationJob) -> dict[str, Any]: result = results.get(account.id) if result is None: continue - verdict = classify_result(result) + verdict = str(result.get("status") or "error") if verdict == "valid": valid += 1 elif verdict == "invalid": invalid += 1 else: errors += 1 - # 结论落定 = 写 ck_check_* + 由好变坏时记事件 + 重算生命周期状态。 - # 三件事的**顺序与口径**收在 `on_ck_verdict` 里,四个检测入口共用。 - on_ck_verdict(db, account, verdict, detail=result, occurred_at=now) + # 自动巡检不额外刷 account_probe 事件;统一落库仍会处理 CK 状态变化 + # 和生命周期事件,避免每 6 小时给所有账号写一条重复查询事件。 + detail = result.get("detail") if isinstance(result.get("detail"), dict) else {} + persist_probe_result( + db, + account, + { + "probe_id": f"ck-health:{now.timestamp()}:{account.id}", + "identity": { + "uid": account.uid, + "username": account.username, + "nickname": detail.get("nickname") or "", + "nickname_source": "session", + }, + "session": result, + "elite": {}, + "eligibility": {}, + "roles": {}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + source="automation.ck_health", + record_event=False, + commit=False, + ) if index % FLUSH_EVERY == 0: db.commit() diff --git a/web/backend/services/cookie_check_service.py b/web/backend/services/cookie_check_service.py index 71687a6..4d959fa 100644 --- a/web/backend/services/cookie_check_service.py +++ b/web/backend/services/cookie_check_service.py @@ -20,6 +20,8 @@ AUTH_FAILURE_MARKERS = ( "重新登陆", "重新登录", "账户登陆", + "expired", + "ck 失效", ) diff --git a/web/backend/services/douyu_account_probe.py b/web/backend/services/douyu_account_probe.py new file mode 100644 index 0000000..0a47e9a --- /dev/null +++ b/web/backend/services/douyu_account_probe.py @@ -0,0 +1,1035 @@ +"""斗鱼账号能力探针的唯一实现。 + +CK、斗鱼昵称、游戏角色、积分、鱼翅和商品不是同一个能力。本模块把这些能力 +分别查询、分别判断,并统一负责写回账号与账号时间线。其他业务模块只能调用 +这里,不再自行解释 bindRole/bindAct 或拼 actAlias。 +""" + +from __future__ import annotations + +import copy +import hashlib +import os +import time +from collections.abc import Callable, Mapping, Sequence +from datetime import UTC, datetime +from typing import Any +from uuid import uuid4 + +from loguru import logger +from sqlalchemy.orm import Session + +from core.douyu import DouyuActivityClient + +from ..models import Account, User +from .account_binding import ( + BIND_BOUND, + BIND_PENDING, + BIND_UNBOUND, + SCOPE_ELITE, + SCOPE_ESPORTS, + SCOPE_PEACE, + binding_snapshot, + derive_from_bind_info, + is_bound_act, + is_pending_binding_role, + role_change_available_at, + set_bind_status, +) +from .account_events_service import CATEGORY_OPS, emit +from .account_lifecycle import on_ck_verdict +from .cookie_check_service import check_douyu_cookie, classify_douyu_cookie_result +from .douyu_activity_query import ( + activity_client, + query_activity_goods, + query_bind_info, + query_csrf, + query_elite_user_info, + query_esports_bind_info, + query_gold_account, + query_limited_goods_result, + query_points, + query_xpd_bind_info, +) +from .douyu_elite_status import ( + elite_is_currently_open, + normalize_elite_expire_time, +) +from .douyu_goods_service import serialize_goods + +SESSION_VALID = "valid" +SESSION_INVALID = "invalid" +SESSION_ERROR = "error" +SESSION_UNVERIFIED = "unverified" +SESSION_UNKNOWN = "unknown" + +ROLE_BOUND = BIND_BOUND +ROLE_PENDING = BIND_PENDING +ROLE_UNBOUND = BIND_UNBOUND +ROLE_ERROR = "error" +ROLE_UNKNOWN = "unknown" + +CAPABILITY_OK = "ok" +CAPABILITY_ERROR = "error" +CAPABILITY_UNKNOWN = "unknown" + +CONFIG_KEYS = ( + "manual_id", + "rid", + "bind_act_alias", + "confirm_act_alias", + "legacy_act_alias", + "esports_manual_id", + "esports_act_alias", + "xpd_act_alias", + "xpd_rid", + "xpd_act_id", + "peace_enabled", +) + +_DEFAULT_SESSION_CHECKER = object() + + +def _env_float(name: str, default: float) -> float: + try: + value = float(os.getenv(name, str(default))) + except ValueError: + return default + return value if value >= 0 else default + + +_CACHE_TTL_SECONDS = _env_float("DOUYU_PROBE_CACHE_SECONDS", 30.0) +_probe_cache: dict[str, tuple[float, dict[str, Any]]] = {} + + +def _now() -> datetime: + return datetime.now(UTC) + + +def _text(value: Any, limit: int = 240) -> str: + text = str(value if value is not None else "").strip() + return text if len(text) <= limit else text[: limit - 3] + "..." + + +def _to_int(value: Any) -> int | None: + if value is None or value == "": + return None + try: + return int(float(value)) + except (TypeError, ValueError): + return None + + +def config_mapping(config: Any) -> dict[str, Any]: + """把 ORM 配置或普通映射整理成探针使用的只读字典。""" + if config is None: + return {} + if isinstance(config, Mapping): + source = config + else: + source = {key: getattr(config, key, None) for key in CONFIG_KEYS} + return {key: source.get(key) for key in CONFIG_KEYS} + + +def profile_from_cookie(cookie: str) -> dict[str, str]: + """从 CK 读取稳定身份字段;展示昵称仍以在线接口结果优先。""" + return DouyuActivityClient.profile_from_cookie(cookie) + + +def update_identity_from_cookie(account: Account, cookie: str) -> dict[str, str]: + """账号导入/登录后的统一身份回填。""" + profile = profile_from_cookie(cookie) + if profile.get("uid"): + account.uid = profile["uid"][:32] + if profile.get("nickname"): + account.nickname = profile["nickname"][:128] + return profile + + +def _dedupe(values: Sequence[Any]) -> list[str]: + result: list[str] = [] + for value in values: + text = str(value or "").strip() + if text and text not in result: + result.append(text) + return result + + +def elite_action_aliases(config: Mapping[str, Any]) -> list[str]: + return _dedupe( + [ + config.get("bind_act_alias"), + config.get("confirm_act_alias"), + ] + ) + + +def elite_query_aliases(config: Mapping[str, Any]) -> list[str]: + return _dedupe( + [ + *elite_action_aliases(config), + config.get("legacy_act_alias"), + ] + ) + + +def query_elite_bind_candidates( + client: DouyuActivityClient, + aliases: Sequence[str], +) -> tuple[list[dict[str, Any]], list[str]]: + """按 alias 批量读取绑定候选;单个 alias 失败不阻断其他来源。""" + candidates: list[dict[str, Any]] = [] + errors: list[str] = [] + for alias in _dedupe(aliases): + try: + info = query_bind_info(client, act_alias=alias) + except Exception as exc: # noqa: BLE001 - 单个 alias 失败不阻断其他来源 + errors.append(f"{alias}: {type(exc).__name__}: {_text(exc)}") + continue + candidates.append({**info, "act_alias": alias}) + return candidates, errors + + +def _role_candidate(info: Mapping[str, Any]) -> dict[str, Any]: + snapshot = binding_snapshot(dict(info)) + return { + "act_alias": str(info.get("act_alias") or ""), + "role_name": snapshot["role_name"], + "area_name": snapshot["area_name"], + "plat_name": snapshot["plat_name"], + "is_bound_act": is_bound_act(dict(info)), + "is_bound_role": bool(info.get("is_bound_role")), + "need_bind_act": bool(info.get("need_bind_act")), + "need_bind_role": bool(info.get("need_bind_role")), + } + + +def _role_result( + *, + status: str, + bind_info: Mapping[str, Any] | None, + candidates: list[dict[str, Any]], + aliases: list[str], + errors: list[str], + pending_info: Mapping[str, Any] | None = None, + bind_infos: Sequence[Mapping[str, Any]] | None = None, +) -> dict[str, Any]: + selected = dict(bind_info) if bind_info else {} + snapshot = binding_snapshot(selected) if selected else {} + pending = dict(pending_info) if pending_info else {} + pending_snapshot = binding_snapshot(pending) if pending else {} + return { + "status": status, + "role_name": str(snapshot.get("role_name") or ""), + "area_name": str(snapshot.get("area_name") or ""), + "plat_name": str(snapshot.get("plat_name") or ""), + "game_channel": str(snapshot.get("game_channel") or ""), + "game_name": str(snapshot.get("game_name") or ""), + "game_account": str(snapshot.get("nickname") or ""), + "source_alias": str(selected.get("act_alias") or ""), + "is_bound_act": bool(snapshot.get("is_bound_act")), + "is_bound_role": bool(snapshot.get("is_bound_role")), + "need_bind_act": bool(snapshot.get("need_bind_act")), + "need_bind_role": bool(snapshot.get("need_bind_role")), + "change_role_wait_time": snapshot.get("change_role_wait_time"), + "can_change_role": snapshot.get("can_change_role"), + "can_change_time": snapshot.get("can_change_time"), + "pending_role_name": str(pending_snapshot.get("role_name") or ""), + "pending_area_name": str(pending_snapshot.get("area_name") or ""), + "pending_plat_name": str(pending_snapshot.get("plat_name") or ""), + "query_act_aliases": aliases, + "candidates": candidates, + "errors": errors, + "snapshot": snapshot, + "bind_info": selected, + "bind_infos": [dict(item) for item in (bind_infos or [])], + } + + +def resolve_elite_role( + client: DouyuActivityClient, + config: Mapping[str, Any], + *, + bind_fetcher: Callable[[str], dict[str, Any]] | None = None, +) -> dict[str, Any]: + """查询精英宝典角色:活动 alias 优先,legacy 负责最新/待确认状态。""" + aliases = elite_query_aliases(config) + if not aliases: + return _role_result( + status=ROLE_ERROR, + bind_info=None, + candidates=[], + aliases=[], + errors=["未配置绑定活动 actAlias"], + ) + + if bind_fetcher is None: + candidates_info, errors = query_elite_bind_candidates(client, aliases) + else: + candidates_info = [] + errors = [] + for alias in aliases: + try: + candidates_info.append({**bind_fetcher(alias), "act_alias": alias}) + except Exception as exc: # noqa: BLE001 + errors.append(f"{alias}: {type(exc).__name__}: {_text(exc)}") + candidates = [_role_candidate(info) for info in candidates_info] + + action_aliases = elite_action_aliases(config) + ordered_aliases = aliases + bound_info = next( + ( + info + for alias in action_aliases + for info in candidates_info + if str(info.get("act_alias") or "") == alias + and derive_from_bind_info(info) == BIND_BOUND + ), + None, + ) + pending_info = next( + ( + info + for alias in ordered_aliases + for info in candidates_info + if str(info.get("act_alias") or "") == alias + and is_pending_binding_role( + info, + baseline_role_name=str((bound_info or {}).get("role_name") or ""), + baseline_is_bound_act=is_bound_act(bound_info), + baseline_info=bound_info, + ) + ), + None, + ) + if bound_info is not None: + return _role_result( + status=ROLE_BOUND, + bind_info=bound_info, + candidates=candidates, + aliases=aliases, + errors=errors, + pending_info=( + pending_info + if str((pending_info or {}).get("role_name") or "") + != str(bound_info.get("role_name") or "") + else None + ), + bind_infos=candidates_info, + ) + if pending_info is not None: + return _role_result( + status=ROLE_PENDING, + bind_info=pending_info, + candidates=candidates, + aliases=aliases, + errors=errors, + bind_infos=candidates_info, + ) + if errors and not candidates_info: + return _role_result( + status=ROLE_ERROR, + bind_info=None, + candidates=candidates, + aliases=aliases, + errors=errors, + bind_infos=candidates_info, + ) + if errors: + return _role_result( + status=ROLE_UNKNOWN, + bind_info=None, + candidates=candidates, + aliases=aliases, + errors=errors, + bind_infos=candidates_info, + ) + if candidates_info and any( + derive_from_bind_info(info) == BIND_UNBOUND for info in candidates_info + ): + first_info = candidates_info[0] + return _role_result( + status=ROLE_UNBOUND, + bind_info=first_info, + candidates=candidates, + aliases=aliases, + errors=[], + bind_infos=candidates_info, + ) + return _role_result( + status=ROLE_UNKNOWN, + bind_info=None, + candidates=candidates, + aliases=aliases, + errors=[], + bind_infos=candidates_info, + ) + + +def _resolve_single_role( + fetcher: Callable[[], dict[str, Any]], + *, + alias: str, +) -> dict[str, Any]: + try: + info = fetcher() + except Exception as exc: # noqa: BLE001 - 角色查询失败要保留上一快照 + return _role_result( + status=ROLE_ERROR, + bind_info=None, + candidates=[], + aliases=[alias] if alias else [], + errors=[f"{alias or '-'}: {type(exc).__name__}: {_text(exc)}"], + ) + info = {**info, "act_alias": alias} + candidate = _role_candidate(info) + if derive_from_bind_info(info) == BIND_BOUND: + status = ROLE_BOUND + elif candidate["role_name"]: + status = ROLE_PENDING + elif derive_from_bind_info(info) == BIND_UNBOUND: + status = ROLE_UNBOUND + else: + status = ROLE_UNKNOWN + return _role_result( + status=status, + bind_info=info if status != ROLE_UNBOUND else None, + candidates=[candidate], + aliases=[alias] if alias else [], + errors=[], + bind_infos=[info], + ) + + +def resolve_esports_role( + client: DouyuActivityClient, + config: Mapping[str, Any], + *, + bind_fetcher: Callable[[str], dict[str, Any]] | None = None, +) -> dict[str, Any]: + alias = str(config.get("esports_act_alias") or "").strip() + if not alias: + return _role_result( + status=ROLE_ERROR, + bind_info=None, + candidates=[], + aliases=[], + errors=["未配置电竞手册活动别名"], + ) + return _resolve_single_role( + ( + (lambda: bind_fetcher(alias)) + if bind_fetcher is not None + else (lambda: query_esports_bind_info(client, act_alias=alias)) + ), + alias=alias, + ) + + +def resolve_peace_role( + client: DouyuActivityClient, + config: Mapping[str, Any], + *, + bind_fetcher: Callable[[str], dict[str, Any]] | None = None, +) -> dict[str, Any]: + alias = str(config.get("xpd_act_alias") or "").strip() + if not alias: + return _role_result( + status=ROLE_ERROR, + bind_info=None, + candidates=[], + aliases=[], + errors=["未配置和平小店活动别名"], + ) + return _resolve_single_role( + ( + (lambda: bind_fetcher(alias)) + if bind_fetcher is not None + else (lambda: query_xpd_bind_info(client, act_alias=alias)) + ), + alias=alias, + ) + + +def probe_session( + cookie: str, + *, + checker: Callable[[str], dict[str, Any]] | None = None, +) -> dict[str, Any]: + """统一 CK 会话检测。只说明账号会话状态,不冒充角色或资产状态。""" + if not str(cookie or "").strip(): + return { + "status": SESSION_UNVERIFIED, + "message": "账号没有 CK", + "checked_at": _now().isoformat(), + "detail": {}, + } + active_checker = checker or check_douyu_cookie + try: + detail = active_checker(cookie) + except Exception as exc: # noqa: BLE001 - 外部检测边界 + return { + "status": SESSION_ERROR, + "message": f"{type(exc).__name__}: {_text(exc)}", + "checked_at": _now().isoformat(), + "detail": {}, + } + status = classify_douyu_cookie_result(detail) + raw_checked_at = detail.get("checked_at") + checked_at = ( + raw_checked_at.isoformat() + if isinstance(raw_checked_at, datetime) + else str(raw_checked_at or _now().isoformat()) + ) + return { + "status": status, + "message": _text(detail.get("message")), + "checked_at": checked_at, + "detail": detail, + } + + +def _points_expire_at( + points_response: Mapping[str, Any] | None, + *, + checked_at: datetime, +) -> datetime | None: + raw = (points_response or {}).get("willExpireTime") or (points_response or {}).get( + "will_expire_time" + ) + value = _to_int(raw) + if value is None or value <= 0: + return None + if value > 10_000_000_000: + value //= 1000 + if value < int(checked_at.timestamp()) - 60: + return None + return datetime.fromtimestamp(value, tz=UTC) + + +def _derive_session( + *, + errors: Mapping[str, str], + capabilities_ok: bool, +) -> dict[str, Any]: + if capabilities_ok: + return { + "status": SESSION_VALID, + "message": "活动接口可用", + "checked_at": _now().isoformat(), + "detail": {}, + } + text = ";".join(errors.values()) + if any(marker in text for marker in ("登录", "Cookie", "重定向")): + status = SESSION_INVALID + elif errors: + status = SESSION_ERROR + else: + status = SESSION_UNKNOWN + return { + "status": status, + "message": _text(text or "没有可用查询结果"), + "checked_at": _now().isoformat(), + "detail": {}, + } + + +def _identity_result( + account: Account, + cookie: str, + *, + elite: Mapping[str, Any], + session: Mapping[str, Any], +) -> dict[str, str]: + profile = profile_from_cookie(cookie) + user_info = ( + elite.get("user_info") if isinstance(elite.get("user_info"), dict) else {} + ) + session_detail = ( + session.get("detail") if isinstance(session.get("detail"), dict) else {} + ) + candidates = [ + ("elite", str(user_info.get("nickname") or "").strip()), + ("session", str(session_detail.get("nickname") or "").strip()), + ("cookie", str(profile.get("nickname") or "").strip()), + ("account", str(account.nickname or "").strip()), + ] + nickname, source = next( + ((value, item_source) for item_source, value in candidates if value), + ("", ""), + ) + return { + "uid": str(account.uid or profile.get("uid") or "").strip(), + "username": str(account.username or "").strip(), + "nickname": nickname, + "nickname_source": source, + } + + +def _cache_key(account: Account, config: Mapping[str, Any], mode: str) -> str: + raw = "|".join( + [ + str(account.id or ""), + hashlib.sha256(str(account.cookie or "").encode()).hexdigest(), + mode, + *(str(config.get(key) or "") for key in CONFIG_KEYS), + ] + ) + return hashlib.sha256(raw.encode()).hexdigest() + + +def probe_account( + account: Account, + config: Any, + *, + client: DouyuActivityClient | None = None, + session_checker: Callable[[str], dict[str, Any]] | None | object = ( + _DEFAULT_SESSION_CHECKER + ), + with_elite: bool = True, + with_eligibility: bool = False, + with_gold: bool = False, + with_goods: bool = False, + with_elite_role: bool = True, + include_esports: bool = False, + include_peace: bool = False, + use_cache: bool = False, + logger_callback: Callable[[str], None] | None = None, +) -> dict[str, Any]: + """读取一个斗鱼账号的身份、会话与按需能力。""" + config_info = config_mapping(config) + cache_mode = "|".join( + [ + f"elite={int(with_elite)}", + f"elig={int(with_eligibility)}", + f"gold={int(with_gold)}", + f"goods={int(with_goods)}", + f"role={int(with_elite_role)}", + f"esports={int(include_esports)}", + f"peace={int(include_peace)}", + ] + ) + cache_key = _cache_key(account, config_info, cache_mode) + if use_cache: + cached = _probe_cache.get(cache_key) + if cached and time.time() - cached[0] <= _CACHE_TTL_SECONDS: + result = copy.deepcopy(cached[1]) + result["probe_id"] = uuid4().hex + return result + + cookie = str(account.cookie or "").strip() + checked_at = _now() + errors: dict[str, str] = {} + active_client = client or activity_client( + cookie, + logger_callback=logger_callback + or ( + lambda message: logger.debug( + "[douyu-probe] account={} {}", account.id, message + ) + ), + ) + if session_checker is _DEFAULT_SESSION_CHECKER: + session_checker = None if client is not None else check_douyu_cookie + session = ( + probe_session(cookie, checker=session_checker) + if callable(session_checker) + else {} + ) + if str(session.get("status") or "") in {SESSION_INVALID, SESSION_UNVERIFIED}: + identity = _identity_result( + account, + cookie, + elite={}, + session=session, + ) + probe = { + "probe_id": uuid4().hex, + "checked_at": checked_at.isoformat(), + "identity": identity, + "session": session, + "elite": { + "status": CAPABILITY_UNKNOWN, + "raw": {}, + "manual_type": None, + "manual_score": None, + "expire_time": None, + "opened": account.elite_opened, + "error": "", + }, + "eligibility": { + "points": account.points, + "points_response": {}, + "points_expire_at": ( + account.points_expire_at.isoformat() + if account.points_expire_at + else None + ), + "limited_goods": [], + "limited_ids": [], + "error": "", + }, + "roles": ( + { + "elite": _role_result( + status=ROLE_UNKNOWN, + bind_info=None, + candidates=[], + aliases=elite_query_aliases(config_info), + errors=[], + ) + } + if with_elite_role + else {} + ), + "gold": {"status": CAPABILITY_UNKNOWN, "balance": account.gold_balance}, + "goods": { + "status": CAPABILITY_UNKNOWN, + "items": [], + "serialized": [], + "count": 0, + }, + "errors": {}, + } + if use_cache: + _probe_cache[cache_key] = (time.time(), probe) + return probe + + ctn = "" + if with_eligibility: + try: + ctn = query_csrf(active_client) + except Exception as exc: # noqa: BLE001 + errors["points"] = f"{type(exc).__name__}: {_text(exc)}" + + elite: dict[str, Any] = {} + manual_id = str(config_info.get("manual_id") or "").strip() + if manual_id and with_elite: + try: + elite = query_elite_user_info( + active_client, + manual_id=manual_id, + rid=str(config_info.get("rid") or ""), + ) + except Exception as exc: # noqa: BLE001 - 单项能力边界 + errors["elite"] = f"{type(exc).__name__}: {_text(exc)}" + + roles: dict[str, dict[str, Any]] = {} + if with_elite_role: + roles["elite"] = resolve_elite_role(active_client, config_info) + if include_esports: + roles["esports"] = resolve_esports_role(active_client, config_info) + if include_peace: + roles["peace"] = resolve_peace_role(active_client, config_info) + + points: int | None = None + points_response: dict[str, Any] = {} + limited_goods: list[dict[str, Any]] = [] + if with_eligibility: + uid = str(account.uid or "").strip() + if ctn: + try: + points_result = query_points(active_client, uid=uid, ctn=ctn) + points = _to_int(points_result.get("points")) + points_response = points_result + except Exception as exc: # noqa: BLE001 + errors["points"] = f"{type(exc).__name__}: {_text(exc)}" + try: + limited_result = query_limited_goods_result( + active_client, + manual_id=manual_id, + rid=str(config_info.get("rid") or ""), + ) + limited_goods = [ + dict(item) + for item in limited_result.get("limited_goods") or [] + if isinstance(item, dict) + ] + except Exception as exc: # noqa: BLE001 + errors["limited_goods"] = f"{type(exc).__name__}: {_text(exc)}" + + gold: dict[str, Any] = {"status": CAPABILITY_UNKNOWN, "balance": None} + if with_gold: + try: + gold_response = query_gold_account(active_client) + gold = { + "status": CAPABILITY_OK, + "balance": _to_int(gold_response.get("gold")), + "raw": gold_response, + } + except Exception as exc: # noqa: BLE001 + errors["gold"] = f"{type(exc).__name__}: {_text(exc)}" + gold = { + "status": CAPABILITY_ERROR, + "balance": None, + "error": errors["gold"], + } + + goods: dict[str, Any] = {"status": CAPABILITY_UNKNOWN, "items": [], "count": 0} + if with_goods: + try: + raw_goods = query_activity_goods( + active_client, + manual_id=manual_id, + rid=str(config_info.get("rid") or ""), + ) + goods = { + "status": CAPABILITY_OK, + "items": raw_goods, + "serialized": [serialize_goods(item) for item in raw_goods], + "count": len(raw_goods), + } + except Exception as exc: # noqa: BLE001 + errors["goods"] = f"{type(exc).__name__}: {_text(exc)}" + goods = { + "status": CAPABILITY_ERROR, + "items": [], + "serialized": [], + "count": 0, + "error": errors["goods"], + } + + if not session: + capabilities_ok = bool( + elite + or (roles.get("elite") or {}).get("status") in {ROLE_BOUND, ROLE_PENDING} + or gold.get("status") == CAPABILITY_OK + or goods.get("status") == CAPABILITY_OK + ) + session = _derive_session(errors=errors, capabilities_ok=capabilities_ok) + + manual_type = _to_int(elite.get("manual_type")) + manual_score = _to_int(elite.get("manual_score")) + expire_time = normalize_elite_expire_time(elite.get("expire_time")) + elite_opened = elite_is_currently_open(manual_type, expire_time, now=checked_at) + if points is None: + points = manual_score + identity = _identity_result( + account, + cookie, + elite=elite, + session=session, + ) + points_expire_at = _points_expire_at(points_response, checked_at=checked_at) + probe = { + "probe_id": uuid4().hex, + "checked_at": checked_at.isoformat(), + "identity": identity, + "session": session, + "elite": { + "status": CAPABILITY_OK + if elite + else CAPABILITY_ERROR + if "elite" in errors + else CAPABILITY_UNKNOWN, + "raw": elite, + "manual_type": manual_type, + "manual_score": manual_score, + "expire_time": expire_time, + "opened": elite_opened, + "error": errors.get("elite", ""), + }, + "eligibility": { + "points": points, + "points_response": points_response, + "points_expire_at": ( + points_expire_at.isoformat() if points_expire_at else None + ), + "limited_goods": limited_goods, + "limited_ids": sorted( + { + str(item.get("commodityId") or item.get("commodity_id") or "") + for item in limited_goods + if str( + item.get("commodityId") or item.get("commodity_id") or "" + ).strip() + } + ), + "error": errors.get("points", ""), + }, + "roles": roles, + "gold": gold, + "goods": goods, + "errors": errors, + } + if use_cache: + _probe_cache[cache_key] = (time.time(), probe) + logger.info( + "[douyu-probe] account={} session={} role={} elite={} gold={} goods={} errors={}", + account.id, + session.get("status"), + (roles.get("elite") or {}).get("status"), + probe["elite"].get("status"), + gold.get("status"), + goods.get("status"), + sorted(errors), + ) + return probe + + +def _apply_role_result( + account: Account, + scope: str, + role: Mapping[str, Any], +) -> None: + status = str(role.get("status") or ROLE_UNKNOWN) + if status in {ROLE_BOUND, ROLE_PENDING, ROLE_UNBOUND}: + set_bind_status(account, scope, status) + if status in {ROLE_ERROR, ROLE_UNKNOWN}: + return + role_name = str(role.get("role_name") or "")[:128] + channel = str(role.get("game_channel") or "").replace(" / ", " · ")[:128] + if scope == SCOPE_ELITE: + account.game_name = role_name + account.game_channel = channel + account.change_role_wait_time = _to_int(role.get("change_role_wait_time")) + account.role_change_available_at = role_change_available_at( + role.get("bind_info") + ) + elif scope == SCOPE_ESPORTS: + account.esports_game_name = role_name + account.esports_game_channel = channel + account.esports_change_role_wait_time = _to_int( + role.get("change_role_wait_time") + ) + account.esports_can_change_time = _to_int(role.get("can_change_time")) + elif scope == SCOPE_PEACE: + account.xpd_game_name = role_name + bind_info = ( + role.get("bind_info") if isinstance(role.get("bind_info"), dict) else {} + ) + account.xpd_openid = str(bind_info.get("openid") or account.xpd_openid or "")[ + :128 + ] + account.xpd_role_id = str( + bind_info.get("role_id") or account.xpd_role_id or "" + )[:64] + + +def persist_probe_result( + db: Session, + account: Account, + probe: Mapping[str, Any], + *, + current: User | None = None, + source: str, + record_event: bool = True, + commit: bool = False, +) -> None: + """把一次探针结果写回账号和生命周期,是账号能力的唯一落库入口。""" + now = _now() + identity = probe.get("identity") or {} + if identity.get("uid"): + account.uid = str(identity["uid"])[:32] + if identity.get("nickname"): + account.nickname = str(identity["nickname"])[:128] + + session = probe.get("session") or {} + session_status = str(session.get("status") or "") + if session_status in {SESSION_VALID, SESSION_INVALID, SESSION_ERROR}: + detail = ( + session.get("detail") if isinstance(session.get("detail"), dict) else {} + ) + on_ck_verdict( + db, + account, + session_status, + detail={ + **detail, + "message": session.get("message") or detail.get("message", ""), + }, + occurred_at=now, + actor_type="user" if current else "system", + actor_id=int(current.id) if current else None, + ) + + elite = probe.get("elite") or {} + if elite.get("status") == CAPABILITY_OK: + account.elite_opened = bool(elite.get("opened")) + account.elite_expire_time = _to_int(elite.get("expire_time")) + if _to_int(elite.get("manual_score")) is not None: + account.points = _to_int(elite.get("manual_score")) + + eligibility = probe.get("eligibility") or {} + if _to_int(eligibility.get("points")) is not None: + account.points = _to_int(eligibility.get("points")) + points_expire_at = eligibility.get("points_expire_at") + if points_expire_at: + try: + account.points_expire_at = datetime.fromisoformat(str(points_expire_at)) + except ValueError: + pass + + roles = probe.get("roles") or {} + for scope in (SCOPE_ELITE, SCOPE_ESPORTS, SCOPE_PEACE): + role = roles.get(scope) + if isinstance(role, dict): + _apply_role_result(account, scope, role) + + gold = probe.get("gold") or {} + if gold.get("status") == CAPABILITY_OK and _to_int(gold.get("balance")) is not None: + account.gold_balance = _to_int(gold.get("balance")) + + account.updated_at = now + if record_event and account.id is not None: + emit( + db, + account_id=int(account.id), + event_type="account_probe", + title=f"账号查询:{source}", + category=CATEGORY_OPS, + occurred_at=now, + detail={ + "probe_id": probe.get("probe_id"), + "source": source, + "session": session_status, + "role": (roles.get(SCOPE_ELITE) or {}).get("status"), + "nickname_source": identity.get("nickname_source"), + "errors": sorted((probe.get("errors") or {}).keys()), + }, + source=source, + subject_type="account", + subject_key=str(account.id), + actor_type="user" if current else "system", + actor_id=int(current.id) if current else None, + source_ref=f"douyu_probe:{probe.get('probe_id')}", + ) + db.flush() + if commit: + db.commit() + + +def clear_probe_cache() -> None: + """测试或手工刷新时清空短期缓存。""" + _probe_cache.clear() + + +__all__ = [ + "CAPABILITY_ERROR", + "CAPABILITY_OK", + "CAPABILITY_UNKNOWN", + "ROLE_BOUND", + "ROLE_ERROR", + "ROLE_PENDING", + "ROLE_UNBOUND", + "ROLE_UNKNOWN", + "SESSION_ERROR", + "SESSION_INVALID", + "SESSION_UNKNOWN", + "SESSION_UNVERIFIED", + "SESSION_VALID", + "activity_client", + "clear_probe_cache", + "config_mapping", + "elite_action_aliases", + "elite_query_aliases", + "persist_probe_result", + "probe_account", + "probe_session", + "profile_from_cookie", + "query_elite_bind_candidates", + "resolve_elite_role", + "resolve_esports_role", + "resolve_peace_role", + "update_identity_from_cookie", +] diff --git a/web/backend/services/douyu_account_state.py b/web/backend/services/douyu_account_state.py index 679b229..cd8e99e 100644 --- a/web/backend/services/douyu_account_state.py +++ b/web/backend/services/douyu_account_state.py @@ -17,24 +17,9 @@ from sqlalchemy.orm import Session from core.douyu import DouyuActivityClient from ..models import Account -from .account_binding import ( - SCOPE_ELITE, - binding_snapshot, - is_role_change_cooling, - role_change_available_at, - set_bind_status, -) -from .account_lifecycle import on_ck_verdict -from .cookie_check_service import check_douyu_cookie, classify_douyu_cookie_result -from .douyu_activity_query import ( - activity_client, - query_bind_info, - query_exchange_eligibility, -) -from .douyu_elite_status import ( - elite_is_currently_open, - normalize_elite_expire_time, -) +from .account_binding import is_role_change_cooling +from .cookie_check_service import check_douyu_cookie +from .douyu_account_probe import config_mapping, persist_probe_result, probe_account @dataclass(frozen=True) @@ -107,192 +92,84 @@ def refresh_douyu_account_state( ) -> DouyuLiveAccountState: """实时刷新单个账号,并把所有可落库状态写回账号。""" now = datetime.now(UTC) - cookie = str(account.cookie or "").strip() - account_name = account.nickname or account.username or f"#{account.id}" - ck_result = cookie_checker(cookie) - ck_verdict = classify_douyu_cookie_result(ck_result) - ck_message = str(ck_result.get("message") or "") - on_ck_verdict( + config_info = config_mapping( + { + "manual_id": manual_id, + "rid": rid, + "bind_act_alias": act_alias, + "confirm_act_alias": act_alias, + } + ) + probe = probe_account( + account, + config_info, + client=client, + session_checker=cookie_checker, + with_eligibility=True, + ) + session = probe.get("session") or {} + role = (probe.get("roles") or {}).get("elite") or {} + elite = probe.get("elite") or {} + eligibility = probe.get("eligibility") or {} + session_status = str(session.get("status") or "") + bind_info = role.get("bind_info") if isinstance(role.get("bind_info"), dict) else {} + errors = list((probe.get("errors") or {}).values()) + errors.extend(role.get("errors") or []) + if session_status != "valid": + errors.append( + f"CK 检测未通过: {session.get('message') or '状态未知'},未继续查询活动状态" + ) + + persist_probe_result( db, account, - ck_verdict, - detail=ck_result, - occurred_at=now, + probe, + source="platform.live_check", + record_event=False, + commit=False, ) - - if ck_verdict != "valid": - snapshot = { - "queried_at": now.isoformat(), - "ck": ck_result, - "errors": ["CK 检测未通过,未继续查询活动状态"], - } - account.overview_snapshot = _json_safe(snapshot) - account.updated_at = now - if commit: - db.commit() - return DouyuLiveAccountState( - account_id=int(account.id), - account_name=account_name, - checked_at=now, - ck_verdict=ck_verdict, - ck_message=ck_message, - elite_opened=account.elite_opened, - points=account.points, - limited_ids=frozenset(), - role_change_available_at=account.role_change_available_at, - ) - - active_client = client or activity_client(cookie) - try: - eligibility = query_exchange_eligibility( - active_client, - cookie=cookie, - manual_id=manual_id, - rid=rid, - uid=str(account.uid or ""), - ) - except Exception as exc: # noqa: BLE001 外部接口边界需要保留单项诊断 - error = f"{type(exc).__name__}: {exc}"[:240] - snapshot = { - "queried_at": now.isoformat(), - "ck": ck_result, - "errors": [error], - } - account.overview_snapshot = _json_safe(snapshot) - account.overview_queried_at = now - account.updated_at = now - if commit: - db.commit() - return DouyuLiveAccountState( - account_id=int(account.id), - account_name=account_name, - checked_at=now, - ck_verdict=ck_verdict, - ck_message=ck_message, - elite_opened=account.elite_opened, - points=account.points, - limited_ids=frozenset(), - role_change_available_at=account.role_change_available_at, - error=error, - ) - - errors: list[str] = [] - bind_info: dict[str, Any] = {} - try: - bind_info = query_bind_info( - active_client, - act_alias=act_alias, - ) - except Exception as exc: # noqa: BLE001 绑定查询失败不应丢弃资产查询结果 - errors.append(f"绑定状态查询失败: {type(exc).__name__}: {exc}"[:240]) - - elite_expire_time = normalize_elite_expire_time( - eligibility.elite_user_info.get("expire_time") - ) - elite_opened = elite_is_currently_open( - eligibility.elite_user_info.get("manual_type"), - elite_expire_time, - now=now, - ) - account.elite_opened = elite_opened - account.elite_expire_time = elite_expire_time - account.points = eligibility.points - account.points_expire_at = _points_expire_at( - eligibility.points_response, - checked_at=now, - ) - role_change_available_at = account.role_change_available_at - if bind_info: - role_change_available_at = _apply_bind_state( - account, - bind_info, - checked_at=now, - ) account.overview_snapshot = _json_safe( { "queried_at": now.isoformat(), - "ck": ck_result, - "elite": eligibility.elite_user_info, - "points": eligibility.points_response, - "limited_goods": eligibility.limited_goods, + "ck": session.get("detail") or {"message": session.get("message")}, + "elite": elite.get("raw") or {}, + "points": eligibility.get("points_response") or {}, + "limited_goods": eligibility.get("limited_goods") or [], "bind": bind_info, "errors": errors, + "probe_id": probe.get("probe_id"), } ) account.overview_queried_at = now - account.high_value_checked_at = now + if session_status == "valid": + account.high_value_checked_at = now account.updated_at = now if commit: db.commit() + limited_ids = frozenset( + str(item) for item in eligibility.get("limited_ids") or [] if str(item) + ) return DouyuLiveAccountState( account_id=int(account.id), - account_name=account_name, + account_name=account.nickname + or (probe.get("identity") or {}).get("nickname") + or account.username + or f"#{account.id}", checked_at=now, - ck_verdict=ck_verdict, - ck_message=ck_message, - elite_opened=elite_opened, - points=eligibility.points, - limited_ids=eligibility.limited_ids, - role_change_available_at=role_change_available_at, + ck_verdict=session_status + if session_status in {"valid", "invalid", "error"} + else "error", + ck_message=str(session.get("message") or ""), + elite_opened=account.elite_opened, + points=account.points, + limited_ids=limited_ids, + role_change_available_at=account.role_change_available_at, error=";".join(errors), role_change_blocked=is_role_change_cooling(bind_info), ) -def _apply_bind_state( - account: Account, - bind_info: dict[str, Any], - *, - checked_at: datetime, -) -> datetime | None: - snapshot = binding_snapshot(bind_info) - derived = snapshot["bind_status"] - if derived is not None: - set_bind_status(account, SCOPE_ELITE, derived) - - role_name = snapshot["role_name"] - if role_name: - account.game_name = role_name[:128] - channel = snapshot["game_channel"] - if channel: - account.game_channel = channel.replace(" / ", " · ")[:128] - - account.change_role_wait_time = snapshot["change_role_wait_time"] - available_at = role_change_available_at(bind_info, checked_at=checked_at) - account.role_change_available_at = available_at - return available_at - - -def _points_expire_at( - points_response: dict[str, Any], - *, - checked_at: datetime, -) -> datetime | None: - raw = ( - points_response.get("willExpireTime") - or points_response.get("will_expire_time") - or points_response.get("expire_time") - ) - value = _to_int(raw) - if value is None or value <= 0: - return None - if value > 10_000_000_000: - value //= 1000 - if value < int(checked_at.timestamp()) - 60: - return None - return datetime.fromtimestamp(value, tz=UTC) - - -def _to_int(value: Any) -> int | None: - if value is None or value == "": - return None - try: - return int(float(value)) - except (TypeError, ValueError): - return None - - def _json_safe(value: Any) -> Any: if isinstance(value, datetime): return value.isoformat() diff --git a/web/backend/services/douyu_activity_query.py b/web/backend/services/douyu_activity_query.py index 52cbb1c..ec5ef8d 100644 --- a/web/backend/services/douyu_activity_query.py +++ b/web/backend/services/douyu_activity_query.py @@ -9,21 +9,24 @@ from __future__ import annotations -from dataclasses import dataclass +from collections.abc import Callable from typing import Any from core.douyu import DouyuActivityClient -from core.douyu.cookie_utils import cookie_value - -from .account_binding import binding_snapshot -from .douyu_goods_service import serialize_goods - -ERROR_MAX_LENGTH = 240 -def activity_client(cookie: str = "") -> DouyuActivityClient: +def activity_client( + cookie: str = "", + *, + logger_callback: Callable[[str], None] | None = None, + proxies: dict[str, str] | None = None, +) -> DouyuActivityClient: """创建统一活动客户端;空 Cookie 可用于公开商品目录查询。""" - return DouyuActivityClient(cookie) + return DouyuActivityClient( + cookie, + logger=logger_callback, + proxies=proxies, + ) def query_csrf( @@ -68,6 +71,29 @@ def query_xpd_bind_info( return client.xpd_bind_info(act_alias=act_alias) +def query_xpd_embed( + client: DouyuActivityClient, + *, + act_alias: str, + rid: str, +) -> dict[str, Any]: + return client.xpd_embed_query(act_alias=act_alias, rid=rid) + + +def query_xpd_role( + client: DouyuActivityClient, + *, + embed_query: dict[str, str], + act_id: str, + rid: str = "", +) -> dict[str, Any]: + return client.xpd_get_role( + embed_query=embed_query, + act_id=act_id, + rid=rid, + ) + + def query_gold_account(client: DouyuActivityClient) -> dict[str, Any]: return client.gold_account() @@ -203,95 +229,8 @@ def query_exchange_orders( return [dict(item) for item in result.get("orders") or [] if isinstance(item, dict)] -@dataclass(frozen=True) -class DouyuEligibilityResult: - elite_user_info: dict[str, Any] - points: int - points_response: dict[str, Any] - limited_goods: list[dict[str, Any]] - limited_ids: frozenset[str] - - -def query_exchange_eligibility( - client: DouyuActivityClient, - *, - cookie: str, - manual_id: str, - rid: str, - uid: str = "", -) -> DouyuEligibilityResult: - """一次读取兑换资格需要的精英状态、积分和限兑商品。""" - ctn = query_csrf(client) - elite = query_elite_user_info(client, manual_id=manual_id, rid=rid) - resolved_uid = str(uid or cookie_value(cookie, "acf_uid") or "").strip() - points_result = query_points(client, uid=resolved_uid, ctn=ctn) - limited = query_limited_goods(client, manual_id=manual_id, rid=rid) - limited_ids = { - str(item.get("commodityId") or item.get("commodity_id") or "").strip() - for item in limited - } - limited_ids.discard("") - return DouyuEligibilityResult( - elite_user_info=elite, - points=int(points_result.get("points") or 0), - points_response=points_result, - limited_goods=limited, - limited_ids=frozenset(limited_ids), - ) - - -def query_account_overview( - client: DouyuActivityClient, - *, - manual_id: str, - rid: str, - act_alias: str, - with_goods: bool = True, -) -> dict[str, Any]: - """账号只读探针,单项失败只进入 errors,不阻断其他查询。""" - elite: dict[str, Any] = {} - bind: dict[str, Any] = {} - gold: dict[str, Any] = {} - goods: list[dict[str, Any]] = [] - errors: dict[str, str] = {} - - try: - elite = query_elite_user_info(client, manual_id=manual_id, rid=rid) - except Exception as exc: # noqa: BLE001 - 外部接口边界 - errors["elite"] = _error_text(exc) - try: - bind = query_bind_info(client, act_alias=act_alias) - except Exception as exc: # noqa: BLE001 - errors["bind"] = _error_text(exc) - try: - gold = query_gold_account(client) - except Exception as exc: # noqa: BLE001 - errors["gold"] = _error_text(exc) - if with_goods: - try: - goods = query_activity_goods(client, manual_id=manual_id, rid=rid) - except Exception as exc: # noqa: BLE001 - errors["goods"] = _error_text(exc) - - return { - "elite": elite, - "bind": bind, - "bind_snapshot": binding_snapshot(bind), - "gold": gold, - "goods": goods, - "serialized_goods": [serialize_goods(item) for item in goods], - "errors": errors, - } - - -def _error_text(exc: BaseException) -> str: - return f"{type(exc).__name__}: {exc}"[:ERROR_MAX_LENGTH] - - __all__ = [ - "DouyuEligibilityResult", "activity_client", - "query_account_overview", "query_activity_goods", "query_bind_info", "query_csrf", @@ -300,7 +239,6 @@ __all__ = [ "query_esports_goods", "query_esports_goods_result", "query_exchange_balance", - "query_exchange_eligibility", "query_exchange_orders", "query_exchange_orders_result", "query_exchange_records", @@ -310,4 +248,6 @@ __all__ = [ "query_limited_goods_result", "query_points", "query_xpd_bind_info", + "query_xpd_embed", + "query_xpd_role", ] diff --git a/web/backend/services/douyu_collab_service.py b/web/backend/services/douyu_collab_service.py index ad9c407..06289d0 100644 --- a/web/backend/services/douyu_collab_service.py +++ b/web/backend/services/douyu_collab_service.py @@ -49,18 +49,22 @@ from .account_events_service import ( from .audit_service import record_account_action, record_audit from .business_events import record_account_query from .collab_common import apply_order_visibility, count_archived -from .douyu_activity_query import ( +from .cookie_check_service import check_douyu_cookie +from .douyu_account_probe import ( + ROLE_BOUND, + ROLE_ERROR, + ROLE_PENDING, + ROLE_UNKNOWN, + SESSION_INVALID, + SESSION_VALID, activity_client, - query_account_overview, - query_activity_goods, - query_elite_user_info, + config_mapping, + persist_probe_result, + probe_account, +) +from .douyu_activity_query import ( query_exchange_orders, query_exchange_records, - query_gold_account, -) -from .douyu_elite_status import ( - elite_is_currently_open, - normalize_elite_expire_time, ) from .douyu_goods_service import ( serialize_live_goods as _serialize_live_goods, @@ -313,7 +317,12 @@ def _client_for_account(account: Account) -> DouyuActivityClient: cookie = str(account.cookie or "").strip() if not cookie: raise CollabError("该账号没有 CK", code="account_no_cookie") - return activity_client(cookie) + return activity_client( + cookie, + logger_callback=lambda message: logger.debug( + "[douyu-collab] account={} {}", account.id, message + ), + ) def serialize_live_goods(goods: list[dict[str, Any]]) -> list[dict[str, Any]]: @@ -327,6 +336,8 @@ def _probe_with_client( manual_id: str, rid: str, act_alias: str, + confirm_act_alias: str = "", + legacy_act_alias: str = "", client: Any | None = None, with_goods: bool = True, ) -> dict[str, Any]: @@ -341,67 +352,104 @@ def _probe_with_client( } active_client = client or _client_for_account(account) - overview = query_account_overview( - active_client, - manual_id=manual_id, - rid=rid, - act_alias=act_alias, - with_goods=with_goods, + caller_supplied_client = client is not None + config_info = config_mapping( + { + "manual_id": manual_id, + "rid": rid, + "bind_act_alias": act_alias, + "confirm_act_alias": confirm_act_alias or act_alias, + "legacy_act_alias": legacy_act_alias, + } ) - elite = overview["elite"] - bind = overview["bind"] - bind_snapshot = overview["bind_snapshot"] - gold = overview["gold"] - goods = overview["serialized_goods"] + result = probe_account( + account, + config_info, + client=active_client, + session_checker=None if caller_supplied_client else check_douyu_cookie, + with_gold=True, + with_goods=with_goods, + use_cache=not caller_supplied_client, + ) + elite = result.get("elite") or {} + role = (result.get("roles") or {}).get("elite") or {} + identity = result.get("identity") or {} + session = result.get("session") or {} + gold = result.get("gold") or {} + goods = result.get("goods") or {} + bind_snapshot = role.get("snapshot") or {} + role_status = str(role.get("status") or ROLE_UNKNOWN) error_labels = { "elite": "手册状态", - "bind": "绑定角色", + "points": "积分", + "limited_goods": "限兑商品", "gold": "鱼翅余额", "goods": "活动商品", } errors = [ f"{error_labels.get(key, key)}: {value}" - for key, value in overview["errors"].items() + for key, value in (result.get("errors") or {}).items() ] - - manual_type = _to_int(elite.get("manual_type")) - manual_score = _to_int(elite.get("manual_score")) - expire_time = normalize_elite_expire_time(elite.get("expire_time")) - user_info = elite.get("user_info") or {} - profile = DouyuActivityClient.profile_from_cookie(str(account.cookie or "")) - bind_role = _text(bind_snapshot["role_name"], max_length=128) - area_name = _text(bind_snapshot["area_name"], max_length=64) - plat_name = _text(bind_snapshot["plat_name"], max_length=64) - bind_channel = " · ".join(item for item in (area_name, plat_name) if item) - bind_account = _text(bind_snapshot["nickname"], max_length=128) - ck_status = CK_VALID if (elite or bind) else CK_INVALID - ok = bool(bind_snapshot["bind_confirmed"]) and not (elite == {} and bind == {}) + errors.extend(role.get("errors") or []) + session_status = str(session.get("status") or "") + if session_status == SESSION_VALID: + ck_status = CK_VALID + elif session_status == SESSION_INVALID: + ck_status = CK_INVALID + else: + ck_status = CK_UNVERIFIED + bind_role = _text(role.get("role_name"), max_length=128) + bind_channel = _text(role.get("game_channel"), max_length=128) + bind_account = _text(role.get("game_account"), max_length=128) + ok = ( + session_status == SESSION_VALID + and role_status == ROLE_BOUND + and bool(bind_role) + ) + if session_status == SESSION_INVALID: + message = f"CK 已失效:{session.get('message') or '请重新登录'}" + elif session_status not in {SESSION_VALID, ""}: + message = f"CK 状态无法确认:{session.get('message') or '请稍后重试'}" + elif role_status == ROLE_ERROR: + message = "角色查询失败" + ( + f":{';'.join(role.get('errors') or [])}" if role.get("errors") else "" + ) + elif role_status == ROLE_UNKNOWN: + message = "角色状态无法确认,已保留上次有效结果" + elif role_status == ROLE_PENDING: + message = "已识别角色,待确认绑定" + elif not bind_role: + message = "CK 正常,但账号未绑定角色" + else: + message = ";".join(errors) + if error_labels.get("gold") and gold.get("error"): + message = f"{message};鱼翅余额: {gold['error']}" return { "found": True, "ok": ok, "ck_status": ck_status, - "message": ";".join(errors) if errors else ("" if ok else "未读到绑定角色"), + "auth_status": session_status, + "role_status": role_status, + "message": message, "errors": errors, "account_id": int(account.id), - "account_username": str(account.username or ""), - "account_uid": _text(account.uid or profile.get("uid"), max_length=32), - "account_nickname": _text( - user_info.get("nickname") or account.nickname or profile.get("nickname"), - max_length=128, - ), - "manual_type": manual_type, - "manual_score": manual_score, - "expire_time": expire_time, - "manual_opened": elite_is_currently_open(manual_type, expire_time), - "bind_status": bind_snapshot["bind_status"], - "bind_phase": bind_snapshot["bind_phase"], + "account_username": identity.get("username") or str(account.username or ""), + "account_uid": _text(identity.get("uid"), max_length=32), + "account_nickname": _text(identity.get("nickname"), max_length=128), + "manual_type": elite.get("manual_type"), + "manual_score": elite.get("manual_score"), + "expire_time": elite.get("expire_time"), + "manual_opened": bool(elite.get("opened")), + "bind_status": bind_snapshot.get("bind_status"), + "bind_phase": bind_snapshot.get("bind_phase"), "bind_game_account": bind_account, "bind_game_role": bind_role, "bind_game_channel": bind_channel, - "fish_fin_balance": _to_int(gold.get("gold")), - "goods": goods, - "goods_count": len(goods), + "fish_fin_balance": _to_int(gold.get("balance")), + "goods": goods.get("serialized") or [], + "goods_count": int(goods.get("count") or 0), + "_probe_result": result, } @@ -426,6 +474,8 @@ def lookup_account( manual_id=str(config.manual_id or ""), rid=str(config.rid or ""), act_alias=str(config.bind_act_alias or ""), + confirm_act_alias=str(config.confirm_act_alias or ""), + legacy_act_alias=str(config.legacy_act_alias or ""), client=client, with_goods=with_goods, ) @@ -444,12 +494,29 @@ def lookup_account( for order in orders ] probe["ck_status_label"] = CK_LABELS.get(str(probe.get("ck_status")), "") + probe.pop("_probe_result", None) return probe def apply_probe_snapshot( - order: DouyuExternalOrder, account: Account, probe: Mapping[str, Any] + db: Session, + current: User, + order: DouyuExternalOrder, + account: Account, + probe: Mapping[str, Any], + *, + source: str, ) -> None: + canonical = probe.get("_probe_result") + if isinstance(canonical, dict): + persist_probe_result( + db, + account, + canonical, + current=current, + source=source, + record_event=True, + ) order.account_id = int(account.id) order.account_username = _text(account.username, max_length=128) or _text( probe.get("account_username"), max_length=128 @@ -458,23 +525,18 @@ def apply_probe_snapshot( order.account_nickname = _text( probe.get("account_nickname") or account.nickname, max_length=128 ) - order.bind_game_account = _text(probe.get("bind_game_account"), max_length=128) - order.bind_game_role = _text(probe.get("bind_game_role"), max_length=128) - order.bind_game_channel = _text(probe.get("bind_game_channel"), max_length=128) - order.bind_snapshot_at = _now() + role_status = str(probe.get("role_status") or "") + if role_status not in {ROLE_ERROR, ROLE_UNKNOWN}: + order.bind_game_account = _text(probe.get("bind_game_account"), max_length=128) + order.bind_game_role = _text(probe.get("bind_game_role"), max_length=128) + order.bind_game_channel = _text(probe.get("bind_game_channel"), max_length=128) + order.bind_snapshot_at = _now() fish = _to_int(probe.get("fish_fin_balance")) points = _to_int(probe.get("manual_score")) if fish is not None: order.fish_fin_balance = fish - account.gold_balance = fish if points is not None: order.points_balance = points - account.points = points - ck_status = str(probe.get("ck_status") or "") - if ck_status in (CK_VALID, CK_INVALID): - account.ck_check_status = ck_status - account.ck_checked_at = _now() - account.updated_at = _now() def _assert_version(order: DouyuExternalOrder, expected: int | None) -> None: @@ -1115,10 +1177,19 @@ def create_order( manual_id=str(config.manual_id or ""), rid=str(config.rid or ""), act_alias=str(config.bind_act_alias or ""), + confirm_act_alias=str(config.confirm_act_alias or ""), + legacy_act_alias=str(config.legacy_act_alias or ""), client=client, with_goods=True, ) - apply_probe_snapshot(order, account, probe) + apply_probe_snapshot( + db, + current, + order, + account, + probe, + source="douyu_collab.create", + ) if explicit_points is None and name: live = next( ( @@ -1608,6 +1679,8 @@ def update_order( manual_id=str(config.manual_id or ""), rid=str(config.rid or ""), act_alias=str(config.bind_act_alias or ""), + confirm_act_alias=str(config.confirm_act_alias or ""), + legacy_act_alias=str(config.legacy_act_alias or ""), client=client, with_goods=True, ) @@ -1619,7 +1692,14 @@ def update_order( force_active=order.status in COLLAB_LEASE_STATUSES, takeover_platform_lease=takeover_platform_lease, ) - apply_probe_snapshot(order, account, probe) + apply_probe_snapshot( + db, + current, + order, + account, + probe, + source="douyu_collab.update", + ) changes["account_id"] = { "old": previous_account_id or None, "new": int(account.id), @@ -1691,6 +1771,8 @@ def set_account( manual_id=str(config.manual_id or ""), rid=str(config.rid or ""), act_alias=str(config.bind_act_alias or ""), + confirm_act_alias=str(config.confirm_act_alias or ""), + legacy_act_alias=str(config.legacy_act_alias or ""), client=client, with_goods=True, ) @@ -1702,7 +1784,14 @@ def set_account( force_active=order.status in COLLAB_LEASE_STATUSES, takeover_platform_lease=takeover_platform_lease, ) - apply_probe_snapshot(order, account, probe) + apply_probe_snapshot( + db, + current, + order, + account, + probe, + source="douyu_collab.account", + ) order.updated_by = current.id order.version = int(order.version or 0) + 1 record_audit( @@ -1752,10 +1841,19 @@ def verify_order( manual_id=str(config.manual_id or ""), rid=str(config.rid or ""), act_alias=str(config.bind_act_alias or ""), + confirm_act_alias=str(config.confirm_act_alias or ""), + legacy_act_alias=str(config.legacy_act_alias or ""), client=client, with_goods=True, ) - apply_probe_snapshot(order, account, probe) + apply_probe_snapshot( + db, + current, + order, + account, + probe, + source="douyu_collab.verify", + ) order.updated_by = current.id order.version = int(order.version or 0) + 1 record_audit( @@ -2105,23 +2203,21 @@ def query_activity( raise CollabError("订单关联的斗鱼账号不存在", code="account_not_found") config = resolve_config(db) active_client = client or _client_for_account(account) - errors: list[str] = [] - elite: dict[str, Any] = {} - gold: dict[str, Any] = {} + probe = probe_account( + account, + config, + client=active_client, + session_checker=None, + with_gold=True, + with_elite_role=False, + ) + elite = (probe.get("elite") or {}).get("raw") or {} + gold = { + "gold": (probe.get("gold") or {}).get("balance"), + } + errors = list((probe.get("errors") or {}).values()) records: list[dict[str, Any]] = [] orders: list[dict[str, Any]] = [] - try: - elite = query_elite_user_info( - active_client, - manual_id=str(config.manual_id or ""), - rid=str(config.rid or ""), - ) - except Exception as exc: # noqa: BLE001 - errors.append(f"积分: {exc}") - try: - gold = query_gold_account(active_client) - except Exception as exc: # noqa: BLE001 - errors.append(f"鱼翅: {exc}") if include_records: try: records = query_exchange_records( @@ -2144,6 +2240,14 @@ def query_activity( manual_score = _to_int(elite.get("manual_score")) fish = _to_int(gold.get("gold")) + persist_probe_result( + db, + account, + probe, + current=current, + source="douyu_collab.query_activity", + record_event=False, + ) if manual_score is not None: order.points_balance = manual_score account.points = manual_score @@ -2643,10 +2747,27 @@ def refresh_activity_goods( raise CollabError("没有带 CK 的斗鱼账号,无法刷新活动商品", code="no_account") active_client = client or _client_for_account(account) try: - goods = query_activity_goods( - active_client, - manual_id=str(config.manual_id or ""), - rid=str(config.rid or ""), + probe = probe_account( + account, + config, + client=active_client, + session_checker=None, + with_elite=False, + with_elite_role=False, + with_goods=True, + ) + goods = (probe.get("goods") or {}).get("items") or [] + if (probe.get("goods") or {}).get("status") == "error": + raise RuntimeError( + (probe.get("goods") or {}).get("error") or "商品查询失败" + ) + persist_probe_result( + db, + account, + probe, + current=current, + source="douyu_collab.goods_refresh", + record_event=False, ) except Exception as exc: record_account_query( diff --git a/web/backend/services/douyu_runner.py b/web/backend/services/douyu_runner.py index 57ba3a7..53e7ffd 100644 --- a/web/backend/services/douyu_runner.py +++ b/web/backend/services/douyu_runner.py @@ -10,8 +10,8 @@ from core.douyu import DouyuActivityError from ..database import SessionLocal from ..models import DouyuTask -from .account_lifecycle import on_ck_verdict from .cookie_check_service import check_douyu_cookie +from .douyu_account_probe import persist_probe_result, probe_session from .douyu_runner_bind import BindMixin from .douyu_runner_core import ( # noqa: F401 (douyu_batch_registry 供 routers 重导出) DouyuBatchRunnerCore, @@ -68,18 +68,42 @@ class DouyuBatchRunner( ) return - cookie_check = check_douyu_cookie(cookie) + cookie_check = probe_session(cookie, checker=check_douyu_cookie) + ck_verdict = str(cookie_check["status"]) # 执行前的这次检测同样要写结论、由好变坏记事件、重算状态。 - on_ck_verdict( + persist_probe_result( worker_db, account, - "valid" if cookie_check["valid"] else "invalid", - detail=cookie_check, - occurred_at=cookie_check["checked_at"], + { + "probe_id": f"task-preflight:{task.id}", + "identity": { + "uid": account.uid, + "username": account.username, + "nickname": ( + (cookie_check.get("detail") or {}).get("nickname") or "" + ), + "nickname_source": "session", + }, + "session": cookie_check, + "elite": {}, + "eligibility": {}, + "roles": {}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + source="douyu_task.preflight", + record_event=False, + commit=False, ) worker_db.commit() - if not cookie_check["valid"]: - message = f"Cookie 已失效,请重新登录:{cookie_check['message']}" + if ck_verdict != "valid": + prefix = ( + "Cookie 已失效,请重新登录" + if ck_verdict == "invalid" + else "Cookie 状态无法确认" + ) + message = f"{prefix}:{cookie_check['message']}" self._mark_task(worker_db, task, "failed", message) self._push_log( "warning", f"[{current}] {self._account_name(account)} {message}" diff --git a/web/backend/services/douyu_runner_bind.py b/web/backend/services/douyu_runner_bind.py index 2ae2189..50df095 100644 --- a/web/backend/services/douyu_runner_bind.py +++ b/web/backend/services/douyu_runner_bind.py @@ -25,7 +25,16 @@ from .account_binding import ( set_bind_status, ) from .business_events import record_bind -from .douyu_activity_query import query_bind_info, query_esports_bind_info +from .douyu_account_probe import ( + ROLE_BOUND, + ROLE_ERROR, + ROLE_PENDING, + ROLE_UNKNOWN, + persist_probe_result, + query_elite_bind_candidates, + resolve_elite_role, +) +from .douyu_activity_query import query_esports_bind_info DOUYU_LEGACY_BIND_ACT_ALIAS = "20250213NQCYX" DOUYU_BIND_ROLE_POLL_SECONDS = 600 @@ -252,21 +261,15 @@ class BindMixin: aliases: list[str], ) -> list[dict]: """按多个 actAlias 查询绑定信息,保留成功结果。""" - results: list[dict] = [] - for alias in aliases: - if not alias: - continue - try: - info = query_bind_info(client, act_alias=alias, v2=True) - except DouyuActivityError as exc: - self._push_log("warning", f"查询绑定信息失败 act={alias}: {exc}") - continue - info = {**info, "act_alias": alias} + results, errors = query_elite_bind_candidates(client, aliases) + for error in errors: + self._push_log("warning", f"查询绑定信息失败 {error}") + for info in results: self._push_log( "info", - f"绑定信息 act={alias} {self._format_bind_summary(info)}", + "绑定信息 " + f"act={info.get('act_alias') or '-'} {self._format_bind_summary(info)}", ) - results.append(info) return results def _role_alias_priority(self, config: dict, primary_alias: str = "") -> list[str]: @@ -1270,41 +1273,17 @@ class BindMixin: self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) - query_aliases = self._query_bind_act_aliases(config) - if not query_aliases: - self._mark_task(db, task, "failed", "请先配置绑定活动 actAlias") - return - candidates = self._fetch_bind_info_candidates(client, query_aliases) - if not candidates: - self._mark_task( - db, task, "failed", "查询绑定信息失败,请检查 Cookie 或 actAlias" - ) - return - - # 1) 优先“已生效绑定”角色(bound_act=1 且有角色名,通常是活动 alias)。 - # 避免把扫码后未确认的新角色当成当前绑定结果。 - bound_info = self._pick_current_bound_info(candidates, config) - # 2) 待确认角色统一交给共享状态机判断。cjm 中与当前绑定同名的残留 - # 不算 pending;同名但活动状态发生 needBindAct 转换才算 pending。 - pending_info = self._pick_pending_role_info( - candidates, - prefer_aliases=self._role_alias_priority(config), - baseline_role_name=str((bound_info or {}).get("role_name") or ""), - baseline_is_bound_act=self._is_bound_act(bound_info), - baseline_info=bound_info, - ) - pending_role = str((pending_info or {}).get("role_name") or "").strip() - bound_role = str(bound_info.get("role_name") or "") if bound_info else "" - has_pending = pending_info is not None and bool(pending_role) - - # 查询结果角色 = 已生效绑定;首次绑定(无绑定)时回退待确认角色 + role = resolve_elite_role(client, config) + status = str(role.get("status") or "") bind_info = ( - bound_info if bound_info else (pending_info if has_pending else None) + role.get("bind_info") if isinstance(role.get("bind_info"), dict) else {} ) - snapshot = self._bind_snapshot(bind_info) if bind_info else {} - role_name = snapshot.get("role_name") or "" - is_bound = snapshot.get("is_bound_act", False) - source_alias = str((bind_info or {}).get("act_alias") or "") + snapshot = ( + role.get("snapshot") if isinstance(role.get("snapshot"), dict) else {} + ) + role_name = str(role.get("role_name") or "") + pending_role = str(role.get("pending_role_name") or "") + source_alias = str(role.get("source_alias") or "") summary = ( f"act={source_alias or '-'} {self._format_bind_summary(bind_info)}" if bind_info @@ -1313,54 +1292,70 @@ class BindMixin: self._push_log( "info", "查询角色 " - f"aliases={','.join(query_aliases)} bound_hit={(bound_info or {}).get('act_alias') or '-'} " - f"pending_hit={(pending_info or {}).get('act_alias') or '-'} " + f"aliases={','.join(role.get('query_act_aliases') or [])} " + f"status={status} source={source_alias or '-'} " f"{self._format_bind_summary(bind_info) if bind_info else 'role=- bound_act=-'}", ) - # 只有已生效绑定才写账号表;待确认角色不污染 game_name - if bind_info and is_bound: - self._apply_bind_info_to_account(account, bind_info) - else: - account.updated_at = datetime.now(UTC) + persist_probe_result( + db, + account, + { + "probe_id": f"task:{task.id}", + "identity": {"uid": account.uid, "username": account.username}, + "session": {}, + "elite": {}, + "eligibility": {}, + "roles": {"elite": role}, + "gold": {}, + "goods": {}, + "errors": {"elite_role": ";".join(role.get("errors") or [])} + if role.get("errors") + else {}, + }, + source="douyu_task.query_game_name", + record_event=False, + ) result = { + **snapshot, "act_alias": source_alias, "query_act_alias": source_alias, - "query_act_aliases": query_aliases, - **snapshot, - "bind_ready_for_confirm": has_pending, - "bind_confirmed": is_bound, + "query_act_aliases": role.get("query_act_aliases") or [], + "role_status": status, + "role_name": role_name, + "bind_ready_for_confirm": status == ROLE_PENDING, + "bind_confirmed": status == ROLE_BOUND, "bind_phase": ( "confirmed" - if is_bound + if status == ROLE_BOUND else ("role_ready" if role_name else "waiting_role") ), "bind_summary": summary, - "bind_candidates": [ - { - "act_alias": item.get("act_alias"), - "role_name": item.get("role_name"), - "is_bound_act": self._is_bound_act(item), - } - for item in candidates - ], + "bind_candidates": role.get("candidates") or [], + "errors": role.get("errors") or [], } - # 已绑定角色之外另有待确认新角色时,单独字段展示,不覆盖 role_name - if has_pending and bound_info and pending_role != bound_role: + if pending_role: result["pending_role_name"] = pending_role - result["pending_area_name"] = str(pending_info.get("area_name") or "") - result["pending_plat_name"] = str(pending_info.get("plat_name") or "") - if not bind_info: - message = f"未获取到游戏名 | {summary}" - elif is_bound: - if has_pending and pending_role != bound_role: - message = ( - f"当前已绑定: {bound_role},待确认: {pending_role} | {summary}" - ) - else: - message = f"当前已绑定: {bound_role} | {summary}" - else: + result["pending_area_name"] = role.get("pending_area_name") or "" + result["pending_plat_name"] = role.get("pending_plat_name") or "" + if status == ROLE_ERROR: + message = f"查询角色失败: {';'.join(role.get('errors') or ['未知错误'])}" + elif status == ROLE_UNKNOWN: + message = "角色状态无法确认,已保留上次有效结果" + elif status == ROLE_BOUND: + message = f"当前已绑定: {role_name} | {summary}" + elif status == ROLE_PENDING: message = f"待确认角色: {role_name} | {summary}" - self._mark_task(db, task, "success" if role_name else "failed", message, result) + else: + message = f"未获取到游戏名 | {summary}" + self._mark_task( + db, + task, + "success" + if status in {ROLE_BOUND, ROLE_PENDING} and bool(role_name) + else "failed", + message, + result, + ) def _pick_change_wait_bind_info( self, candidates: list[dict], config: dict @@ -1387,39 +1382,74 @@ class BindMixin: self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) - query_aliases = self._query_bind_act_aliases(config) - if not query_aliases: - self._mark_task(db, task, "failed", "请先配置绑定活动 actAlias") - return - candidates = self._fetch_bind_info_candidates(client, query_aliases) - if not candidates: + role = resolve_elite_role(client, config) + status = str(role.get("status") or "") + query_aliases = role.get("query_act_aliases") or [] + raw_candidates = role.get("bind_infos") or [] + if status == ROLE_ERROR: self._mark_task( - db, task, "failed", "查询绑定信息失败,请检查 Cookie 或 actAlias" + db, + task, + "failed", + f"查询绑定信息失败: {';'.join(role.get('errors') or ['未知错误'])}", ) return - for item in candidates: + for item in raw_candidates: self._push_log( "info", f"查询换绑时间候选 act={item.get('act_alias') or '-'} " f"{self._format_bind_summary(item)}", ) - current_bound = self._pick_current_bound_info(candidates, config) - pending_info = self._pick_pending_role_info( - candidates, - prefer_aliases=self._role_alias_priority(config), - baseline_role_name=str((current_bound or {}).get("role_name") or ""), - baseline_is_bound_act=self._is_bound_act(current_bound), - baseline_info=current_bound, - ) - pending_role = str((pending_info or {}).get("role_name") or "").strip() # 换绑时间看“当前已绑定”活动态,不要优先 cjm(cjm 常无 changeRoleWaitTime) + action_aliases = self._action_act_aliases(config) + bind_info = next( + ( + item + for alias in action_aliases + for item in raw_candidates + if str(item.get("act_alias") or "") == alias + and item.get("change_role_wait_time") is not None + ), + None, + ) bind_info = ( - self._pick_change_wait_bind_info(candidates, config) or candidates[0] + bind_info + or ( + role.get("bind_info") + if isinstance(role.get("bind_info"), dict) + else None + ) + or (raw_candidates[0] if raw_candidates else {}) ) snapshot = self._bind_snapshot(bind_info) wait_time = snapshot["change_role_wait_time"] - account.change_role_wait_time = wait_time - account.updated_at = datetime.now(UTC) + persist_role = { + **role, + "bind_info": bind_info, + "snapshot": snapshot, + "role_name": snapshot.get("role_name") or "", + "game_channel": snapshot.get("game_channel") or "", + "change_role_wait_time": wait_time, + "can_change_role": snapshot.get("can_change_role"), + "can_change_time": snapshot.get("can_change_time"), + } + persist_probe_result( + db, + account, + { + "probe_id": f"task:{task.id}", + "identity": {"uid": account.uid, "username": account.username}, + "session": {}, + "elite": {}, + "eligibility": {}, + "roles": {"elite": persist_role}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + source="douyu_task.query_change_bind_time", + record_event=False, + ) source_alias = str(bind_info.get("act_alias") or "") wait_text = self._format_wait_time(wait_time) can_change = snapshot["can_change_role"] @@ -1442,31 +1472,16 @@ class BindMixin: "query_act_aliases": query_aliases, **snapshot, "change_role_wait_text": wait_text, - # 待确认语义统一由 _pick_pending_role_info 决定;这里不再根据 - # “只是有角色名且 bindAct=0”自行推断。 - "bind_ready_for_confirm": pending_info is not None, + "role_status": status, + "bind_ready_for_confirm": status == ROLE_PENDING, "bind_confirmed": snapshot["is_bound_act"], "bind_summary": f"act={source_alias or '-'} {self._format_bind_summary(bind_info)}", - "bind_candidates": [ - { - "act_alias": item.get("act_alias"), - "role_name": item.get("role_name"), - "is_bound_act": self._is_bound_act(item), - "change_role_wait_time": self._to_int( - item.get("change_role_wait_time") - ), - "can_change_role": item.get("can_change_role"), - } - for item in candidates - ], + "bind_candidates": role.get("candidates") or [], } - if ( - pending_info is not None - and pending_role != str(snapshot["role_name"] or "").strip() - ): - result["pending_role_name"] = pending_role - result["pending_area_name"] = str(pending_info.get("area_name") or "") - result["pending_plat_name"] = str(pending_info.get("plat_name") or "") + if role.get("pending_role_name"): + result["pending_role_name"] = role.get("pending_role_name") + result["pending_area_name"] = role.get("pending_area_name") or "" + result["pending_plat_name"] = role.get("pending_plat_name") or "" self._push_log( "info", f"查询换绑时间 hit={source_alias or '-'} role={role_name} " diff --git a/web/backend/services/douyu_runner_core.py b/web/backend/services/douyu_runner_core.py index 9a6bb67..62dc8e5 100644 --- a/web/backend/services/douyu_runner_core.py +++ b/web/backend/services/douyu_runner_core.py @@ -23,6 +23,7 @@ from ..models import ( from ..models import ( ProxyConfig as ProxyConfigModel, ) +from .douyu_account_probe import activity_client from .douyu_goods_service import upsert_goods_snapshot from .douyu_service import ( DOUYU_CONFIG_FIELDS, @@ -411,9 +412,9 @@ class DouyuBatchRunnerCore: def _client(self, cookie: str) -> DouyuActivityClient: """任务 HTTP 客户端:写操作任务注入会话级代理(兑换/锁单/支付/充值/送礼), 读操作任务直连;见 DOUYU_PROXY_TASK_TYPES。""" - return DouyuActivityClient( + return activity_client( cookie, - logger=lambda msg: self._push_log("debug", msg), + logger_callback=lambda msg: self._push_log("debug", msg), proxies=self._proxies_for_task(), ) diff --git a/web/backend/services/douyu_runner_overview.py b/web/backend/services/douyu_runner_overview.py index d4e38c1..e2b78a7 100644 --- a/web/backend/services/douyu_runner_overview.py +++ b/web/backend/services/douyu_runner_overview.py @@ -33,16 +33,27 @@ from sqlalchemy.orm import Session from core.douyu import DouyuActivityClient from ..models import Account, DouyuTask -from .account_binding import binding_snapshot, set_bind_status from .account_capability_service import sync_account_goods_states from .business_events import record_official_exchange +from .douyu_account_probe import ( + ROLE_BOUND, + ROLE_ERROR, + ROLE_PENDING, + ROLE_UNBOUND, + ROLE_UNKNOWN, + persist_probe_result, + query_elite_bind_candidates, + resolve_elite_role, + resolve_esports_role, + resolve_peace_role, +) from .douyu_activity_query import ( query_activity_goods, - query_bind_info, query_csrf, query_esports_bind_info, query_exchange_records, query_xpd_bind_info, + query_xpd_embed, ) from .douyu_runner_donate import _parse_expire_at, _points_expire_at from .high_value_service import ( @@ -199,7 +210,10 @@ class OverviewMixin: ) -> dict[str, Any]: """按作用域查绑定信息(三个接口不同,收敛在一处)。""" if scope == "elite": - return query_bind_info(client, act_alias=alias) + rows, errors = query_elite_bind_candidates(client, [alias]) + if errors: + raise RuntimeError(";".join(errors)) + return rows[0] if rows else {} if scope == "esports": return query_esports_bind_info(client, act_alias=alias) return query_xpd_bind_info(client, act_alias=alias) @@ -238,7 +252,8 @@ class OverviewMixin: esports_manual_id: str, ) -> list[dict[str, Any]]: """和平小店:先要一次性短时授权,再查购买记录。""" - embed = client.xpd_embed_query( + embed = query_xpd_embed( + client, act_alias=str(config["xpd_act_alias"]), rid=str(config["xpd_rid"]), ) @@ -383,6 +398,11 @@ class OverviewMixin: ) overview["bind"] = {} + role_resolvers = { + "elite": resolve_elite_role, + "esports": resolve_esports_role, + "peace": resolve_peace_role, + } for scope, label, alias_key in ( ("elite", "精英宝典", "bind_act_alias"), ("esports", "电竞手册", "esports_act_alias"), @@ -394,32 +414,55 @@ class OverviewMixin: if not alias: errors[f"bind_{scope}"] = f"未配置{label}活动别名" continue - try: - info = self._fetch_bind_info(client, scope, alias) - snapshot = binding_snapshot(info) - derived = snapshot["bind_status"] - # 把**明细**也带上:运营要看的是"绑的哪个角色、哪个区服、 - # 什么时候能换绑",不是一个"已绑定"就完事。 - overview["bind"][scope] = { - "derived": derived, - "phase": snapshot["bind_phase"], - "role_name": snapshot["role_name"], - "area_name": snapshot["area_name"], - "plat_name": snapshot["plat_name"], - "nickname": snapshot["nickname"], - "game_id": snapshot["game_id"], - "game_name": snapshot["game_name"], - "is_change_cooling": snapshot["is_change_cooling"], - "can_change_role": snapshot["can_change_role"], - "change_role_wait_time": _ts(snapshot["change_role_wait_time"]), - "can_change_time": _ts(snapshot["can_change_time"]), - } - if derived is not None: - # 唯一写入者;推不出来(None)时**不动原值** —— 宁可留 unknown, - # 也不要把"没查到"写成"没绑定" - set_bind_status(account, scope, derived) - except Exception as exc: # noqa: BLE001 外部接口边界需要宽泛兜底 - errors[f"bind_{scope}"] = _err(exc) + role = role_resolvers[scope]( + client, + config, + bind_fetcher=lambda selected_alias, selected_scope=scope: ( + self._fetch_bind_info(client, selected_scope, selected_alias) + ), + ) + status = str(role.get("status") or "") + snapshot = ( + role.get("snapshot") if isinstance(role.get("snapshot"), dict) else {} + ) + overview["bind"][scope] = { + "status": status, + "derived": snapshot.get("bind_status"), + "phase": snapshot.get("bind_phase"), + "role_name": snapshot.get("role_name") or "", + "area_name": snapshot.get("area_name") or "", + "plat_name": snapshot.get("plat_name") or "", + "nickname": snapshot.get("nickname") or "", + "game_id": snapshot.get("game_id") or "", + "game_name": snapshot.get("game_name") or "", + "source_alias": role.get("source_alias") or "", + "is_change_cooling": snapshot.get("is_change_cooling"), + "can_change_role": snapshot.get("can_change_role"), + "change_role_wait_time": _ts(snapshot.get("change_role_wait_time")), + "can_change_time": _ts(snapshot.get("can_change_time")), + } + if status in {ROLE_ERROR, ROLE_UNKNOWN} and role.get("errors"): + errors[f"bind_{scope}"] = ";".join(role.get("errors") or []) + if status == ROLE_ERROR: + continue + if status in {ROLE_BOUND, ROLE_PENDING, ROLE_UNBOUND}: + persist_probe_result( + db, + account, + { + "probe_id": f"task:{task.id}:role:{scope}", + "identity": {"uid": account.uid, "username": account.username}, + "session": {}, + "elite": {}, + "eligibility": {}, + "roles": {scope: role}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + source=f"douyu_task.query_account_overview.{scope}", + record_event=False, + ) # ---- 官方兑换记录(**三个作用域都拉**)---- # diff --git a/web/backend/services/douyu_runner_xpd.py b/web/backend/services/douyu_runner_xpd.py index 8cad50d..d7c84c5 100644 --- a/web/backend/services/douyu_runner_xpd.py +++ b/web/backend/services/douyu_runner_xpd.py @@ -19,7 +19,11 @@ from .account_binding import ( set_bind_status, ) from .business_events import record_exchange -from .douyu_activity_query import query_xpd_bind_info +from .douyu_activity_query import ( + query_xpd_bind_info, + query_xpd_embed, + query_xpd_role, +) DOUYU_XPD_BIND_POLL_SECONDS = 300 DOUYU_XPD_BIND_POLL_INTERVAL = 5 @@ -43,11 +47,13 @@ class XpdMixin: def _xpd_role_context(self, client: DouyuActivityClient, config: dict) -> dict: """获取小店 H5 参数 + 绑定角色信息,小店任务共用。""" - embed = client.xpd_embed_query( + embed = query_xpd_embed( + client, act_alias=str(config["xpd_act_alias"]), rid=str(config["xpd_rid"]), ) - role = client.xpd_get_role( + role = query_xpd_role( + client, embed_query=embed["query"], act_id=str(config["xpd_act_id"]), rid=str(config["xpd_rid"]), @@ -456,7 +462,8 @@ class XpdMixin: ): """查询和平小店道聚城购买记录。""" client = self._client(cookie) - embed = client.xpd_embed_query( + embed = query_xpd_embed( + client, act_alias=str(config["xpd_act_alias"]), rid=str(config["xpd_rid"]), ) @@ -528,13 +535,15 @@ class XpdMixin: return client = self._client(cookie) - embed = client.xpd_embed_query( + embed = query_xpd_embed( + client, act_alias=str(config["xpd_act_alias"]), rid=str(config["xpd_rid"]), ) role: dict = {} try: - role = client.xpd_get_role( + role = query_xpd_role( + client, embed_query=embed["query"], act_id=str(config["xpd_act_id"]), rid=str(config["xpd_rid"]), diff --git a/web/backend/services/douyu_service.py b/web/backend/services/douyu_service.py index ea8f6aa..3e3fd92 100644 --- a/web/backend/services/douyu_service.py +++ b/web/backend/services/douyu_service.py @@ -10,7 +10,6 @@ from loguru import logger from sqlalchemy import and_, func, select from sqlalchemy.orm import Session -from core.douyu.activity_client import DouyuActivityClient from core.douyu.cookie_utils import cookie_value from ..models import Account, DouyuConfig, DouyuTask, LoginTask @@ -362,11 +361,9 @@ def _lock_payment_accounts( def update_account_profile_from_cookie(account: Account, cookie: str) -> None: """从 Cookie 回填 uid/nickname。""" - profile = DouyuActivityClient.profile_from_cookie(cookie) - if profile["uid"]: - account.uid = profile["uid"] - if profile["nickname"]: - account.nickname = profile["nickname"] + from .douyu_account_probe import update_identity_from_cookie + + update_identity_from_cookie(account, cookie) def account_uid(account: Account, cookie: str) -> str: diff --git a/web/backend/services/login_service.py b/web/backend/services/login_service.py index aa667f5..89d19b2 100644 --- a/web/backend/services/login_service.py +++ b/web/backend/services/login_service.py @@ -26,8 +26,9 @@ from .account_events_service import ( EVENT_RELOGIN_OK, emit, ) -from .account_lifecycle import on_ck_verdict, on_login_success, sync_status +from .account_lifecycle import on_login_success, sync_status from .cookie_check_service import check_douyu_cookie +from .douyu_account_probe import persist_probe_result, probe_session from .douyu_service import LOGIN_ATTEMPT_IN_FLIGHT_STATUSES from .login_failure import classify_failure, failure_kind_label, is_account_fault from .proxy_service import build_proxy_runtime @@ -495,20 +496,45 @@ class LoginBatchRunner: elif result.success: message = result.message or "登录成功" if self.mode == "relogin" and account is not None: - check_result = check_douyu_cookie(result.cookie) - # 复检结论写账号(CK 在哪,健康状态就在哪),走统一入口: - # 写结论 + 由好变坏记事件 + 重算状态。 - on_ck_verdict( + check_result = probe_session( + result.cookie, + checker=check_douyu_cookie, + ) + detail = ( + check_result.get("detail") + if isinstance(check_result.get("detail"), dict) + else {} + ) + persist_probe_result( worker_db, account, - "valid" if check_result["valid"] else "invalid", - detail=check_result, - occurred_at=check_result["checked_at"], + { + "probe_id": f"relogin:{self.batch_id}:{task.id}", + "identity": { + "uid": account.uid, + "username": account.username, + "nickname": detail.get("nickname") or "", + "nickname_source": "session", + }, + "session": check_result, + "elite": {}, + "eligibility": {}, + "roles": {}, + "gold": {}, + "goods": {}, + "errors": {}, + }, + source="login.relogin_verify", + record_event=False, + commit=False, ) - if check_result["valid"]: + if check_result["status"] == "valid": message = "重新登录成功,Cookie 有效" else: - message = f"重新登录成功,但 Cookie 有效性检测失败: {check_result['message']}" + message = ( + "重新登录成功,但 Cookie 有效性检测失败: " + f"{check_result['message']}" + ) # 唯一替换旧 CK 的入口:登录成功后写回账号。 # # ⚠️ 必须传 **worker_db**(本线程的会话),不能传 self.db: diff --git a/web/backend/services/platform_fulfillment/service.py b/web/backend/services/platform_fulfillment/service.py index a23402c..1a415df 100644 --- a/web/backend/services/platform_fulfillment/service.py +++ b/web/backend/services/platform_fulfillment/service.py @@ -37,13 +37,14 @@ from ..account_capability_service import ( record_account_commodity_state, ) from ..business_events import record_account_query, record_douyu_task_started -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_elite_status import ( - elite_is_currently_open, - normalize_elite_expire_time, +from ..douyu_account_probe import ( + CAPABILITY_OK, + config_mapping, + persist_probe_result, + probe_account, ) +from ..douyu_account_state import DouyuLiveAccountState, refresh_douyu_account_state +from ..douyu_batch_launcher import start_douyu_batch, stop_douyu_batches from ..douyu_service import ( SUPPORTED_DOUYU_TASK_TYPES, douyu_config_value, @@ -2195,24 +2196,32 @@ def refresh_exchange_eligibility( 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 ""), + probe = probe_account( + account, + config_mapping(config), + session_checker=None, + with_elite_role=False, + with_eligibility=True, ) - elite_expire_time = normalize_elite_expire_time( - eligibility.elite_user_info.get("expire_time") + if (probe.get("elite") or {}).get("status") != CAPABILITY_OK: + raise RuntimeError( + (probe.get("errors") or {}).get("elite") or "精英宝典状态查询失败" + ) + if "points" in (probe.get("errors") or {}): + raise RuntimeError((probe.get("errors") or {})["points"]) + limited_ids = frozenset( + str(item) + for item in (probe.get("eligibility") or {}).get("limited_ids") or [] + if str(item) ) - account.elite_opened = elite_is_currently_open( - eligibility.elite_user_info.get("manual_type"), - elite_expire_time, + persist_probe_result( + db, + account, + probe, + current=current, + source="platform.exchange_eligibility", + record_event=True, ) - account.elite_expire_time = elite_expire_time - account.points = eligibility.points except Exception as exc: # noqa: BLE001 外部接口错误要落成可重试的检查失败 record_account_query( db, @@ -2240,7 +2249,7 @@ def refresh_exchange_eligibility( db.commit() return get_task_detail(db, task.id) - if task.commodity_id in eligibility.limited_ids: + if task.commodity_id in limited_ids: task.exchange_status = "limited" task.issue_code = "commodity_limit_reached" task.last_error = "该账号已达到此商品兑换上限" @@ -2262,15 +2271,13 @@ def refresh_exchange_eligibility( commodity_id=task.commodity_id, availability=( AVAILABILITY_LIMITED - if task.commodity_id in eligibility.limited_ids + if task.commodity_id in limited_ids else AVAILABILITY_AVAILABLE ), blocking_reason=( - "该账号已达此商品兑换上限" - if task.commodity_id in eligibility.limited_ids - else "" + "该账号已达此商品兑换上限" if task.commodity_id in limited_ids else "" ), - raw_status="1" if task.commodity_id in eligibility.limited_ids else "0", + raw_status="1" if task.commodity_id in limited_ids else "0", observed_at=_now(), source="eligibility_check", scope=task.scope or SCOPE_ELITE, @@ -2284,7 +2291,7 @@ def refresh_exchange_eligibility( detail={ "commodity_id": task.commodity_id, "exchange_status": task.exchange_status, - "limited": task.commodity_id in eligibility.limited_ids, + "limited": task.commodity_id in limited_ids, "points": account.points, "elite_opened": account.elite_opened, }, @@ -2303,7 +2310,7 @@ def refresh_exchange_eligibility( actor_id=current.id, detail={ "exchangeStatus": task.exchange_status, - "limitedCount": len(eligibility.limited_ids), + "limitedCount": len(limited_ids), }, ) _emit_order_site_binding_state(db, task.id) diff --git a/web/frontend/src/api/douyuCollab.ts b/web/frontend/src/api/douyuCollab.ts index cdd960a..0c85413 100644 --- a/web/frontend/src/api/douyuCollab.ts +++ b/web/frontend/src/api/douyuCollab.ts @@ -202,6 +202,8 @@ export interface DouyuCollabAccountLookup { account_nickname: string; ck_status: string; ck_status_label: string; + auth_status: string; + role_status: string; manual_type: number | null; manual_score: number | null; expire_time: number | null; diff --git a/web/frontend/src/pages/DouyuCollabPage.tsx b/web/frontend/src/pages/DouyuCollabPage.tsx index 983fb36..1aaad79 100644 --- a/web/frontend/src/pages/DouyuCollabPage.tsx +++ b/web/frontend/src/pages/DouyuCollabPage.tsx @@ -1018,6 +1018,16 @@ export default function DouyuCollabPage() { } }; + const copyAccountUsername = async (row: DouyuCollabOrder) => { + if (!row.account_username) return; + try { + await copyTextToClipboard(row.account_username); + message.success(`已复制斗鱼账号 ${row.account_username}`); + } catch (error) { + message.error(`复制失败:${getErrorMessage(error)}`); + } + }; + const openUsernameExport = async () => { if (selectedIds.length === 0) { message.warning('请先勾选协作单'); @@ -1218,15 +1228,29 @@ export default function DouyuCollabPage() { width: 210, render: (_, row) => ( - + + + {row.account_username && ( + +