Files
live-hub-py/web/backend/services/douyu_runner_manual.py
T

577 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""斗鱼任务执行器:手册开通与积分(由 douyu_runner.py 按功能域拆分)。"""
from __future__ import annotations
from datetime import UTC, datetime
from typing import TYPE_CHECKING, Any
from sqlalchemy.orm import Session
from core.douyu import DouyuActivityClient, DouyuActivityError
from ..models import Account, DouyuTask
from .account_events_service import EVENT_ELITE_OPENED, EVENT_ESPORTS_OPENED, emit
from .douyu_activity_query import query_csrf, query_elite_user_info, query_points
from .douyu_elite_status import (
elite_is_currently_open,
normalize_elite_expire_time,
)
from .douyu_service import account_uid, update_account_profile_from_cookie
class ManualMixin:
"""手册域:精英/电竞手册开通支付、积分查询与到账轮询。"""
if TYPE_CHECKING:
_stop: Any
@staticmethod
def _to_int(value: Any) -> int | None: ...
def _client(
self, cookie: str, *, direct: bool = False
) -> DouyuActivityClient: ...
def _task_payload(self, task: DouyuTask) -> dict: ...
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 _schedule_payment_poll(self, *args: Any, **kwargs: Any) -> None: ...
@classmethod
def _confirm_act_alias(cls, config: dict) -> str: ...
@classmethod
def _bind_qr_act_alias(cls, config: dict) -> str: ...
def _refresh_account_points(
self,
client: DouyuActivityClient,
account: Account,
cookie: str,
*,
ctn: str | None = None,
) -> dict:
"""刷新账号积分并写回账号表。"""
uid = account_uid(account, cookie)
if not uid:
raise DouyuActivityError("Cookie 中没有 acf_uid,无法查询积分")
ctn_value = ctn or query_csrf(client)
result = query_points(client, uid=uid, ctn=ctn_value)
points = self._to_int(result.get("points"))
account.uid = uid
account.points = points
update_account_profile_from_cookie(account, cookie)
account.updated_at = datetime.now(UTC)
return {"points": points, "points_query": result}
@staticmethod
def _format_expire_text(expire_time: int | None) -> str:
"""把到期时间戳格式化成中文描述,缺失或为 0 时返回空串。"""
if not expire_time or expire_time <= 0:
return ""
expire_at = datetime.fromtimestamp(expire_time, tz=UTC).astimezone()
return f"(到期 {expire_at:%Y-%m-%d %H:%M})"
def _refresh_elite_handbook(
self,
client: DouyuActivityClient,
account: Account,
*,
manual_id: str,
rid: str = "",
) -> dict:
"""查询精英宝典开通状态(manualType/expireTime)并写回账号。
积分区分不了「开通后积分花完」和「从未开通」。manualType >= 1
表示开通过,expireTime 决定当前是否仍有效;已到期必须按未开通处理。
"""
result = query_elite_user_info(client, manual_id=manual_id, rid=rid)
manual_type = self._to_int(result.get("manual_type")) or 0
manual_score = self._to_int(result.get("manual_score"))
expire_time = normalize_elite_expire_time(result.get("expire_time")) or 0
opened = elite_is_currently_open(manual_type, expire_time)
expired = manual_type >= 1 and not opened
account.elite_opened = opened
account.elite_expire_time = expire_time or None
if manual_score is not None:
account.points = manual_score
account.updated_at = datetime.now(UTC)
return {
"elite_manual_type": manual_type,
"elite_manual_score": manual_score,
"elite_expire_time": expire_time,
"elite_opened": opened,
"elite_expired": expired,
"elite_user_info": result,
"points": manual_score,
}
def _execute_query_elite_status(
self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict
):
"""查询精英宝典是否已开通、到期时间与积分。"""
manual_id = str(config.get("manual_id") or "").strip()
if not manual_id:
self._mark_task(db, task, "failed", "请先配置精英宝典 manualID")
return
client = self._client(cookie)
result = self._refresh_elite_handbook(
client,
account,
manual_id=manual_id,
rid=str(config.get("rid") or ""),
)
account.updated_at = datetime.now(UTC)
state = (
"已过期"
if result["elite_expired"]
else ("已开通" if result["elite_opened"] else "未开通")
)
expire_text = self._format_expire_text(result["elite_expire_time"])
points = result["elite_manual_score"]
self._mark_task(
db,
task,
"success",
f"精英宝典{state}{expire_text},积分: {points if points is not None else '-'}",
result,
)
def _poll_create_elite_qr_once(
self,
db: Session,
task: DouyuTask,
account: Account,
cookie: str,
config: dict,
) -> None:
"""查询一次精英宝典开通到账。"""
del config
result = dict(task.result or {})
result["payment_polling"] = True
result["payment_target_points"] = 300
result["payment_poll_count"] = int(result.get("payment_poll_count") or 0) + 1
baseline_points = self._to_int(result.get("elite_points_baseline"))
try:
client = self._client(cookie, direct=True)
ctn = str(result.get("payment_ctn") or "")
if not ctn:
ctn = query_csrf(client, refresh_subscribe=True)
result["payment_ctn"] = ctn
points_result = self._refresh_account_points(
client, account, cookie, ctn=ctn
)
db.commit()
last_points = points_result["points"]
result.update(points_result)
arrived = last_points is not None and (
last_points > baseline_points
if baseline_points is not None
else last_points >= 300
)
if arrived:
result.pop("payment_poll_error", None)
result["payment_polling"] = False
result["elite_opened"] = True
account.elite_opened = True
# 到账判定本身已经调用过积分接口;成功后再收口一次,确保任务结果
# 和账号积分反映的是开通完成后的最终值。
try:
final_points = self._refresh_account_points(
client, account, cookie, ctn=ctn
)
result.update(final_points)
result["points_refreshed_after_elite_opened"] = True
self._push_log(
"info",
"精英宝典开通成功,已刷新积分: "
f"{account.points if account.points is not None else '-'}",
)
except Exception as exc: # noqa: BLE001 开通成功后刷新失败不翻盘
result["points_refreshed_after_elite_opened"] = False
result["elite_open_points_refresh_error"] = str(exc)
self._push_log("warning", f"精英宝典开通后刷新积分失败: {exc}")
account.updated_at = datetime.now(UTC)
spent = _points_spent(baseline_points, account.points)
emit(
db,
account_id=account.id,
event_type=EVENT_ELITE_OPENED,
title=f"精英宝典开通 -{spent}" if spent else "精英宝典开通",
occurred_at=account.updated_at,
amount=-spent if spent else None,
detail={
"points": account.points,
"expire_time": account.elite_expire_time,
"spent": spent,
},
source="manual",
actor_type="user",
actor_id=int(task.created_by),
source_ref=(
f"elite_opened:{account.id}:"
f"{int(account.updated_at.timestamp())}"
),
)
self._mark_task(
db,
task,
"success",
f"精英宝典已开通,积分: {account.points}",
result,
)
return
result.pop("payment_poll_error", None)
self._schedule_payment_poll(
db,
task,
result,
"精英宝典支付码已生成,等待开通到账"
f"(当前积分 {last_points if last_points is not None else '-'})",
)
except Exception as exc: # noqa: BLE001 外部接口失败继续等待
result["payment_poll_error"] = str(exc)
self._schedule_payment_poll(
db,
task,
result,
f"等待精英宝典开通到账: {exc}",
)
def _refresh_esports_handbook(
self,
client: DouyuActivityClient,
account: Account,
*,
manual_id: str,
) -> dict:
"""刷新电竞手册开通状态并将积分写回账号。"""
result = client.esports_user_info(manual_id=manual_id)
manual_type = self._to_int(result.get("manual_type"))
manual_score = self._to_int(result.get("manual_score"))
account.esports_points = manual_score
# 开通状态也要落库 —— 与精英对称。
# 之前只有 elite 那支写 `account.elite_opened`,电竞的 `esports_opened`
# **只在"开通"任务里被设置**,于是详情页的电竞「已开通/未开通」
# 根本不会被一键查询更新(用户报"电竞到期时间拿不到"时顺带查出来的)。
# 判定口径与 create_esports_qr 一致:manual_type >= 1 即已开通。
account.esports_opened = manual_type is not None and manual_type >= 1
# 到期时间也落库 —— 否则界面只能显示"已开通",看不到什么时候到期
expire_raw = result.get("expire_time")
expire_int = self._to_int(expire_raw)
# ⚠️ 斗鱼用 0 表示「没有到期时间」。直接存 0 的话界面会显示 1970/1/1
# (这个坑在积分到期上踩过一次,这里别再踩)。
account.esports_expire_time = (
expire_int if expire_int and expire_int > 0 else None
)
account.updated_at = datetime.now(UTC)
return {
"esports_manual_type": manual_type,
"esports_manual_score": manual_score,
"esports_expire_time": result.get("expire_time"),
"esports_user_info": result,
"esports_points": manual_score,
"points": manual_score,
}
def _poll_create_esports_qr_once(
self,
db: Session,
task: DouyuTask,
account: Account,
cookie: str,
config: dict,
) -> None:
"""查询一次电竞手册开通到账。"""
result = dict(task.result or {})
result["payment_polling"] = True
result["payment_poll_count"] = int(result.get("payment_poll_count") or 0) + 1
manual_id = str(
result.get("payment_manual_id") or config.get("esports_manual_id") or ""
).strip()
baseline_manual_score = self._to_int(
result.get("esports_manual_score_baseline")
)
if not manual_id:
self._mark_task(
db,
task,
"failed",
"请先配置电竞手册 manualID",
result,
)
return
try:
client = self._client(cookie, direct=True)
handbook_result = self._refresh_esports_handbook(
client,
account,
manual_id=manual_id,
)
db.commit()
last_manual_type = handbook_result["esports_manual_type"]
last_manual_score = handbook_result["esports_manual_score"]
result.update(handbook_result)
opened = (last_manual_type is not None and last_manual_type >= 1) or (
baseline_manual_score is not None
and last_manual_score is not None
and last_manual_score > baseline_manual_score
)
if opened:
result.pop("payment_poll_error", None)
result["payment_polling"] = False
result["esports_opened"] = True
account.updated_at = datetime.now(UTC)
spent = _points_spent(baseline_manual_score, account.esports_points)
emit(
db,
account_id=account.id,
event_type=EVENT_ESPORTS_OPENED,
title=f"电竞手册开通 -{spent}" if spent else "电竞手册开通",
occurred_at=account.updated_at,
amount=-spent if spent else None,
detail={"points": account.esports_points, "spent": spent},
source="manual",
actor_type="user",
actor_id=int(task.created_by),
source_ref=(
f"esports_opened:{account.id}:"
f"{int(account.updated_at.timestamp())}"
),
)
self._mark_task(
db,
task,
"success",
"电竞手册已开通,积分: "
f"{account.esports_points if account.esports_points is not None else '-'}",
result,
)
return
result.pop("payment_poll_error", None)
self._schedule_payment_poll(
db,
task,
result,
"电竞手册支付码已生成,等待开通到账"
f"(类型 {last_manual_type if last_manual_type is not None else '-'},"
f"积分 {last_manual_score if last_manual_score is not None else '-'})",
)
except Exception as exc: # noqa: BLE001 外部接口失败继续等待
result["payment_poll_error"] = str(exc)
self._schedule_payment_poll(
db,
task,
result,
f"等待电竞手册开通到账: {exc}",
)
def _execute_create_elite_qr(
self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict
):
client = self._client(cookie)
ctn = str(self._task_payload(task).get("ctn") or "")
if not ctn:
ctn = query_csrf(client, refresh_subscribe=True)
act_alias = self._confirm_act_alias(config) or self._bind_qr_act_alias(config)
if not act_alias:
self._mark_task(db, task, "failed", "请先配置开通宝典活动 actAlias")
return
# 开通前先查状态(对齐电竞手册):已开通的账号直接给出结论,不再生成
# 支付码 —— 既避免二维码刚弹出来就因「积分本来就够」被判成功而消失,
# 也避免给已开通账号生成一张无意义的真实支付单。
manual_id = str(config.get("manual_id") or "").strip()
baseline_points: int | None = None
if manual_id:
try:
baseline = self._refresh_elite_handbook(
client,
account,
manual_id=manual_id,
rid=str(config.get("rid") or ""),
)
db.commit()
except Exception as exc: # noqa: BLE001 外部接口与任务边界需要保留宽泛异常兜底
self._push_log(
"warning", f"开通前查询精英宝典状态失败,按未开通流程继续: {exc}"
)
else:
if baseline["elite_opened"]:
expire_text = self._format_expire_text(
baseline["elite_expire_time"]
)
points = baseline["elite_manual_score"]
account.updated_at = datetime.now(UTC)
self._mark_task(
db,
task,
"success",
f"精英宝典已开通{expire_text},积分: "
f"{points if points is not None else '-'}",
{
**baseline,
"elite_already_opened": True,
"payment_polling": False,
},
)
return
baseline_points = baseline["elite_manual_score"]
# 到账轮询读的是 credit/balance,基线也用同一个接口取,
# 避免两个口径不一致时把「余额本来就高」误判成刚到账。
try:
baseline_points = self._refresh_account_points(
client, account, cookie, ctn=ctn
)["points"]
db.commit()
except Exception as exc: # noqa: BLE001 外部接口与任务边界需要保留宽泛异常兜底
self._push_log(
"warning", f"开通前查询积分基线失败,改用手册积分: {exc}"
)
result = client.create_elite_qr(
ctn=ctn,
act_alias=act_alias,
amount=int(config["elite_amount"]),
room_id=str(config["room_id"]),
)
result.update(
{
"payment_ctn": ctn,
"elite_points_baseline": baseline_points,
"payment_manual_id": manual_id,
"payment_rid": str(config.get("rid") or ""),
}
)
account.updated_at = datetime.now(UTC)
self._schedule_payment_poll(
db,
task,
result,
"精英宝典支付码已生成,等待开通到账",
)
def _execute_create_esports_qr(
self,
db: Session,
task: DouyuTask,
account: Account,
cookie: str,
config: dict,
):
"""生成电竞手册支付二维码,并通过活动状态确认开通到账。"""
client = self._client(cookie)
ctn = str(self._task_payload(task).get("ctn") or "")
if not ctn:
ctn = query_csrf(client, refresh_subscribe=True)
act_alias = str(config.get("esports_act_alias") or "").strip()
manual_id = str(config.get("esports_manual_id") or "").strip()
if not act_alias or not manual_id:
self._mark_task(
db, task, "failed", "请先配置电竞手册活动 actAlias 和 manualID"
)
return
baseline_manual_type = None
baseline_manual_score = None
baseline_result: dict = {}
try:
baseline_result = self._refresh_esports_handbook(
client, account, manual_id=manual_id
)
baseline_manual_type = baseline_result["esports_manual_type"]
baseline_manual_score = baseline_result["esports_manual_score"]
db.commit()
except Exception as exc: # noqa: BLE001 外部接口与任务边界需要保留宽泛异常兜底
self._push_log("warning", f"生成电竞手册支付码前查询活动状态失败: {exc}")
if baseline_manual_type is not None and baseline_manual_type >= 1:
# 这里已确认开通:写独立状态列(以前只把它塞进 esports_bind_status)
account.esports_opened = True
account.updated_at = datetime.now(UTC)
self._mark_task(
db,
task,
"success",
f"电竞手册已开通,积分: {baseline_manual_score if baseline_manual_score is not None else '-'}",
{**baseline_result, "esports_opened": True, "payment_polling": False},
)
return
result = client.create_esports_qr(
ctn=ctn,
act_alias=act_alias,
amount=int(config["esports_amount"]),
room_id=str(config["room_id"]),
)
result.update(
{
**baseline_result,
"payment_ctn": ctn,
"payment_manual_id": manual_id,
"esports_manual_type_baseline": baseline_manual_type,
"esports_manual_score_baseline": baseline_manual_score,
}
)
account.updated_at = datetime.now(UTC)
self._schedule_payment_poll(
db,
task,
result,
"电竞手册支付码已生成,等待开通到账",
)
def _execute_query_esports_points(
self,
db: Session,
task: DouyuTask,
account: Account,
cookie: str,
config: dict,
):
"""查询电竞手册积分。"""
manual_id = str(config.get("esports_manual_id") or "").strip()
if not manual_id:
self._mark_task(db, task, "failed", "请先配置电竞手册 manualID")
return
client = self._client(cookie)
result = self._refresh_esports_handbook(client, account, manual_id=manual_id)
account.updated_at = datetime.now(UTC)
points = result["esports_points"]
self._mark_task(
db,
task,
"success",
f"电竞积分: {points if points is not None else '-'}",
result,
)
def _execute_query_points(
self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict
):
client = self._client(cookie)
ctn = query_csrf(client)
result = self._refresh_account_points(client, account, cookie, ctn=ctn)
account.updated_at = datetime.now(UTC)
points = result["points"]
self._mark_task(
db,
task,
"success",
f"积分: {points if points is not None else '-'}",
result,
)
def _points_spent(before: int | None, after: int | None) -> int | None:
"""开通前后积分余额的差(正数 = 花掉的)。
用**实测的余额差**而不是"开通要多少分"的常量 —— 活动价、折扣、
赠送都会让实际扣减不同,只有观测到的差是真的。
任一侧拿不到就返回 None(事件就不写金额,而不是编一个)。
"""
if not isinstance(before, (int, float)) or not isinstance(after, (int, float)):
return None
delta = int(before) - int(after)
return delta if delta > 0 else None