feat(douyu): 落地账号平台同步与登录配额
This commit is contained in:
@@ -60,6 +60,7 @@ async def lifespan(app: FastAPI):
|
||||
from .database import SessionLocal, dispose_engines
|
||||
from .services.douyu_service import cleanup_orphan_douyu_tasks
|
||||
from .services.huya_service import cleanup_orphan_huya_tasks
|
||||
from .services.login_quota_service import cleanup_orphan_login_attempts
|
||||
from .services.login_service import (
|
||||
cleanup_orphan_login_tasks,
|
||||
cleanup_orphan_relogin_tasks,
|
||||
@@ -84,6 +85,9 @@ async def lifespan(app: FastAPI):
|
||||
cleaned_login = cleanup_orphan_login_tasks(db)
|
||||
if cleaned_login:
|
||||
logger.info(f"启动清理登录残留任务: {cleaned_login} 条")
|
||||
cleaned_attempts = cleanup_orphan_login_attempts(db)
|
||||
if cleaned_attempts:
|
||||
logger.info(f"启动收敛中断的登录尝试流水: {cleaned_attempts} 条")
|
||||
from .services.yyb_service import cleanup_orphan_yyb_tasks
|
||||
|
||||
cleaned_yyb = cleanup_orphan_yyb_tasks(db, message="任务已中断(服务重启)")
|
||||
|
||||
@@ -437,6 +437,10 @@
|
||||
"20261121_0109_account_pool_tier_index.py": {
|
||||
"revision": "20261121_0109",
|
||||
"sha256": "0aa85febbc0f2c99f5768bba2364f8797a748c4de740780e33a2017311f591b0"
|
||||
},
|
||||
"20261121_0110_account_platform_foundation.py": {
|
||||
"revision": "20261121_0110",
|
||||
"sha256": "94c0158a061a7670d1c15cfd57172d98eddd271a4d82be0cb7d0ea65013f8712"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,650 @@
|
||||
"""斗鱼账号平台基础:CK 周期、同步状态、工作队列、供给目标和登录配额。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlalchemy as sa
|
||||
from alembic import op
|
||||
|
||||
revision: str = "20261121_0110"
|
||||
down_revision: str | None = "20261121_0109"
|
||||
branch_labels: str | None = None
|
||||
depends_on: str | None = None
|
||||
|
||||
|
||||
def _table_exists(table: str) -> bool:
|
||||
return bool(
|
||||
op.get_bind()
|
||||
.execute(
|
||||
sa.text(
|
||||
"""
|
||||
SELECT COUNT(*)
|
||||
FROM information_schema.tables
|
||||
WHERE table_schema = DATABASE()
|
||||
AND table_name = :table
|
||||
"""
|
||||
),
|
||||
{"table": table},
|
||||
)
|
||||
.scalar()
|
||||
)
|
||||
|
||||
|
||||
def _column_exists(table: str, column: str) -> bool:
|
||||
return bool(
|
||||
op.get_bind()
|
||||
.execute(
|
||||
sa.text(
|
||||
"""
|
||||
SELECT COUNT(*)
|
||||
FROM information_schema.columns
|
||||
WHERE table_schema = DATABASE()
|
||||
AND table_name = :table
|
||||
AND column_name = :column
|
||||
"""
|
||||
),
|
||||
{"table": table, "column": column},
|
||||
)
|
||||
.scalar()
|
||||
)
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
for column in (
|
||||
sa.Column("ck_expected_expires_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("ck_last_valid_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("ck_invalid_detected_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("ck_observed_lifetime_seconds", sa.Integer(), nullable=True),
|
||||
sa.Column(
|
||||
"ck_expiry_source",
|
||||
sa.String(length=24),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
):
|
||||
if not _column_exists("accounts", column.name):
|
||||
op.add_column("accounts", column)
|
||||
|
||||
# 商品级原始字段:已有商品能力表,必须只做加法,不能靠 create_table 兜底。
|
||||
if not _column_exists("account_commodity_states", "raw_json"):
|
||||
op.add_column(
|
||||
"account_commodity_states",
|
||||
sa.Column("raw_json", sa.JSON(), nullable=True),
|
||||
)
|
||||
|
||||
if not _table_exists("account_sync_states"):
|
||||
op.create_table(
|
||||
"account_sync_states",
|
||||
sa.Column("id", sa.BigInteger(), primary_key=True, autoincrement=True),
|
||||
sa.Column(
|
||||
"account_id",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("accounts.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column(
|
||||
"platform",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="douyu",
|
||||
),
|
||||
sa.Column("domain", sa.String(length=32), nullable=False),
|
||||
sa.Column("last_attempt_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("last_success_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("valid_until", sa.DateTime(), nullable=True),
|
||||
sa.Column("next_retry_at", sa.DateTime(), nullable=True),
|
||||
sa.Column(
|
||||
"status",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="never",
|
||||
),
|
||||
sa.Column(
|
||||
"error_code",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("error_message", sa.Text(), nullable=False),
|
||||
sa.Column(
|
||||
"source",
|
||||
sa.String(length=32),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column(
|
||||
"payload_hash",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("raw_payload_json", sa.JSON(), nullable=True),
|
||||
sa.Column(
|
||||
"state_version",
|
||||
sa.BigInteger(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.UniqueConstraint(
|
||||
"account_id",
|
||||
"platform",
|
||||
"domain",
|
||||
name="uq_account_sync_state_domain",
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_sync_state_due",
|
||||
"account_sync_states",
|
||||
["platform", "domain", "status", "next_retry_at", "account_id"],
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_sync_state_success",
|
||||
"account_sync_states",
|
||||
["platform", "domain", "last_success_at", "account_id"],
|
||||
)
|
||||
elif not _column_exists("account_sync_states", "raw_payload_json"):
|
||||
op.add_column(
|
||||
"account_sync_states",
|
||||
sa.Column("raw_payload_json", sa.JSON(), nullable=True),
|
||||
)
|
||||
|
||||
if not _table_exists("account_sync_runs"):
|
||||
op.create_table(
|
||||
"account_sync_runs",
|
||||
sa.Column("id", sa.BigInteger(), primary_key=True, autoincrement=True),
|
||||
sa.Column(
|
||||
"account_id",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("accounts.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column(
|
||||
"platform",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="douyu",
|
||||
),
|
||||
sa.Column("domain", sa.String(length=32), nullable=False),
|
||||
sa.Column("task_id", sa.BigInteger(), nullable=True),
|
||||
sa.Column("started_at", sa.DateTime(), nullable=False),
|
||||
sa.Column("finished_at", sa.DateTime(), nullable=True),
|
||||
sa.Column(
|
||||
"status",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="running",
|
||||
),
|
||||
sa.Column(
|
||||
"source",
|
||||
sa.String(length=32),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column(
|
||||
"item_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"changed_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"duration_ms",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"error_code",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("error_message", sa.Text(), nullable=False),
|
||||
sa.Column("official_observed_at", sa.DateTime(), nullable=True),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_sync_runs_account_domain_time",
|
||||
"account_sync_runs",
|
||||
["account_id", "domain", "started_at"],
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_sync_runs_domain_status_time",
|
||||
"account_sync_runs",
|
||||
["domain", "status", "started_at"],
|
||||
)
|
||||
|
||||
if not _table_exists("account_work_items"):
|
||||
op.create_table(
|
||||
"account_work_items",
|
||||
sa.Column("id", sa.BigInteger(), primary_key=True, autoincrement=True),
|
||||
sa.Column(
|
||||
"account_id",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("accounts.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column("work_type", sa.String(length=32), nullable=False),
|
||||
sa.Column(
|
||||
"priority",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="100",
|
||||
),
|
||||
sa.Column(
|
||||
"status",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="pending",
|
||||
),
|
||||
sa.Column("due_at", sa.DateTime(), nullable=False),
|
||||
sa.Column("expires_at", sa.DateTime(), nullable=True),
|
||||
sa.Column(
|
||||
"attempt_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"max_attempts",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="3",
|
||||
),
|
||||
sa.Column("dedupe_key", sa.String(length=191), nullable=False),
|
||||
sa.Column(
|
||||
"active_dedupe_key",
|
||||
sa.String(length=191),
|
||||
sa.Computed(
|
||||
"CASE WHEN status IN ('pending', 'running') "
|
||||
"THEN dedupe_key ELSE NULL END",
|
||||
persisted=False,
|
||||
),
|
||||
nullable=True,
|
||||
),
|
||||
sa.Column(
|
||||
"reason",
|
||||
sa.String(length=255),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("payload_json", sa.JSON(), nullable=True),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.Column("started_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("finished_at", sa.DateTime(), nullable=True),
|
||||
sa.Column("last_error", sa.Text(), nullable=False),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"uq_account_work_active_dedupe",
|
||||
"account_work_items",
|
||||
["active_dedupe_key"],
|
||||
unique=True,
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_work_due",
|
||||
"account_work_items",
|
||||
["status", "work_type", "due_at", "priority", "id"],
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_work_account_status",
|
||||
"account_work_items",
|
||||
["account_id", "status", "work_type"],
|
||||
)
|
||||
|
||||
if not _table_exists("account_supply_targets"):
|
||||
op.create_table(
|
||||
"account_supply_targets",
|
||||
sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
|
||||
sa.Column(
|
||||
"platform",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="douyu",
|
||||
),
|
||||
sa.Column(
|
||||
"scope",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="elite",
|
||||
),
|
||||
sa.Column(
|
||||
"commodity_id",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("value_class", sa.String(length=16), nullable=False),
|
||||
sa.Column(
|
||||
"target_covered",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"target_available",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"target_allocatable",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"safety_buffer",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"enabled",
|
||||
sa.Boolean(),
|
||||
nullable=False,
|
||||
server_default="1",
|
||||
),
|
||||
sa.Column(
|
||||
"updated_by",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("users.id", ondelete="SET NULL"),
|
||||
nullable=True,
|
||||
),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.UniqueConstraint(
|
||||
"platform",
|
||||
"scope",
|
||||
"commodity_id",
|
||||
"value_class",
|
||||
name="uq_account_supply_target",
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_account_supply_target_enabled",
|
||||
"account_supply_targets",
|
||||
["platform", "enabled", "scope"],
|
||||
)
|
||||
|
||||
if not _table_exists("login_attempts"):
|
||||
op.create_table(
|
||||
"login_attempts",
|
||||
sa.Column("id", sa.BigInteger(), primary_key=True, autoincrement=True),
|
||||
sa.Column(
|
||||
"account_id",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("accounts.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
),
|
||||
sa.Column(
|
||||
"batch_id",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column("category", sa.String(length=32), nullable=False),
|
||||
sa.Column(
|
||||
"trigger_source",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="manual",
|
||||
),
|
||||
sa.Column(
|
||||
"created_by",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("users.id", ondelete="SET NULL"),
|
||||
nullable=True,
|
||||
),
|
||||
sa.Column(
|
||||
"started_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.Column("finished_at", sa.DateTime(), nullable=True),
|
||||
sa.Column(
|
||||
"status",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="pending",
|
||||
),
|
||||
sa.Column(
|
||||
"failure_kind",
|
||||
sa.String(length=16),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column(
|
||||
"duration_ms",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"proxy_key",
|
||||
sa.String(length=64),
|
||||
nullable=False,
|
||||
server_default="",
|
||||
),
|
||||
sa.Column(
|
||||
"email_code_requested",
|
||||
sa.Boolean(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column("quota_day", sa.Date(), nullable=False),
|
||||
sa.Column(
|
||||
"created_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_login_attempts_account_day",
|
||||
"login_attempts",
|
||||
["account_id", "quota_day", "category"],
|
||||
)
|
||||
op.create_index(
|
||||
"ix_login_attempts_day_category_status",
|
||||
"login_attempts",
|
||||
["quota_day", "category", "status"],
|
||||
)
|
||||
op.create_index(
|
||||
"ix_login_attempts_batch",
|
||||
"login_attempts",
|
||||
["batch_id", "account_id"],
|
||||
)
|
||||
|
||||
if not _table_exists("login_quota_settings"):
|
||||
op.create_table(
|
||||
"login_quota_settings",
|
||||
sa.Column("id", sa.Integer(), primary_key=True),
|
||||
sa.Column(
|
||||
"daily_attempt_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="1500",
|
||||
),
|
||||
sa.Column(
|
||||
"hourly_attempt_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="100",
|
||||
),
|
||||
sa.Column(
|
||||
"per_account_daily_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="2",
|
||||
),
|
||||
sa.Column(
|
||||
"onboarding_daily_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="150",
|
||||
),
|
||||
sa.Column(
|
||||
"relogin_high_value_daily_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="300",
|
||||
),
|
||||
sa.Column(
|
||||
"relogin_ordinary_daily_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="500",
|
||||
),
|
||||
sa.Column(
|
||||
"manual_daily_limit",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="300",
|
||||
),
|
||||
sa.Column(
|
||||
"login_concurrency",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="3",
|
||||
),
|
||||
sa.Column(
|
||||
"failure_pause_ratio",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="40",
|
||||
),
|
||||
sa.Column(
|
||||
"enabled",
|
||||
sa.Boolean(),
|
||||
nullable=False,
|
||||
server_default="1",
|
||||
),
|
||||
sa.Column(
|
||||
"updated_by",
|
||||
sa.Integer(),
|
||||
sa.ForeignKey("users.id", ondelete="SET NULL"),
|
||||
nullable=True,
|
||||
),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
)
|
||||
op.execute(
|
||||
sa.text("INSERT IGNORE INTO login_quota_settings (id) VALUES (1)")
|
||||
)
|
||||
|
||||
if not _table_exists("login_quota_usage"):
|
||||
op.create_table(
|
||||
"login_quota_usage",
|
||||
sa.Column("id", sa.BigInteger(), primary_key=True, autoincrement=True),
|
||||
sa.Column("quota_day", sa.Date(), nullable=False),
|
||||
sa.Column("quota_hour", sa.Integer(), nullable=False),
|
||||
sa.Column("category", sa.String(length=32), nullable=False),
|
||||
sa.Column(
|
||||
"attempt_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"success_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"failure_count",
|
||||
sa.Integer(),
|
||||
nullable=False,
|
||||
server_default="0",
|
||||
),
|
||||
sa.Column(
|
||||
"updated_at",
|
||||
sa.DateTime(),
|
||||
nullable=False,
|
||||
server_default=sa.text("CURRENT_TIMESTAMP"),
|
||||
),
|
||||
sa.UniqueConstraint(
|
||||
"quota_day",
|
||||
"quota_hour",
|
||||
"category",
|
||||
name="uq_login_quota_usage_bucket",
|
||||
),
|
||||
)
|
||||
op.create_index(
|
||||
"ix_login_quota_usage_day_category",
|
||||
"login_quota_usage",
|
||||
["quota_day", "category"],
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
for table in (
|
||||
"login_quota_usage",
|
||||
"login_quota_settings",
|
||||
"login_attempts",
|
||||
"account_supply_targets",
|
||||
"account_work_items",
|
||||
"account_sync_runs",
|
||||
"account_sync_states",
|
||||
):
|
||||
if _table_exists(table):
|
||||
op.drop_table(table)
|
||||
|
||||
for column in (
|
||||
"ck_expiry_source",
|
||||
"ck_observed_lifetime_seconds",
|
||||
"ck_invalid_detected_at",
|
||||
"ck_last_valid_at",
|
||||
"ck_expected_expires_at",
|
||||
):
|
||||
if _column_exists("accounts", column):
|
||||
op.drop_column("accounts", column)
|
||||
if _column_exists("account_commodity_states", "raw_json"):
|
||||
op.drop_column("account_commodity_states", "raw_json")
|
||||
+411
-1
@@ -2,7 +2,7 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
from datetime import UTC, date, datetime
|
||||
|
||||
from sqlalchemy import (
|
||||
JSON,
|
||||
@@ -10,6 +10,7 @@ from sqlalchemy import (
|
||||
Boolean,
|
||||
CheckConstraint,
|
||||
Computed,
|
||||
Date,
|
||||
ForeignKey,
|
||||
Index,
|
||||
Integer,
|
||||
@@ -227,6 +228,23 @@ class Account(Base):
|
||||
) # valid / invalid / error / 空 = 未检测
|
||||
ck_check_result: Mapped[dict | None] = mapped_column(JSON, nullable=True)
|
||||
ck_checked_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
# 当前 CK 周期的预测和观测信息。真实签发时间继续使用 cookie_updated_at。
|
||||
ck_expected_expires_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
ck_last_valid_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
ck_invalid_detected_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
ck_observed_lifetime_seconds: Mapped[int | None] = mapped_column(
|
||||
Integer, nullable=True
|
||||
)
|
||||
# observed / predicted / provider_expiry
|
||||
ck_expiry_source: Mapped[str] = mapped_column(
|
||||
String(24), nullable=False, default="", server_default=""
|
||||
)
|
||||
|
||||
# ── 登录态:自动重登的退避进度 ─────────────────────────────────────────
|
||||
relogin_attempts: Mapped[int] = mapped_column(
|
||||
@@ -1803,6 +1821,9 @@ class AccountCommodityState(Base):
|
||||
raw_status: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="", server_default=""
|
||||
)
|
||||
# 官方商品原始字段。限时窗口、场次、库存、资格字段以后可能增加;
|
||||
# 归一化状态出问题时必须能回到原始响应,不再只靠猜测字段名。
|
||||
raw_json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
|
||||
time_limited: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, default=False, server_default="0"
|
||||
)
|
||||
@@ -2215,6 +2236,395 @@ class PlatformFulfillmentEvent(Base):
|
||||
)
|
||||
|
||||
|
||||
class AccountSyncState(Base):
|
||||
"""账号在某个查询域的当前同步状态。"""
|
||||
|
||||
__tablename__ = "account_sync_states"
|
||||
|
||||
id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
account_id: Mapped[int] = mapped_column(
|
||||
ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False
|
||||
)
|
||||
platform: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="douyu", server_default="douyu"
|
||||
)
|
||||
domain: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
last_attempt_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
last_success_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
valid_until: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
next_retry_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
status: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="never", server_default="never"
|
||||
)
|
||||
error_code: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
error_message: Mapped[str] = mapped_column(Text, nullable=False, default="")
|
||||
source: Mapped[str] = mapped_column(
|
||||
String(32), nullable=False, default="", server_default=""
|
||||
)
|
||||
payload_hash: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
# 最近一次官方查询拿到的完整原始响应。商品级原始字段在
|
||||
# account_commodity_states.raw_json,这里保留整个响应以支持协议回溯。
|
||||
raw_payload_json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
|
||||
state_version: Mapped[int] = mapped_column(
|
||||
BigInteger, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
UTCDateTime, default=_utcnow, onupdate=_utcnow
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
UniqueConstraint(
|
||||
"account_id",
|
||||
"platform",
|
||||
"domain",
|
||||
name="uq_account_sync_state_domain",
|
||||
),
|
||||
Index(
|
||||
"ix_account_sync_state_due",
|
||||
"platform",
|
||||
"domain",
|
||||
"status",
|
||||
"next_retry_at",
|
||||
"account_id",
|
||||
),
|
||||
Index(
|
||||
"ix_account_sync_state_success",
|
||||
"platform",
|
||||
"domain",
|
||||
"last_success_at",
|
||||
"account_id",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class AccountSyncRun(Base):
|
||||
"""一次账号查询同步尝试,只追加。"""
|
||||
|
||||
__tablename__ = "account_sync_runs"
|
||||
|
||||
id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
account_id: Mapped[int] = mapped_column(
|
||||
ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False
|
||||
)
|
||||
platform: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="douyu", server_default="douyu"
|
||||
)
|
||||
domain: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
task_id: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
|
||||
started_at: Mapped[datetime] = mapped_column(UTCDateTime, nullable=False)
|
||||
finished_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
status: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="running"
|
||||
)
|
||||
source: Mapped[str] = mapped_column(
|
||||
String(32), nullable=False, default="", server_default=""
|
||||
)
|
||||
item_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
changed_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
duration_ms: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
error_code: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
error_message: Mapped[str] = mapped_column(Text, nullable=False, default="")
|
||||
official_observed_at: Mapped[datetime | None] = mapped_column(
|
||||
UTCDateTime, nullable=True
|
||||
)
|
||||
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
|
||||
__table_args__ = (
|
||||
Index(
|
||||
"ix_account_sync_runs_account_domain_time",
|
||||
"account_id",
|
||||
"domain",
|
||||
"started_at",
|
||||
),
|
||||
Index(
|
||||
"ix_account_sync_runs_domain_status_time",
|
||||
"domain",
|
||||
"status",
|
||||
"started_at",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class AccountWorkItem(Base):
|
||||
"""账号内部维护工作队列,不是用户可见业务任务。"""
|
||||
|
||||
__tablename__ = "account_work_items"
|
||||
|
||||
id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
account_id: Mapped[int] = mapped_column(
|
||||
ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False
|
||||
)
|
||||
work_type: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
priority: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=100, server_default="100"
|
||||
)
|
||||
status: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="pending", server_default="pending"
|
||||
)
|
||||
due_at: Mapped[datetime] = mapped_column(UTCDateTime, nullable=False)
|
||||
expires_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
attempt_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
max_attempts: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=3, server_default="3"
|
||||
)
|
||||
dedupe_key: Mapped[str] = mapped_column(String(191), nullable=False)
|
||||
active_dedupe_key: Mapped[str | None] = mapped_column(
|
||||
String(191),
|
||||
Computed(
|
||||
"CASE WHEN status IN ('pending', 'running') THEN dedupe_key ELSE NULL END",
|
||||
persisted=False,
|
||||
),
|
||||
nullable=True,
|
||||
)
|
||||
reason: Mapped[str] = mapped_column(
|
||||
String(255), nullable=False, default="", server_default=""
|
||||
)
|
||||
payload_json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
|
||||
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
started_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
finished_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
last_error: Mapped[str] = mapped_column(Text, nullable=False, default="")
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
UTCDateTime, default=_utcnow, onupdate=_utcnow
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
Index("uq_account_work_active_dedupe", "active_dedupe_key", unique=True),
|
||||
Index(
|
||||
"ix_account_work_due",
|
||||
"status",
|
||||
"work_type",
|
||||
"due_at",
|
||||
"priority",
|
||||
"id",
|
||||
),
|
||||
Index(
|
||||
"ix_account_work_account_status",
|
||||
"account_id",
|
||||
"status",
|
||||
"work_type",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class AccountSupplyTarget(Base):
|
||||
"""高价值、普通和商品维度的账号供给目标。"""
|
||||
|
||||
__tablename__ = "account_supply_targets"
|
||||
|
||||
id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
|
||||
platform: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="douyu", server_default="douyu"
|
||||
)
|
||||
scope: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="elite", server_default="elite"
|
||||
)
|
||||
commodity_id: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
value_class: Mapped[str] = mapped_column(String(16), nullable=False)
|
||||
target_covered: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
target_available: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
target_allocatable: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
safety_buffer: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
enabled: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, default=True, server_default="1"
|
||||
)
|
||||
updated_by: Mapped[int | None] = mapped_column(
|
||||
ForeignKey("users.id", ondelete="SET NULL"), nullable=True
|
||||
)
|
||||
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
UTCDateTime, default=_utcnow, onupdate=_utcnow
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
UniqueConstraint(
|
||||
"platform",
|
||||
"scope",
|
||||
"commodity_id",
|
||||
"value_class",
|
||||
name="uq_account_supply_target",
|
||||
),
|
||||
Index(
|
||||
"ix_account_supply_target_enabled",
|
||||
"platform",
|
||||
"enabled",
|
||||
"scope",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class LoginAttempt(Base):
|
||||
"""一次完整登录/重登/账号检测尝试,只追加。"""
|
||||
|
||||
__tablename__ = "login_attempts"
|
||||
|
||||
id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
account_id: Mapped[int] = mapped_column(
|
||||
ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False
|
||||
)
|
||||
batch_id: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
category: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
trigger_source: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="manual", server_default="manual"
|
||||
)
|
||||
created_by: Mapped[int | None] = mapped_column(
|
||||
ForeignKey("users.id", ondelete="SET NULL"), nullable=True
|
||||
)
|
||||
started_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
finished_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
|
||||
status: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="pending", server_default="pending"
|
||||
)
|
||||
failure_kind: Mapped[str] = mapped_column(
|
||||
String(16), nullable=False, default="", server_default=""
|
||||
)
|
||||
duration_ms: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
proxy_key: Mapped[str] = mapped_column(
|
||||
String(64), nullable=False, default="", server_default=""
|
||||
)
|
||||
email_code_requested: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, default=False, server_default="0"
|
||||
)
|
||||
quota_day: Mapped[date] = mapped_column(Date, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
|
||||
|
||||
__table_args__ = (
|
||||
Index(
|
||||
"ix_login_attempts_account_day",
|
||||
"account_id",
|
||||
"quota_day",
|
||||
"category",
|
||||
),
|
||||
Index(
|
||||
"ix_login_attempts_day_category_status",
|
||||
"quota_day",
|
||||
"category",
|
||||
"status",
|
||||
),
|
||||
Index(
|
||||
"ix_login_attempts_batch",
|
||||
"batch_id",
|
||||
"account_id",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class LoginQuotaSetting(Base):
|
||||
"""全局登录预算设置,默认只有 id=1 一行。"""
|
||||
|
||||
__tablename__ = "login_quota_settings"
|
||||
|
||||
id: Mapped[int] = mapped_column(Integer, primary_key=True)
|
||||
daily_attempt_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=1500, server_default="1500"
|
||||
)
|
||||
hourly_attempt_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=100, server_default="100"
|
||||
)
|
||||
per_account_daily_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=2, server_default="2"
|
||||
)
|
||||
onboarding_daily_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=150, server_default="150"
|
||||
)
|
||||
relogin_high_value_daily_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=300, server_default="300"
|
||||
)
|
||||
relogin_ordinary_daily_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=500, server_default="500"
|
||||
)
|
||||
manual_daily_limit: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=300, server_default="300"
|
||||
)
|
||||
login_concurrency: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=3, server_default="3"
|
||||
)
|
||||
failure_pause_ratio: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=40, server_default="40"
|
||||
)
|
||||
enabled: Mapped[bool] = mapped_column(
|
||||
Boolean, nullable=False, default=True, server_default="1"
|
||||
)
|
||||
updated_by: Mapped[int | None] = mapped_column(
|
||||
ForeignKey("users.id", ondelete="SET NULL"), nullable=True
|
||||
)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
UTCDateTime, default=_utcnow, onupdate=_utcnow
|
||||
)
|
||||
|
||||
|
||||
class LoginQuotaUsage(Base):
|
||||
"""按小时和分类累计登录配额用量。"""
|
||||
|
||||
__tablename__ = "login_quota_usage"
|
||||
|
||||
id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
|
||||
quota_day: Mapped[date] = mapped_column(Date, nullable=False)
|
||||
quota_hour: Mapped[int] = mapped_column(Integer, nullable=False)
|
||||
category: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
attempt_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
success_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
failure_count: Mapped[int] = mapped_column(
|
||||
Integer, nullable=False, default=0, server_default="0"
|
||||
)
|
||||
updated_at: Mapped[datetime] = mapped_column(
|
||||
UTCDateTime, default=_utcnow, onupdate=_utcnow
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
UniqueConstraint(
|
||||
"quota_day",
|
||||
"quota_hour",
|
||||
"category",
|
||||
name="uq_login_quota_usage_bucket",
|
||||
),
|
||||
Index(
|
||||
"ix_login_quota_usage_day_category",
|
||||
"quota_day",
|
||||
"category",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class IntegrationOutbox(Base):
|
||||
"""跨系统待发送事件;与业务状态在同一数据库事务内提交。"""
|
||||
|
||||
|
||||
@@ -364,10 +364,10 @@ class AccountOut(BaseModel):
|
||||
|
||||
# ---- 登录任务 ----
|
||||
class LoginBatchRequest(BaseModel):
|
||||
account_ids: list[int]
|
||||
max_login_retries: int = 0 # 登录整体重试次数,0=无限重试直到成功(后端兜底 20 次)
|
||||
max_total_time: float = 300 # 单账号登录总时长上限(秒),0=不限制
|
||||
concurrency: int = 3 # 并发数,1-10
|
||||
account_ids: list[int] = Field(..., min_length=1, max_length=50)
|
||||
max_login_retries: int = Field(0, ge=0)
|
||||
max_total_time: float = Field(300, ge=0)
|
||||
concurrency: int = Field(3, ge=1, le=10)
|
||||
api_strategy: str = "wgapi" # 接口策略: wgapi(新版)或 iframe(旧版备选)
|
||||
mode: str = Field(
|
||||
"login", pattern="^(login|check)$"
|
||||
@@ -375,7 +375,10 @@ class LoginBatchRequest(BaseModel):
|
||||
|
||||
|
||||
class CookieReloginRequest(BaseModel):
|
||||
ids: list[int] = [] # 需要重新登录的**账号** ID(2026-10-04 CK 解耦前是记录 ID)
|
||||
ids: list[int] = Field(
|
||||
default_factory=list,
|
||||
max_length=50,
|
||||
) # 需要重新登录的**账号** ID(2026-10-04 CK 解耦前是记录 ID)
|
||||
|
||||
|
||||
class LoginTaskOut(BaseModel):
|
||||
|
||||
@@ -11,7 +11,7 @@ from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import case, func
|
||||
from sqlalchemy import case, func, or_
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import Account, AccountCommodityState, AccountEvent
|
||||
@@ -189,6 +189,37 @@ def classify_goods_item(
|
||||
return AVAILABILITY_UNKNOWN, "官方商品列表未返回可判定的账号状态", raw_status
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GoodsAssessment:
|
||||
availability: str
|
||||
blocking_reason: str
|
||||
raw_status: str
|
||||
|
||||
|
||||
def classify_goods_items(
|
||||
goods_items: list[dict[str, Any]],
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> dict[str, GoodsAssessment]:
|
||||
"""一次性归一完整商品列表,供选号、实时复核和展示共享。"""
|
||||
assessments: dict[str, GoodsAssessment] = {}
|
||||
for item in goods_items:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
commodity_id = str(
|
||||
item.get("commodityId") or item.get("commodity_id") or ""
|
||||
).strip()
|
||||
if not commodity_id:
|
||||
continue
|
||||
availability, reason, raw_status = classify_goods_item(item, now=now)
|
||||
assessments[commodity_id] = GoodsAssessment(
|
||||
availability=availability,
|
||||
blocking_reason=reason,
|
||||
raw_status=raw_status,
|
||||
)
|
||||
return assessments
|
||||
|
||||
|
||||
def _exchange_stats(
|
||||
db: Session,
|
||||
*,
|
||||
@@ -279,7 +310,7 @@ def sync_account_goods_states(
|
||||
if not goods_items or account.id is None:
|
||||
return 0
|
||||
moment = observed_at or datetime.now(UTC)
|
||||
valid_until = moment + timedelta(seconds=capability_ttl_seconds())
|
||||
ttl_valid_until = moment + timedelta(seconds=capability_ttl_seconds())
|
||||
|
||||
existing_rows = (
|
||||
db.query(AccountCommodityState)
|
||||
@@ -324,17 +355,18 @@ def sync_account_goods_states(
|
||||
state.availability = availability
|
||||
state.blocking_reason = reason[:255]
|
||||
state.raw_status = raw_status[:16]
|
||||
state.raw_json = dict(item)
|
||||
state.time_limited = window.time_limited
|
||||
state.available_from = window.start
|
||||
state.available_until = window.end
|
||||
state.schedule_json = window.schedule or None
|
||||
state.observed_at = moment
|
||||
state.valid_until = valid_until
|
||||
state.next_check_at = (
|
||||
min(valid_until, window.next_boundary)
|
||||
state.valid_until = (
|
||||
min(ttl_valid_until, window.next_boundary)
|
||||
if window.next_boundary is not None
|
||||
else valid_until
|
||||
else ttl_valid_until
|
||||
)
|
||||
state.next_check_at = state.valid_until
|
||||
state.last_exchange_at = last_exchange_at
|
||||
state.exchange_count_365d = int(exchange_count)
|
||||
state.source = source[:24]
|
||||
@@ -353,9 +385,14 @@ def sync_account_goods_states(
|
||||
continue
|
||||
state.availability = AVAILABILITY_NOT_OFFERED
|
||||
state.blocking_reason = "官方商品列表本次未返回该商品"
|
||||
state.raw_json = None
|
||||
state.time_limited = False
|
||||
state.available_from = None
|
||||
state.available_until = None
|
||||
state.schedule_json = None
|
||||
state.observed_at = moment
|
||||
state.valid_until = None
|
||||
state.next_check_at = valid_until
|
||||
state.next_check_at = ttl_valid_until
|
||||
state.source = source[:24]
|
||||
state.updated_at = moment
|
||||
changed += 1
|
||||
@@ -538,6 +575,14 @@ def account_capability_counts(
|
||||
AccountCommodityState.availability == AVAILABILITY_AVAILABLE,
|
||||
AccountCommodityState.valid_until.isnot(None),
|
||||
AccountCommodityState.valid_until > moment,
|
||||
or_(
|
||||
AccountCommodityState.available_from.is_(None),
|
||||
AccountCommodityState.available_from <= moment,
|
||||
),
|
||||
or_(
|
||||
AccountCommodityState.available_until.is_(None),
|
||||
AccountCommodityState.available_until >= moment,
|
||||
),
|
||||
)
|
||||
.scalar()
|
||||
or 0
|
||||
@@ -557,9 +602,11 @@ __all__ = [
|
||||
"AVAILABILITY_NOT_OPEN",
|
||||
"AVAILABILITY_NO_STOCK",
|
||||
"AVAILABILITY_UNKNOWN",
|
||||
"GoodsAssessment",
|
||||
"account_capability_counts",
|
||||
"capability_ttl_seconds",
|
||||
"classify_goods_item",
|
||||
"classify_goods_items",
|
||||
"goods_time_window",
|
||||
"invalidate_account_commodity_states",
|
||||
"mark_commodity_exchanged",
|
||||
|
||||
@@ -28,7 +28,7 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
from loguru import logger
|
||||
@@ -43,8 +43,12 @@ from .account_events_service import (
|
||||
EVENT_STATUS_CHANGED,
|
||||
emit,
|
||||
)
|
||||
from .account_work_queue import complete_account_work_type, enqueue_account_work
|
||||
from .high_value_service import invalidate_high_value
|
||||
|
||||
WORK_LOGIN_RELOGIN = "login_relogin"
|
||||
DEFAULT_CK_LIFETIME = timedelta(days=7)
|
||||
|
||||
# ── 状态取值域(6 个)──────────────────────────────────────
|
||||
# 刻意**不做** `relogin`(退避重试中):它完全等价于
|
||||
# `invalid + relogin_next_at is not None`,独立成状态就多出一个必须与
|
||||
@@ -318,6 +322,53 @@ def on_ck_verdict(
|
||||
}
|
||||
account.ck_checked_at = now
|
||||
|
||||
if verdict == "valid":
|
||||
account.ck_last_valid_at = now
|
||||
account.ck_invalid_detected_at = None
|
||||
issued_at = _as_utc(account.cookie_updated_at)
|
||||
if issued_at is not None:
|
||||
account.ck_expected_expires_at = issued_at + DEFAULT_CK_LIFETIME
|
||||
account.ck_expiry_source = "predicted"
|
||||
if account.id is not None:
|
||||
try:
|
||||
complete_account_work_type(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
work_type=WORK_LOGIN_RELOGIN,
|
||||
now=now,
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 - 队列是派生索引
|
||||
logger.warning(
|
||||
"完成重登工作项失败 account_id={}: {}",
|
||||
account.id,
|
||||
exc,
|
||||
)
|
||||
elif verdict == "invalid":
|
||||
if previous != "invalid":
|
||||
account.ck_invalid_detected_at = now
|
||||
issued_at = _as_utc(account.cookie_updated_at)
|
||||
if issued_at is not None and issued_at <= now:
|
||||
lifetime = int((now - issued_at).total_seconds())
|
||||
if 0 < lifetime <= int(timedelta(days=90).total_seconds()):
|
||||
account.ck_observed_lifetime_seconds = lifetime
|
||||
account.ck_expected_expires_at = None
|
||||
account.ck_expiry_source = "observed"
|
||||
if account.id is not None:
|
||||
try:
|
||||
enqueue_account_work(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
work_type=WORK_LOGIN_RELOGIN,
|
||||
priority=30,
|
||||
reason="CK 已判定失效,等待受预算控制的重登",
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 - 生命周期主流程优先
|
||||
logger.warning(
|
||||
"登记自动重登工作项失败 account_id={}: {}",
|
||||
account.id,
|
||||
exc,
|
||||
)
|
||||
|
||||
if verdict == "invalid" and previous != "invalid":
|
||||
emit(
|
||||
db,
|
||||
@@ -357,6 +408,12 @@ def on_login_success(
|
||||
account.relogin_next_at = None
|
||||
account.relogin_failure_kind = ""
|
||||
account.relogin_last_error = ""
|
||||
complete_account_work_type(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
work_type=WORK_LOGIN_RELOGIN,
|
||||
now=occurred_at,
|
||||
)
|
||||
sync_status(db, account, occurred_at=occurred_at)
|
||||
|
||||
|
||||
@@ -380,6 +437,11 @@ def on_ck_cleared(
|
||||
account.ck_check_status = ""
|
||||
account.ck_check_result = None
|
||||
account.ck_checked_at = None
|
||||
account.ck_expected_expires_at = None
|
||||
account.ck_last_valid_at = None
|
||||
account.ck_invalid_detected_at = None
|
||||
account.ck_observed_lifetime_seconds = None
|
||||
account.ck_expiry_source = ""
|
||||
|
||||
emit(
|
||||
db,
|
||||
@@ -424,3 +486,9 @@ def warn_if_drift(account: Account) -> None:
|
||||
logger.warning(
|
||||
f"账号状态漂移:account={account.id} 落库={account.status} 推导={expected}"
|
||||
)
|
||||
|
||||
|
||||
def _as_utc(value: datetime | None) -> datetime | None:
|
||||
if value is None:
|
||||
return None
|
||||
return value.replace(tzinfo=UTC) if value.tzinfo is None else value.astimezone(UTC)
|
||||
|
||||
@@ -0,0 +1,301 @@
|
||||
"""账号同步状态、运行记录和官网结果投影。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import Account, AccountSyncRun, AccountSyncState
|
||||
from .account_capability_service import (
|
||||
capability_ttl_seconds,
|
||||
sync_account_goods_states,
|
||||
)
|
||||
from .douyu_read_gateway import StorehomeSnapshot
|
||||
from .high_value_service import (
|
||||
DEFAULT_HIGH_VALUE_GOODS,
|
||||
apply_high_value_goods,
|
||||
extract_high_value_goods,
|
||||
)
|
||||
|
||||
DOMAIN_STOREHOME = "storehome"
|
||||
DOMAIN_EXCHANGE_RECORDS = "exchange_records"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class StorehomeSyncResult:
|
||||
item_count: int
|
||||
changed_count: int
|
||||
observed_at: datetime
|
||||
|
||||
|
||||
def _payload_hash(raw_payload: dict[str, Any]) -> str:
|
||||
payload = json.dumps(
|
||||
raw_payload,
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
)
|
||||
return hashlib.sha256(payload.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def get_sync_state(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
domain: str,
|
||||
platform: str = "douyu",
|
||||
) -> AccountSyncState | None:
|
||||
return (
|
||||
db.query(AccountSyncState)
|
||||
.filter(
|
||||
AccountSyncState.account_id == account_id,
|
||||
AccountSyncState.platform == platform,
|
||||
AccountSyncState.domain == domain,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
|
||||
|
||||
def is_domain_fresh(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
domain: str,
|
||||
now: datetime | None = None,
|
||||
) -> bool:
|
||||
moment = now or datetime.now(UTC)
|
||||
state = get_sync_state(db, account_id=account_id, domain=domain)
|
||||
return bool(
|
||||
state
|
||||
and state.status == "success"
|
||||
and state.valid_until
|
||||
and state.valid_until > moment
|
||||
)
|
||||
|
||||
|
||||
def _get_or_create_state(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
domain: str,
|
||||
platform: str = "douyu",
|
||||
) -> AccountSyncState:
|
||||
state = get_sync_state(
|
||||
db,
|
||||
account_id=account_id,
|
||||
domain=domain,
|
||||
platform=platform,
|
||||
)
|
||||
if state is None:
|
||||
state = AccountSyncState(
|
||||
account_id=account_id,
|
||||
platform=platform,
|
||||
domain=domain,
|
||||
)
|
||||
db.add(state)
|
||||
db.flush()
|
||||
return state
|
||||
|
||||
|
||||
def mark_domain_dirty(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
domain: str,
|
||||
reason: str = "",
|
||||
) -> AccountSyncState:
|
||||
state = _get_or_create_state(db, account_id=account_id, domain=domain)
|
||||
state.status = "dirty"
|
||||
state.valid_until = None
|
||||
state.next_retry_at = datetime.now(UTC)
|
||||
state.error_code = "dirty"
|
||||
state.error_message = reason[:2000]
|
||||
state.state_version = int(state.state_version or 0) + 1
|
||||
db.flush()
|
||||
return state
|
||||
|
||||
|
||||
def start_sync_run(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
domain: str,
|
||||
source: str,
|
||||
task_id: int | None = None,
|
||||
) -> AccountSyncRun:
|
||||
moment = datetime.now(UTC)
|
||||
state = _get_or_create_state(db, account_id=account_id, domain=domain)
|
||||
state.last_attempt_at = moment
|
||||
state.status = "running"
|
||||
state.error_code = ""
|
||||
state.error_message = ""
|
||||
state.source = source[:32]
|
||||
run = AccountSyncRun(
|
||||
account_id=account_id,
|
||||
platform="douyu",
|
||||
domain=domain,
|
||||
task_id=task_id,
|
||||
started_at=moment,
|
||||
status="running",
|
||||
source=source[:32],
|
||||
)
|
||||
db.add(run)
|
||||
db.flush()
|
||||
return run
|
||||
|
||||
|
||||
def finish_sync_success(
|
||||
db: Session,
|
||||
run: AccountSyncRun,
|
||||
*,
|
||||
item_count: int,
|
||||
changed_count: int,
|
||||
observed_at: datetime,
|
||||
valid_for_seconds: int | None = None,
|
||||
raw_payload: dict[str, Any] | None = None,
|
||||
) -> None:
|
||||
moment = datetime.now(UTC)
|
||||
duration_ms = max(0, int((moment - run.started_at).total_seconds() * 1000))
|
||||
run.status = "success"
|
||||
run.finished_at = moment
|
||||
run.item_count = int(item_count)
|
||||
run.changed_count = int(changed_count)
|
||||
run.duration_ms = duration_ms
|
||||
run.official_observed_at = observed_at
|
||||
state = _get_or_create_state(
|
||||
db,
|
||||
account_id=int(run.account_id),
|
||||
domain=run.domain,
|
||||
platform=run.platform,
|
||||
)
|
||||
state.status = "success"
|
||||
state.last_success_at = moment
|
||||
state.valid_until = moment + timedelta(
|
||||
seconds=max(
|
||||
1,
|
||||
int(
|
||||
valid_for_seconds
|
||||
if valid_for_seconds is not None
|
||||
else capability_ttl_seconds()
|
||||
),
|
||||
)
|
||||
)
|
||||
state.next_retry_at = state.valid_until
|
||||
state.error_code = ""
|
||||
state.error_message = ""
|
||||
if raw_payload is not None:
|
||||
state.raw_payload_json = raw_payload
|
||||
state.payload_hash = _payload_hash(raw_payload)
|
||||
state.state_version = int(state.state_version or 0) + 1
|
||||
db.flush()
|
||||
|
||||
|
||||
def finish_sync_failure(
|
||||
db: Session,
|
||||
run: AccountSyncRun,
|
||||
*,
|
||||
error: BaseException,
|
||||
retry_after_seconds: int = 300,
|
||||
error_code: str = "sync_failed",
|
||||
raw_payload: dict[str, Any] | None = None,
|
||||
) -> None:
|
||||
moment = datetime.now(UTC)
|
||||
duration_ms = max(0, int((moment - run.started_at).total_seconds() * 1000))
|
||||
message = f"{type(error).__name__}: {error}"[:2000]
|
||||
run.status = "failed"
|
||||
run.finished_at = moment
|
||||
run.duration_ms = duration_ms
|
||||
run.error_code = error_code[:64]
|
||||
run.error_message = message
|
||||
state = _get_or_create_state(
|
||||
db,
|
||||
account_id=int(run.account_id),
|
||||
domain=run.domain,
|
||||
platform=run.platform,
|
||||
)
|
||||
state.status = "failed"
|
||||
state.next_retry_at = moment + timedelta(seconds=max(1, retry_after_seconds))
|
||||
state.error_code = error_code[:64]
|
||||
state.error_message = message
|
||||
if raw_payload is not None:
|
||||
state.raw_payload_json = raw_payload
|
||||
state.payload_hash = _payload_hash(raw_payload)
|
||||
state.state_version = int(state.state_version or 0) + 1
|
||||
db.flush()
|
||||
|
||||
|
||||
def sync_storehome_snapshot(
|
||||
db: Session,
|
||||
account: Account,
|
||||
snapshot: StorehomeSnapshot,
|
||||
*,
|
||||
source: str,
|
||||
task_id: int | None = None,
|
||||
) -> StorehomeSyncResult:
|
||||
"""把一次完整 storehome 快照投影成账号全部商品状态。"""
|
||||
start = time.monotonic()
|
||||
run = start_sync_run(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
domain=DOMAIN_STOREHOME,
|
||||
source=source,
|
||||
task_id=task_id,
|
||||
)
|
||||
try:
|
||||
items = list(snapshot.items)
|
||||
changed = sync_account_goods_states(
|
||||
db,
|
||||
account,
|
||||
items,
|
||||
scope="elite",
|
||||
observed_at=snapshot.observed_at,
|
||||
source="storehome_sync",
|
||||
)
|
||||
high_value = extract_high_value_goods(
|
||||
items,
|
||||
DEFAULT_HIGH_VALUE_GOODS,
|
||||
[],
|
||||
)
|
||||
apply_high_value_goods(account, high_value, checked_at=snapshot.observed_at)
|
||||
account.updated_at = snapshot.observed_at
|
||||
finish_sync_success(
|
||||
db,
|
||||
run,
|
||||
item_count=len(items),
|
||||
changed_count=changed,
|
||||
observed_at=snapshot.observed_at,
|
||||
raw_payload=snapshot.raw,
|
||||
)
|
||||
run.duration_ms = max(
|
||||
int(run.duration_ms or 0),
|
||||
int((time.monotonic() - start) * 1000),
|
||||
)
|
||||
return StorehomeSyncResult(
|
||||
item_count=len(items),
|
||||
changed_count=changed,
|
||||
observed_at=snapshot.observed_at,
|
||||
)
|
||||
except Exception as exc:
|
||||
finish_sync_failure(db, run, error=exc, raw_payload=snapshot.raw)
|
||||
raise
|
||||
|
||||
|
||||
__all__ = [
|
||||
"DOMAIN_EXCHANGE_RECORDS",
|
||||
"DOMAIN_STOREHOME",
|
||||
"StorehomeSyncResult",
|
||||
"finish_sync_failure",
|
||||
"finish_sync_success",
|
||||
"get_sync_state",
|
||||
"is_domain_fresh",
|
||||
"mark_domain_dirty",
|
||||
"start_sync_run",
|
||||
"sync_storehome_snapshot",
|
||||
]
|
||||
@@ -157,6 +157,24 @@ def is_high_value_expr(*, now: datetime | None = None):
|
||||
return value_tier_expr(now=now) <= HIGH_VALUE_TIER_MAX
|
||||
|
||||
|
||||
def is_high_value_account(
|
||||
account: Account,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> bool:
|
||||
"""Python 侧价值判定,供登录分类和库存队列复用 SQL 口径。"""
|
||||
moment = now or datetime.now(UTC)
|
||||
fresh = bool(
|
||||
account.high_value_checked_at
|
||||
and account.high_value_checked_at >= high_value_fresh_cutoff(now=moment)
|
||||
)
|
||||
available = fresh and (
|
||||
account.high_value_bairimeng_status == HIGH_VALUE_STATUS_AVAILABLE
|
||||
or account.high_value_mengtu_status == HIGH_VALUE_STATUS_AVAILABLE
|
||||
)
|
||||
return available or int(account.points or 0) >= HIGH_VALUE_POINTS
|
||||
|
||||
|
||||
def suit_sort_rank_expr(*, now: datetime | None = None):
|
||||
"""列表「高价值套装」列的排序,和格子上看到的一致。数字越小越值钱。
|
||||
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
"""账号内部维护工作队列。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import AccountWorkItem
|
||||
|
||||
|
||||
def enqueue_account_work(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
work_type: str,
|
||||
priority: int = 100,
|
||||
due_at: datetime | None = None,
|
||||
max_attempts: int = 3,
|
||||
reason: str = "",
|
||||
payload: dict[str, Any] | None = None,
|
||||
) -> AccountWorkItem:
|
||||
dedupe_key = f"{work_type}:{account_id}"
|
||||
existing = (
|
||||
db.query(AccountWorkItem)
|
||||
.filter(
|
||||
AccountWorkItem.account_id == account_id,
|
||||
AccountWorkItem.work_type == work_type,
|
||||
AccountWorkItem.status.in_(("pending", "running")),
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if existing is not None:
|
||||
existing.priority = min(existing.priority, priority)
|
||||
if due_at is not None and due_at < existing.due_at:
|
||||
existing.due_at = due_at
|
||||
db.flush()
|
||||
return existing
|
||||
item = AccountWorkItem(
|
||||
account_id=account_id,
|
||||
work_type=work_type[:32],
|
||||
priority=int(priority),
|
||||
due_at=due_at or datetime.now(UTC),
|
||||
max_attempts=max(1, int(max_attempts)),
|
||||
dedupe_key=dedupe_key[:191],
|
||||
reason=reason[:255],
|
||||
payload_json=payload,
|
||||
)
|
||||
try:
|
||||
with db.begin_nested():
|
||||
db.add(item)
|
||||
db.flush()
|
||||
return item
|
||||
except IntegrityError:
|
||||
return (
|
||||
db.query(AccountWorkItem)
|
||||
.filter(AccountWorkItem.active_dedupe_key == dedupe_key[:191])
|
||||
.one()
|
||||
)
|
||||
|
||||
|
||||
def claim_account_work(
|
||||
db: Session,
|
||||
*,
|
||||
work_types: tuple[str, ...],
|
||||
limit: int = 10,
|
||||
now: datetime | None = None,
|
||||
) -> list[AccountWorkItem]:
|
||||
moment = now or datetime.now(UTC)
|
||||
rows = (
|
||||
db.query(AccountWorkItem)
|
||||
.filter(
|
||||
AccountWorkItem.work_type.in_(work_types),
|
||||
AccountWorkItem.status == "pending",
|
||||
AccountWorkItem.due_at <= moment,
|
||||
)
|
||||
.order_by(
|
||||
AccountWorkItem.priority.asc(),
|
||||
AccountWorkItem.due_at.asc(),
|
||||
AccountWorkItem.id.asc(),
|
||||
)
|
||||
.with_for_update(skip_locked=True)
|
||||
.limit(max(1, int(limit)))
|
||||
.all()
|
||||
)
|
||||
for row in rows:
|
||||
row.status = "running"
|
||||
row.started_at = moment
|
||||
row.attempt_count = int(row.attempt_count or 0) + 1
|
||||
row.updated_at = moment
|
||||
if rows:
|
||||
db.flush()
|
||||
return rows
|
||||
|
||||
|
||||
def complete_account_work(
|
||||
db: Session,
|
||||
item: AccountWorkItem,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
moment = now or datetime.now(UTC)
|
||||
item.status = "success"
|
||||
item.finished_at = moment
|
||||
item.last_error = ""
|
||||
item.updated_at = moment
|
||||
db.flush()
|
||||
|
||||
|
||||
def complete_account_work_type(
|
||||
db: Session,
|
||||
*,
|
||||
account_id: int,
|
||||
work_type: str,
|
||||
now: datetime | None = None,
|
||||
) -> int:
|
||||
"""完成某个账号指定类型的待办;成功后旧待办不再阻塞后续工作。"""
|
||||
moment = now or datetime.now(UTC)
|
||||
items = (
|
||||
db.query(AccountWorkItem)
|
||||
.filter(
|
||||
AccountWorkItem.account_id == account_id,
|
||||
AccountWorkItem.work_type == work_type,
|
||||
AccountWorkItem.status.in_(("pending", "running")),
|
||||
)
|
||||
.all()
|
||||
)
|
||||
for item in items:
|
||||
complete_account_work(db, item, now=moment)
|
||||
return len(items)
|
||||
|
||||
|
||||
def fail_account_work(
|
||||
db: Session,
|
||||
item: AccountWorkItem,
|
||||
*,
|
||||
error: BaseException | str,
|
||||
retry_after_seconds: int = 300,
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
moment = now or datetime.now(UTC)
|
||||
message = str(error)[:2000]
|
||||
item.last_error = message
|
||||
item.updated_at = moment
|
||||
if int(item.attempt_count or 0) >= int(item.max_attempts or 1):
|
||||
item.status = "failed"
|
||||
item.finished_at = moment
|
||||
else:
|
||||
item.status = "pending"
|
||||
item.due_at = moment + timedelta(seconds=max(1, retry_after_seconds))
|
||||
db.flush()
|
||||
|
||||
|
||||
__all__ = [
|
||||
"claim_account_work",
|
||||
"complete_account_work",
|
||||
"complete_account_work_type",
|
||||
"enqueue_account_work",
|
||||
"fail_account_work",
|
||||
]
|
||||
@@ -68,6 +68,9 @@ def _candidates_query(db: Session, job: AutomationJob, now: datetime):
|
||||
db.query(Account)
|
||||
.filter(cookie_operable_filter())
|
||||
.filter(Account.auto_managed.is_(True))
|
||||
# invalid 已进入自动重登队列,manual 已停止自动处理;普通 CK 探针
|
||||
# 再扫它们只会重复消耗官方请求,并掩盖真正需要发现的新失效。
|
||||
.filter(Account.ck_check_status.notin_(("invalid", "manual")))
|
||||
# 生命周期状态机:停用/归档的账号不参与任何自动化(见 account_lifecycle)。
|
||||
.filter(Account.status.notin_(MANUAL_STATES))
|
||||
.filter(
|
||||
|
||||
@@ -255,6 +255,7 @@ def run_ck_relogin(db: Session, job: AutomationJob) -> dict[str, Any]:
|
||||
loop=None,
|
||||
concurrency=max(min(int(job.concurrency or 3), 8), 1),
|
||||
mode="relogin",
|
||||
trigger_source="automation",
|
||||
)
|
||||
batch_id = runner.batch_id
|
||||
try:
|
||||
|
||||
@@ -733,6 +733,8 @@ def probe_account(
|
||||
points: int | None = None
|
||||
points_response: dict[str, Any] = {}
|
||||
limited_goods: list[dict[str, Any]] = []
|
||||
storehome_goods: list[dict[str, Any]] = []
|
||||
storehome_raw: dict[str, Any] = {}
|
||||
if with_eligibility:
|
||||
uid = str(account.uid or "").strip()
|
||||
if ctn:
|
||||
@@ -754,6 +756,22 @@ def probe_account(
|
||||
for item in limited_result.get("limited_goods") or []
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
raw_storehome = (
|
||||
limited_result.get("raw")
|
||||
if isinstance(limited_result.get("raw"), dict)
|
||||
else {}
|
||||
)
|
||||
raw_data = (
|
||||
raw_storehome.get("data")
|
||||
if isinstance(raw_storehome.get("data"), dict)
|
||||
else {}
|
||||
)
|
||||
raw_list = raw_data.get("list")
|
||||
storehome_goods = [
|
||||
dict(item)
|
||||
for item in (raw_list if isinstance(raw_list, list) else [])
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
except Exception as exc: # noqa: BLE001
|
||||
errors["limited_goods"] = f"{type(exc).__name__}: {_text(exc)}"
|
||||
|
||||
@@ -839,6 +857,8 @@ def probe_account(
|
||||
"error": errors.get("elite", ""),
|
||||
},
|
||||
"eligibility": {
|
||||
"manual_id": manual_id,
|
||||
"rid": str(config_info.get("rid") or ""),
|
||||
"points": points,
|
||||
"points_response": points_response,
|
||||
"points_expire_at": (
|
||||
@@ -854,6 +874,8 @@ def probe_account(
|
||||
).strip()
|
||||
}
|
||||
),
|
||||
"storehome_goods": storehome_goods,
|
||||
"storehome_raw": storehome_raw,
|
||||
"error": errors.get("points", ""),
|
||||
},
|
||||
"roles": roles,
|
||||
@@ -979,6 +1001,39 @@ def persist_probe_result(
|
||||
if gold.get("status") == CAPABILITY_OK and _to_int(gold.get("balance")) is not None:
|
||||
account.gold_balance = _to_int(gold.get("balance"))
|
||||
|
||||
eligibility = probe.get("eligibility") or {}
|
||||
storehome_goods = [
|
||||
dict(item)
|
||||
for item in eligibility.get("storehome_goods") or []
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
if account.id is not None and storehome_goods:
|
||||
from .account_sync_service import sync_storehome_snapshot
|
||||
from .douyu_read_gateway import StorehomeSnapshot
|
||||
|
||||
storehome_raw = (
|
||||
eligibility.get("storehome_raw")
|
||||
if isinstance(eligibility.get("storehome_raw"), dict)
|
||||
else {}
|
||||
)
|
||||
sync_storehome_snapshot(
|
||||
db,
|
||||
account,
|
||||
StorehomeSnapshot(
|
||||
manual_id=str(eligibility.get("manual_id") or ""),
|
||||
rid=str(eligibility.get("rid") or ""),
|
||||
observed_at=now,
|
||||
items=tuple(storehome_goods),
|
||||
limited_ids=frozenset(
|
||||
str(item)
|
||||
for item in eligibility.get("limited_ids") or []
|
||||
if str(item)
|
||||
),
|
||||
raw=storehome_raw,
|
||||
),
|
||||
source=source[:32],
|
||||
)
|
||||
|
||||
account.updated_at = now
|
||||
if record_event and account.id is not None:
|
||||
emit(
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Callable
|
||||
from dataclasses import dataclass
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
@@ -18,6 +18,10 @@ from core.douyu import DouyuActivityClient
|
||||
|
||||
from ..models import Account
|
||||
from .account_binding import is_role_change_cooling
|
||||
from .account_capability_service import (
|
||||
AVAILABILITY_AVAILABLE,
|
||||
classify_goods_items,
|
||||
)
|
||||
from .cookie_check_service import check_douyu_cookie
|
||||
from .douyu_account_probe import config_mapping, persist_probe_result, probe_account
|
||||
|
||||
@@ -35,6 +39,8 @@ class DouyuLiveAccountState:
|
||||
role_change_available_at: datetime | None
|
||||
error: str = ""
|
||||
role_change_blocked: bool = False
|
||||
commodity_availability: dict[str, str] = field(default_factory=dict)
|
||||
commodity_blocking_reasons: dict[str, str] = field(default_factory=dict)
|
||||
|
||||
def blocking_reasons(
|
||||
self,
|
||||
@@ -48,6 +54,15 @@ class DouyuLiveAccountState:
|
||||
reasons.append(self.error)
|
||||
if commodity_id in self.limited_ids:
|
||||
reasons.append("该商品已达限兑上限")
|
||||
elif self.commodity_availability:
|
||||
availability = self.commodity_availability.get(commodity_id)
|
||||
if availability is None:
|
||||
reasons.append("官方商品列表本次未返回该商品,可能已下架")
|
||||
elif availability != AVAILABILITY_AVAILABLE:
|
||||
reasons.append(
|
||||
self.commodity_blocking_reasons.get(commodity_id)
|
||||
or f"商品当前不可兑换({availability})"
|
||||
)
|
||||
if self.role_change_blocked:
|
||||
available_text = (
|
||||
self.role_change_available_at.isoformat()
|
||||
@@ -150,6 +165,23 @@ def refresh_douyu_account_state(
|
||||
limited_ids = frozenset(
|
||||
str(item) for item in eligibility.get("limited_ids") or [] if str(item)
|
||||
)
|
||||
assessments = classify_goods_items(
|
||||
[
|
||||
item
|
||||
for item in eligibility.get("storehome_goods") or []
|
||||
if isinstance(item, dict)
|
||||
],
|
||||
now=now,
|
||||
)
|
||||
commodity_availability = {
|
||||
commodity_id: assessment.availability
|
||||
for commodity_id, assessment in assessments.items()
|
||||
}
|
||||
commodity_blocking_reasons = {
|
||||
commodity_id: assessment.blocking_reason
|
||||
for commodity_id, assessment in assessments.items()
|
||||
if assessment.blocking_reason
|
||||
}
|
||||
return DouyuLiveAccountState(
|
||||
account_id=int(account.id),
|
||||
account_name=account.nickname
|
||||
@@ -167,6 +199,8 @@ def refresh_douyu_account_state(
|
||||
role_change_available_at=account.role_change_available_at,
|
||||
error=";".join(errors),
|
||||
role_change_blocked=is_role_change_cooling(bind_info),
|
||||
commodity_availability=commodity_availability,
|
||||
commodity_blocking_reasons=commodity_blocking_reasons,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@@ -108,10 +108,23 @@ def query_activity_goods(
|
||||
manual_id: str,
|
||||
rid: str,
|
||||
) -> list[dict[str, Any]]:
|
||||
result = client.list_goods(manual_id=manual_id, rid=rid)
|
||||
result = query_activity_goods_result(
|
||||
client,
|
||||
manual_id=manual_id,
|
||||
rid=rid,
|
||||
)
|
||||
return [dict(item) for item in result.get("goods") or [] if isinstance(item, dict)]
|
||||
|
||||
|
||||
def query_activity_goods_result(
|
||||
client: DouyuActivityClient,
|
||||
*,
|
||||
manual_id: str,
|
||||
rid: str,
|
||||
) -> dict[str, Any]:
|
||||
return client.list_goods(manual_id=manual_id, rid=rid)
|
||||
|
||||
|
||||
def query_esports_goods_result(
|
||||
client: DouyuActivityClient,
|
||||
*,
|
||||
@@ -232,6 +245,7 @@ def query_exchange_orders(
|
||||
__all__ = [
|
||||
"activity_client",
|
||||
"query_activity_goods",
|
||||
"query_activity_goods_result",
|
||||
"query_bind_info",
|
||||
"query_csrf",
|
||||
"query_elite_user_info",
|
||||
|
||||
@@ -48,6 +48,10 @@ from .account_binding import (
|
||||
can_change_role,
|
||||
role_change_available_at,
|
||||
)
|
||||
from .account_capability_service import (
|
||||
AVAILABILITY_AVAILABLE,
|
||||
classify_goods_items,
|
||||
)
|
||||
from .account_events_service import (
|
||||
CATEGORY_OPS,
|
||||
EVENT_COLLAB_SYNCED,
|
||||
@@ -793,6 +797,20 @@ def recommend_accounts(
|
||||
}
|
||||
if cid and cid in limited_ids:
|
||||
return
|
||||
if cid:
|
||||
assessments = classify_goods_items(
|
||||
[
|
||||
item
|
||||
for item in eligibility.get("storehome_goods") or []
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
)
|
||||
assessment = assessments.get(str(cid))
|
||||
if assessments and (
|
||||
assessment is None
|
||||
or assessment.availability != AVAILABILITY_AVAILABLE
|
||||
):
|
||||
return
|
||||
|
||||
elite = probe.get("elite") or {}
|
||||
live_points = _to_int(eligibility.get("points"))
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
"""斗鱼只读查询网关。
|
||||
|
||||
所有账号同步都从这里获取结构化快照,避免页面、Runner 和自动化各自解释原始响应。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from core.douyu import DouyuActivityClient
|
||||
|
||||
from .douyu_activity_query import query_limited_goods_result
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class StorehomeSnapshot:
|
||||
"""单账号完整商城资格快照。"""
|
||||
|
||||
manual_id: str
|
||||
rid: str
|
||||
observed_at: datetime
|
||||
items: tuple[dict[str, Any], ...]
|
||||
limited_ids: frozenset[str]
|
||||
raw: dict[str, Any]
|
||||
|
||||
@property
|
||||
def item_count(self) -> int:
|
||||
return len(self.items)
|
||||
|
||||
|
||||
def extract_storehome_goods(raw: Any) -> list[dict[str, Any]]:
|
||||
"""从官方 ``storehome`` 响应中提取完整商品列表。"""
|
||||
if not isinstance(raw, dict):
|
||||
return []
|
||||
data = raw.get("data")
|
||||
if not isinstance(data, dict):
|
||||
return []
|
||||
rows = data.get("list")
|
||||
if not isinstance(rows, list):
|
||||
return []
|
||||
return [dict(item) for item in rows if isinstance(item, dict)]
|
||||
|
||||
|
||||
def storehome_snapshot_from_result(
|
||||
result: dict[str, Any],
|
||||
*,
|
||||
manual_id: str,
|
||||
rid: str,
|
||||
observed_at: datetime | None = None,
|
||||
) -> StorehomeSnapshot:
|
||||
"""把已经拿到的官方响应归一成可落库的完整快照。"""
|
||||
raw = result.get("raw") if isinstance(result.get("raw"), dict) else {}
|
||||
if raw and raw.get("error") not in (None, 0, "0"):
|
||||
raise RuntimeError(str(raw.get("msg") or "查询商城商品列表失败"))
|
||||
items = extract_storehome_goods(raw)
|
||||
if not items and isinstance(result.get("goods"), list):
|
||||
items = [
|
||||
dict(item) for item in result["goods"] if isinstance(item, dict)
|
||||
]
|
||||
limited_ids = frozenset(
|
||||
str(item.get("commodityId") or item.get("commodity_id") or "")
|
||||
for item in items
|
||||
if str(item.get("status") or "") == "1"
|
||||
and str(item.get("commodityId") or item.get("commodity_id") or "").strip()
|
||||
)
|
||||
return StorehomeSnapshot(
|
||||
manual_id=str(manual_id),
|
||||
rid=str(rid or ""),
|
||||
observed_at=observed_at or datetime.now(UTC),
|
||||
items=tuple(items),
|
||||
limited_ids=limited_ids,
|
||||
raw=raw,
|
||||
)
|
||||
|
||||
|
||||
def fetch_storehome_snapshot(
|
||||
client: DouyuActivityClient,
|
||||
*,
|
||||
manual_id: str,
|
||||
rid: str,
|
||||
) -> StorehomeSnapshot:
|
||||
"""一次请求返回当前账号全部商品资格。"""
|
||||
result = query_limited_goods_result(
|
||||
client,
|
||||
manual_id=manual_id,
|
||||
rid=str(rid or ""),
|
||||
)
|
||||
return storehome_snapshot_from_result(
|
||||
result,
|
||||
manual_id=manual_id,
|
||||
rid=rid,
|
||||
)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"StorehomeSnapshot",
|
||||
"extract_storehome_goods",
|
||||
"fetch_storehome_snapshot",
|
||||
"storehome_snapshot_from_result",
|
||||
]
|
||||
@@ -12,15 +12,26 @@ from sqlalchemy.orm import Session
|
||||
from core.douyu import DouyuActivityClient, DouyuActivityError
|
||||
|
||||
from ..models import Account, DouyuEsportsGoodsSnapshot, DouyuGoodsSnapshot, DouyuTask
|
||||
from .account_sync_service import (
|
||||
DOMAIN_EXCHANGE_RECORDS,
|
||||
finish_sync_failure,
|
||||
finish_sync_success,
|
||||
start_sync_run,
|
||||
sync_storehome_snapshot,
|
||||
)
|
||||
from .business_events import record_exchange
|
||||
from .douyu_activity_query import (
|
||||
query_activity_goods,
|
||||
query_activity_goods_result,
|
||||
query_csrf,
|
||||
query_elite_user_info,
|
||||
query_esports_goods_result,
|
||||
query_exchange_records_result,
|
||||
query_limited_goods_result,
|
||||
)
|
||||
from .douyu_goods_service import upsert_goods_snapshot
|
||||
from .douyu_read_gateway import storehome_snapshot_from_result
|
||||
from .douyu_runner_overview import record_official_exchange_records
|
||||
from .high_value_service import (
|
||||
DEFAULT_HIGH_VALUE_GOODS,
|
||||
HIGH_VALUE_STATUS_OWNED,
|
||||
@@ -78,12 +89,29 @@ class GoodsMixin:
|
||||
self, db: Session, task: DouyuTask, account: Account, cookie: str, config: dict
|
||||
):
|
||||
client = self._client(cookie)
|
||||
goods = query_activity_goods(
|
||||
result = query_activity_goods_result(
|
||||
client,
|
||||
manual_id=str(config["manual_id"]),
|
||||
rid=str(config["rid"]),
|
||||
)
|
||||
self._upsert_goods(db, goods)
|
||||
goods = [
|
||||
dict(item)
|
||||
for item in result.get("goods") or []
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
snapshot = storehome_snapshot_from_result(
|
||||
result,
|
||||
manual_id=str(config["manual_id"]),
|
||||
rid=str(config["rid"]),
|
||||
)
|
||||
upsert_goods_snapshot(db, goods, commit=False)
|
||||
sync_storehome_snapshot(
|
||||
db,
|
||||
account,
|
||||
snapshot,
|
||||
source="douyu_task.refresh_goods",
|
||||
task_id=task.id,
|
||||
)
|
||||
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)
|
||||
@@ -723,7 +751,19 @@ class GoodsMixin:
|
||||
client, manual_id=str(config["manual_id"]), rid=str(config["rid"])
|
||||
)
|
||||
limited = result["limited_goods"]
|
||||
goods = (result.get("raw") or {}).get("data", {}).get("list") or []
|
||||
snapshot = storehome_snapshot_from_result(
|
||||
result,
|
||||
manual_id=str(config["manual_id"]),
|
||||
rid=str(config["rid"]),
|
||||
)
|
||||
goods = list(snapshot.items)
|
||||
sync_storehome_snapshot(
|
||||
db,
|
||||
account,
|
||||
snapshot,
|
||||
source="douyu_task.query_limited_goods",
|
||||
task_id=task.id,
|
||||
)
|
||||
high_value_goods = extract_high_value_goods(goods, DEFAULT_HIGH_VALUE_GOODS, [])
|
||||
apply_high_value_goods(account, high_value_goods)
|
||||
names = [
|
||||
@@ -760,6 +800,45 @@ class GoodsMixin:
|
||||
offset=0,
|
||||
)
|
||||
records = result.get("records") or []
|
||||
observed_at = datetime.now(UTC)
|
||||
sync_run = start_sync_run(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
domain=DOMAIN_EXCHANGE_RECORDS,
|
||||
source="douyu_task.query_exchange_records",
|
||||
task_id=task.id,
|
||||
)
|
||||
try:
|
||||
added = record_official_exchange_records(
|
||||
db,
|
||||
account,
|
||||
[("elite", record) for record in records if isinstance(record, dict)],
|
||||
)
|
||||
finish_sync_success(
|
||||
db,
|
||||
sync_run,
|
||||
item_count=len(records),
|
||||
changed_count=added,
|
||||
observed_at=observed_at,
|
||||
raw_payload=(
|
||||
result.get("raw")
|
||||
if isinstance(result.get("raw"), dict)
|
||||
else None
|
||||
),
|
||||
)
|
||||
except Exception as exc:
|
||||
finish_sync_failure(
|
||||
db,
|
||||
sync_run,
|
||||
error=exc,
|
||||
raw_payload=(
|
||||
result.get("raw")
|
||||
if isinstance(result.get("raw"), dict)
|
||||
else None
|
||||
),
|
||||
)
|
||||
raise
|
||||
result["exchange_events_added"] = added
|
||||
account.updated_at = datetime.now(UTC)
|
||||
self._mark_task(
|
||||
db,
|
||||
|
||||
@@ -33,7 +33,7 @@ from sqlalchemy.orm import Session
|
||||
from core.douyu import DouyuActivityClient
|
||||
|
||||
from ..models import Account, DouyuTask
|
||||
from .account_capability_service import sync_account_goods_states
|
||||
from .account_sync_service import sync_storehome_snapshot
|
||||
from .business_events import record_official_exchange
|
||||
from .douyu_account_probe import (
|
||||
ROLE_BOUND,
|
||||
@@ -48,13 +48,14 @@ from .douyu_account_probe import (
|
||||
resolve_peace_role,
|
||||
)
|
||||
from .douyu_activity_query import (
|
||||
query_activity_goods,
|
||||
query_activity_goods_result,
|
||||
query_csrf,
|
||||
query_esports_bind_info,
|
||||
query_exchange_records,
|
||||
query_xpd_bind_info,
|
||||
query_xpd_embed,
|
||||
)
|
||||
from .douyu_read_gateway import StorehomeSnapshot, storehome_snapshot_from_result
|
||||
from .douyu_runner_donate import _parse_expire_at, _points_expire_at
|
||||
from .high_value_service import (
|
||||
DEFAULT_HIGH_VALUE_GOODS,
|
||||
@@ -84,7 +85,7 @@ def _group_by_scope(
|
||||
return grouped
|
||||
|
||||
|
||||
def _record_official_exchanges(
|
||||
def record_official_exchange_records(
|
||||
db: Session, account: Account, pairs: list[tuple[str, dict[str, Any]]]
|
||||
) -> int:
|
||||
"""把官方兑换记录补成账号事件,返回**新写入**的条数。
|
||||
@@ -293,6 +294,7 @@ class OverviewMixin:
|
||||
all_records: list[tuple[str, dict[str, Any]]] = []
|
||||
pending_goods: list[dict[str, Any]] = []
|
||||
goods_query_ok = False
|
||||
storehome_snapshot: StorehomeSnapshot | None = None
|
||||
|
||||
# ---- 鱼翅 + 钱包兑换余额 ----
|
||||
try:
|
||||
@@ -372,7 +374,18 @@ class OverviewMixin:
|
||||
goods_items: list[dict[str, Any]] = []
|
||||
try:
|
||||
# 🎯 拉取完整商城商品列表(含每个商品准确的 status 状态:1=已达兑换上限,0=可兑换)
|
||||
goods_items = query_activity_goods(client, manual_id=manual_id, rid=rid)
|
||||
goods_result = query_activity_goods_result(
|
||||
client,
|
||||
manual_id=manual_id,
|
||||
rid=rid,
|
||||
)
|
||||
storehome_snapshot = storehome_snapshot_from_result(
|
||||
goods_result,
|
||||
manual_id=manual_id,
|
||||
rid=rid,
|
||||
observed_at=queried_at,
|
||||
)
|
||||
goods_items = list(storehome_snapshot.items)
|
||||
overview["limited_goods_total"] = len(goods_items)
|
||||
goods_query_ok = True
|
||||
except Exception as exc: # noqa: BLE001
|
||||
@@ -496,7 +509,7 @@ class OverviewMixin:
|
||||
# 兑换记录开始前结束前一步可能留下的角色快照事务。
|
||||
db.commit()
|
||||
# 把官方记录**补成账号事件**(带真实兑换时间、按作用域去重)。
|
||||
overview["exchange_events_added"] = _record_official_exchanges(
|
||||
overview["exchange_events_added"] = record_official_exchange_records(
|
||||
db, account, all_records
|
||||
)
|
||||
overview["exchange_records"] = {
|
||||
@@ -508,14 +521,15 @@ class OverviewMixin:
|
||||
# 只有完整商城列表查询成功时才更新,避免把网络失败写成“不可兑换”。
|
||||
if goods_query_ok:
|
||||
try:
|
||||
overview["commodity_states_synced"] = sync_account_goods_states(
|
||||
if storehome_snapshot is None:
|
||||
raise RuntimeError("完整商品响应未形成快照")
|
||||
overview["commodity_states_synced"] = sync_storehome_snapshot(
|
||||
db,
|
||||
account,
|
||||
pending_goods,
|
||||
scope="elite",
|
||||
observed_at=queried_at,
|
||||
source="overview",
|
||||
)
|
||||
storehome_snapshot,
|
||||
source="douyu_task.account_overview",
|
||||
task_id=task.id,
|
||||
).changed_count
|
||||
except Exception as exc: # noqa: BLE001
|
||||
errors["commodity_states"] = _err(exc)
|
||||
|
||||
|
||||
@@ -0,0 +1,341 @@
|
||||
"""登录尝试流水和数据库级登录预算。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, date, datetime
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..models import (
|
||||
Account,
|
||||
LoginAttempt,
|
||||
LoginQuotaSetting,
|
||||
LoginQuotaUsage,
|
||||
LoginTask,
|
||||
)
|
||||
from .account_value import is_high_value_account
|
||||
from .douyu_service import LOGIN_ATTEMPT_IN_FLIGHT_STATUSES
|
||||
|
||||
CATEGORY_ALL = "all"
|
||||
CATEGORY_MANUAL = "manual_login"
|
||||
CATEGORY_ONBOARDING = "onboarding"
|
||||
CATEGORY_RELOGIN_HIGH = "relogin_high_value"
|
||||
CATEGORY_RELOGIN_ORDINARY = "relogin_ordinary"
|
||||
CATEGORY_ACCOUNT_CHECK = "account_check"
|
||||
|
||||
BUSINESS_TZ = ZoneInfo("Asia/Shanghai")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class QuotaDecision:
|
||||
allowed: bool
|
||||
reason: str = ""
|
||||
attempt: LoginAttempt | None = None
|
||||
|
||||
|
||||
def _bucket(now: datetime | None = None) -> tuple[date, int]:
|
||||
moment = now or datetime.now(UTC)
|
||||
aware = moment if moment.tzinfo else moment.replace(tzinfo=UTC)
|
||||
local = aware.astimezone(BUSINESS_TZ)
|
||||
return local.date(), local.hour
|
||||
|
||||
|
||||
def classify_login_category(
|
||||
account: Account,
|
||||
*,
|
||||
mode: str,
|
||||
trigger_source: str = "manual",
|
||||
now: datetime | None = None,
|
||||
) -> str:
|
||||
if mode == "check":
|
||||
return CATEGORY_ACCOUNT_CHECK
|
||||
if mode == "relogin":
|
||||
return (
|
||||
CATEGORY_RELOGIN_HIGH
|
||||
if is_high_value_account(account, now=now)
|
||||
else CATEGORY_RELOGIN_ORDINARY
|
||||
)
|
||||
if (
|
||||
trigger_source == "automation"
|
||||
or account.status == "imported"
|
||||
or not account.cookie
|
||||
or account.cookie_updated_at is None
|
||||
):
|
||||
return CATEGORY_ONBOARDING
|
||||
return CATEGORY_MANUAL
|
||||
|
||||
|
||||
def _setting(db: Session) -> LoginQuotaSetting:
|
||||
row = (
|
||||
db.query(LoginQuotaSetting)
|
||||
.filter(LoginQuotaSetting.id == 1)
|
||||
.with_for_update()
|
||||
.first()
|
||||
)
|
||||
if row is None:
|
||||
row = LoginQuotaSetting(id=1)
|
||||
db.add(row)
|
||||
db.flush()
|
||||
return row
|
||||
|
||||
|
||||
def login_concurrency_limit(db: Session) -> int:
|
||||
"""读取数据库配置的登录并发上限;未初始化时使用保守默认值。"""
|
||||
setting = db.query(LoginQuotaSetting).filter(LoginQuotaSetting.id == 1).first()
|
||||
if setting is None or not setting.enabled:
|
||||
return 3
|
||||
return max(1, min(int(setting.login_concurrency or 3), 10))
|
||||
|
||||
|
||||
def _usage_row(
|
||||
db: Session,
|
||||
*,
|
||||
quota_day: date,
|
||||
quota_hour: int,
|
||||
category: str,
|
||||
) -> LoginQuotaUsage:
|
||||
row = (
|
||||
db.query(LoginQuotaUsage)
|
||||
.filter(
|
||||
LoginQuotaUsage.quota_day == quota_day,
|
||||
LoginQuotaUsage.quota_hour == quota_hour,
|
||||
LoginQuotaUsage.category == category,
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if row is None:
|
||||
row = LoginQuotaUsage(
|
||||
quota_day=quota_day,
|
||||
quota_hour=quota_hour,
|
||||
category=category,
|
||||
)
|
||||
db.add(row)
|
||||
db.flush()
|
||||
return row
|
||||
|
||||
|
||||
def _daily_total(db: Session, quota_day: date) -> int:
|
||||
rows = (
|
||||
db.query(LoginQuotaUsage.attempt_count)
|
||||
.filter(
|
||||
LoginQuotaUsage.quota_day == quota_day,
|
||||
LoginQuotaUsage.category == CATEGORY_ALL,
|
||||
)
|
||||
.all()
|
||||
)
|
||||
return sum(int(value or 0) for (value,) in rows)
|
||||
|
||||
|
||||
def _hourly_total(db: Session, quota_day: date, quota_hour: int) -> int:
|
||||
value = (
|
||||
db.query(LoginQuotaUsage.attempt_count)
|
||||
.filter(
|
||||
LoginQuotaUsage.quota_day == quota_day,
|
||||
LoginQuotaUsage.quota_hour == quota_hour,
|
||||
LoginQuotaUsage.category == CATEGORY_ALL,
|
||||
)
|
||||
.scalar()
|
||||
)
|
||||
return int(value or 0)
|
||||
|
||||
|
||||
def _category_daily_total(db: Session, quota_day: date, category: str) -> int:
|
||||
rows = (
|
||||
db.query(LoginQuotaUsage.attempt_count)
|
||||
.filter(
|
||||
LoginQuotaUsage.quota_day == quota_day,
|
||||
LoginQuotaUsage.category == category,
|
||||
)
|
||||
.all()
|
||||
)
|
||||
return sum(int(value or 0) for (value,) in rows)
|
||||
|
||||
|
||||
def _category_limit(setting: LoginQuotaSetting, category: str) -> int:
|
||||
return {
|
||||
CATEGORY_ONBOARDING: int(setting.onboarding_daily_limit),
|
||||
CATEGORY_RELOGIN_HIGH: int(setting.relogin_high_value_daily_limit),
|
||||
CATEGORY_RELOGIN_ORDINARY: int(setting.relogin_ordinary_daily_limit),
|
||||
CATEGORY_MANUAL: int(setting.manual_daily_limit),
|
||||
CATEGORY_ACCOUNT_CHECK: int(setting.manual_daily_limit),
|
||||
}.get(category, int(setting.daily_attempt_limit))
|
||||
|
||||
|
||||
def reserve_login_attempt(
|
||||
db: Session,
|
||||
*,
|
||||
account: Account,
|
||||
mode: str,
|
||||
trigger_source: str,
|
||||
batch_id: str,
|
||||
created_by: int | None,
|
||||
now: datetime | None = None,
|
||||
) -> QuotaDecision:
|
||||
moment = now or datetime.now(UTC)
|
||||
quota_day, quota_hour = _bucket(moment)
|
||||
setting = _setting(db)
|
||||
if not setting.enabled:
|
||||
category = classify_login_category(
|
||||
account,
|
||||
mode=mode,
|
||||
trigger_source=trigger_source,
|
||||
now=moment,
|
||||
)
|
||||
attempt = LoginAttempt(
|
||||
account_id=int(account.id),
|
||||
batch_id=batch_id[:64],
|
||||
category=category,
|
||||
trigger_source=trigger_source[:16],
|
||||
created_by=created_by,
|
||||
started_at=moment,
|
||||
status="pending",
|
||||
quota_day=quota_day,
|
||||
)
|
||||
db.add(attempt)
|
||||
db.flush()
|
||||
return QuotaDecision(True, attempt=attempt)
|
||||
|
||||
in_flight = (
|
||||
db.query(LoginTask.id)
|
||||
.filter(
|
||||
LoginTask.account_id == account.id,
|
||||
LoginTask.attempt_status.in_(LOGIN_ATTEMPT_IN_FLIGHT_STATUSES),
|
||||
)
|
||||
.first()
|
||||
)
|
||||
in_flight_attempt = (
|
||||
db.query(LoginAttempt.id)
|
||||
.filter(
|
||||
LoginAttempt.account_id == account.id,
|
||||
LoginAttempt.status.in_(("pending", "running")),
|
||||
)
|
||||
.first()
|
||||
)
|
||||
if in_flight is not None or in_flight_attempt is not None:
|
||||
return QuotaDecision(False, reason="该账号已有登录任务在执行")
|
||||
|
||||
account_day_count = (
|
||||
db.query(LoginAttempt.id)
|
||||
.filter(
|
||||
LoginAttempt.account_id == account.id,
|
||||
LoginAttempt.quota_day == quota_day,
|
||||
)
|
||||
.count()
|
||||
)
|
||||
if account_day_count >= int(setting.per_account_daily_limit):
|
||||
return QuotaDecision(False, reason="该账号已达到今日登录尝试上限")
|
||||
|
||||
if _daily_total(db, quota_day) >= int(setting.daily_attempt_limit):
|
||||
return QuotaDecision(False, reason="全局每日登录尝试预算已用完")
|
||||
if _hourly_total(db, quota_day, quota_hour) >= int(
|
||||
setting.hourly_attempt_limit
|
||||
):
|
||||
return QuotaDecision(False, reason="全局每小时登录尝试预算已用完")
|
||||
|
||||
category = classify_login_category(
|
||||
account,
|
||||
mode=mode,
|
||||
trigger_source=trigger_source,
|
||||
now=moment,
|
||||
)
|
||||
if _category_daily_total(db, quota_day, category) >= _category_limit(
|
||||
setting, category
|
||||
):
|
||||
return QuotaDecision(False, reason=f"{category} 今日登录预算已用完")
|
||||
|
||||
attempt = LoginAttempt(
|
||||
account_id=int(account.id),
|
||||
batch_id=batch_id[:64],
|
||||
category=category,
|
||||
trigger_source=trigger_source[:16],
|
||||
created_by=created_by,
|
||||
started_at=moment,
|
||||
status="pending",
|
||||
quota_day=quota_day,
|
||||
)
|
||||
db.add(attempt)
|
||||
for usage_category in (CATEGORY_ALL, category):
|
||||
usage = _usage_row(
|
||||
db,
|
||||
quota_day=quota_day,
|
||||
quota_hour=quota_hour,
|
||||
category=usage_category,
|
||||
)
|
||||
usage.attempt_count = int(usage.attempt_count or 0) + 1
|
||||
db.flush()
|
||||
return QuotaDecision(True, attempt=attempt)
|
||||
|
||||
|
||||
def finish_login_attempt(
|
||||
db: Session,
|
||||
attempt: LoginAttempt,
|
||||
*,
|
||||
status: str,
|
||||
failure_kind: str = "",
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
if attempt.status in {"success", "failed", "error", "stopped"}:
|
||||
return
|
||||
moment = now or datetime.now(UTC)
|
||||
attempt.status = status[:16]
|
||||
attempt.failure_kind = failure_kind[:16]
|
||||
attempt.finished_at = moment
|
||||
attempt.duration_ms = max(
|
||||
0,
|
||||
int((moment - attempt.started_at).total_seconds() * 1000),
|
||||
)
|
||||
quota_day, quota_hour = _bucket(attempt.started_at)
|
||||
for usage_category in (CATEGORY_ALL, attempt.category):
|
||||
usage = _usage_row(
|
||||
db,
|
||||
quota_day=quota_day,
|
||||
quota_hour=quota_hour,
|
||||
category=usage_category,
|
||||
)
|
||||
if status == "success":
|
||||
usage.success_count = int(usage.success_count or 0) + 1
|
||||
elif status in {"failed", "error"}:
|
||||
usage.failure_count = int(usage.failure_count or 0) + 1
|
||||
db.flush()
|
||||
|
||||
|
||||
def cleanup_orphan_login_attempts(
|
||||
db: Session,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> int:
|
||||
"""服务重启后把遗留的尝试流水收敛为 interrupted。"""
|
||||
moment = now or datetime.now(UTC)
|
||||
attempts = (
|
||||
db.query(LoginAttempt)
|
||||
.filter(LoginAttempt.status.in_(("pending", "running")))
|
||||
.all()
|
||||
)
|
||||
for attempt in attempts:
|
||||
finish_login_attempt(
|
||||
db,
|
||||
attempt,
|
||||
status="failed",
|
||||
failure_kind="interrupted",
|
||||
now=moment,
|
||||
)
|
||||
if attempts:
|
||||
db.commit()
|
||||
return len(attempts)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"CATEGORY_ACCOUNT_CHECK",
|
||||
"CATEGORY_MANUAL",
|
||||
"CATEGORY_ONBOARDING",
|
||||
"CATEGORY_RELOGIN_HIGH",
|
||||
"CATEGORY_RELOGIN_ORDINARY",
|
||||
"QuotaDecision",
|
||||
"classify_login_category",
|
||||
"cleanup_orphan_login_attempts",
|
||||
"finish_login_attempt",
|
||||
"login_concurrency_limit",
|
||||
"reserve_login_attempt",
|
||||
]
|
||||
@@ -18,7 +18,7 @@ from core.douyu import DouyuLogin, create_login_api_strategy
|
||||
from core.douyu.login import AccountLike
|
||||
|
||||
from ..models import Account as AccountModel
|
||||
from ..models import LoginTask
|
||||
from ..models import LoginAttempt, LoginTask
|
||||
from ..models import ProxyConfig as ProxyConfigModel
|
||||
from .account_events_service import (
|
||||
EVENT_LOGIN_FAILED,
|
||||
@@ -27,10 +27,17 @@ from .account_events_service import (
|
||||
emit,
|
||||
)
|
||||
from .account_lifecycle import on_login_success, sync_status
|
||||
from .account_sync_service import DOMAIN_STOREHOME, mark_domain_dirty
|
||||
from .account_work_queue import enqueue_account_work
|
||||
from .cookie_check_service import check_douyu_cookie
|
||||
from .douyu_account_probe import persist_probe_result, probe_session
|
||||
from .douyu_service import LOGIN_ATTEMPT_IN_FLIGHT_STATUSES
|
||||
from .login_failure import classify_failure, failure_kind_label, is_account_fault
|
||||
from .login_quota_service import (
|
||||
finish_login_attempt,
|
||||
login_concurrency_limit,
|
||||
reserve_login_attempt,
|
||||
)
|
||||
from .proxy_service import build_proxy_runtime
|
||||
from .task_runtime import TaskLane, submit
|
||||
|
||||
@@ -240,6 +247,23 @@ def _write_login_success(
|
||||
)
|
||||
|
||||
|
||||
def _enqueue_post_login_sync(db: Session, account: AccountModel) -> None:
|
||||
"""登录并验证成功后,把商品能力标脏并进入内部同步队列。"""
|
||||
mark_domain_dirty(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
domain=DOMAIN_STOREHOME,
|
||||
reason="登录成功,等待同步完整商城商品能力",
|
||||
)
|
||||
enqueue_account_work(
|
||||
db,
|
||||
account_id=int(account.id),
|
||||
work_type=DOMAIN_STOREHOME + "_sync",
|
||||
priority=20,
|
||||
reason="登录成功联动同步",
|
||||
)
|
||||
|
||||
|
||||
def _persist_login_cookie_verification(
|
||||
db: Session,
|
||||
task: LoginTask,
|
||||
@@ -313,6 +337,7 @@ class LoginBatchRunner:
|
||||
concurrency: int = 3,
|
||||
api_strategy: str = "wgapi",
|
||||
mode: str = "login",
|
||||
trigger_source: str = "manual",
|
||||
):
|
||||
self.db = db
|
||||
self.account_ids = account_ids
|
||||
@@ -326,9 +351,16 @@ class LoginBatchRunner:
|
||||
self.log_queue = log_queue
|
||||
self.loop = loop
|
||||
self.batch_id = uuid.uuid4().hex[:12]
|
||||
self.concurrency = max(1, min(concurrency, 10)) # 限制 1-10
|
||||
self.concurrency = max(
|
||||
1,
|
||||
min(concurrency, 10, login_concurrency_limit(db)),
|
||||
)
|
||||
self.api_strategy = create_login_api_strategy(api_strategy)
|
||||
self.mode = mode if mode in ("login", "check", "relogin") else "login"
|
||||
self.trigger_source = trigger_source if trigger_source in {
|
||||
"manual",
|
||||
"automation",
|
||||
} else "manual"
|
||||
self._stop = threading.Event()
|
||||
self._counter_lock = threading.Lock()
|
||||
self._completed = 0
|
||||
@@ -587,6 +619,14 @@ class LoginBatchRunner:
|
||||
batch_id=self.batch_id,
|
||||
mode=self.mode,
|
||||
)
|
||||
if account.ck_check_status == "valid":
|
||||
try:
|
||||
_enqueue_post_login_sync(worker_db, account)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
self._push_log(
|
||||
"warning",
|
||||
f"[{current}] 登录成功,但登记商品同步队列失败: {exc}",
|
||||
)
|
||||
if account is not None and account.ck_check_status == "valid":
|
||||
self._push_log(
|
||||
"success",
|
||||
@@ -718,6 +758,21 @@ class LoginBatchRunner:
|
||||
self._push_log("warning", f"跳过无权账号: {acc.username}")
|
||||
continue
|
||||
|
||||
quota = reserve_login_attempt(
|
||||
self.db,
|
||||
account=acc,
|
||||
mode=self.mode,
|
||||
trigger_source=self.trigger_source,
|
||||
batch_id=batch_id,
|
||||
created_by=self.created_by,
|
||||
)
|
||||
if not quota.allowed:
|
||||
self._push_log(
|
||||
"warning",
|
||||
f"跳过账号 {acc.username}: {quota.reason}",
|
||||
)
|
||||
continue
|
||||
|
||||
# 解耦后不再需要「哪一行持有 CK」这个不变量(CK 在账号上)。
|
||||
# 这里只需要保证**同一账号不并发两行**:
|
||||
# ① 复用该账号在途的尝试(避免并发两个批次各建一行);
|
||||
@@ -806,6 +861,10 @@ class LoginBatchRunner:
|
||||
self._push_log("info", f"批量{action_name}任务 {batch_id} 完成")
|
||||
self._push_log("result", "")
|
||||
finally:
|
||||
try:
|
||||
_settle_login_attempts(batch_id)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
logger.exception(f"[登录批次 {batch_id}] 结算登录尝试流水失败: {exc}")
|
||||
# 标记批次结束:WS 端据此决定何时清理注册表(断线重连可继续订阅日志)。
|
||||
batch_registry.mark_finished(batch_id)
|
||||
# 确保 DB Session 被关闭,避免连接泄漏
|
||||
@@ -853,6 +912,61 @@ class BatchRegistry:
|
||||
return self._batches.pop(batch_id, None)
|
||||
|
||||
|
||||
def _settle_login_attempts(batch_id: str) -> None:
|
||||
"""用新的短事务把本批不可变登录流水结转到终态。"""
|
||||
session = WorkerSessionLocal()
|
||||
try:
|
||||
attempts = (
|
||||
session.query(LoginAttempt)
|
||||
.filter(
|
||||
LoginAttempt.batch_id == batch_id,
|
||||
LoginAttempt.status.in_(("pending", "running")),
|
||||
)
|
||||
.all()
|
||||
)
|
||||
for attempt in attempts:
|
||||
task = (
|
||||
session.query(LoginTask)
|
||||
.filter(
|
||||
LoginTask.account_id == attempt.account_id,
|
||||
LoginTask.attempt_batch_id == batch_id,
|
||||
)
|
||||
.order_by(LoginTask.id.desc())
|
||||
.first()
|
||||
)
|
||||
task_status = (task.attempt_status if task else "") or (
|
||||
task.status if task else ""
|
||||
)
|
||||
message = (task.attempt_message if task else "") or (
|
||||
task.message if task else ""
|
||||
)
|
||||
if task_status == "success" or task_status == "account_verified":
|
||||
status = "success"
|
||||
failure_kind = ""
|
||||
elif task_status in CHECK_STATUS_MESSAGES:
|
||||
status = "failed"
|
||||
failure_kind = (
|
||||
"network"
|
||||
if task_status == "account_auth_unknown"
|
||||
else "credential"
|
||||
)
|
||||
elif task_status in {"failed", "error"}:
|
||||
status = task_status
|
||||
failure_kind = classify_failure(message)
|
||||
else:
|
||||
status = "failed"
|
||||
failure_kind = "interrupted"
|
||||
finish_login_attempt(
|
||||
session,
|
||||
attempt,
|
||||
status=status,
|
||||
failure_kind=failure_kind,
|
||||
)
|
||||
session.commit()
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
|
||||
# 模块级单例
|
||||
batch_registry = BatchRegistry()
|
||||
|
||||
|
||||
@@ -35,7 +35,13 @@ from ..account_binding import (
|
||||
)
|
||||
from ..account_capability_service import (
|
||||
AVAILABILITY_AVAILABLE,
|
||||
AVAILABILITY_EXPIRED,
|
||||
AVAILABILITY_LIMITED,
|
||||
AVAILABILITY_NO_STOCK,
|
||||
AVAILABILITY_NOT_OFFERED,
|
||||
AVAILABILITY_NOT_OPEN,
|
||||
AVAILABILITY_UNKNOWN,
|
||||
classify_goods_items,
|
||||
record_account_commodity_state,
|
||||
)
|
||||
from ..business_events import record_account_query, record_douyu_task_started
|
||||
@@ -92,6 +98,47 @@ def _matching_mode() -> str:
|
||||
return mode if mode in {"legacy", "hybrid", "capability"} else "hybrid"
|
||||
|
||||
|
||||
def _exchange_gate(
|
||||
state: DouyuLiveAccountState,
|
||||
commodity_id: str,
|
||||
) -> tuple[str, str, str]:
|
||||
"""把实时商品资格映射为履约可展示的硬门槛。"""
|
||||
if commodity_id in state.limited_ids:
|
||||
return (
|
||||
"limited",
|
||||
"commodity_limit_reached",
|
||||
"该账号已达到此商品兑换上限",
|
||||
)
|
||||
if not state.commodity_availability:
|
||||
return "", "", ""
|
||||
availability = state.commodity_availability.get(commodity_id)
|
||||
reason = state.commodity_blocking_reasons.get(commodity_id, "")
|
||||
if availability is None:
|
||||
return (
|
||||
"not_available",
|
||||
"commodity_not_offered",
|
||||
reason or "官方商品列表本次未返回该商品,可能已下架",
|
||||
)
|
||||
if availability == AVAILABILITY_AVAILABLE:
|
||||
return "", "", ""
|
||||
issue_map = {
|
||||
AVAILABILITY_NOT_OPEN: ("commodity_not_open", "商品限时兑换尚未开始"),
|
||||
AVAILABILITY_EXPIRED: ("commodity_expired", "商品限时兑换已经结束"),
|
||||
AVAILABILITY_NO_STOCK: ("commodity_no_stock", "商品当前无库存"),
|
||||
AVAILABILITY_NOT_OFFERED: ("commodity_not_offered", "商品当前未上架"),
|
||||
AVAILABILITY_UNKNOWN: ("commodity_status_unknown", "商品资格状态未知"),
|
||||
AVAILABILITY_LIMITED: (
|
||||
"commodity_limit_reached",
|
||||
"该账号已达到此商品兑换上限",
|
||||
),
|
||||
}
|
||||
issue_code, fallback = issue_map.get(
|
||||
availability,
|
||||
("commodity_not_exchangeable", "商品当前不可兑换"),
|
||||
)
|
||||
return "not_available", issue_code, reason or fallback
|
||||
|
||||
|
||||
_SYNC_LOCK = Lock()
|
||||
_AUTO_SYNC_LOCK = Lock()
|
||||
_AUTO_SYNC_LAST_ATTEMPT = float("-inf")
|
||||
@@ -2152,14 +2199,27 @@ def allocate_task(db: Session, *, task_id: int, current: User) -> dict[str, Any]
|
||||
|
||||
if live_state.ck_verdict == "valid" and not live_state.error:
|
||||
try:
|
||||
availability = live_state.commodity_availability.get(
|
||||
task.commodity_id
|
||||
)
|
||||
blocking_reason = live_state.commodity_blocking_reasons.get(
|
||||
task.commodity_id,
|
||||
"",
|
||||
)
|
||||
if limited:
|
||||
availability = AVAILABILITY_LIMITED
|
||||
blocking_reason = "该账号已达此商品兑换上限"
|
||||
elif live_state.commodity_availability and availability is None:
|
||||
availability = AVAILABILITY_NOT_OFFERED
|
||||
blocking_reason = "官方商品列表本次未返回该商品,可能已下架"
|
||||
elif availability is None:
|
||||
availability = AVAILABILITY_AVAILABLE
|
||||
record_account_commodity_state(
|
||||
db,
|
||||
account,
|
||||
commodity_id=task.commodity_id,
|
||||
availability=(
|
||||
AVAILABILITY_LIMITED if limited else AVAILABILITY_AVAILABLE
|
||||
),
|
||||
blocking_reason=("该账号已达此商品兑换上限" if limited else ""),
|
||||
availability=availability,
|
||||
blocking_reason=blocking_reason,
|
||||
raw_status="1" if limited else "0",
|
||||
observed_at=live_state.checked_at,
|
||||
source="live_check",
|
||||
@@ -2307,10 +2367,13 @@ def allocate_task(db: Session, *, task_id: int, current: User) -> dict[str, Any]
|
||||
soft_reasons = selected_state.soft_requirement_reasons(
|
||||
required_points=required_points
|
||||
)
|
||||
if task.commodity_id in selected_state.limited_ids:
|
||||
task.exchange_status = "limited"
|
||||
task.issue_code = "commodity_limit_reached"
|
||||
task.last_error = "该账号已达到此商品兑换上限"
|
||||
gate_status, gate_issue, gate_message = _exchange_gate(
|
||||
selected_state, task.commodity_id
|
||||
)
|
||||
if gate_status:
|
||||
task.exchange_status = gate_status
|
||||
task.issue_code = gate_issue
|
||||
task.last_error = gate_message
|
||||
elif selected_state.elite_opened is not True:
|
||||
task.exchange_status = "not_opened"
|
||||
task.issue_code = "elite_not_opened"
|
||||
@@ -2875,10 +2938,47 @@ def refresh_exchange_eligibility(
|
||||
db.commit()
|
||||
return get_task_detail(db, task.id)
|
||||
|
||||
eligibility = probe.get("eligibility") or {}
|
||||
storehome_goods = [
|
||||
dict(item)
|
||||
for item in eligibility.get("storehome_goods") or []
|
||||
if isinstance(item, dict)
|
||||
]
|
||||
assessments = classify_goods_items(storehome_goods, now=_now())
|
||||
assessment = assessments.get(task.commodity_id)
|
||||
if task.commodity_id in limited_ids:
|
||||
task.exchange_status = "limited"
|
||||
task.issue_code = "commodity_limit_reached"
|
||||
task.last_error = "该账号已达到此商品兑换上限"
|
||||
availability = AVAILABILITY_LIMITED
|
||||
commodity_status = "limited"
|
||||
issue_code = "commodity_limit_reached"
|
||||
commodity_message = "该账号已达到此商品兑换上限"
|
||||
elif assessments and assessment is None:
|
||||
availability = AVAILABILITY_NOT_OFFERED
|
||||
commodity_status = "not_available"
|
||||
issue_code = "commodity_not_offered"
|
||||
commodity_message = "官方商品列表本次未返回该商品,可能已下架"
|
||||
elif assessment is not None and assessment.availability != AVAILABILITY_AVAILABLE:
|
||||
availability = assessment.availability
|
||||
commodity_status = "not_available"
|
||||
issue_code = {
|
||||
AVAILABILITY_NOT_OPEN: "commodity_not_open",
|
||||
AVAILABILITY_EXPIRED: "commodity_expired",
|
||||
AVAILABILITY_NO_STOCK: "commodity_no_stock",
|
||||
AVAILABILITY_NOT_OFFERED: "commodity_not_offered",
|
||||
AVAILABILITY_UNKNOWN: "commodity_status_unknown",
|
||||
}.get(assessment.availability, "commodity_not_exchangeable")
|
||||
commodity_message = (
|
||||
assessment.blocking_reason or "商品当前不可兑换"
|
||||
)
|
||||
else:
|
||||
availability = AVAILABILITY_AVAILABLE
|
||||
commodity_status = ""
|
||||
issue_code = ""
|
||||
commodity_message = ""
|
||||
|
||||
if commodity_status:
|
||||
task.exchange_status = commodity_status
|
||||
task.issue_code = issue_code
|
||||
task.last_error = commodity_message
|
||||
elif not account.elite_opened:
|
||||
task.exchange_status = "not_opened"
|
||||
task.issue_code = "elite_not_opened"
|
||||
@@ -2895,15 +2995,15 @@ def refresh_exchange_eligibility(
|
||||
db,
|
||||
account,
|
||||
commodity_id=task.commodity_id,
|
||||
availability=(
|
||||
AVAILABILITY_LIMITED
|
||||
availability=availability,
|
||||
blocking_reason=commodity_message,
|
||||
raw_status=(
|
||||
assessment.raw_status
|
||||
if assessment is not None
|
||||
else "1"
|
||||
if task.commodity_id in limited_ids
|
||||
else AVAILABILITY_AVAILABLE
|
||||
else "0"
|
||||
),
|
||||
blocking_reason=(
|
||||
"该账号已达此商品兑换上限" if task.commodity_id in limited_ids else ""
|
||||
),
|
||||
raw_status="1" if task.commodity_id in limited_ids else "0",
|
||||
observed_at=_now(),
|
||||
source="eligibility_check",
|
||||
scope=task.scope or SCOPE_ELITE,
|
||||
@@ -2918,6 +3018,8 @@ def refresh_exchange_eligibility(
|
||||
"commodity_id": task.commodity_id,
|
||||
"exchange_status": task.exchange_status,
|
||||
"limited": task.commodity_id in limited_ids,
|
||||
"availability": availability,
|
||||
"issue_code": task.issue_code,
|
||||
"points": account.points,
|
||||
"elite_opened": account.elite_opened,
|
||||
},
|
||||
|
||||
@@ -72,6 +72,7 @@ const EXCHANGE_STATUS_LABELS: Record<string, string> = {
|
||||
points_short: '积分不足',
|
||||
not_opened: '精英宝典未开通',
|
||||
limited: '已达限兑上限',
|
||||
not_available: '商品当前不可兑换',
|
||||
check_failed: '资格查询失败',
|
||||
manual_done: '人工兑换完成',
|
||||
};
|
||||
@@ -146,6 +147,12 @@ const ISSUE_LABELS: Record<string, string> = {
|
||||
points_short: '积分不足',
|
||||
elite_not_opened: '精英宝典未开通',
|
||||
commodity_limit_reached: '商品已达限兑上限',
|
||||
commodity_not_open: '商品限时兑换未开始',
|
||||
commodity_expired: '商品限时兑换已结束',
|
||||
commodity_no_stock: '商品当前无库存',
|
||||
commodity_not_offered: '商品当前未上架',
|
||||
commodity_status_unknown: '商品资格状态未知',
|
||||
commodity_not_exchangeable: '商品当前不可兑换',
|
||||
eligibility_check_failed: '资格查询失败',
|
||||
binding_failed: '绑定失败',
|
||||
account_role_cooldown: '斗鱼账号仍在换绑冷却期',
|
||||
@@ -188,6 +195,7 @@ function exchangeStatusHint(status: string) {
|
||||
if (status === 'points_short') return '当前积分不足,账号不会被淘汰。完成充值后点击“刷新兑换资格”即可继续。';
|
||||
if (status === 'not_opened') return '账号尚未开通精英宝典,不会被淘汰。开通后点击“刷新兑换资格”即可继续。';
|
||||
if (status === 'limited') return '当前账号已达到该商品限兑上限,可等待限制解除、人工处理或释放后换号。';
|
||||
if (status === 'not_available') return '商品当前受时间、库存或上架状态限制,暂不可兑换。请等待开放后重新查询资格。';
|
||||
if (status === 'check_failed') return '实时查询失败,账号仍保留。请稍后重新刷新兑换资格。';
|
||||
if (status === 'eligible') return '账号已满足当前商品兑换条件,可以继续人工兑换。';
|
||||
return '';
|
||||
|
||||
Reference in New Issue
Block a user