feat(douyu): 高价值套装改用官方 storehome 三态判定

高价值套装的准入判定改为只认官方精英宝典 storehome 里账号级的
status:0=可兑换、1=已达兑换上限,商品缺失/接口异常=unknown。
兑换记录和积分记录只作历史展示,不参与是否拥有的判定。

原来的 high_value_owned(JSON 名单)无法区分「确认可兑换」和
「官方接口没返回商品」,也无法表达部分失败。改为两套独立状态 +
检查时间(迁移 20261106_0065),旧快照保守回填:status 缺失的
一律 unknown,不猜。

CK 判定失效时在数据层作废结论(降为 unknown),不是展示层降级。
官方 status 是账号维度的,但 CK 失效那段时间账号可能被别人手工
登录并兑换(这些号共享给客服),缓存里的「可兑换」就不成立了;
只在展示层降级的话,CK 恢复后那条陈旧的「可换」会重新变绿。
error(查不到)不作废 —— 查不到不等于账号出问题了。

高价值结论有自己的时钟:资料刷新除了看 overview_queried_at,还看
high_value_checked_at。两者会脱钩(商品接口单独失败时资料时间被刷新、
高价值时间停在原地),少了这一条这类账号会永久停在旧结论。作废的
结论按 6 小时慢速重试,但「从来没查到过」不因此重选 —— 那是接口对
该账号稳定失败,每轮都重选只会反复撞墙。

商城商品列表改用精英宝典的 manualID 拉取,不再寄生在电竞手册分支里
(否则没配电竞手册的配置就永远拉不到商城,三态全部停在待确认)。

