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

639 lines
18 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""斗鱼账号供给库存、目标缺口和定向补货入队。"""
from __future__ import annotations
import os
from dataclasses import dataclass
from datetime import UTC, datetime
from sqlalchemy import and_, case, func, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from ..models import (
Account,
AccountCommodityState,
AccountSupplyTarget,
AccountSyncState,
)
from .account_query_filters import (
active_collab_order_exists,
active_lease_exists,
assigned_to_pool_filter,
automatable_account_filter,
cookie_present_filter,
fresh_ck_cutoff,
fresh_eligible_state_filter,
role_change_ready_filter,
valid_ck_filter,
)
from .account_sync_runner import ACCOUNT_SYNC_WORK_TYPES, WORK_STOREHOME_SYNC
from .account_value import is_high_value_expr
from .account_work_queue import (
active_account_work_count,
active_account_work_exists,
enqueue_account_work,
)
VALUE_HIGH = "high_value"
VALUE_ORDINARY = "ordinary"
VALID_VALUES = frozenset({VALUE_HIGH, VALUE_ORDINARY})
DEFAULT_SUPPLY_TARGETS = (
{
"scope": "elite",
"value_class": VALUE_HIGH,
# 2026-11-22:旧 30/20/10/3 只适合功能验证,无法覆盖当前十余客服、
# 每小时 200+ 次领取峰值和 24 小时约 220 个 CK 流失。默认改为生产基线。
"target_covered": 2000,
"target_available": 300,
"target_allocatable": 200,
"safety_buffer": 60,
},
{
"scope": "elite",
"value_class": VALUE_ORDINARY,
"target_covered": 1800,
"target_available": 200,
"target_allocatable": 150,
"safety_buffer": 60,
},
)
@dataclass(frozen=True)
class SupplyInventory:
target_id: int
scope: str
commodity_id: str
value_class: str
covered: int
available: int
allocatable: int
target_covered: int
target_available: int
target_allocatable: int
safety_buffer: int
covered_shortage: int
available_shortage: int
allocatable_shortage: int
@property
def needs_replenishment(self) -> bool:
return bool(
self.covered_shortage
or self.available_shortage
or self.allocatable_shortage
)
@dataclass(frozen=True)
class SupplyReplenishmentResult:
targets: int
queued: int
shortages: int
def _value_filter(value_class: str, *, now: datetime):
high_value = is_high_value_expr(now=now)
if value_class == VALUE_HIGH:
return high_value
if value_class == VALUE_ORDINARY:
return ~high_value
raise ValueError(f"不支持的账号价值分类: {value_class}")
def _base_account_filter(*, now: datetime):
return and_(
cookie_present_filter(),
valid_ck_filter(checked_since=fresh_ck_cutoff(now)),
automatable_account_filter(),
)
def _base_account_query(
db: Session,
*,
now: datetime,
value_class: str,
):
return (
db.query(Account)
.filter(_base_account_filter(now=now))
.filter(_value_filter(value_class, now=now))
)
def _allocatable_filter(now: datetime):
return and_(
~active_lease_exists(),
~active_collab_order_exists(),
assigned_to_pool_filter(),
role_change_ready_filter(now),
)
def _fresh_eligible_filter(now: datetime):
return fresh_eligible_state_filter(now, allow_before_open=True)
def _commodity_query(
db: Session,
*,
now: datetime,
target: AccountSupplyTarget,
):
query = (
_base_account_query(
db,
now=now,
value_class=target.value_class,
)
.join(
AccountCommodityState,
AccountCommodityState.account_id == Account.id,
)
.filter(
AccountCommodityState.platform == target.platform,
AccountCommodityState.scope == target.scope,
AccountCommodityState.commodity_id == target.commodity_id,
AccountCommodityState.observed_at.isnot(None),
)
)
return query
def _global_state_exists_for(*, platform: str, scope: str):
return (
select(AccountCommodityState.id)
.where(
AccountCommodityState.account_id == Account.id,
AccountCommodityState.platform == platform,
AccountCommodityState.scope == scope,
AccountCommodityState.observed_at.isnot(None),
)
.exists()
)
def _global_inventory_totals(
db: Session,
*,
platform: str,
scope: str,
now: datetime,
) -> dict[str, tuple[int, int, int]]:
"""一次算出某作用域下高价值/普通的覆盖、可兑换和可分配数量。
全局目标不指定 commodity_id,因此不能用
``ix_account_commodity_match`` 的 commodity_id 前缀。固定拆成两条 SQL:
1. accounts + EXISTS:计算 covered;
2. account_commodity_states JOIN accounts:同时计算 available/allocatable。
第二条走 ``ix_account_commodity_global_available``,避免先物化全部商品状态。
"""
value_class = case(
(is_high_value_expr(now=now), VALUE_HIGH),
else_=VALUE_ORDINARY,
)
base_filter = _base_account_filter(now=now)
covered_rows = (
db.query(value_class, func.count(Account.id))
.select_from(Account)
.filter(
base_filter,
_global_state_exists_for(platform=platform, scope=scope),
)
.group_by(value_class)
.all()
)
totals = {
VALUE_HIGH: [0, 0, 0],
VALUE_ORDINARY: [0, 0, 0],
}
for class_name, covered in covered_rows:
totals[str(class_name)][0] = int(covered or 0)
allocatable_account = case(
(_allocatable_filter(now), Account.id),
else_=None,
)
available_rows = (
db.query(
value_class,
func.count(func.distinct(Account.id)),
func.count(func.distinct(allocatable_account)),
)
.select_from(Account)
.join(
AccountCommodityState,
AccountCommodityState.account_id == Account.id,
)
.filter(
base_filter,
AccountCommodityState.platform == platform,
AccountCommodityState.scope == scope,
_fresh_eligible_filter(now),
)
.group_by(value_class)
.all()
)
for class_name, available, allocatable in available_rows:
bucket = totals[str(class_name)]
bucket[1] = int(available or 0)
bucket[2] = int(allocatable or 0)
return {
class_name: (values[0], values[1], values[2])
for class_name, values in totals.items()
}
def _inventory_from_counts(
target: AccountSupplyTarget,
*,
covered: int,
available: int,
allocatable: int,
) -> SupplyInventory:
return SupplyInventory(
target_id=int(target.id),
scope=target.scope,
commodity_id=target.commodity_id,
value_class=target.value_class,
covered=covered,
available=available,
allocatable=allocatable,
target_covered=int(target.target_covered or 0),
target_available=int(target.target_available or 0),
target_allocatable=int(target.target_allocatable or 0),
safety_buffer=int(target.safety_buffer or 0),
covered_shortage=max(
0,
int(target.target_covered or 0) + int(target.safety_buffer or 0) - covered,
),
available_shortage=max(
0,
int(target.target_available or 0)
+ int(target.safety_buffer or 0)
- available,
),
allocatable_shortage=max(
0,
int(target.target_allocatable or 0)
+ int(target.safety_buffer or 0)
- allocatable,
),
)
def evaluate_supply_target(
db: Session,
target: AccountSupplyTarget,
*,
now: datetime | None = None,
) -> SupplyInventory:
"""计算一条供给目标的 covered / available / allocatable 库存。"""
moment = now or datetime.now(UTC)
if target.value_class not in VALID_VALUES:
raise ValueError(f"不支持的账号价值分类: {target.value_class}")
if target.commodity_id:
base = _commodity_query(db, now=moment, target=target)
covered = base.count()
available_query = base.filter(_fresh_eligible_filter(moment))
available = available_query.count()
allocatable = available_query.filter(_allocatable_filter(moment)).count()
else:
totals = _global_inventory_totals(
db,
platform=target.platform,
scope=target.scope,
now=moment,
)
covered, available, allocatable = totals[target.value_class]
return _inventory_from_counts(
target,
covered=covered,
available=available,
allocatable=allocatable,
)
def evaluate_supply_targets(
db: Session,
*,
now: datetime | None = None,
) -> list[SupplyInventory]:
moment = now or datetime.now(UTC)
targets = (
db.query(AccountSupplyTarget)
.filter(AccountSupplyTarget.enabled.is_(True))
.order_by(
AccountSupplyTarget.platform.asc(),
AccountSupplyTarget.scope.asc(),
AccountSupplyTarget.value_class.asc(),
AccountSupplyTarget.commodity_id.asc(),
)
.all()
)
global_totals: dict[tuple[str, str], dict[str, tuple[int, int, int]]] = {}
inventories: list[SupplyInventory] = []
for target in targets:
if target.commodity_id:
inventories.append(evaluate_supply_target(db, target, now=moment))
continue
key = (target.platform, target.scope)
if key not in global_totals:
global_totals[key] = _global_inventory_totals(
db,
platform=target.platform,
scope=target.scope,
now=moment,
)
covered, available, allocatable = global_totals[key][target.value_class]
inventories.append(
_inventory_from_counts(
target,
covered=covered,
available=available,
allocatable=allocatable,
)
)
return inventories
def upsert_supply_target(
db: Session,
*,
platform: str = "douyu",
scope: str,
commodity_id: str,
value_class: str,
target_covered: int,
target_available: int,
target_allocatable: int,
safety_buffer: int,
enabled: bool,
updated_by: int | None,
) -> AccountSupplyTarget:
"""新增或更新一条供给目标。"""
if value_class not in VALID_VALUES:
raise ValueError(f"不支持的账号价值分类: {value_class}")
for name, value in (
("target_covered", target_covered),
("target_available", target_available),
("target_allocatable", target_allocatable),
("safety_buffer", safety_buffer),
):
if int(value) < 0:
raise ValueError(f"{name} 不能为负数")
target = (
db.query(AccountSupplyTarget)
.filter(
AccountSupplyTarget.platform == platform,
AccountSupplyTarget.scope == scope,
AccountSupplyTarget.commodity_id == commodity_id,
AccountSupplyTarget.value_class == value_class,
)
.first()
)
if target is None:
target = AccountSupplyTarget(
platform=platform,
scope=scope,
commodity_id=commodity_id,
value_class=value_class,
)
db.add(target)
target.target_covered = int(target_covered)
target.target_available = int(target_available)
target.target_allocatable = int(target_allocatable)
target.safety_buffer = int(safety_buffer)
target.enabled = bool(enabled)
target.updated_by = updated_by
target.updated_at = datetime.now(UTC)
try:
with db.begin_nested():
db.flush()
except IntegrityError:
target = (
db.query(AccountSupplyTarget)
.filter(
AccountSupplyTarget.platform == platform,
AccountSupplyTarget.scope == scope,
AccountSupplyTarget.commodity_id == commodity_id,
AccountSupplyTarget.value_class == value_class,
)
.one()
)
db.commit()
return target
def ensure_default_supply_targets(db: Session) -> int:
"""Bootstrap conservative supply targets when none have ever been configured."""
enabled = os.getenv("DOUYU_DEFAULT_SUPPLY_TARGETS_ENABLED", "true").strip().lower()
if enabled in {"0", "false", "no", "off"}:
return 0
if db.query(AccountSupplyTarget.id).first() is not None:
return 0
created = 0
for spec in DEFAULT_SUPPLY_TARGETS:
target = AccountSupplyTarget(
platform="douyu",
scope=str(spec["scope"]),
commodity_id="",
value_class=str(spec["value_class"]),
target_covered=int(spec["target_covered"]),
target_available=int(spec["target_available"]),
target_allocatable=int(spec["target_allocatable"]),
safety_buffer=int(spec["safety_buffer"]),
enabled=True,
)
db.add(target)
created += 1
try:
db.commit()
except IntegrityError:
db.rollback()
return 0
return created
def update_supply_target(
db: Session,
target: AccountSupplyTarget,
*,
target_covered: int,
target_available: int,
target_allocatable: int,
safety_buffer: int,
enabled: bool,
updated_by: int | None,
) -> AccountSupplyTarget:
return upsert_supply_target(
db,
platform=target.platform,
scope=target.scope,
commodity_id=target.commodity_id,
value_class=target.value_class,
target_covered=target_covered,
target_available=target_available,
target_allocatable=target_allocatable,
safety_buffer=safety_buffer,
enabled=enabled,
updated_by=updated_by,
)
def _sync_candidate_query(
db: Session,
*,
target: AccountSupplyTarget,
now: datetime,
):
query = _base_account_query(
db,
now=now,
value_class=target.value_class,
)
if target.commodity_id:
state_exists = (
select(AccountCommodityState.id)
.where(
AccountCommodityState.account_id == Account.id,
AccountCommodityState.platform == target.platform,
AccountCommodityState.scope == target.scope,
AccountCommodityState.commodity_id == target.commodity_id,
AccountCommodityState.valid_until.isnot(None),
AccountCommodityState.valid_until > now,
)
.exists()
)
else:
state_exists = (
select(AccountSyncState.id)
.where(
AccountSyncState.account_id == Account.id,
AccountSyncState.platform == target.platform,
AccountSyncState.domain == "storehome",
AccountSyncState.status == "success",
AccountSyncState.valid_until.isnot(None),
AccountSyncState.valid_until > now,
)
.exists()
)
return (
query.filter(
~state_exists,
~active_account_work_exists(work_type=WORK_STOREHOME_SYNC),
assigned_to_pool_filter(),
)
.order_by(
case((active_lease_exists(), 1), else_=0),
case((active_collab_order_exists(), 1), else_=0),
case((role_change_ready_filter(now), 0), else_=1),
case((Account.role_bind_status == "unbound", 0), else_=1),
Account.overview_queried_at.is_(None).desc(),
Account.overview_queried_at.asc(),
Account.id.asc(),
)
)
def _account_sync_queue_target_pending() -> int:
raw = os.getenv("ACCOUNT_SYNC_QUEUE_TARGET_PENDING", "60")
try:
total = max(1, int(raw))
except ValueError:
total = 60
# 通用供给补货只占低水位;剩余水位留给有明确订单的履约商品,
# 防止注册顺序靠前的普通补货把待分配订单的紧急刷新挤到下一轮。
raw_supply = os.getenv("ACCOUNT_SUPPLY_QUEUE_TARGET_PENDING", "20")
try:
supply = max(1, int(raw_supply))
except ValueError:
supply = 20
return min(total, supply)
def enqueue_supply_replenishment(
db: Session,
*,
now: datetime | None = None,
max_per_target: int = 50,
) -> SupplyReplenishmentResult:
"""按本地目标缺口定向入队 storehome 同步,不发起外部请求。"""
moment = now or datetime.now(UTC)
inventories = evaluate_supply_targets(db, now=moment)
queued = 0
shortages = 0
pending = active_account_work_count(
db,
work_types=ACCOUNT_SYNC_WORK_TYPES,
)
headroom = max(0, _account_sync_queue_target_pending() - pending)
for inventory in inventories:
if not inventory.needs_replenishment:
continue
shortages += 1
if headroom <= 0:
continue
target = db.get(AccountSupplyTarget, inventory.target_id)
if target is None:
continue
missing = max(
inventory.covered_shortage,
inventory.available_shortage,
inventory.allocatable_shortage,
)
limit = max(1, min(int(max_per_target), missing, headroom))
accounts = (
_sync_candidate_query(
db,
target=target,
now=moment,
)
.limit(limit)
.all()
)
for account in accounts:
enqueue_account_work(
db,
account_id=int(account.id),
work_type=WORK_STOREHOME_SYNC,
priority=35,
due_at=moment,
reason=(
f"供给短缺: {target.scope}/{target.commodity_id or 'all'}"
f"/{target.value_class}"
),
)
queued += 1
headroom -= 1
if queued:
db.commit()
return SupplyReplenishmentResult(
targets=len(inventories),
queued=queued,
shortages=shortages,
)
__all__ = [
"VALUE_HIGH",
"VALUE_ORDINARY",
"SupplyInventory",
"SupplyReplenishmentResult",
"enqueue_supply_replenishment",
"ensure_default_supply_targets",
"evaluate_supply_target",
"evaluate_supply_targets",
"update_supply_target",
"upsert_supply_target",
]