"""斗鱼任务执行器:角色绑定(由 douyu_runner.py 按功能域拆分)。""" from __future__ import annotations import json import os import time from datetime import UTC, datetime, timedelta from typing import TYPE_CHECKING, Any from sqlalchemy.orm import Session from core.douyu import DouyuActivityClient, DouyuActivityError from ..models import Account, DouyuTask from .account_binding import ( BIND_BOUND, BIND_PENDING, BIND_UNBOUND, SCOPE_ELITE, SCOPE_ESPORTS, binding_pending_decision, binding_snapshot, is_bound_act, is_pending_binding_role, is_role_change_cooling, role_change_available_at, set_bind_status, ) from .business_events import record_bind 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 from .douyu_role_audit import ( record_role_api_candidates, record_role_api_response, ) DOUYU_LEGACY_BIND_ACT_ALIAS = "20250213NQCYX" def _positive_env_int(name: str, default: int) -> int: try: value = int(os.getenv(name, str(default))) except ValueError: return default return value if value > 0 else default # 繁忙时段成功案例也可能轮询 60+ 次才出现角色,10 分钟过短。 DOUYU_BIND_ROLE_POLL_SECONDS = _positive_env_int( "DOUYU_BIND_ROLE_POLL_SECONDS", 20 * 60, ) DOUYU_BIND_ROLE_POLL_INTERVAL = 5 DOUYU_BIND_ROLE_POLL_FAST_SECONDS = 2 * 60 DOUYU_BIND_ROLE_POLL_MEDIUM_SECONDS = 10 * 60 DOUYU_BIND_ROLE_POLL_SLOW_INTERVAL = 20 DOUYU_BIND_ACTION_ALIAS_EVERY_POLLS = 3 DOUYU_CONFIRM_EFFECT_POLL_TIMES = 3 DOUYU_CONFIRM_EFFECT_POLL_INTERVAL = 3 def bind_poll_interval_seconds(elapsed_seconds: float) -> int: """Return the scan-wait polling cadence for a task's elapsed lifetime.""" elapsed = max(0.0, float(elapsed_seconds or 0)) if elapsed < DOUYU_BIND_ROLE_POLL_FAST_SECONDS: return DOUYU_BIND_ROLE_POLL_INTERVAL if elapsed < DOUYU_BIND_ROLE_POLL_MEDIUM_SECONDS: return 10 return DOUYU_BIND_ROLE_POLL_SLOW_INTERVAL class BindMixin: """游戏角色绑定域:绑定状态机、扫码/确认绑定、换绑冷却。""" if TYPE_CHECKING: _stop: Any payload: dict @staticmethod def _to_int(value: Any) -> int | None: ... @staticmethod def _format_wait_time(seconds: int | None) -> str: ... def _push_log(self, level: str, message: str) -> None: ... def _mark_task(self, *args: Any, **kwargs: Any) -> None: ... def _update_task_progress(self, *args: Any, **kwargs: Any) -> None: ... def _client(self, cookie: str) -> DouyuActivityClient: ... @staticmethod def _action_act_alias(config: dict, key: str) -> str: """动作类接口用的活动 alias,排除只用于查询最新角色的 legacy alias。""" alias = str(config.get(key) or "").strip() query_only_alias = str(config.get("legacy_act_alias") or "").strip() if not alias: return "" if alias in {query_only_alias, DOUYU_LEGACY_BIND_ACT_ALIAS}: return "" return alias @classmethod def _bind_qr_act_alias(cls, config: dict) -> str: """生成绑定二维码用的活动 alias。""" return cls._action_act_alias(config, "bind_act_alias") or cls._action_act_alias( config, "confirm_act_alias" ) @staticmethod def _query_bind_act_aliases(config: dict) -> list[str]: """查询/轮询角色用的 alias 列表。 现网最新绑定信息在 legacy(cjm);活动 alias 可能仍用于扫码/确认, 所以按优先级去重返回多个,轮询时取“更像新扫码结果”的那个。 """ ordered = [ str(config.get("legacy_act_alias") or "").strip(), str(config.get("confirm_act_alias") or "").strip(), str(config.get("bind_act_alias") or "").strip(), ] aliases: list[str] = [] for alias in ordered: if alias and alias not in aliases: aliases.append(alias) return aliases @classmethod def _confirm_act_alias(cls, config: dict) -> str: """确认绑定接口用的活动 alias。""" return cls._action_act_alias( config, "confirm_act_alias" ) or cls._action_act_alias(config, "bind_act_alias") # 兼容旧调用名 @classmethod def _current_bind_act_alias(cls, config: dict) -> str: return cls._confirm_act_alias(config) or cls._bind_qr_act_alias(config) @classmethod def _action_act_aliases(cls, config: dict) -> list[str]: """当前活动动作 alias;不包含只用于查询最新扫码态的 legacy/cjm。""" aliases: list[str] = [] for key in ("confirm_act_alias", "bind_act_alias"): alias = cls._action_act_alias(config, key) if alias and alias not in aliases: aliases.append(alias) return aliases @classmethod def _is_bound_act(cls, bind_info: dict | None) -> bool: return is_bound_act(bind_info) @classmethod def _is_change_cooling(cls, bind_info: dict | None) -> bool: """是否处于换绑冷却:已有绑定角色且当前不可换绑。""" return is_role_change_cooling(bind_info) @classmethod def _is_pending_role( cls, bind_info: dict | None, *, baseline_role_name: str = "", baseline_is_bound_act: bool = False, baseline_info: dict | None = None, actionable_aliases: tuple[str, ...] | list[str] = (), ) -> bool: """判断是否出现了可确认的扫码角色。 规则: 1. 必须有角色名 2. 角色名相对 baseline 变化,说明出现了新角色 3. 角色名相同但活动状态从已绑定转为 needBindAct,说明用户本次 扫码选择了同名角色,仍算 pending 4. 无 baseline 且有角色,视为首次绑定的待确认角色 """ return is_pending_binding_role( bind_info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=actionable_aliases, ) @classmethod def _is_newly_confirmed_binding( cls, snapshot: dict, *, baseline_role_name: str, baseline_is_bound_act: bool, ) -> bool: """扫码完成后官方可能直接返回 bindAct=1,而不是 pending。""" role_name = str(snapshot.get("role_name") or "").strip() if not snapshot.get("is_bound_act") or not role_name: return False baseline_role = baseline_role_name.strip() if not baseline_is_bound_act or not baseline_role: return True return role_name.casefold() != baseline_role.casefold() @classmethod def _find_newly_confirmed_binding( cls, candidates: list[dict], *, baseline_role_name: str, baseline_is_bound_act: bool, ) -> dict | None: """Find a scan result that the official API already confirmed.""" for candidate in candidates: if cls._is_newly_confirmed_binding( binding_snapshot(candidate), baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, ): return candidate return None @staticmethod def _bind_poll_snapshot(info: dict | None) -> dict[str, Any] | None: """Small, JSON-safe snapshot used only to detect polling changes.""" if not isinstance(info, dict): return None snapshot = binding_snapshot(info) return { "role_name": snapshot["role_name"], "area_name": snapshot["area_name"], "plat_name": snapshot["plat_name"], "is_bound_act": bool(snapshot["is_bound_act"]), "is_bound_role": bool(snapshot["is_bound_role"]), "need_bind_act": bool(snapshot["need_bind_act"]), "need_bind_role": bool(snapshot["need_bind_role"]), } @classmethod def _bind_poll_snapshot_changed( cls, previous: dict | None, current: dict | None, ) -> bool: current_snapshot = cls._bind_poll_snapshot(current) if current_snapshot is None: return False previous_snapshot = cls._bind_poll_snapshot(previous) if previous_snapshot is not None: return previous_snapshot != current_snapshot return bool( current_snapshot["role_name"] or current_snapshot["is_bound_act"] or current_snapshot["is_bound_role"] or current_snapshot["need_bind_act"] or current_snapshot["need_bind_role"] ) @staticmethod def _split_bind_poll_aliases( query_aliases: list[str], config: dict, ) -> tuple[list[str], list[str]]: """Prefer the cheap legacy probe; activity aliases are verified on change.""" legacy_alias = str(config.get("legacy_act_alias") or "").strip() if legacy_alias and legacy_alias in query_aliases: return ( [legacy_alias], [alias for alias in query_aliases if alias != legacy_alias], ) return query_aliases, [] @staticmethod def _bind_poll_elapsed_seconds( result: dict, *, now: datetime, deadline: datetime | None, ) -> float: raw_generated_at = str(result.get("qr_generated_at") or "").strip() generated_at: datetime | None = None if raw_generated_at: try: generated_at = datetime.fromisoformat(raw_generated_at) except ValueError: generated_at = None if generated_at is not None and generated_at.tzinfo is None: generated_at = generated_at.replace(tzinfo=UTC) if generated_at is None and deadline is not None: generated_at = deadline - timedelta(seconds=DOUYU_BIND_ROLE_POLL_SECONDS) if generated_at is None: return 0.0 return max(0.0, (now - generated_at).total_seconds()) def _bind_snapshot(self, bind_info: dict | None) -> dict: return binding_snapshot(bind_info) def _format_bind_summary( self, bind_info: dict | None, *, pending: bool | None = None ) -> str: snap = self._bind_snapshot(bind_info) role = snap["role_name"] or "-" area = snap["area_name"] or "-" plat = snap["plat_name"] or "-" pending_text = "" if pending is not None: pending_text = f" pending={1 if pending else 0}" return ( f"role={role} area={area} plat={plat}" f" bound_act={1 if snap['is_bound_act'] else 0}" f" bound_role={1 if snap['is_bound_role'] else 0}" f" need_act={1 if snap['need_bind_act'] else 0}" f" need_role={1 if snap['need_bind_role'] else 0}" f" wait={snap['change_role_wait_time'] if snap['change_role_wait_time'] is not None else '-'}" f" can_change_time={snap['can_change_time'] if snap['can_change_time'] is not None else '-'}" f" can={snap['can_change_role']}" f"{pending_text}" ) def _binding_candidate_decisions( self, candidates: list[dict], *, baseline_role_name: str = "", baseline_is_bound_act: bool = False, baseline_info: dict | None = None, actionable_aliases: list[str] | tuple[str, ...] = (), ) -> list[dict[str, Any]]: """按同一规则解释每个 actAlias 候选,供任务结果和日志复盘。""" return [ binding_pending_decision( info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=actionable_aliases, ) for info in candidates ] def _push_binding_decision_log( self, *, task: DouyuTask, stage: str, candidates: list[dict], decisions: list[dict[str, Any]], selected: dict | None, baseline_info: dict | None, actionable_aliases: list[str] | tuple[str, ...], ) -> None: """输出一条可检索的多渠道判定日志,不包含 Cookie 等凭据。""" compact = [ { "alias": item.get("alias") or "", "role": item.get("role_name") or "", "bind_act": 1 if item.get("is_bound_act") else 0, "bind_role": 1 if item.get("is_bound_role") else 0, "need_act": 1 if item.get("need_bind_act") else 0, "need_role": 1 if item.get("need_bind_role") else 0, "actionable_alias": bool(item.get("actionable_alias")), "confirmable": bool(item.get("confirmable")), "reason": item.get("reason") or "", } for item in decisions ] self._push_log( "info", "绑定多渠道判定 | " + json.dumps( { "task_id": int(task.id), "stage": stage, "action_aliases": list(actionable_aliases), "baseline_alias": str((baseline_info or {}).get("act_alias") or ""), "baseline_role": str((baseline_info or {}).get("role_name") or ""), "baseline_bind_act": 1 if self._is_bound_act(baseline_info) else 0, "selected_alias": str((selected or {}).get("act_alias") or ""), "candidate_count": len(candidates), "candidates": compact, }, ensure_ascii=False, separators=(",", ":"), ), ) def _apply_bind_info_to_account( self, account: Account, bind_info: dict, state: str | None = None ) -> None: """写精英角色的**当前值**。 `state` 传 `None` 表示「只更新角色信息,不动绑定状态」—— 纯查询任务 (`query_game_name` 等)就该这样:它们**没有资格**改变绑定状态。 传值时只能是 `account_binding` 的四个枚举。 """ snapshot = binding_snapshot(bind_info) role_name = snapshot["role_name"] account.game_name = role_name or account.game_name account.game_channel = ( snapshot["game_channel"].replace(" / ", " · ") or account.game_channel ) account.change_role_wait_time = snapshot["change_role_wait_time"] account.role_change_available_at = role_change_available_at(bind_info) if state is not None: set_bind_status(account, SCOPE_ELITE, state) account.updated_at = datetime.now(UTC) def _apply_esports_bind_info_to_account( self, account: Account, bind_info: dict, state: str | None = None ) -> None: """将电竞手册角色状态写入专属字段,避免覆盖精英宝典数据。""" snapshot = binding_snapshot(bind_info) role_name = snapshot["role_name"] account.esports_game_name = role_name or account.esports_game_name account.esports_game_channel = ( snapshot["game_channel"].replace(" / ", " · ") or account.esports_game_channel ) account.esports_change_role_wait_time = snapshot["change_role_wait_time"] account.esports_can_change_time = snapshot["can_change_time"] if state is not None: set_bind_status(account, SCOPE_ESPORTS, state) account.updated_at = datetime.now(UTC) def _esports_bind_state( self, client: DouyuActivityClient, act_alias: str, ) -> dict: """查询电竞手册活动状态,接口同时返回当前角色和换绑冷却信息。""" activity_info = query_esports_bind_info(client, act_alias=act_alias) activity_snapshot = self._bind_snapshot(activity_info) esports_bound = activity_snapshot["is_bound_act"] has_selected_role = bool(activity_snapshot["role_name"]) return { **activity_snapshot, "is_bound_role": has_selected_role, "act_alias": act_alias, "game_id": activity_snapshot["game_id"], "esports_bound": esports_bound, "has_selected_role": has_selected_role, "bind_ready_for_confirm": has_selected_role and not esports_bound, "bind_confirmed": esports_bound, "bind_phase": "confirmed" if esports_bound else ("role_ready" if has_selected_role else "waiting_role"), "activity_bind_info": activity_info, "activity_bind_snapshot": activity_snapshot, "role_source": "activity", } @staticmethod def _esports_role_text(state: dict) -> str: role_name = str(state.get("role_name") or "") channel = " / ".join( str(part) for part in [state.get("plat_name"), state.get("area_name")] if part ) if not role_name: return "" return f"{role_name}({channel})" if channel else role_name def _fetch_bind_info_candidates( self, client: DouyuActivityClient, aliases: list[str], ) -> list[dict]: """按多个 actAlias 查询绑定信息,保留成功结果。""" 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={info.get('act_alias') or '-'} {self._format_bind_summary(info)}", ) return results def _role_alias_priority(self, config: dict, primary_alias: str = "") -> list[str]: """角色来源优先级:当前动作 alias > cjm/legacy 最新态。""" ordered = [ primary_alias, str(config.get("confirm_act_alias") or "").strip(), str(config.get("bind_act_alias") or "").strip(), str(config.get("legacy_act_alias") or "").strip(), ] aliases: list[str] = [] for alias in ordered: if alias and alias not in aliases: aliases.append(alias) return aliases def _pick_role_info_for_aliases( self, candidates: list[dict], aliases: list[str], *, pending_only: bool = False, exclude_role_name: str = "", required_role_name: str = "", ) -> dict | None: """按 alias 优先级取角色;可排除指定旧角色,只找发生变化的角色。""" excluded = exclude_role_name.strip().casefold() required = required_role_name.strip().casefold() for alias in aliases: for info in candidates: if str(info.get("act_alias") or "") != alias: continue role_name = str(info.get("role_name") or "").strip() if not role_name: continue if pending_only and self._is_bound_act(info): continue if excluded and role_name.casefold() == excluded: continue if required and role_name.casefold() != required: continue return info return None def _pick_target_role_info( self, candidates: list[dict], config: dict, *, primary_alias: str = "", ) -> dict | None: """选本次操作要确认的角色,优先使用活动 alias 上的新待确认角色。""" if not candidates: return None bound = self._pick_current_bound_info( candidates, config, extra_prefer_aliases=[primary_alias] if primary_alias else None, ) aliases = self._role_alias_priority(config, primary_alias) actionable_aliases = self._action_act_aliases(config) if bound is not None: changed_pending = self._pick_pending_role_info( candidates, prefer_aliases=aliases, baseline_role_name=str(bound.get("role_name") or ""), baseline_is_bound_act=self._is_bound_act(bound), baseline_info=bound, actionable_aliases=actionable_aliases, ) return changed_pending or bound return self._pick_pending_role_info( candidates, prefer_aliases=aliases, baseline_role_name="", baseline_is_bound_act=False, baseline_info=None, actionable_aliases=actionable_aliases, ) or self._pick_role_info_for_aliases(candidates, aliases) def _pick_bind_info( self, candidates: list[dict], *, baseline_role_name: str = "", baseline_is_bound_act: bool = False, baseline_info: dict | None = None, prefer_pending: bool = True, prefer_aliases: list[str] | None = None, actionable_aliases: list[str] | tuple[str, ...] = (), ) -> dict | None: """从多个 alias 结果里挑最有用的绑定信息。 - prefer_pending=True:优先选“待确认/新扫码角色”(通常来自 cjm) - prefer_aliases:在同等条件下优先指定 alias(如活动当前绑定) """ if not candidates: return None ordered = self._ordered_bind_candidates(candidates, prefer_aliases) if prefer_pending: pending = self._pick_pending_role_info( ordered, prefer_aliases=prefer_aliases, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=actionable_aliases, ) if pending is not None: return pending for info in ordered: if str(info.get("role_name") or "").strip(): return info return ordered[0] @staticmethod def _ordered_bind_candidates( candidates: list[dict], prefer_aliases: list[str] | None, ) -> list[dict]: """按业务 alias 优先级稳定排序,供所有角色候选选择复用。""" def _alias_rank(info: dict) -> int: alias = str(info.get("act_alias") or "") if not prefer_aliases: return 0 try: return prefer_aliases.index(alias) except ValueError: return len(prefer_aliases) + 1 ranked = sorted( enumerate(candidates), key=lambda item: (_alias_rank(item[1]), item[0]), ) return [item[1] for item in ranked] def _pick_pending_role_info( self, candidates: list[dict], *, prefer_aliases: list[str] | None, baseline_role_name: str = "", baseline_is_bound_act: bool = False, baseline_info: dict | None = None, actionable_aliases: list[str] | tuple[str, ...] = (), ) -> dict | None: """唯一的新角色候选选择入口。 “是否 pending”只调用 ``_is_pending_role``;二维码轮询、查询角色和换绑 时间查询都从这里选候选,避免各自用角色名或 bindRole 再写一套判断。 """ ordered = self._ordered_bind_candidates(candidates, prefer_aliases) baseline = baseline_role_name.strip().casefold() if baseline: for info in ordered: role_name = str(info.get("role_name") or "").strip() if not role_name or role_name.casefold() == baseline: continue if self._is_pending_role( info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=actionable_aliases, ): return info for info in ordered: if self._is_pending_role( info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=actionable_aliases, ): return info return None def _pick_current_bound_info( self, candidates: list[dict], config: dict, *, extra_prefer_aliases: list[str] | None = None, ) -> dict | None: """选当前活动已生效绑定,避免把 legacy/cjm 的待确认态当成当前角色。""" if not candidates: return None prefer = [] for alias in [*(extra_prefer_aliases or []), *self._action_act_aliases(config)]: alias = str(alias or "").strip() if alias and alias not in prefer: prefer.append(alias) bound = [ info for info in candidates if self._is_bound_act(info) and str(info.get("role_name") or "").strip() and str(info.get("act_alias") or "") in prefer ] if not bound: return None return min( bound, key=lambda info: prefer.index(str(info.get("act_alias") or "")) ) def _pick_baseline_bind_info( self, candidates: list[dict], config: dict, ) -> dict | None: """选“扫码前当前角色”作为 baseline。 活动 alias(20260120QYOOB)上的已绑定或已选待确认角色都可能是 上一次残留。baseline 必须覆盖这两种状态,否则旧角色会被误判成 本次扫码产生的新角色。 """ if not candidates: return None current_bound = self._pick_current_bound_info(candidates, config) if current_bound is not None: return current_bound return self._pick_role_info_for_aliases( candidates, self._role_alias_priority(config), ) def _wait_bind_role_result( self, client: DouyuActivityClient, db: Session, task: DouyuTask, account: Account, query_aliases: list[str], result: dict, baseline_role_name: str = "", baseline_is_bound_act: bool = False, baseline_info: dict | None = None, ) -> tuple[str, dict]: """生成二维码后轮询绑定信息,直到识别到待确认角色、超时或停止。""" deadline = time.monotonic() + DOUYU_BIND_ROLE_POLL_SECONDS result["bind_polling"] = True result["bind_phase"] = result.get("bind_phase") or "waiting_scan" result["bind_ready_for_confirm"] = False result["bind_confirmed"] = False result["baseline_role_name"] = baseline_role_name result["baseline_is_bound_act"] = baseline_is_bound_act result["query_act_aliases"] = query_aliases action_aliases = [ str(value) for value in (result.get("action_act_aliases") or []) if str(value or "").strip() ] self._push_log( "info", "开始轮询绑定角色 " f"aliases={','.join(query_aliases) or '-'} " f"baseline={baseline_role_name or '-'} bound={1 if baseline_is_bound_act else 0}", ) self._update_task_progress( db, task, "running", "已生成绑定二维码,等待扫码绑定", result ) poll_count = 0 last_summary = "" while not self._stop.is_set() and time.monotonic() < deadline: if self._stop.wait(DOUYU_BIND_ROLE_POLL_INTERVAL): break candidates = self._fetch_bind_info_candidates(client, query_aliases) if not candidates: result["bind_poll_error"] = "所有 actAlias 查询绑定信息失败" self._update_task_progress( db, task, "running", "等待绑定角色同步: 查询失败", result ) continue poll_count += 1 bind_info = ( self._pick_bind_info( candidates, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, prefer_pending=True, prefer_aliases=query_aliases, actionable_aliases=action_aliases, ) or candidates[0] ) snapshot = self._bind_snapshot(bind_info) is_pending_role = self._is_pending_role( bind_info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=action_aliases, ) query_alias = str(bind_info.get("act_alias") or "") summary = ( f"act={query_alias or '-'} " f"{self._format_bind_summary(bind_info, pending=is_pending_role)}" ) # 字段变化或每 3 次打印一次,避免刷屏但仍能看到过程 if summary != last_summary or poll_count == 1 or poll_count % 3 == 0: self._push_log("info", f"轮询绑定#{poll_count}: {summary}") last_summary = summary # 注意:未识别到新角色时,不要把当前已绑定角色写进 role_name, # 否则前端会把旧角色误当成“待确认角色/查询结果”。 if is_pending_role: result.update( { **snapshot, "act_alias": query_alias, "query_act_alias": query_alias, "bind_ready_for_confirm": True, "bind_confirmed": False, "bind_phase": "role_ready", "bind_polling": False, "poll_count": poll_count, "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 ], } ) role_name = snapshot["role_name"] # 待确认角色只回传前端展示,不写入账号表,避免“未换绑成功但角色信息已变新” account.updated_at = datetime.now(UTC) self._push_log( "success", f"识别到待确认角色: {role_name} (act={query_alias})" ) self._update_task_progress( db, task, "running", f"已识别角色: {role_name},待确认绑定", result, ) return role_name, result if snapshot["role_name"] and snapshot["is_bound_act"]: result["current_role_name"] = snapshot["role_name"] result["current_area_name"] = snapshot["area_name"] result["current_plat_name"] = snapshot["plat_name"] result.update( { "bind_info": bind_info, "act_alias": query_alias, "query_act_alias": query_alias, "is_bound_act": snapshot["is_bound_act"], "is_bound_role": snapshot["is_bound_role"], "is_bound_account": snapshot["is_bound_account"], "need_bind_act": snapshot["need_bind_act"], "need_bind_role": snapshot["need_bind_role"], "change_role_wait_time": snapshot["change_role_wait_time"], "can_change_role": snapshot["can_change_role"], "role_name": "", "area_name": "", "plat_name": "", "bind_ready_for_confirm": False, "bind_confirmed": False, "bind_phase": "waiting_scan", "bind_polling": True, "poll_count": poll_count, "bind_summary": summary, } ) self._update_task_progress( db, task, "running", f"等待扫码绑定 ({summary})", result ) result["bind_polling"] = False result["bind_ready_for_confirm"] = False result["bind_phase"] = "stopped" if self._stop.is_set() else "role_timeout" result["poll_count"] = poll_count if last_summary: result["bind_summary"] = last_summary self._push_log( "warning", f"轮询结束 phase={result['bind_phase']} polls={poll_count} last={last_summary or '-'}", ) return "", result @staticmethod def _schedule_next_bind_poll( task: DouyuTask, *, now: datetime, interval_seconds: int, ) -> None: task.queue_lane = "binding_poll" task.next_run_at = now + timedelta(seconds=max(1, interval_seconds)) task.last_run_at = now def poll_bind_role_once( self, db: Session, task: DouyuTask, account: Account, config: dict, ) -> None: """Run one scheduled binding poll and immediately release the worker.""" now = datetime.now(UTC) task.last_run_at = now task.attempt_count = int(task.attempt_count or 0) + 1 result = dict(task.result or {}) query_aliases = [ str(value) for value in (result.get("query_act_aliases") or []) if str(value or "").strip() ] if not query_aliases: query_aliases = self._query_bind_act_aliases(config) deadline = task.run_deadline_at poll_number = int(result.get("poll_count") or 0) + 1 interval_seconds = bind_poll_interval_seconds( self._bind_poll_elapsed_seconds(result, now=now, deadline=deadline) ) last_poll = bool( deadline is not None and ( now >= deadline or now + timedelta(seconds=interval_seconds) >= deadline ) ) def finish_timeout() -> None: result.update( { "bind_polling": False, "bind_ready_for_confirm": False, "bind_phase": "role_timeout", } ) task.queue_lane = "" task.next_run_at = None self._mark_task( db, task, "failed", "绑定二维码已过期,未识别到新扫码角色", result, ) client = self._client(str(account.cookie or "")) primary_aliases, action_aliases_to_verify = self._split_bind_poll_aliases( query_aliases, config, ) candidates = self._fetch_bind_info_candidates(client, primary_aliases) primary_info = candidates[0] if candidates else None legacy_changed = self._bind_poll_snapshot_changed( result.get("bind_poll_legacy_snapshot"), primary_info, ) verify_action_alias = bool( action_aliases_to_verify and ( legacy_changed or last_poll or poll_number % DOUYU_BIND_ACTION_ALIAS_EVERY_POLLS == 0 ) ) action_candidates: list[dict] = [] if verify_action_alias: action_candidates = self._fetch_bind_info_candidates( client, action_aliases_to_verify, ) candidates.extend(action_candidates) if primary_info is not None and legacy_changed: record_role_api_candidates( db, account_id=account.id, task_id=task.id, candidates=[primary_info], scope=SCOPE_ELITE, stage="binding_poll.legacy_changed", source="douyu_task.get_bind_qr", ) action_snapshot = [ self._bind_poll_snapshot(item) for item in action_candidates ] if action_candidates and action_snapshot != result.get( "bind_poll_action_audit" ): record_role_api_candidates( db, account_id=account.id, task_id=task.id, candidates=action_candidates, scope=SCOPE_ELITE, stage="binding_poll.action_alias", source="douyu_task.get_bind_qr", ) result["bind_poll_action_audit"] = action_snapshot result["bind_poll_round"] = poll_number result["bind_poll_query_aliases"] = [ *primary_aliases, *(action_aliases_to_verify if verify_action_alias else []), ] if primary_info is not None: result["bind_poll_legacy_snapshot"] = self._bind_poll_snapshot(primary_info) if not candidates: if deadline is not None and datetime.now(UTC) >= deadline: finish_timeout() return result["bind_poll_error"] = "所有 actAlias 查询绑定信息失败" result["bind_polling"] = True result["bind_phase"] = "waiting_scan" self._schedule_next_bind_poll( task, now=now, interval_seconds=interval_seconds, ) self._update_task_progress( db, task, "running", "等待扫码绑定:角色查询暂时失败", result, sync_platform=False, ) return baseline_role_name = str(result.get("baseline_role_name") or "") baseline_is_bound_act = bool(result.get("baseline_is_bound_act")) baseline_info = result.get("before_bind_info") if not isinstance(baseline_info, dict): baseline_info = None action_aliases = self._action_act_aliases(config) bind_info = ( self._pick_bind_info( candidates, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, prefer_pending=True, prefer_aliases=query_aliases, actionable_aliases=action_aliases, ) or candidates[0] ) snapshot = self._bind_snapshot(bind_info) candidate_decisions = self._binding_candidate_decisions( candidates, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=action_aliases, ) selected_decision = binding_pending_decision( bind_info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=action_aliases, ) is_pending_role = bool(selected_decision["confirmable"]) query_alias = str(bind_info.get("act_alias") or "") summary = ( f"act={query_alias or '-'} " f"{self._format_bind_summary(bind_info, pending=is_pending_role)}" ) self._push_binding_decision_log( task=task, stage=f"poll:{poll_number}", candidates=candidates, decisions=candidate_decisions, selected=bind_info, baseline_info=baseline_info, actionable_aliases=action_aliases, ) directly_confirmed = self._find_newly_confirmed_binding( candidates, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, ) if directly_confirmed is not None: bind_info = directly_confirmed snapshot = self._bind_snapshot(bind_info) query_alias = str(bind_info.get("act_alias") or "") selected_decision = binding_pending_decision( bind_info, baseline_role_name=baseline_role_name, baseline_is_bound_act=baseline_is_bound_act, baseline_info=baseline_info, actionable_aliases=action_aliases, ) selected_decision = { **selected_decision, "confirmable": False, "reason": "directly_confirmed", } summary = ( f"act={query_alias or '-'} " f"{self._format_bind_summary(bind_info, pending=False)}" ) task.queue_lane = "" task.next_run_at = None result.update( { **snapshot, "act_alias": query_alias, "query_act_alias": query_alias, "role_name": snapshot["role_name"], "current_role_name": snapshot["role_name"], "current_area_name": snapshot["area_name"], "current_plat_name": snapshot["plat_name"], "bind_ready_for_confirm": False, "bind_confirmed": True, "bind_phase": "confirmed", "bind_polling": False, "poll_count": poll_number, "bind_summary": summary, "action_act_aliases": action_aliases, "bind_decision": selected_decision, "bind_candidate_decisions": candidate_decisions, } ) self._apply_bind_info_to_account(account, bind_info, BIND_BOUND) self._mark_task( db, task, "success", f"绑定成功: {snapshot['role_name']}", result, ) return if is_pending_role: task.queue_lane = "" task.next_run_at = None result.update( { **snapshot, "act_alias": query_alias, "query_act_alias": query_alias, "bind_ready_for_confirm": True, "bind_confirmed": False, "bind_phase": "role_ready", "bind_polling": False, "pending_role_name": snapshot["role_name"], "poll_count": poll_number, "bind_summary": summary, "action_act_aliases": action_aliases, "bind_decision": selected_decision, "bind_candidate_decisions": candidate_decisions, } ) account.updated_at = now self._mark_task( db, task, "success", f"已识别角色: {snapshot['role_name']},待确认绑定", result, ) return if snapshot["role_name"] and snapshot["is_bound_act"]: result["current_role_name"] = snapshot["role_name"] result["current_area_name"] = snapshot["area_name"] result["current_plat_name"] = snapshot["plat_name"] result.update( { "bind_info": bind_info, "act_alias": query_alias, "query_act_alias": query_alias, "is_bound_act": snapshot["is_bound_act"], "is_bound_role": snapshot["is_bound_role"], "is_bound_account": snapshot["is_bound_account"], "need_bind_act": snapshot["need_bind_act"], "need_bind_role": snapshot["need_bind_role"], "change_role_wait_time": snapshot["change_role_wait_time"], "can_change_role": snapshot["can_change_role"], "role_name": "", "area_name": "", "plat_name": "", "bind_ready_for_confirm": False, "bind_confirmed": False, "bind_phase": "waiting_scan", "bind_polling": True, "poll_count": poll_number, "bind_summary": summary, "action_act_aliases": action_aliases, "bind_decision": selected_decision, "bind_candidate_decisions": candidate_decisions, } ) if deadline is not None and datetime.now(UTC) >= deadline: finish_timeout() return self._schedule_next_bind_poll( task, now=now, interval_seconds=interval_seconds, ) self._update_task_progress( db, task, "running", f"等待扫码绑定 ({summary})", result, sync_platform=False, ) def _execute_get_bind_qr( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) qr_act_alias = self._bind_qr_act_alias(config) query_aliases = self._query_bind_act_aliases(config) action_aliases = self._action_act_aliases(config) if not qr_act_alias and not query_aliases: self._mark_task(db, task, "failed", "请先配置绑定活动 actAlias") return if qr_act_alias and qr_act_alias not in query_aliases: query_aliases = [qr_act_alias, *query_aliases] before_candidates = self._fetch_bind_info_candidates(client, query_aliases) if not before_candidates: self._mark_task( db, task, "failed", "查询绑定信息失败,请检查 Cookie 或 actAlias" ) return record_role_api_candidates( db, account_id=account.id, task_id=task.id, candidates=before_candidates, scope=SCOPE_ELITE, stage="bind_qr.preflight", source="douyu_task.get_bind_qr", ) # baseline 用活动 alias 的“当前已绑定”;pending 检测优先 cjm 的换绑最新态 before = self._pick_baseline_bind_info(before_candidates, config) or {} # 换绑冷却必须看活动当前绑定(QYOOB),不要用 cjm cooldown_info = self._pick_change_wait_bind_info(before_candidates, config) cooldown = cooldown_info or {} pending_before = ( self._pick_bind_info( before_candidates, baseline_role_name=str(before.get("role_name") or ""), baseline_is_bound_act=self._is_bound_act(before), baseline_info=before, prefer_pending=True, prefer_aliases=query_aliases, actionable_aliases=action_aliases, ) or before or before_candidates[0] ) candidate_decisions = self._binding_candidate_decisions( before_candidates, baseline_role_name=str(before.get("role_name") or ""), baseline_is_bound_act=self._is_bound_act(before), baseline_info=before, actionable_aliases=action_aliases, ) pending_decision = binding_pending_decision( pending_before, baseline_role_name=str(before.get("role_name") or ""), baseline_is_bound_act=self._is_bound_act(before), baseline_info=before, actionable_aliases=action_aliases, ) before_snapshot = self._bind_snapshot(before) cooldown_snapshot = self._bind_snapshot(cooldown_info) current_role_name = before_snapshot["role_name"] or ( cooldown_snapshot["role_name"] if cooldown_snapshot["is_bound_act"] else "" ) wait_time = cooldown_snapshot["change_role_wait_time"] self._push_log( "info", "绑定前状态 " f"qr_act={qr_act_alias or '-'} query={','.join(query_aliases)} " f"baseline_hit={before.get('act_alias') or '-'} {self._format_bind_summary(before)} " f"cooldown_hit={cooldown.get('act_alias') or '-'} " f"{self._format_bind_summary(cooldown_info)} " f"pending_hit={pending_before.get('act_alias') or '-'} " f"{self._format_bind_summary(pending_before)}", ) self._push_binding_decision_log( task=task, stage="qr_preflight", candidates=before_candidates, decisions=candidate_decisions, selected=pending_before, baseline_info=before, actionable_aliases=action_aliases, ) # 生成二维码前强制检查换绑冷却:冷却中直接失败,绝不发码 if self._is_change_cooling(cooldown_info): role_label = ( current_role_name or cooldown_snapshot["role_name"] or "当前角色" ) wait_text = self._format_wait_time(wait_time) or "冷却中" self._push_log( "warning", f"换绑冷却中,跳过生成二维码 role={role_label} wait={wait_time if wait_time is not None else '-'} " f"can={cooldown.get('can_change_role')}", ) result = { "act_alias": qr_act_alias or cooldown.get("act_alias") or before.get("act_alias"), "query_act_alias": cooldown.get("act_alias") or before.get("act_alias"), "query_act_aliases": query_aliases, "before_bind_info": before, "cooldown_bind_info": cooldown_info, **cooldown_snapshot, "current_role_name": role_label if role_label != "当前角色" else current_role_name, "current_area_name": cooldown_snapshot["area_name"] or before_snapshot["area_name"], "current_plat_name": cooldown_snapshot["plat_name"] or before_snapshot["plat_name"], "change_role_wait_time": wait_time, "change_role_wait_text": self._format_wait_time(wait_time), "bind_ready_for_confirm": False, "bind_confirmed": bool( cooldown_snapshot["is_bound_act"] or before_snapshot["is_bound_act"] ), "bind_phase": "change_waiting", "bind_polling": False, } self._apply_bind_info_to_account( account, cooldown if cooldown_snapshot["role_name"] else before, BIND_BOUND if result["bind_confirmed"] else None, ) self._mark_task( db, task, "failed", f"{role_label} 暂不能换绑,剩余 {wait_text}", result, ) return if not qr_act_alias: self._mark_task(db, task, "failed", "请先配置绑定二维码活动 actAlias") return self._push_log( "info", f"换绑校验通过,开始生成二维码 act={qr_act_alias} " f"role={current_role_name or '-'} wait={wait_time if wait_time is not None else 0}", ) qr_result = client.get_bind_qr(qr_act_alias) qr_generated_at = datetime.now(UTC) result = { **qr_result, "act_alias": qr_act_alias, "query_act_aliases": query_aliases, "before_bind_info": before, "current_role_name": current_role_name, "current_area_name": before_snapshot["area_name"], "current_plat_name": before_snapshot["plat_name"], "role_name": "", "area_name": "", "plat_name": "", "bind_ready_for_confirm": False, "bind_confirmed": False, "bind_phase": "waiting_scan", "bind_polling": True, "qr_generated_at": qr_generated_at.isoformat(), "qr_expires_at": ( qr_generated_at + timedelta(seconds=DOUYU_BIND_ROLE_POLL_SECONDS) ).isoformat(), "baseline_role_name": current_role_name, "baseline_is_bound_act": before_snapshot["is_bound_act"], "action_act_aliases": action_aliases, "bind_decision": pending_decision, "bind_candidate_decisions": candidate_decisions, "poll_count": 0, "bind_poll_legacy_snapshot": self._bind_poll_snapshot( next( ( item for item in before_candidates if str(item.get("act_alias") or "") == str(config.get("legacy_act_alias") or "") ), None, ) ), } if pending_decision["confirmable"]: pending_snapshot = self._bind_snapshot(pending_before) pending_role = str(pending_snapshot["role_name"] or "") pending_alias = str(pending_before.get("act_alias") or "") pending_summary = ( f"act={pending_alias or '-'} " f"{self._format_bind_summary(pending_before, pending=True)}" ) result.update( { **pending_snapshot, "act_alias": pending_alias, "query_act_alias": pending_alias, "pending_role_name": pending_role, "bind_ready_for_confirm": True, "bind_confirmed": False, "bind_phase": "role_ready", "bind_polling": False, "bind_summary": pending_summary, } ) account.updated_at = qr_generated_at self._push_log( "success", "生成二维码前已发现活动 alias 待确认角色 " f"act={pending_alias or '-'} role={pending_role or '-'} " f"reason={pending_decision['reason']}", ) self._mark_task( db, task, "success", f"已识别现有待确认角色: {pending_role},待确认绑定", result, ) return account.updated_at = datetime.now(UTC) task.queue_lane = "binding_poll" task.next_run_at = qr_generated_at + timedelta( seconds=DOUYU_BIND_ROLE_POLL_INTERVAL ) task.run_deadline_at = qr_generated_at + timedelta( seconds=DOUYU_BIND_ROLE_POLL_SECONDS ) task.last_run_at = qr_generated_at task.attempt_count = 0 # Publish the QR immediately, then return without holding a worker while # the customer scans. The durable scheduler resumes role polling. self._update_task_progress( db, task, "running", "已生成绑定二维码,等待扫码绑定", result ) def _execute_confirm_bind( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) confirm_alias = self._confirm_act_alias(config) query_aliases = self._query_bind_act_aliases(config) action_aliases = self._action_act_aliases(config) if confirm_alias and confirm_alias not in query_aliases: query_aliases = [confirm_alias, *query_aliases] if not confirm_alias: self._mark_task(db, task, "failed", "请先配置确认绑定活动 actAlias") return if not query_aliases: self._mark_task(db, task, "failed", "请先配置绑定活动 actAlias") return before_candidates = self._fetch_bind_info_candidates(client, query_aliases) if not before_candidates: self._mark_task( db, task, "failed", "查询绑定信息失败,请检查 Cookie 或 actAlias" ) return record_role_api_candidates( db, account_id=account.id, task_id=task.id, candidates=before_candidates, scope=SCOPE_ELITE, stage="confirm_bind.precheck", source="douyu_task.confirm_bind", ) # 确认前“已生效绑定”角色(bound_act=1),确认失败/回查失败时写库用,避免待确认角色污染 game_name before_bound = self._pick_current_bound_info( before_candidates, config, extra_prefer_aliases=[confirm_alias], ) expected_role_name = str( (task.result or {}).get("expected_role_name") or "" ).strip() if expected_role_name: before = self._pick_role_info_for_aliases( before_candidates, self._role_alias_priority(config, confirm_alias), required_role_name=expected_role_name, ) else: before = self._pick_target_role_info( before_candidates, config, primary_alias=confirm_alias, ) before = before or before_bound or before_candidates[0] before_snapshot = self._bind_snapshot(before) candidate_decisions = self._binding_candidate_decisions( before_candidates, baseline_role_name=str((before_bound or {}).get("role_name") or ""), baseline_is_bound_act=self._is_bound_act(before_bound), baseline_info=before_bound, actionable_aliases=action_aliases, ) self._push_binding_decision_log( task=task, stage="confirm_precheck", candidates=before_candidates, decisions=candidate_decisions, selected=before, baseline_info=before_bound, actionable_aliases=action_aliases, ) role_name = before_snapshot["role_name"] query_alias = str(before.get("act_alias") or "") if expected_role_name and role_name.casefold() != expected_role_name.casefold(): self._mark_task( db, task, "failed", f"待确认角色已变化,未找到: {expected_role_name}", { "act_alias": confirm_alias, "query_act_aliases": query_aliases, "expected_role_name": expected_role_name, "bind_ready_for_confirm": False, "bind_confirmed": False, "bind_phase": "confirm_failed", "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 before_candidates ], }, ) return self._push_log( "info", f"确认前状态 confirm_act={confirm_alias or '-'} hit={query_alias or '-'} " f"expected={expected_role_name or '-'} " f"{self._format_bind_summary(before)}", ) if not role_name: self._mark_task( db, task, "failed", "尚未识别到待确认角色,请先扫码完成绑定", { "act_alias": confirm_alias or query_alias, "query_act_alias": query_alias, "query_act_aliases": query_aliases, "before_bind_info": before, **before_snapshot, "bind_ready_for_confirm": False, "bind_confirmed": False, "bind_phase": "waiting_role", }, ) return before_is_current_bound = ( before_bound is not None and str(before.get("act_alias") or "") == str(before_bound.get("act_alias") or "") and role_name == str(before_bound.get("role_name") or "") ) if before_is_current_bound and before_bound is not None: self._apply_bind_info_to_account(account, before_bound, BIND_BOUND) self._mark_task( db, task, "success", f"已绑定: {role_name}", { "act_alias": confirm_alias or query_alias, "query_act_alias": query_alias, "query_act_aliases": query_aliases, "before_bind_info": before_bound, **self._bind_snapshot(before_bound), "bind_ready_for_confirm": True, "bind_confirmed": True, "bind_phase": "confirmed", }, ) return # 确认接口优先用配置的确认 alias;没有则回退到命中查询的 alias use_confirm_alias = confirm_alias or query_alias try: confirm_result = client.confirm_bind(use_confirm_alias) except DouyuActivityError as exc: confirm_msg = str(exc) self._push_log("warning", f"确认绑定接口失败: {confirm_msg}") # 待绑定游戏账号侧换绑限制(未到换绑时间等)导致确认失败:保留原绑定并给出明确提示 if before_bound is not None: self._apply_bind_info_to_account(account, before_bound) else: account.updated_at = datetime.now(UTC) self._mark_task( db, task, "failed", f"待绑定游戏账号({role_name or '-'})未到换绑时间(不是斗鱼/虎牙账号),请重新换账号扫码绑定", { "act_alias": use_confirm_alias, "query_act_alias": query_alias, "query_act_aliases": query_aliases, "before_bind_info": before, **before_snapshot, "confirm_error": confirm_msg, "bind_ready_for_confirm": True, "bind_confirmed": False, "bind_phase": "confirm_failed", }, ) return confirm_raw = confirm_result.get("raw") or {} record_role_api_response( db, account_id=account.id, task_id=task.id, response=confirm_raw if isinstance(confirm_raw, dict) else {}, scope=SCOPE_ELITE, stage="confirm_bind.response", source="douyu_task.confirm_bind", act_alias=use_confirm_alias, ) self._push_log( "info", f"确认绑定接口返回 act={use_confirm_alias} " f"error={confirm_raw.get('error')} msg={confirm_raw.get('msg') or '-'}", ) def _pick_bound_after(candidates: list[dict]) -> dict | None: """确认后回查:只认活动 alias 上的已生效绑定(bound_act=1)。""" return self._pick_current_bound_info( candidates, config, extra_prefer_aliases=[use_confirm_alias], ) try: after_candidates = self._fetch_bind_info_candidates(client, query_aliases) if not after_candidates: raise DouyuActivityError("确认后回查绑定信息失败") after = _pick_bound_after(after_candidates) # 已生效绑定存在同步延迟:确认接口已成功但未生效时短轮询等待 if after is None: for _ in range(DOUYU_CONFIRM_EFFECT_POLL_TIMES): if self._stop.wait(DOUYU_CONFIRM_EFFECT_POLL_INTERVAL): break after_candidates = self._fetch_bind_info_candidates( client, query_aliases ) if not after_candidates: break after = _pick_bound_after(after_candidates) if after is not None: break if after_candidates: record_role_api_candidates( db, account_id=account.id, task_id=task.id, candidates=after_candidates, scope=SCOPE_ELITE, stage="confirm_bind.after", source="douyu_task.confirm_bind", ) if after is None: # 已生效绑定始终未出现:确认未生效(或同步延迟超时),保留原绑定 if before_bound is not None: self._apply_bind_info_to_account(account, before_bound) else: account.updated_at = datetime.now(UTC) self._mark_task( db, task, "failed", f"待绑定游戏账号({role_name or '-'})未到换绑时间(不是斗鱼/虎牙账号),请重新换账号扫码绑定", { "act_alias": use_confirm_alias, "query_act_alias": query_alias, "query_act_aliases": query_aliases, "before_bind_info": before, "confirm": confirm_result, "after_bind_info": None, **before_snapshot, "bind_ready_for_confirm": True, "bind_confirmed": False, "bind_phase": "confirm_failed", "confirm_wait_error": "确认后短轮询未等到已生效绑定", }, ) return self._push_log( "info", f"确认后回查 hit={after.get('act_alias') or '-'} " f"{self._format_bind_summary(after)}", ) except DouyuActivityError as exc: # 查询接口异常:确认接口已成功时按成功处理,但保留错误信息。 # 写库优先确认前已生效绑定,避免待确认角色被误写入。 if before_bound is not None: self._apply_bind_info_to_account(account, before_bound, BIND_BOUND) else: account.updated_at = datetime.now(UTC) # 确认接口成功了,但回查抛异常 —— 没能亲眼看到绑定生效。 # 仍然记(确认请求确实发出且成功),但 weak=True 标出来。 record_bind( db, account, task_id=task.id, scope="elite", role_name=role_name, act_alias=use_confirm_alias, rebind=_bind_is_rebind(before_snapshot), weak=True, actor_id=int(task.created_by), ) self._mark_task( db, task, "success", f"绑定成功: {role_name}", { "act_alias": use_confirm_alias, "query_act_alias": query_alias, "query_act_aliases": query_aliases, "before_bind_info": before, "confirm": confirm_result, **before_snapshot, "bind_ready_for_confirm": True, "bind_confirmed": True, "bind_phase": "confirmed", "refresh_error": str(exc), }, ) return after_snapshot = self._bind_snapshot(after) final_role_name = after_snapshot["role_name"] or role_name self._apply_bind_info_to_account(account, after, BIND_BOUND) # 强事实:确认接口成功 + 回查命中已生效绑定。 # ⚠️ 上面还有一条 success 是「检测到账号**本来就已经绑定**」(什么都没做), # 那条**不发事件** —— 否则用户每点一次「确认绑定」时间线就多一条假的绑定记录。 record_bind( db, account, task_id=task.id, scope="elite", role_name=final_role_name, act_alias=use_confirm_alias, rebind=_bind_is_rebind(after_snapshot), actor_id=int(task.created_by), ) self._mark_task( db, task, "success", f"绑定成功: {final_role_name}", { "act_alias": use_confirm_alias, "query_act_alias": after.get("act_alias") or query_alias, "query_act_aliases": query_aliases, "before_bind_info": before, "confirm": confirm_result, "after_bind_info": after, **after_snapshot, "bind_ready_for_confirm": True, "bind_confirmed": True, "bind_phase": "confirmed", }, ) def _execute_prepare_esports_bind( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict, ): """打开电竞手册绑定面板:查活动状态、当前角色和换绑冷却。""" client = self._client(cookie) act_alias = str(config.get("esports_act_alias") or "").strip() if not act_alias: self._mark_task(db, task, "failed", "请先配置电竞手册活动 actAlias") return state = self._esports_bind_state(client, act_alias) esports_bound = state["esports_bound"] role_text = self._esports_role_text(state) self._apply_esports_bind_info_to_account( account, state, BIND_BOUND if esports_bound else (BIND_PENDING if role_text else BIND_UNBOUND), ) # 二维码用于重新选择角色,不应因为已有角色或换绑冷却而隐藏。 # 冷却是否允许最终由 actBind 返回结果决定。 qr_result = client.get_esports_bind_qr(act_alias) result = { **state, **qr_result, "esports_bind_dialog": True, "can_open_role_selector": True, } if esports_bound: message = f"电竞手册已绑定: {role_text or '-'},可扫码换绑" elif role_text: message = f"当前角色: {role_text},可扫码切换角色或直接完成绑定" else: message = "请扫码选择游戏角色,完成后查询最新角色" self._mark_task(db, task, "success", message, result) def _execute_get_esports_bind_qr( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict, ): """生成电竞手册切换角色用的腾讯入口。""" client = self._client(cookie) act_alias = str(config.get("esports_act_alias") or "").strip() if not act_alias: self._mark_task(db, task, "failed", "请先配置电竞手册活动 actAlias") return state = self._esports_bind_state(client, act_alias) qr_result = client.get_esports_bind_qr(act_alias) result = { **state, **qr_result, "esports_bind_dialog": True, "can_open_role_selector": True, "bind_phase": "switching_role", } account.updated_at = datetime.now(UTC) self._mark_task( db, task, "success", "请在腾讯页面选择角色,返回后查询最新角色", result, ) def _execute_confirm_esports_bind( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict, ): """通过 actBind 确认电竞手册绑定,并回读唯一状态接口确认结果。""" client = self._client(cookie) act_alias = str(config.get("esports_act_alias") or "").strip() if not act_alias: self._mark_task(db, task, "failed", "请先配置电竞手册活动 actAlias") return account.updated_at = datetime.now(UTC) self._update_task_progress( db, task, "running", "正在确认电竞手册绑定", { "bind_phase": "confirming", "bind_confirmed": False, }, ) confirm_result = client.confirm_esports_bind( act_alias, room_id=str(config.get("room_id") or "9263298"), ) after_state = self._esports_bind_state(client, act_alias) result = { **after_state, "confirm": confirm_result, "bind_phase": "confirmed" if after_state["esports_bound"] else "confirm_failed", } if not after_state["esports_bound"]: self._apply_esports_bind_info_to_account(account, after_state, BIND_PENDING) self._mark_task( db, task, "failed", f"电竞手册绑定未生效: {self._esports_role_text(after_state) or '-'}", result, ) return self._apply_esports_bind_info_to_account(account, after_state, BIND_BOUND) # 业务事实在这一刻成立:确认接口成功 + 回查 esports_bound 为真。 # 必须在 _mark_task 之前发 —— 它内部 commit,而 emit 只 RELEASE SAVEPOINT、 # 不提交外层事务,runner 的 finally 只 close(未提交即回滚),之后发会被静默丢弃。 role_text = self._esports_role_text(after_state) or "" record_bind( db, account, task_id=task.id, scope="esports", role_name=role_text, act_alias=act_alias, actor_id=int(task.created_by), ) self._mark_task( db, task, "success", f"电竞手册绑定成功: {role_text or '-'}", result, ) def _execute_query_esports_game_name( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict, ): """查询电竞手册活动返回的最新角色和换绑冷却状态。""" client = self._client(cookie) act_alias = str(config.get("esports_act_alias") or "").strip() if not act_alias: self._mark_task(db, task, "failed", "请先配置电竞手册活动 actAlias") return state = self._esports_bind_state(client, act_alias) role_name = state["role_name"] is_bound = state["esports_bound"] self._apply_esports_bind_info_to_account( account, state, BIND_BOUND if is_bound else ("esports_bind_ready" if role_name else "game_not_bound"), ) result = { **state, "esports_bind_dialog": True, "can_open_role_selector": True, } if role_name: message = f"最新角色: {self._esports_role_text(state)}" else: message = "未查询到游戏角色,请先切换角色" self._mark_task(db, task, "success", message, result) def _execute_query_game_name( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) role = resolve_elite_role(client, config) status = str(role.get("status") or "") bind_info = ( role.get("bind_info") if isinstance(role.get("bind_info"), dict) else {} ) 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 "") action_aliases = self._action_act_aliases(config) raw_candidates = [ item for item in (role.get("bind_infos") or []) if isinstance(item, dict) ] candidate_decisions = self._binding_candidate_decisions( raw_candidates, baseline_role_name=str(role_name or ""), baseline_is_bound_act=status == ROLE_BOUND, baseline_info=bind_info if isinstance(bind_info, dict) else None, actionable_aliases=action_aliases, ) summary = ( f"act={source_alias or '-'} {self._format_bind_summary(bind_info)}" if bind_info else "act=- role=-" ) self._push_log( "info", "查询角色 " 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=-'}", ) self._push_binding_decision_log( task=task, stage="query_game_name", candidates=raw_candidates, decisions=candidate_decisions, selected=bind_info, baseline_info=bind_info if isinstance(bind_info, dict) else None, actionable_aliases=action_aliases, ) 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": 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 status == ROLE_BOUND else ("role_ready" if role_name else "waiting_role") ), "bind_summary": summary, "bind_candidates": role.get("candidates") or [], "action_act_aliases": action_aliases, "bind_decision": role.get("decision") or {}, "bind_candidate_decisions": candidate_decisions, "errors": role.get("errors") or [], } if pending_role: result["pending_role_name"] = pending_role 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}" 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 ) -> dict | None: """换绑倒计时优先看活动当前绑定(QYOOB),不是 cjm 换绑最新态。""" if not candidates: return None # 冷却是“当前已生效绑定”的属性,不能用 legacy/cjm 的待确认角色判断。 current_bound = self._pick_current_bound_info(candidates, config) if current_bound is not None: return current_bound action_aliases = self._action_act_aliases(config) return self._pick_bind_info( [ info for info in candidates if str(info.get("act_alias") or "") in action_aliases ], prefer_pending=False, prefer_aliases=action_aliases, ) def _execute_query_change_bind_time( self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict ): client = self._client(cookie) 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", f"查询绑定信息失败: {';'.join(role.get('errors') or ['未知错误'])}", ) return for item in raw_candidates: self._push_log( "info", f"查询换绑时间候选 act={item.get('act_alias') or '-'} " f"{self._format_bind_summary(item)}", ) # 换绑时间看“当前已绑定”活动态,不要优先 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 = ( 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"] 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"] role_name = snapshot["role_name"] or "-" if wait_time is None: if can_change is False: status_text = "不可换绑(接口未返回倒计时)" elif can_change is True: status_text = "可换绑" else: status_text = "未返回换绑倒计时" elif wait_time <= 0: status_text = "可换绑" wait_text = "0" else: status_text = f"剩余 {wait_text}" result = { "act_alias": source_alias, "query_act_alias": source_alias, "query_act_aliases": query_aliases, **snapshot, "change_role_wait_text": wait_text, "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": role.get("candidates") 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} " f"wait={wait_time if wait_time is not None else '-'} can={can_change}", ) self._mark_task( db, task, "success", f"{role_name} {status_text} | act={source_alias or '-'}", result, ) def _bind_is_rebind(snapshot: dict) -> bool: """这次是「换绑」还是「首次绑定」。 `before_bound` 命中说明确认前**该账号已有一个生效绑定**,本次是把角色换掉; 否则是首次绑定。旧收集器不区分,时间线上看不出「换绑」这件事。 """ return bool( snapshot.get("bound_act") or snapshot.get("bind_confirmed") or snapshot.get("role_name") )