筛选拆成三类「查不到」:unqueried(未查资料,旧口径不变)、
high_value_never(从未读到商城)、high_value_unknown(查过但结论
未知/过期)。之前第二类无处可寻 —— 它既不满足 unqueried 也不满足
high_value_unknown。
This commit is contained in:
yml2213
2026-11-06 12:25:08 +08:00
parent e7e187cf57
commit 4c1aff47da
23 changed files with 1658 additions and 317 deletions
+14
View File
@@ -43,6 +43,7 @@ from .account_events_service import (
EVENT_STATUS_CHANGED,
emit,
)
from .high_value_service import invalidate_high_value
# ── 状态取值域(6 个)──────────────────────────────────────
# 刻意**不做** `relogin`(退避重试中):它完全等价于
@@ -276,6 +277,19 @@ def on_ck_verdict(
now = occurred_at or datetime.now(UTC)
if verdict != "error":
account.ck_check_status = verdict
# CK 失效 → 高价值结论**作废**。
#
# 官方 storehome.status 是账号维度的,正常只随这个账号自己的兑换而变;
# 但 CK 失效那段时间,账号**可能被别人手工登录并兑换**(这些号共享给
# 客服),缓存里的「可兑换」就不成立了。
#
# ⚠️ 必须**在这里**作废(而不是只在展示层降级):CK 恢复之后,展示层
# 就不再降级了 —— 那条陈旧的「可换」会重新显示成绿色,运营会拿一份
# 失效结论去兑换。作废是单向的:等下一次真的读到官方 storehome 才写回。
#
# `error`(查不到)**不**作废:查不到不等于账号出问题了。
if verdict == "invalid":
invalidate_high_value(account)
data = detail or {}
account.ck_check_result = {
"fish_ball": data.get("fish_ball"),
+116 -45
View File
@@ -2,7 +2,7 @@
列表上的「高价值待救」和巡检 / 重登共用这里的口径,避免两套规则各说各的。
分档只读账号上已经有的字段(兑换记录、积分、鱼翅、宝典),不看标签。
分档只读账号上已经有的当前字段(官方准入三态、积分、鱼翅、宝典),不看标签。
数字越小越值钱:
1. 查过资料,兔兔白日梦和狂战萌兔都还没换
@@ -16,14 +16,20 @@
from __future__ import annotations
import json
from datetime import UTC, datetime, timedelta
from sqlalchemy import String, and_, case, cast, or_
from sqlalchemy import and_, case, or_
from ..models import Account
from .high_value_service import (
HIGH_VALUE_FRESH_SECONDS,
HIGH_VALUE_STATUS_AVAILABLE,
HIGH_VALUE_STATUS_OWNED,
HIGH_VALUE_STATUS_UNKNOWN,
HIGH_VALUE_UNKNOWN_RETRY_SECONDS,
high_value_fresh_cutoff,
)
SUIT_BAIRIMENG = "兔兔白日梦"
SUIT_MENGTU = "狂战萌兔"
HIGH_VALUE_POINTS = 300
# 第 1、2 档都是「还值得抢救」的号。
@@ -33,42 +39,109 @@ HIGH_VALUE_TIER_MAX = 2
HIGH_VALUE_RECHECK_SECONDS = 6 * 3600
def suit_owned_expr(column, text: str):
"""JSON 列里是否包含这个套装名。MySQL 与 SQLite 都按字符串匹配。"""
escaped = json.dumps(text).strip('"')
return or_(
cast(column, String).like(f"%{text}%"),
cast(column, String).like(f"%{escaped}%"),
)
def high_value_fresh_expr(*, now: datetime | None = None):
"""高价值三态是否仍在有效期内。"""
cutoff = high_value_fresh_cutoff(now=now or datetime.now(UTC))
return Account.high_value_checked_at >= cutoff
def is_suit_queried_expr():
"""判断账号是否有效完成过高价值套装查询。
def suit_status_expr(key: str):
return getattr(Account, f"high_value_{key}_status")
必须同时满足:
1. 有查询时间 overview_queried_at
2. high_value_owned 必须是有效 JSON 数组(排除 SQL NULL 与 JSON NULL)
"""
def suit_available_expr(key: str, *, now: datetime | None = None):
return and_(
Account.overview_queried_at.isnot(None),
Account.high_value_owned.isnot(None),
cast(Account.high_value_owned, String).like("[%"),
high_value_fresh_expr(now=now),
suit_status_expr(key) == HIGH_VALUE_STATUS_AVAILABLE,
)
def value_tier_expr():
"""1–5 档。没查过、也没有任何资产信号时落在第 5 档。"""
hv_queried = is_suit_queried_expr()
owns_bairimeng = suit_owned_expr(Account.high_value_owned, SUIT_BAIRIMENG)
owns_mengtu = suit_owned_expr(Account.high_value_owned, SUIT_MENGTU)
both_available = and_(hv_queried, ~owns_bairimeng, ~owns_mengtu)
one_available = and_(
hv_queried,
def suit_owned_expr(key: str, *, now: datetime | None = None):
return and_(
high_value_fresh_expr(now=now),
suit_status_expr(key) == HIGH_VALUE_STATUS_OWNED,
)
def high_value_unknown_expr(*, now: datetime | None = None):
"""已检查过,但结果过期或至少一套官方状态未知。"""
return and_(
Account.high_value_checked_at.isnot(None),
or_(
and_(~owns_bairimeng, owns_mengtu),
and_(owns_bairimeng, ~owns_mengtu),
~high_value_fresh_expr(now=now),
suit_status_expr("bairimeng").is_(None),
suit_status_expr("bairimeng") == HIGH_VALUE_STATUS_UNKNOWN,
suit_status_expr("mengtu").is_(None),
suit_status_expr("mengtu") == HIGH_VALUE_STATUS_UNKNOWN,
),
)
def high_value_needs_refresh_expr(
*,
now: datetime | None = None,
max_seconds: int = HIGH_VALUE_FRESH_SECONDS,
unknown_seconds: int = HIGH_VALUE_UNKNOWN_RETRY_SECONDS,
):
"""高价值结论**已经过期** —— 需要再拉一次官方 ``storehome``。
和「资料是否过期」是**两件事**:
- ``overview_queried_at`` 说「上次一键查询是什么时候」;
- ``high_value_checked_at`` 说「上次**成功读到官方商品状态**是什么时候」。
两者会脱钩 —— 比如一键查询里商品接口单独失败(其它项都拿到了),
资料时间被刷新了,高价值时间却停在原地。再比如 CK 失效那段时间查不动,
账号恢复后高价值结论还挂着「查不到」。
所以定时刷新必须看**后者**:高价值结论过期就该再查一次 —— 哪怕账号的
整体资料看起来还很新。
三种情况:
- **过期**(查过但超过 ``max_seconds``):尽快重拉 —— 结论太旧,
而「可兑换」随时会变;
- **结论被作废**(状态是 ``unknown``,比如 CK 失效期间被作废):
按 ``unknown_seconds`` 慢速重试;
- **从来没查到过**(``checked_at IS NULL``):**不算**。那种情况要么
账号确实没查过资料(本来就该被选中),要么商品接口对这个账号稳定失败
(没配 manualID、账号没有宝典)—— 后者若每轮都重选,同一批账号会
反复撞墙,挤掉真正有新欠账的账号。它由「资料过期」那条兜着就够了。
``max_seconds`` 由调用方给:默认 7 天,与列表上「待确认」的判定同源。
"""
seconds = max(int(max_seconds or 0), 60)
unknown = max(int(unknown_seconds or 0), 60)
current = now or datetime.now(UTC)
cutoff = current - timedelta(seconds=seconds)
unknown_cutoff = current - timedelta(seconds=unknown)
unknown_status = or_(
suit_status_expr("bairimeng").is_(None),
suit_status_expr("bairimeng") == HIGH_VALUE_STATUS_UNKNOWN,
suit_status_expr("mengtu").is_(None),
suit_status_expr("mengtu") == HIGH_VALUE_STATUS_UNKNOWN,
)
return and_(
Account.high_value_checked_at.isnot(None),
or_(
Account.high_value_checked_at < cutoff,
and_(
unknown_status,
Account.high_value_checked_at < unknown_cutoff,
),
),
)
def value_tier_expr(*, now: datetime | None = None):
"""1–5 档。没查过、也没有任何资产信号时落在第 5 档。"""
available_bairimeng = suit_available_expr("bairimeng", now=now)
available_mengtu = suit_available_expr("mengtu", now=now)
both_available = and_(available_bairimeng, available_mengtu)
one_available = or_(
available_bairimeng,
available_mengtu,
)
return case(
(both_available, 1),
(or_(one_available, Account.points >= HIGH_VALUE_POINTS), 2),
@@ -78,12 +151,12 @@ def value_tier_expr():
)
def is_high_value_expr():
def is_high_value_expr(*, now: datetime | None = None):
"""第 1、2 档:巡检加密、重登插队、列表「高价值待救」都用这一条。"""
return value_tier_expr() <= HIGH_VALUE_TIER_MAX
return value_tier_expr(now=now) <= HIGH_VALUE_TIER_MAX
def suit_sort_rank_expr():
def suit_sort_rank_expr(*, now: datetime | None = None):
"""列表「高价值套装」列的排序,和格子上看到的一致。数字越小越值钱。
0 查过、两套都还能换
@@ -93,18 +166,16 @@ def suit_sort_rank_expr():
不掺积分、鱼翅。那是巡检分档的事,点这一列的人是在排套装。
"""
hv_queried = is_suit_queried_expr()
owns_bairimeng = suit_owned_expr(Account.high_value_owned, SUIT_BAIRIMENG)
owns_mengtu = suit_owned_expr(Account.high_value_owned, SUIT_MENGTU)
both_available = and_(hv_queried, ~owns_bairimeng, ~owns_mengtu)
one_available = and_(
hv_queried,
or_(
and_(~owns_bairimeng, owns_mengtu),
and_(owns_bairimeng, ~owns_mengtu),
),
available_bairimeng = suit_available_expr("bairimeng", now=now)
available_mengtu = suit_available_expr("mengtu", now=now)
owned_bairimeng = suit_owned_expr("bairimeng", now=now)
owned_mengtu = suit_owned_expr("mengtu", now=now)
both_available = and_(available_bairimeng, available_mengtu)
one_available = or_(
available_bairimeng,
available_mengtu,
)
both_owned = and_(hv_queried, owns_bairimeng, owns_mengtu)
both_owned = and_(owned_bairimeng, owned_mengtu)
return case(
(both_available, 0),
(one_available, 1),
@@ -48,6 +48,7 @@ from sqlalchemy.orm import Session
from ....models import Account, AutomationJob
from ...account_lifecycle import MANUAL_STATES
from ...account_value import high_value_needs_refresh_expr
from ...douyu_runner import DouyuBatchRunner
from ...douyu_service import cookie_operable_filter, create_douyu_planned_tasks
@@ -126,6 +127,14 @@ def _base_query(db: Session, job: AutomationJob, now: datetime):
or_(
Account.overview_queried_at.is_(None),
Account.overview_queried_at < cutoff,
# 高价值结论有**自己独立的时钟**(`high_value_checked_at`):
# 一键查询里商品接口单独失败时,资料时间被刷新了、高价值时间却
# 停在原地;CK 失效那段时间查不动也一样。少了这一条,这类账号
# 的高价值状态会**永久**停在旧结论,没人再拉它。
#
# 用的是**同一把尺子**(作业上那个「同一账号多久重检」),
# 不是另设一个窗口 —— 否则界面上那个字段对本作业就又变成半死的。
high_value_needs_refresh_expr(now=now, max_seconds=recheck_seconds),
),
)
+64 -2
View File
@@ -13,6 +13,14 @@ from core.douyu import DouyuActivityClient, DouyuActivityError
from ..models import Account, DouyuEsportsGoodsSnapshot, DouyuGoodsSnapshot, DouyuTask
from .business_events import record_exchange
from .high_value_service import (
DEFAULT_HIGH_VALUE_GOODS,
HIGH_VALUE_STATUS_OWNED,
apply_high_value_goods,
extract_high_value_goods,
high_value_key,
mark_high_value_owned,
)
# 兑换节奏与重试(对齐 8.30 浏览器抓包:锁单->支付间隔约 2.2~4.2s;火爆类错误要长退避而不是秒级连打)
DOUYU_EXCHANGE_PRE_CREATE_JITTER = (0.3, 1.2)
@@ -65,15 +73,55 @@ class GoodsMixin:
result = client.list_goods(manual_id=config["manual_id"], rid=config["rid"])
goods = result["goods"]
self._upsert_goods(db, goods)
high_value_goods = extract_high_value_goods(goods, DEFAULT_HIGH_VALUE_GOODS, [])
apply_high_value_goods(account, high_value_goods)
account.updated_at = datetime.now(UTC)
self._mark_task(
db,
task,
"success",
f"已刷新商品 {len(goods)} 个",
{"goods_count": len(goods), "goods": goods},
{
"goods_count": len(goods),
"goods": goods,
"high_value_goods": high_value_goods,
},
)
def _refresh_high_value_after_exchange(
self,
client: DouyuActivityClient,
account: Account,
*,
manual_id: str,
rid: str,
commodity_name: str,
) -> None:
"""兑换成功后立即刷新官方准入;失败时只标记本次已换套装。"""
try:
goods = client.list_goods(manual_id=manual_id, rid=rid).get("goods") or []
evaluated = extract_high_value_goods(goods, DEFAULT_HIGH_VALUE_GOODS, [])
apply_high_value_goods(account, evaluated)
key = high_value_key(commodity_name)
selected = next(
(item for item in evaluated if item.get("key") == key), None
)
# ⚠️ 官方 storehome 有缓存延迟:刚兑换完立刻查,它可能还返回旧的
# status=0(可兑换)。但**兑换成功是确定事实**,所以本次换掉的套装
# 必须收口成「已达上限」,不能被随后的旧快照覆盖回「可兑换」。
if key and (
selected is None or selected.get("state") != HIGH_VALUE_STATUS_OWNED
):
mark_high_value_owned(account, commodity_name)
except Exception as exc: # noqa: BLE001 旁路刷新,不能带崩已成功的兑换
self._push_log(
"warning", f"兑换成功但刷新高价值准入失败,按本次兑换结果收口: {exc}"
)
# 回查完全失败 = 两套的当前状态都查不到,一律记「未知」,
# 只有本次换掉的那套按「兑换成功」收口为「已达上限」。
apply_high_value_goods(account, [])
mark_high_value_owned(account, commodity_name)
def _execute_refresh_esports_goods(
self,
db: Session,
@@ -530,6 +578,13 @@ class GoodsMixin:
points_after=(points_refresh or {}).get("points"),
scope="elite",
)
self._refresh_high_value_after_exchange(
client,
account,
manual_id=manual_id,
rid=rid,
commodity_name=name,
)
self._mark_task(
db,
task,
@@ -653,6 +708,9 @@ class GoodsMixin:
manual_id=str(config["manual_id"]), rid=str(config["rid"])
)
limited = result["limited_goods"]
goods = (result.get("raw") or {}).get("data", {}).get("list") or []
high_value_goods = extract_high_value_goods(goods, DEFAULT_HIGH_VALUE_GOODS, [])
apply_high_value_goods(account, high_value_goods)
names = [
str(item.get("commodityName") or "")
for item in limited
@@ -669,7 +727,11 @@ class GoodsMixin:
task,
"success",
message,
{"limited_count": len(limited), "limited_goods": limited},
{
"limited_count": len(limited),
"limited_goods": limited,
"high_value_goods": high_value_goods,
},
)
def _execute_query_exchange_records(
+27 -113
View File
@@ -36,9 +36,11 @@ from ..models import Account, DouyuTask
from .account_binding import derive_from_bind_info, set_bind_status
from .business_events import record_official_exchange
from .douyu_runner_donate import _parse_expire_at, _points_expire_at
#: 默认关注的高价值商品。必须精确关注两款核心套装,排除头盔、背包等配件散件。
DEFAULT_HIGH_VALUE_GOODS: tuple[str, ...] = ("套装-兔兔白日梦", "套装-狂战萌兔")
from .high_value_service import (
DEFAULT_HIGH_VALUE_GOODS,
apply_high_value_goods,
extract_high_value_goods,
)
#: 官方兑换记录默认取多少条(完整记录可能很多,一次性拉回来没必要)
EXCHANGE_RECORD_LIMIT = 20
@@ -46,115 +48,11 @@ EXCHANGE_RECORD_LIMIT = 20
#: 单项错误的摘要长度(避免把整个 traceback 塞进 task.result)
_ERROR_MAX = 200
#: 配件散件排除关键词列表(避免把头盔、背包误识别为高价值套装)
SUIT_EXCLUDE_KEYWORDS = ("头盔", "背包", "手榴弹", "挂件", "降落伞", "枪")
def _err(exc: BaseException) -> str:
return f"{type(exc).__name__}: {exc}"[:_ERROR_MAX]
def _match_suit_item(want: str, rows: list[dict[str, Any]]) -> dict[str, Any] | None:
"""在商品列表中精确匹配套装商品,严格排除头盔、背包等配件干扰。"""
# 1. 优先完全一致匹配
for it in rows:
cname = str(it.get("commodityName") or "").strip()
if cname == want:
return it
# 2. 核心词(如 兔兔白日梦 / 狂战萌兔)精准匹配,排除配件关键词
core = want.replace("套装-", "").strip()
# 优先找带「套装」前缀的
for it in rows:
cname = str(it.get("commodityName") or "").strip()
if (
core in cname
and "套装" in cname
and not any(k in cname for k in SUIT_EXCLUDE_KEYWORDS)
):
return it
# 3. 兜底匹配不带排除词的项
for it in rows:
cname = str(it.get("commodityName") or "").strip()
if core in cname and not any(k in cname for k in SUIT_EXCLUDE_KEYWORDS):
return it
return None
def _match_suit_records(want: str, recs: list[dict[str, Any]]) -> list[str]:
"""在官方兑换记录中匹配对应套装,严格排除配件干扰。"""
core = want.replace("套装-", "").strip()
got: list[str] = []
for r in recs:
cname = str(r.get("commodityName") or r.get("name") or "").strip()
if core in cname and not any(k in cname for k in SUIT_EXCLUDE_KEYWORDS):
got.append(cname)
return got
def extract_high_value_goods(
items: list[dict[str, Any]] | None,
wanted: tuple[str, ...] | list[str] | None = DEFAULT_HIGH_VALUE_GOODS,
records: list[dict[str, Any]] | None = None,
) -> list[dict[str, Any]]:
"""挑出高价值套装,并判定「该账号是否已获得 / 已达兑换上限」。
## 判定依据:**官方商城商品 status** + 官方兑换记录双重保障
在斗鱼官方精英手册商城中:
- `item.status == 1`:斗鱼官方页面按钮展示为【已达兑换上限】(该账号限量 1 件已满,已兑换,不可再兑);
- `item.status == 0`:斗鱼官方页面按钮展示为【立即兑换】(该账号未兑换,可兑换);
- `records`(官方兑换记录):斗鱼官方常会清理历史兑换记录导致 records 返回空列表(0 条),
但若 records 中仍存在记录,同样确认为已兑换;若商品已在商城下架不在列表里,records 作为历史兜底。
"""
names = [str(w).strip() for w in (wanted or []) if str(w).strip()]
rows = [it for it in (items or []) if isinstance(it, dict)]
recs = [r for r in (records or []) if isinstance(r, dict)]
out: list[dict[str, Any]] = []
for want in names:
hit = _match_suit_item(want, rows)
got = _match_suit_records(want, recs)
# 🎯 核心判定:
# 1. 官方商城明确声明 status == 1 即为「已达兑换上限」(已兑换)
# 2. 官方历史兑换记录中存在记录即为「已兑换」
status_blocked = hit is not None and str(hit.get("status") or "") == "1"
records_owned = bool(got)
is_owned = status_blocked or records_owned
reason = ""
if hit is None and not got:
reason = "商品列表和官方兑换记录里都没有这个商品"
elif status_blocked and not records_owned:
reason = "官方商城显示已达兑换上限"
elif records_owned and not status_blocked:
reason = "官方兑换记录显示已兑换"
elif status_blocked and records_owned:
reason = "已达兑换上限且有官方兑换记录"
out.append(
{
"name": str(hit.get("commodityName") or want) if hit else want,
"commodity_id": str(hit.get("commodityId") or "") if hit else "",
# 🎯 是否已获得 / 已达上限
"owned": is_owned,
"obtained_names": got,
# 以下是全局的展示信息
"score": hit.get("score") if hit else None,
"count": hit.get("count") if hit else None,
"count_limited": hit.get("countLimited") if hit else None,
"start_time": _ts(hit.get("startTime")) if hit else None,
"end_time": _ts(hit.get("endTime")) if hit else None,
"pic": str(hit.get("pic") or "") if hit else "",
"in_goods_list": hit is not None,
"missing": hit is None and not got,
"reason": reason,
}
)
return out
def _group_by_scope(
pairs: list[tuple[str, dict[str, Any]]],
) -> dict[str, list[dict[str, Any]]]:
@@ -357,8 +255,9 @@ class OverviewMixin:
esports_manual_id = str(config.get("esports_manual_id") or "").strip()
rid = str(config.get("rid") or "").strip()
queried_at = datetime.now(UTC)
overview: dict[str, Any] = {
"queried_at": datetime.now(UTC).isoformat(),
"queried_at": queried_at.isoformat(),
"assets": {},
"elite": {},
"esports": {},
@@ -370,6 +269,7 @@ class OverviewMixin:
# (作用域, 官方记录) 扁平列表,便于补事件
all_records: list[tuple[str, dict[str, Any]]] = []
pending_goods: list[dict[str, Any]] = []
goods_query_ok = False
# ---- 鱼翅 + 钱包兑换余额 ----
try:
@@ -436,12 +336,23 @@ class OverviewMixin:
except Exception as exc: # noqa: BLE001
errors["esports"] = _err(exc)
# ---- 精英宝典商城商品列表(高价值套装的**唯一**判据来源)----
#
# ⚠️ 必须用**精英宝典**的 manual_id(与 `refresh_goods` 任务一致),
# 而且**不能**寄生在上面的「电竞手册」分支里:那是两个无关的活动。
# 之前商品列表被写在电竞手册的 else 分支内 —— 于是一旦没配
# `esports_manual_id`,商城商品就永远拉不到,高价值三态就永远
# 落不到 `available`/`owned`(全部显示「待确认」)。
if not manual_id:
errors["limited_goods"] = "未配置精英宝典 manualID"
else:
goods_items: list[dict[str, Any]] = []
try:
# 🎯 拉取完整商城商品列表(含每个商品准确的 status 状态:1=已达兑换上限,0=可兑换)
goods = client.list_goods(manual_id=manual_id, rid=rid)
goods_items = goods.get("goods") or []
overview["limited_goods_total"] = len(goods_items)
goods_query_ok = True
except Exception as exc: # noqa: BLE001
errors["limited_goods"] = _err(exc)
# 商品列表带有 status 准入状态,结合兑换记录在后文判定高价值资产
@@ -545,6 +456,13 @@ class OverviewMixin:
_goods_config(config),
[rec for _scope, rec in all_records],
)
if goods_query_ok:
apply_high_value_goods(
account,
overview["high_value_goods"],
checked_at=queried_at,
)
overview["high_value_checked_at"] = queried_at.isoformat()
except Exception as exc: # noqa: BLE001
errors["high_value_goods"] = _err(exc)
@@ -566,11 +484,7 @@ class OverviewMixin:
# 落到账号上:任务会被保留策略清掉,而「这个账号现在什么情况」是账号的信息,
# 应该在账号管理里看,不该依赖一条日志的寿命。
account.overview_snapshot = overview
account.overview_queried_at = datetime.now(UTC)
# 再落「已兑换过的高价值套装名」给列表用(列表不能带整份快照)
account.high_value_owned = [
g["name"] for g in overview.get("high_value_goods", []) if g.get("owned")
]
account.overview_queried_at = queried_at
logger.info(f"[douyu] 一键查询账号 {account.id}: {message}")
self._mark_task(db, task, "success", message, overview)
+277
View File
@@ -0,0 +1,277 @@
"""斗鱼高价值套装的官方准入状态。
唯一裁判是精英宝典 ``storehome`` 商品列表中的账号级 ``status``:
- ``0`` = 当前账号可兑换;
- ``1`` = 当前账号已达兑换上限;
- 商品缺失、列表为空、请求失败 = 未知。
兑换记录和积分记录会长期保留,但可能被官方清理或暂时查不到,因此只作历史展示,
不参与当前是否拥有的判定。
"""
from __future__ import annotations
from datetime import UTC, datetime, timedelta
from typing import Any
from ..models import Account
HIGH_VALUE_STATUS_OWNED = "owned"
HIGH_VALUE_STATUS_AVAILABLE = "available"
HIGH_VALUE_STATUS_UNKNOWN = "unknown"
HIGH_VALUE_KEYS: tuple[str, ...] = ("bairimeng", "mengtu")
HIGH_VALUE_NAMES: dict[str, str] = {
"bairimeng": "套装-兔兔白日梦",
"mengtu": "套装-狂战萌兔",
}
DEFAULT_HIGH_VALUE_GOODS: tuple[str, ...] = tuple(HIGH_VALUE_NAMES.values())
# 列表展示的“当前准入”最多接受 7 天前的官方结果;过期只能显示待确认。
HIGH_VALUE_FRESH_SECONDS = 7 * 24 * 3600
#: 结论被作废(CK 失效期间)后,多久再拉一次官方状态。
#:
#: 取 6 小时是**故意**的:CK 恢复之后,账号的高价值结论必须尽快重新确认 ——
#: 失效期间账号可能被别人兑换过,运营正要拿这条结论去兑换。
#: 但也不能更密:商品接口对某些账号稳定失败(没配 manualID),那类账号的
#: 结论会一直是 ``unknown``,每轮都重选就是反复撞墙。
HIGH_VALUE_UNKNOWN_RETRY_SECONDS = 6 * 3600
# 防止头盔、背包等同一套装家族的散件被误当成整套。
SUIT_EXCLUDE_KEYWORDS = ("头盔", "背包", "手榴弹", "挂件", "降落伞", "枪")
def high_value_key(name: str) -> str:
"""把配置里的商品名映射为稳定的短键。"""
text = str(name or "").strip()
for key, suit_name in HIGH_VALUE_NAMES.items():
if suit_name.replace("套装-", "") in text:
return key
return ""
def _match_suit_item(want: str, rows: list[dict[str, Any]]) -> dict[str, Any] | None:
"""精确匹配整套,严格排除头盔、背包等散件。"""
for item in rows:
if str(item.get("commodityName") or "").strip() == want:
return item
core = want.replace("套装-", "").strip()
for item in rows:
name = str(item.get("commodityName") or "").strip()
if (
core in name
and "套装" in name
and not any(word in name for word in SUIT_EXCLUDE_KEYWORDS)
):
return item
for item in rows:
name = str(item.get("commodityName") or "").strip()
if core in name and not any(word in name for word in SUIT_EXCLUDE_KEYWORDS):
return item
return None
def _match_suit_records(want: str, records: list[dict[str, Any]]) -> list[str]:
"""匹配历史记录,仅用于界面展示,不参与当前准入判定。"""
core = want.replace("套装-", "").strip()
matched: list[str] = []
for record in records:
name = str(record.get("commodityName") or record.get("name") or "").strip()
if core in name and not any(word in name for word in SUIT_EXCLUDE_KEYWORDS):
matched.append(name)
return matched
def _official_state(item: dict[str, Any] | None) -> tuple[str, Any]:
if item is None:
return HIGH_VALUE_STATUS_UNKNOWN, None
status = item.get("status")
normalized = str(status).strip() if status is not None else ""
if normalized == "0":
return HIGH_VALUE_STATUS_AVAILABLE, status
if normalized == "1":
return HIGH_VALUE_STATUS_OWNED, status
return HIGH_VALUE_STATUS_UNKNOWN, status
def _ts(value: Any) -> Any:
"""斗鱼用 0/空串表示没有时间,归一成 None。"""
if value is None or isinstance(value, bool):
return None
if isinstance(value, (int, float)):
return None if int(value) <= 0 else value
text = str(value).strip()
if not text:
return None
if text.lstrip("-").isdigit() and int(text) <= 0:
return None
return value
def extract_high_value_goods(
items: list[dict[str, Any]] | None,
wanted: tuple[str, ...] | list[str] | None = DEFAULT_HIGH_VALUE_GOODS,
records: list[dict[str, Any]] | None = None,
) -> list[dict[str, Any]]:
"""按官方 ``storehome.status`` 生成高价值套装的当前准入状态。"""
names = [str(name).strip() for name in (wanted or []) if str(name).strip()]
rows = [item for item in (items or []) if isinstance(item, dict)]
historical = [item for item in (records or []) if isinstance(item, dict)]
result: list[dict[str, Any]] = []
for wanted_name in names:
item = _match_suit_item(wanted_name, rows)
state, raw_status = _official_state(item)
obtained_names = _match_suit_records(wanted_name, historical)
if state == HIGH_VALUE_STATUS_OWNED:
reason = "官方商城显示已达兑换上限"
elif state == HIGH_VALUE_STATUS_AVAILABLE:
reason = "官方商城显示当前可兑换"
elif item is None:
reason = "官方商城未返回该套装,当前状态未知"
else:
reason = f"官方商城状态异常(status={raw_status!r})"
if obtained_names and state != HIGH_VALUE_STATUS_UNKNOWN:
reason += ";历史兑换记录仅供展示"
result.append(
{
"key": high_value_key(wanted_name),
"name": str(item.get("commodityName") or wanted_name)
if item
else wanted_name,
"commodity_id": str(item.get("commodityId") or "") if item else "",
"state": state,
# 兼容详情页旧字段;是否拥有的唯一来源仍是官方 status。
"owned": state == HIGH_VALUE_STATUS_OWNED,
"available": state == HIGH_VALUE_STATUS_AVAILABLE,
"status": raw_status,
"obtained_names": obtained_names,
"score": item.get("score") if item else None,
"count": item.get("count") if item else None,
"count_limited": item.get("countLimited") if item else None,
"start_time": _ts(item.get("startTime")) if item else None,
"end_time": _ts(item.get("endTime")) if item else None,
"pic": str(item.get("pic") or "") if item else "",
"in_goods_list": item is not None,
"missing": item is None,
"reason": reason,
}
)
return result
def apply_high_value_goods(
account: Account,
goods: list[dict[str, Any]],
*,
checked_at: datetime | None = None,
) -> None:
"""把一次成功读取的官方商城结果写到账号当前状态。"""
by_key = {
str(item.get("key") or high_value_key(str(item.get("name") or ""))): item
for item in goods
if isinstance(item, dict)
}
for key in HIGH_VALUE_KEYS:
item = by_key.get(key) or {}
state = str(item.get("state") or HIGH_VALUE_STATUS_UNKNOWN)
if state not in {
HIGH_VALUE_STATUS_OWNED,
HIGH_VALUE_STATUS_AVAILABLE,
HIGH_VALUE_STATUS_UNKNOWN,
}:
state = HIGH_VALUE_STATUS_UNKNOWN
setattr(account, f"high_value_{key}_status", state)
account.high_value_checked_at = checked_at or datetime.now(UTC)
def mark_high_value_owned(
account: Account,
commodity_name: str,
*,
checked_at: datetime | None = None,
) -> bool:
"""官方兑换成功后立即收口单个套装状态。
正常路径会再查一次 ``storehome``;这个函数是查询失败时的保守兜底,
依据是官方兑换接口已经成功,不再依赖可能被清理的兑换记录。
"""
key = high_value_key(commodity_name)
if not key:
return False
setattr(account, f"high_value_{key}_status", HIGH_VALUE_STATUS_OWNED)
account.high_value_checked_at = checked_at or datetime.now(UTC)
return True
def invalidate_high_value(account: Account) -> None:
"""CK 失效时把高价值结论**作废**(降为「待确认」)。
为什么 CK 一失效就要作废:官方 ``storehome.status`` 是**账号维度**的,
正常只随这个账号自己的兑换而变。但 CK 失效那段时间,账号**可能被别人
手工登录并兑换**(这些号是共享给客服的)—— 这时缓存里的「可兑换」就
不成立了。
更要命的是 CK 恢复之后:如果不作废,``high_value_payload`` 不再降级,
那条陈旧的「可换」会**重新显示成绿色**,运营就会拿着一份失效结论去兑换。
所以作废是**单向**的:写 ``unknown``,等下一次真的读到官方 ``storehome``
再写回真实的 ``available``/``owned``。``checked_at`` 保留(那确实是
「上次成功读到官方状态」的时间),但结论本身已经不算数。
"""
for key in HIGH_VALUE_KEYS:
setattr(account, f"high_value_{key}_status", HIGH_VALUE_STATUS_UNKNOWN)
def high_value_payload(
account: Account, *, now: datetime | None = None
) -> dict[str, Any]:
"""给列表/详情使用的紧凑三态结果。"""
current = now or datetime.now(UTC)
checked_at = account.high_value_checked_at
if checked_at is not None and checked_at.tzinfo is None:
checked_at = checked_at.replace(tzinfo=UTC)
# CK 失效 = 查不动了。此时缓存里的「可兑换」已经无法确认当前是否还成立,
# 只能当作待确认 —— 否则运营会拿一个过期结论去兑换。
ck_broken = (account.ck_check_status or "") in {"invalid", "error"}
stale = bool(
ck_broken
or (
checked_at
and current - checked_at > timedelta(seconds=HIGH_VALUE_FRESH_SECONDS)
)
)
values = {
key: str(getattr(account, f"high_value_{key}_status", "") or "")
for key in HIGH_VALUE_KEYS
}
has_unknown = any(
value not in {HIGH_VALUE_STATUS_OWNED, HIGH_VALUE_STATUS_AVAILABLE}
for value in values.values()
)
if checked_at is None:
state = "never"
elif stale:
state = "stale"
elif has_unknown:
state = "partial"
else:
state = "complete"
return {
"state": state,
"checked_at": checked_at,
"stale": stale,
"fresh": state in {"complete", "partial"},
**values,
"names": HIGH_VALUE_NAMES,
}
def high_value_fresh_cutoff(*, now: datetime | None = None) -> datetime:
current = now or datetime.now(UTC)
return current - timedelta(seconds=HIGH_VALUE_FRESH_SECONDS)