fix(scripts): seed 脚本补 username 并新增反馈 mock 脚本

User.username 现为 NOT NULL+unique,原 seed 脚本未设 username 会 IntegrityError,补 _gen_unique_username(仿真实注册生成)。顺带 zip(strict=True)、timezone.utc→datetime.UTC(与代码库统一)。新增 seed_mock_feedback.py:造待审核/已采纳/未采纳三态用户反馈 + 可加载纯色 PNG 截图,供后台反馈工单页联调。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

alembic/versions/coupon_claim_event.py

@@ -1,93 +0,0 @@
-"""add per-session coupon claim event table
-
-Revision ID: coupon_claim_event
-Revises: 8e04cc13a211
-Create Date: 2026-07-23
-"""
-
-from collections.abc import Sequence
-
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-from alembic import op
-
-revision: str = "coupon_claim_event"
-down_revision: str | Sequence[str] | None = "8e04cc13a211"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-_JSON = sa.JSON().with_variant(postgresql.JSONB(), "postgresql")
-
-
-def upgrade() -> None:
-    op.create_table(
-        "coupon_claim_event",
-        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
-        sa.Column("trace_id", sa.String(length=64), nullable=False),
-        sa.Column("device_id", sa.String(length=64), nullable=False),
-        sa.Column("user_id", sa.Integer(), nullable=True),
-        sa.Column("coupon_id", sa.String(length=64), nullable=False),
-        sa.Column("claim_date", sa.Date(), nullable=False),
-        sa.Column("status", sa.String(length=24), nullable=False),
-        sa.Column("app_env", sa.String(length=16), nullable=True),
-        sa.Column("vendor", sa.String(length=48), nullable=True),
-        sa.Column("coupon_name", sa.String(length=128), nullable=True),
-        sa.Column("claimed_count", sa.Integer(), nullable=True),
-        sa.Column("reason", sa.String(length=255), nullable=True),
-        sa.Column("extra", _JSON, nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-        sa.UniqueConstraint(
-            "trace_id", "coupon_id",
-            name="uq_coupon_claim_event_trace_coupon",
-        ),
-    )
-    op.create_index(
-        "ix_coupon_claim_event_date_env",
-        "coupon_claim_event",
-        ["claim_date", "app_env"],
-        unique=False,
-    )
-    op.create_index(
-        op.f("ix_coupon_claim_event_app_env"),
-        "coupon_claim_event",
-        ["app_env"],
-        unique=False,
-    )
-    op.create_index(
-        op.f("ix_coupon_claim_event_trace_id"),
-        "coupon_claim_event",
-        ["trace_id"],
-        unique=False,
-    )
-    op.create_index(
-        op.f("ix_coupon_claim_event_user_id"),
-        "coupon_claim_event",
-        ["user_id"],
-        unique=False,
-    )
-
-    # 旧表只能回填当前仍保留的 trace；历史上已被每日去重覆盖的关联无法恢复。
-    op.execute(
-        """
-        INSERT INTO coupon_claim_event (
-            trace_id, device_id, user_id, coupon_id, claim_date, status, app_env,
-            vendor, coupon_name, claimed_count, reason, extra, created_at, updated_at
-        )
-        SELECT
-            trace_id, device_id, user_id, coupon_id, claim_date, status, app_env,
-            vendor, coupon_name, claimed_count, reason, extra, created_at, updated_at
-        FROM coupon_claim_record
-        WHERE trace_id IS NOT NULL
-        """
-    )
-
-
-def downgrade() -> None:
-    op.drop_index(op.f("ix_coupon_claim_event_user_id"), table_name="coupon_claim_event")
-    op.drop_index(op.f("ix_coupon_claim_event_trace_id"), table_name="coupon_claim_event")
-    op.drop_index(op.f("ix_coupon_claim_event_app_env"), table_name="coupon_claim_event")
-    op.drop_index("ix_coupon_claim_event_date_env", table_name="coupon_claim_event")
-    op.drop_table("coupon_claim_event")

app/admin/repositories/coupon_data.py

@@ -16,7 +16,7 @@ from sqlalchemy import case, func, or_, select
 from sqlalchemy.orm import Session
 
 from app.core import rewards
-from app.models.coupon_state import CouponClaimEvent, CouponClaimRecord, CouponSession
+from app.models.coupon_state import CouponClaimRecord, CouponSession
 from app.models.user import User
 from app.repositories import ad_ecpm as crud_ecpm
 from app.repositories.coupon_state import DEFAULT_PLATFORMS, coupon_id_to_platform
@@ -193,18 +193,18 @@ def _point_scores_by_trace(db: Session, trace_ids: list[str]) -> dict[str, dict[
     """聚合查询批量返回逐场点位分数，不加载逐券明细。"""
     if not trace_ids:
         return {}
-    succeeded = func.sum(case((CouponClaimEvent.status.in_(_SLOT_OK), 1), else_=0))
+    succeeded = func.sum(case((CouponClaimRecord.status.in_(_SLOT_OK), 1), else_=0))
     rows = db.execute(
         select(
-            CouponClaimEvent.trace_id,
+            CouponClaimRecord.trace_id,
             succeeded.label("succeeded"),
             func.count().label("tried"),
         )
         .where(
-            CouponClaimEvent.trace_id.in_(trace_ids),
-            CouponClaimEvent.status.in_(_SLOT_TRIED),
+            CouponClaimRecord.trace_id.in_(trace_ids),
+            CouponClaimRecord.status.in_(_SLOT_TRIED),
         )
-        .group_by(CouponClaimEvent.trace_id)
+        .group_by(CouponClaimRecord.trace_id)
     ).all()
     return {
         trace_id: {"succeeded": int(success_count or 0), "tried": int(tried or 0)}
@@ -217,13 +217,13 @@ def coupon_point_details(db: Session, *, trace_id: str) -> list[dict]:
     """按单个 trace 查询逐券结果；仅在后台用户点击分数时调用。"""
     rows = db.execute(
         select(
-            CouponClaimEvent.coupon_id,
-            CouponClaimEvent.coupon_name,
-            CouponClaimEvent.status,
-            CouponClaimEvent.reason,
+            CouponClaimRecord.coupon_id,
+            CouponClaimRecord.coupon_name,
+            CouponClaimRecord.status,
+            CouponClaimRecord.reason,
         )
-        .where(CouponClaimEvent.trace_id == trace_id)
-        .order_by(CouponClaimEvent.id)
+        .where(CouponClaimRecord.trace_id == trace_id)
+        .order_by(CouponClaimRecord.id)
     ).all()
     return [
         {

app/admin/repositories/queries.py

@@ -1171,30 +1171,24 @@ def user_reward_stats(
     acc = db.get(CoinAccount, user_id)  # 现金余额:当前快照,不随窗口
     cash_balance = acc.cash_balance_cents if acc else 0
 
-    # 只投影本统计实际使用的列。避免滚动发布或旧本地库尚未补齐无关新列时，
-    # SQLAlchemy 因 select(ORM) 自动展开整表字段而让提现详情整体 500。
-    rv = db.execute(
-        select(AdRewardRecord.ecpm_raw, AdRewardRecord.coin).where(
+    rv = list(db.execute(
+        select(AdRewardRecord).where(
             AdRewardRecord.user_id == user_id,
             AdRewardRecord.reward_scene == "reward_video",
             AdRewardRecord.status == "granted",
             *_window_conds(AdRewardRecord.created_at, date_from, date_to),
         )
-    ).all()
+    ).scalars())
     rv_ecpms = [rewards.parse_ecpm_fen(r.ecpm_raw) for r in rv if r.ecpm_raw]
     rv_coins = sum(r.coin for r in rv)
 
-    feed = db.execute(
-        select(
-            AdFeedRewardRecord.unit_count,
-            AdFeedRewardRecord.ecpm_raw,
-            AdFeedRewardRecord.coin,
-        ).where(
+    feed = list(db.execute(
+        select(AdFeedRewardRecord).where(
             AdFeedRewardRecord.user_id == user_id,
             AdFeedRewardRecord.status == "granted",
             *_window_conds(AdFeedRewardRecord.created_at, date_from, date_to),
         )
-    ).all()
+    ).scalars())
     feed_ecpms = [rewards.parse_ecpm_fen(f.ecpm_raw) for f in feed if f.ecpm_raw]
     feed_coins = sum(f.coin for f in feed)
 
@@ -1252,14 +1246,8 @@ def user_coin_records(
     signin_from = date_from + timedelta(hours=8) if date_from is not None else None
     signin_to = date_to + timedelta(hours=8) if date_to is not None else None
 
-    # 三类来源都只取页面需要的列，避免无关 ORM 新列造成旧库查询失败。
     for rec in db.execute(
-        select(
-            AdRewardRecord.reward_scene,
-            AdRewardRecord.created_at,
-            AdRewardRecord.ecpm_raw,
-            AdRewardRecord.coin,
-        )
+        select(AdRewardRecord)
         .where(
             AdRewardRecord.user_id == user_id,
             AdRewardRecord.status == "granted",
@@ -1267,7 +1255,7 @@ def user_coin_records(
         )
         .order_by(AdRewardRecord.created_at.desc())
         .limit(fetch)
-    ).all():
+    ).scalars():
         is_video = rec.reward_scene == "reward_video"
         rows.append({
             "source": rec.reward_scene,
@@ -1278,12 +1266,7 @@ def user_coin_records(
         })
 
     for rec in db.execute(
-        select(
-            AdFeedRewardRecord.feed_scene,
-            AdFeedRewardRecord.created_at,
-            AdFeedRewardRecord.ecpm_raw,
-            AdFeedRewardRecord.coin,
-        )
+        select(AdFeedRewardRecord)
         .where(
             AdFeedRewardRecord.user_id == user_id,
             AdFeedRewardRecord.status == "granted",
@@ -1291,7 +1274,7 @@ def user_coin_records(
         )
         .order_by(AdFeedRewardRecord.created_at.desc())
         .limit(fetch)
-    ).all():
+    ).scalars():
         rows.append({
             "source": "feed",
             "source_label": _FEED_SCENE_LABEL.get(rec.feed_scene, "信息流广告"),
@@ -1301,7 +1284,7 @@ def user_coin_records(
         })
 
     for rec in db.execute(
-        select(CoinTransaction.created_at, CoinTransaction.amount)
+        select(CoinTransaction)
         .where(
             CoinTransaction.user_id == user_id,
             CoinTransaction.biz_type == "signin",
@@ -1309,7 +1292,7 @@ def user_coin_records(
         )
         .order_by(CoinTransaction.created_at.desc())
         .limit(fetch)
-    ).all():
+    ).scalars():
         rows.append({
             "source": "signin",
             "source_label": "签到",

app/admin/repositories/stats.py

@@ -30,17 +30,18 @@ from app.models.user import User
 from app.models.wallet import CoinTransaction, WithdrawOrder
 
 _BEIJING = timezone(timedelta(hours=8))
-REWARD_VIDEO_BIZ_TYPES = ("reward_video", "ad_reward", "signin_boost")
+REWARD_VIDEO_BIZ_TYPES = ("reward_video", "ad_reward")
 # 领券/比价奖励金币的真实来源是信息流广告发奖(ad_feed_reward_record,按 feed_scene 分场景);
 # coin_transaction 里只有扁平的 feed_ad_reward、biz_type 不分 coupon/comparison,故这俩桶历史从未
-# 被写入,仅留作未来兜底,实际金额在下方按 feed_scene 汇总 ad_feed_reward_record 得出。
-# reward_video/ad_reward 及历史 signin_boost 均归看视频桶，不再混进领券奖励或常规任务。
+# 被写入,仅留作未来兜底,实际金额在下方按 feed_scene 汇总 ad_feed_reward_record 得出。reward_video/
+# ad_reward 是激励视频,单独成桶、不再混进领券奖励(历史误并会把激励视频金币双计进领券)。
 COUPON_REWARD_BIZ_TYPES = ("coupon", "coupon_reward")
 COMPARISON_REWARD_BIZ_TYPES = ("comparison", "compare_reward", "comparison_reward")
 # 常规任务必须按明确来源相加；不能从全部正向流水反减排除项，否则新增广告/运营
 # biz_type 时会在排除清单更新前自动混入该桶。task_ 前缀在查询处单独覆盖现有及未来任务。
 REGULAR_TASK_EXACT_BIZ_TYPES = (
     "signin",
+    "signin_boost",
     "price_report_reward",
     "feedback_reward",
 )

app/admin/schemas/coupon_data.py

@@ -79,10 +79,10 @@ class CouponDataRow(BaseModel):
     started_at: datetime = Field(..., description="发起时刻(明细「时间」列)")
     claimed_count: int | None = None
     point_success_count: int | None = Field(
-        None, description="本次成功单券数(success+already_claimed);无逐券事件为空"
+        None, description="本次成功券点位数(success+already_claimed);无逐券埋点为空"
     )
     point_total_count: int | None = Field(
-        None, description="本次尝试单券数(success+already_claimed+failed,不含 skipped);无逐券事件为空"
+        None, description="本次尝试券点位数(success+already_claimed+failed,不含 skipped);无逐券埋点为空"
     )
     trace_url: str | None = Field(None, description="pricebot 公网 trace 链接(仅 completed 有);admin 渲染可点链接,无则显示可复制 trace_id")
     ad_revenue_yuan: float = Field(

app/api/v1/compare_record.py

@@ -20,8 +20,6 @@ from app.db.session import SessionLocal
 from app.models.comparison import ComparisonRecord
 from app.repositories import comparison as crud_compare
 from app.schemas.compare_record import (
-    CompareStartReserveIn,
-    CompareStartReserveOut,
     CompareStatsOut,
     ComparisonRecordCreatedOut,
     ComparisonRecordDetailOut,
@@ -37,41 +35,6 @@ logger = logging.getLogger("shagua.compare_record")
 router = APIRouter(prefix="/api/v1/compare", tags=["compare-record"])
 
 
-@router.post(
-    "/start",
-    response_model=CompareStartReserveOut,
-    summary="预占一次当日比价发起次数（每人每天最多100次）",
-)
-def reserve_compare_start(
-    payload: CompareStartReserveIn,
-    user: CurrentUser,
-    db: DbSession,
-) -> CompareStartReserveOut:
-    try:
-        _, used = crud_compare.reserve_daily_start(
-            db,
-            user_id=user.id,
-            trace_id=payload.trace_id,
-            business_type=payload.business_type,
-            device_id=payload.device_id,
-        )
-    except crud_compare.DailyCompareStartLimitExceeded:
-        raise HTTPException(
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-            detail="今日已比价超过100次，请明天再试",
-        ) from None
-    except crud_compare.ComparisonTraceOwnershipError:
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="比价任务标识冲突，请重新发起",
-        ) from None
-    return CompareStartReserveOut(
-        limit=crud_compare.DAILY_COMPARE_START_LIMIT,
-        used=used,
-        remaining=max(crud_compare.DAILY_COMPARE_START_LIMIT - used, 0),
-    )
-
-
 @router.post(
     "/record",
     response_model=ComparisonRecordCreatedOut,

app/api/v1/coupon.py

@@ -81,7 +81,7 @@ def _record_claims_blocking(
     device_id: str, user_id: int | None, trace_id: str | None, results: list[dict]
 ) -> None:
     with SessionLocal() as db:
-        # 取本次 session 环境，给每日资产和逐次事件同时打环境标。
+        # 取本次 session 环境,给 coupon_claim_record 打 app_env 标(每券成功率表按它过滤;设计 §13)。
         app_env = coupon_repo.session_app_env(db, trace_id)
         coupon_repo.record_claims(db, device_id, user_id, trace_id, results, app_env=app_env)
         # 顺带把本帧「成功平台」并入 coupon_session.platform_success(admin 领券数据 ②整单/③点位成功率;
@@ -176,7 +176,7 @@ async def coupon_step(
 
     resp_json = resp.json()
 
-    # 领券结果沉淀:每日资产 + 逐次事件；中间帧和 done 全量帧均幂等写库。
+    # 领券结果沉淀(资产):中间帧 last_coupon_result + done 帧 coupon_results 幂等写库。
     # 当前只记录、不参与"要不要领"判断(MVP 先不去重)。写库失败不影响返回。
     if device_id:
         results = _extract_coupon_results(resp_json)

app/models/__init__.py

@@ -21,7 +21,6 @@ from app.models.cps_wx_user import CpsWxUser  # noqa: F401
 from app.models.comparison_milestone import ComparisonMilestoneClaim  # noqa: F401
 from app.models.device import DeviceLiveness  # noqa: F401
 from app.models.coupon_state import (  # noqa: F401
-    CouponClaimEvent,
     CouponClaimRecord,
     CouponDailyCompletion,
     CouponPromptEngagement,

app/models/coupon_state.py

@@ -96,40 +96,6 @@ class CouponClaimRecord(Base):
         )
 
 
-class CouponClaimEvent(Base):
-    """一次领券任务中的单券结果，按 ``(trace_id, coupon_id)`` 幂等。"""
-
-    __tablename__ = "coupon_claim_event"
-    __table_args__ = (
-        UniqueConstraint(
-            "trace_id", "coupon_id",
-            name="uq_coupon_claim_event_trace_coupon",
-        ),
-        Index("ix_coupon_claim_event_date_env", "claim_date", "app_env"),
-    )
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    trace_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
-    device_id: Mapped[str] = mapped_column(String(64), nullable=False)
-    user_id: Mapped[int | None] = mapped_column(Integer, index=True, nullable=True)
-    coupon_id: Mapped[str] = mapped_column(String(64), nullable=False)
-    claim_date: Mapped[date] = mapped_column(Date, nullable=False)
-    status: Mapped[str] = mapped_column(String(24), nullable=False)
-    app_env: Mapped[str | None] = mapped_column(String(16), index=True, nullable=True)
-    vendor: Mapped[str | None] = mapped_column(String(48), nullable=True)
-    coupon_name: Mapped[str | None] = mapped_column(String(128), nullable=True)
-    claimed_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
-    reason: Mapped[str | None] = mapped_column(String(255), nullable=True)
-    extra: Mapped[dict | None] = mapped_column(_JSON, nullable=True)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), server_default=func.now(), nullable=False
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), server_default=func.now(), onupdate=func.now(),
-        nullable=False,
-    )
-
-
 class CouponDailyCompletion(Base):
     """按 (device, 自然日) 记"今天是否已跑完整轮领券(到 done 帧)"——首页置灰源。
 

app/repositories/comparison.py

@@ -5,7 +5,7 @@
 """
 from __future__ import annotations
 
-from datetime import datetime, timedelta
+from datetime import datetime
 
 from sqlalchemy import func, or_, select
 from sqlalchemy.orm import Session, defer
@@ -14,19 +14,8 @@ from app.core.rewards import CN_TZ
 from app.models.ad_feed_reward import AdFeedRewardRecord
 from app.models.comparison import ComparisonRecord
 from app.models.savings import SavingsRecord
-from app.models.user import User
 from app.schemas.compare_record import ComparisonRecordIn
 
-DAILY_COMPARE_START_LIMIT = 100
-
-
-class DailyCompareStartLimitExceeded(Exception):
-    """The authenticated user has consumed today's comparison-start quota."""
-
-
-class ComparisonTraceOwnershipError(Exception):
-    """A trace id already belongs to a different authenticated user."""
-
 
 def _yuan_to_cents(yuan: float | None) -> int | None:
     """元(float)→ 分(int)。None 透传。"""
@@ -254,78 +243,6 @@ def _get_by_trace(db: Session, trace_id: str) -> ComparisonRecord | None:
     ).scalar_one_or_none()
 
 
-def reserve_daily_start(
-    db: Session,
-    *,
-    user_id: int,
-    trace_id: str,
-    business_type: str = "food",
-    device_id: str | None = None,
-    now: datetime | None = None,
-) -> tuple[ComparisonRecord, int]:
-    """Atomically reserve one of a user's 100 Beijing-day comparison starts.
-
-    ``trace_id`` makes client retries idempotent. Locking the user row serializes
-    concurrent starts for one account, so parallel requests cannot both consume
-    the final available slot. The reservation is the existing ``running``
-    comparison row; later result reporting updates that same row.
-    """
-    db.execute(select(User.id).where(User.id == user_id).with_for_update()).scalar_one()
-
-    existing = _get_by_trace(db, trace_id)
-    if existing is not None:
-        if existing.user_id not in (None, user_id):
-            raise ComparisonTraceOwnershipError
-        if existing.user_id is None:
-            existing.user_id = user_id
-            if existing.device_id is None and device_id:
-                existing.device_id = device_id
-            db.commit()
-            db.refresh(existing)
-
-        existing_at = existing.created_at
-        if existing_at.tzinfo is not None:
-            existing_at = existing_at.astimezone(CN_TZ).replace(tzinfo=None)
-        day_start = existing_at.replace(hour=0, minute=0, second=0, microsecond=0)
-        day_end = day_start + timedelta(days=1)
-        used = db.scalar(
-            select(func.count(ComparisonRecord.id)).where(
-                ComparisonRecord.user_id == user_id,
-                ComparisonRecord.created_at >= day_start,
-                ComparisonRecord.created_at < day_end,
-            )
-        ) or 0
-        return existing, int(used)
-
-    current = now or datetime.now(CN_TZ)
-    if current.tzinfo is not None:
-        current = current.astimezone(CN_TZ).replace(tzinfo=None)
-    day_start = current.replace(hour=0, minute=0, second=0, microsecond=0)
-    day_end = day_start + timedelta(days=1)
-    used = db.scalar(
-        select(func.count(ComparisonRecord.id)).where(
-            ComparisonRecord.user_id == user_id,
-            ComparisonRecord.created_at >= day_start,
-            ComparisonRecord.created_at < day_end,
-        )
-    ) or 0
-    if used >= DAILY_COMPARE_START_LIMIT:
-        raise DailyCompareStartLimitExceeded
-
-    rec = ComparisonRecord(
-        trace_id=trace_id,
-        user_id=user_id,
-        business_type=business_type or "food",
-        device_id=device_id,
-        status="running",
-        created_at=current,
-    )
-    db.add(rec)
-    db.commit()
-    db.refresh(rec)
-    return rec, int(used) + 1
-
-
 def harvest_running(
     db: Session,
     *,

app/repositories/coupon_state.py

@@ -14,7 +14,6 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
 from app.models.coupon_state import (
-    CouponClaimEvent,
     CouponClaimRecord,
     CouponDailyCompletion,
     CouponPromptEngagement,
@@ -165,12 +164,11 @@ def record_claims(
     results: list[dict],
     app_env: str | None = None,
 ) -> int:
-    """一批券领取结果同时写入每日资产表和逐次事件表。
+    """一批券领取结果幂等写入,返回写入(新增 + 更新)条数。
 
     results 单项取自 pricebot 的 last_coupon_result / done.coupon_results,识别字段:
     coupon_id(必需)/ status(必需)/ name / vendor / reason /(display_count)。
-    - CouponClaimRecord 按 (device, coupon_id, 今天) 幂等，供每日资产口径使用。
-    - CouponClaimEvent 按 (trace_id, coupon_id) 幂等，供 admin 逐场统计使用。
+    (device, coupon_id, 今天) 唯一:重复上报同张券走更新(status 以最后一次为准)。
     """
     today = today_cn()
     written = 0
@@ -210,41 +208,6 @@ def record_claims(
                 claimed_count=count, trace_id=trace_id, reason=r.get("reason"),
                 extra=r,
             ))
-        if trace_id:
-            event = db.execute(
-                select(CouponClaimEvent).where(
-                    CouponClaimEvent.trace_id == trace_id,
-                    CouponClaimEvent.coupon_id == coupon_id,
-                )
-            ).scalar_one_or_none()
-            if event is not None:
-                event.device_id = device_id
-                event.status = status
-                event.reason = r.get("reason")
-                event.vendor = r.get("vendor")
-                event.coupon_name = r.get("name")
-                event.extra = r
-                if user_id is not None:
-                    event.user_id = user_id
-                if count is not None:
-                    event.claimed_count = count
-                if app_env is not None:
-                    event.app_env = app_env
-            else:
-                db.add(CouponClaimEvent(
-                    trace_id=trace_id,
-                    device_id=device_id,
-                    user_id=user_id,
-                    coupon_id=coupon_id,
-                    claim_date=today,
-                    status=status,
-                    app_env=app_env,
-                    vendor=r.get("vendor"),
-                    coupon_name=r.get("name"),
-                    claimed_count=count,
-                    reason=r.get("reason"),
-                    extra=r,
-                ))
         written += 1
     if written == 0:
         return 0

app/schemas/compare_record.py

@@ -13,6 +13,7 @@ from datetime import datetime
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+
 # ===== 上报请求 =====
 
 class ComparisonItemIn(BaseModel):
@@ -197,20 +198,6 @@ class ComparisonRecordCreatedOut(BaseModel):
     id: int = Field(..., description="写入(或已存在)的记录 id")
 
 
-class CompareStartReserveIn(BaseModel):
-    """Reserve one authenticated comparison start before the agent begins."""
-
-    trace_id: str = Field(..., min_length=1, max_length=64)
-    business_type: str = Field(default="food", min_length=1, max_length=16)
-    device_id: str | None = Field(default=None, max_length=64)
-
-
-class CompareStartReserveOut(BaseModel):
-    limit: int
-    used: int
-    remaining: int
-
-
 class CompareStatsOut(BaseModel):
     """「我的」页省钱战绩卡(比价口径)聚合。"""
 

scripts/seed_coupon_session_mock.py

@@ -1,197 +0,0 @@
-"""生成 admin「领券记录」本地联调数据。
-
-用法:
-    python scripts/seed_coupon_session_mock.py
-
-脚本只清理 ``mock-coupon-repeat-*`` 前缀的数据并重新生成。打开后台「领券记录」，
-日期选今天；分别切换 prod/dev，可验证同一设备同一天多次领券仍各自显示正确分数。
-"""
-
-from __future__ import annotations
-
-import sys
-from datetime import UTC, datetime
-from pathlib import Path
-from zoneinfo import ZoneInfo
-
-from sqlalchemy import delete, select
-
-ROOT = Path(__file__).resolve().parents[1]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-from app.db.session import SessionLocal, engine  # noqa: E402
-from app.models.coupon_state import (  # noqa: E402
-    CouponClaimEvent,
-    CouponClaimRecord,
-    CouponSession,
-)
-from app.models.user import User  # noqa: E402
-from app.repositories.coupon_state import record_claims, today_cn  # noqa: E402
-
-PREFIX = "mock-coupon-repeat-"
-CN_TZ = ZoneInfo("Asia/Shanghai")
-DEVICE_REPEAT = f"{PREFIX}device"
-DEVICE_CONTROL = f"{PREFIX}control-device"
-PHONE = "19900009001"
-USERNAME = "80000009001"
-PLATFORM_ELAPSED = {
-    "meituan-waimai": 46_800,
-    "taobao-shanguang": 19_500,
-    "jd-waimai": 24_000,
-}
-
-FIRST_RESULTS = [
-    {"coupon_id": "mt_mock_1", "name": "美团模拟券1", "vendor": "meituan", "status": "success"},
-    {"coupon_id": "mt_mock_2", "name": "美团模拟券2", "vendor": "meituan", "status": "success"},
-    {"coupon_id": "mt_mock_3", "name": "美团模拟券3", "vendor": "meituan", "status": "success"},
-    {"coupon_id": "mt_mock_4", "name": "美团模拟券4", "vendor": "meituan", "status": "failed", "reason": "模拟失败"},
-    {"coupon_id": "tb_mock_1", "name": "淘宝模拟券1", "vendor": "taobao", "status": "success"},
-    {"coupon_id": "tb_mock_2", "name": "淘宝模拟券2", "vendor": "taobao", "status": "success"},
-    {"coupon_id": "tb_mock_3", "name": "淘宝模拟券3", "vendor": "taobao", "status": "success"},
-    {"coupon_id": "jd_mock_1", "name": "京东模拟券", "vendor": "jingdong", "status": "success"},
-]
-
-SECOND_RESULTS = [
-    {"coupon_id": "mt_mock_1", "name": "美团模拟券1", "vendor": "meituan", "status": "skipped", "reason": "模拟跳过，不计分母"},
-    {"coupon_id": "mt_mock_2", "name": "美团模拟券2", "vendor": "meituan", "status": "already_claimed"},
-    {"coupon_id": "mt_mock_3", "name": "美团模拟券3", "vendor": "meituan", "status": "success"},
-    {"coupon_id": "mt_mock_4", "name": "美团模拟券4", "vendor": "meituan", "status": "success"},
-    {"coupon_id": "tb_mock_1", "name": "淘宝模拟券1", "vendor": "taobao", "status": "success"},
-    {"coupon_id": "tb_mock_2", "name": "淘宝模拟券2", "vendor": "taobao", "status": "success"},
-    {"coupon_id": "tb_mock_3", "name": "淘宝模拟券3", "vendor": "taobao", "status": "already_claimed"},
-    {"coupon_id": "jd_mock_1", "name": "京东模拟券", "vendor": "jingdong", "status": "success"},
-]
-
-
-def _started_at(hour: int, minute: int) -> datetime:
-    local = datetime.combine(today_cn(), datetime.min.time()).replace(
-        hour=hour, minute=minute, tzinfo=CN_TZ
-    )
-    return local.astimezone(UTC)
-
-
-def _session(
-    *,
-    trace_id: str,
-    device_id: str,
-    user_id: int,
-    app_env: str,
-    hour: int,
-    minute: int,
-    status: str = "completed",
-    elapsed_ms: int | None = 91_900,
-    platform_elapsed: dict[str, int] | None = None,
-) -> CouponSession:
-    started_at = _started_at(hour, minute)
-    return CouponSession(
-        trace_id=trace_id,
-        device_id=device_id,
-        user_id=user_id,
-        status=status,
-        app_env=app_env,
-        platforms=[],
-        origin_package=None,
-        device_model="Mock Phone",
-        rom="MockOS 1",
-        started_at=started_at,
-        started_date=today_cn(),
-        finished_at=started_at if status != "started" else None,
-        elapsed_ms=elapsed_ms,
-        platform_elapsed=platform_elapsed,
-        platform_success=(
-            ["meituan-waimai", "taobao-shanguang", "jd-waimai"]
-            if status == "completed" else None
-        ),
-        claimed_count=7 if status == "completed" else 0,
-    )
-
-
-def main() -> None:
-    # 本地旧库 Alembic 版本链可能未同步；仅为联调补建新事件表，正式环境仍走 migration。
-    CouponClaimEvent.__table__.create(bind=engine, checkfirst=True)
-    with SessionLocal() as db:
-        db.execute(delete(CouponClaimEvent).where(
-            CouponClaimEvent.trace_id.startswith(PREFIX)
-        ))
-        db.execute(delete(CouponClaimRecord).where(
-            CouponClaimRecord.device_id.startswith(PREFIX)
-        ))
-        db.execute(delete(CouponSession).where(
-            CouponSession.trace_id.startswith(PREFIX)
-        ))
-        user = db.execute(select(User).where(User.phone == PHONE)).scalar_one_or_none()
-        if user is None:
-            user = User(
-                phone=PHONE,
-                username=USERNAME,
-                register_channel="sms",
-                nickname="领券重复测试",
-            )
-            db.add(user)
-            db.flush()
-
-        first_trace = f"{PREFIX}dev-first"
-        second_trace = f"{PREFIX}prod-second"
-        abandoned_trace = f"{PREFIX}prod-abandoned"
-        control_trace = f"{PREFIX}prod-control"
-        db.add_all([
-            _session(
-                trace_id=first_trace,
-                device_id=DEVICE_REPEAT,
-                user_id=user.id,
-                app_env="dev",
-                hour=10,
-                minute=0,
-                platform_elapsed=PLATFORM_ELAPSED,
-            ),
-            _session(
-                trace_id=second_trace,
-                device_id=DEVICE_REPEAT,
-                user_id=user.id,
-                app_env="prod",
-                hour=15,
-                minute=0,
-                platform_elapsed=PLATFORM_ELAPSED,
-            ),
-            _session(
-                trace_id=abandoned_trace,
-                device_id=DEVICE_REPEAT,
-                user_id=user.id,
-                app_env="prod",
-                hour=16,
-                minute=0,
-                status="abandoned",
-                elapsed_ms=21_500,
-                platform_elapsed={"meituan-waimai": 20_500},
-            ),
-            _session(
-                trace_id=control_trace,
-                device_id=DEVICE_CONTROL,
-                user_id=user.id,
-                app_env="prod",
-                hour=17,
-                minute=0,
-                platform_elapsed=PLATFORM_ELAPSED,
-            ),
-        ])
-        db.commit()
-
-        record_claims(
-            db, DEVICE_REPEAT, user.id, first_trace, FIRST_RESULTS, app_env="dev"
-        )
-        record_claims(
-            db, DEVICE_REPEAT, user.id, second_trace, SECOND_RESULTS, app_env="prod"
-        )
-        record_claims(
-            db, DEVICE_CONTROL, user.id, control_trace, FIRST_RESULTS, app_env="prod"
-        )
-
-    print(f"已生成 {today_cn()} 的领券 mock 数据。")
-    print("筛选用户 19900009001。")
-    print("prod 应有：7/7（100.0%）、-、7/8（87.5%）三条。")
-    print("dev 应有：7/8（87.5%）一条。")
-
-
-if __name__ == "__main__":
-    main()

tests/test_admin_read.py

@@ -5,11 +5,10 @@ from datetime import datetime
 
 import pytest
 from fastapi.testclient import TestClient
-from sqlalchemy import event
 
 from app.admin.main import admin_app
 from app.admin.repositories import admin_user as admin_repo
-from app.db.session import SessionLocal, engine
+from app.db.session import SessionLocal
 from app.models.comparison import ComparisonRecord
 from app.models.feedback import Feedback
 from app.models.wallet import CashTransaction, WithdrawOrder
@@ -133,35 +132,6 @@ def test_user_list_and_detail(admin_client: TestClient, admin_token: str) -> Non
     assert admin_client.get("/admin/api/users/999999", headers=_auth(admin_token)).status_code == 404
 
 
-def test_user_reward_detail_does_not_select_unrelated_new_ad_columns(
-    admin_client: TestClient, admin_token: str
-) -> None:
-    """旧库缺少无关新列时，提现详情的统计和金币记录仍应可读。"""
-    uid = _seed_user_with_data("13800000022")
-
-    def reject_full_ad_reward_projection(
-        _conn, _cursor, statement: str, _parameters, _context, _executemany
-    ) -> None:
-        if "ad_reward_record.boost_round_id" in statement:
-            raise AssertionError("提现详情不应查询未使用的 boost_round_id")
-
-    event.listen(engine, "before_cursor_execute", reject_full_ad_reward_projection)
-    try:
-        stats = admin_client.get(
-            f"/admin/api/users/{uid}/reward-stats", headers=_auth(admin_token)
-        )
-        records = admin_client.get(
-            f"/admin/api/users/{uid}/coin-records",
-            params={"limit": 10, "cursor": 0},
-            headers=_auth(admin_token),
-        )
-    finally:
-        event.remove(engine, "before_cursor_execute", reject_full_ad_reward_projection)
-
-    assert stats.status_code == 200, stats.text
-    assert records.status_code == 200, records.text
-
-
 def test_user_filter_by_status(admin_client: TestClient, admin_token: str) -> None:
     _seed_user_with_data("13800000003")
     r = admin_client.get("/admin/api/users", params={"status": "active"}, headers=_auth(admin_token))
@@ -498,13 +468,13 @@ def test_period_regular_task_coin_uses_explicit_allowlist(
     d = "2021-06-18"
     included = {
         "signin": 100,
+        "signin_boost": 200,
         "task_enable_notification": 300,
         "task_other": 400,
         "price_report_reward": 500,
         "feedback_reward": 600,
     }
     excluded = {
-        "signin_boost": 200,
         "feed_ad_reward_coupon": 700,
         "feed_ad_reward_comparison": 800,
         "feed_ad_reward": 900,
@@ -544,51 +514,3 @@ def test_period_regular_task_coin_uses_explicit_allowlist(
     coins = response.json()["period"]["coins"]
     assert coins["regular_task_coin_total"] == sum(included.values())
     assert coins["task_coin_total"] == 700
-    assert coins["reward_video_coin_total"] == 1200
-
-
-def test_period_signin_boost_moves_to_reward_video_without_double_count(
-    admin_client: TestClient, admin_token: str
-) -> None:
-    """历史签到膨胀归看视频桶，不再进常规任务；本期发放总额不变且不重复计算。"""
-    from datetime import datetime
-
-    from app.models.wallet import CoinTransaction
-
-    d = "2021-06-19"
-    rows = [
-        ("signin_boost", 200),
-        ("reward_video", 100),
-        ("signin", 50),
-    ]
-    db = SessionLocal()
-    try:
-        uid = user_repo.upsert_user_for_login(
-            db, phone="13800008805", register_channel="sms"
-        ).id
-        balance = 0
-        for index, (biz_type, amount) in enumerate(rows, start=1):
-            balance += amount
-            db.add(CoinTransaction(
-                user_id=uid,
-                amount=amount,
-                balance_after=balance,
-                biz_type=biz_type,
-                ref_id=f"signin-boost-route-{index}",
-                created_at=datetime(2021, 6, 19, 12, 0, index),
-            ))
-        db.commit()
-    finally:
-        db.close()
-
-    response = admin_client.get(
-        "/admin/api/stats/overview",
-        params={"date_from": d, "date_to": d},
-        headers=_auth(admin_token),
-    )
-    assert response.status_code == 200, response.text
-    coins = response.json()["period"]["coins"]
-    assert coins["granted_total"] == 350
-    assert coins["reward_video_coin_total"] == 300
-    assert coins["regular_task_coin_total"] == 50
-    assert coins["signin_boost_coin_total"] == 200

tests/test_compare_daily_limit.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-import time
-from datetime import datetime, timedelta
-
-from sqlalchemy import func, select
-
-from app.core.rewards import CN_TZ
-from app.core.security import decode_token
-from app.db.session import SessionLocal
-from app.models.comparison import ComparisonRecord
-
-
-def _login(client) -> tuple[str, int]:
-    phone = f"137{int(time.time() * 1000) % 100000000:08d}"
-    sent = client.post("/api/v1/auth/sms/send", json={"phone": phone})
-    assert sent.status_code == 200, sent.text
-    logged_in = client.post(
-        "/api/v1/auth/sms/login",
-        json={"phone": phone, "code": "123456"},
-    )
-    assert logged_in.status_code == 200, logged_in.text
-    token = logged_in.json()["access_token"]
-    return token, int(decode_token(token, expected_type="access")["sub"])
-
-
-def _headers(token: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def test_compare_start_requires_login(client) -> None:
-    response = client.post(
-        "/api/v1/compare/start",
-        json={"trace_id": "quota-no-auth", "business_type": "food"},
-    )
-    assert response.status_code == 401
-
-
-def test_compare_start_is_idempotent_by_trace_id(client) -> None:
-    token, user_id = _login(client)
-    payload = {
-        "trace_id": f"quota-idempotent-{user_id}",
-        "business_type": "ecom",
-        "device_id": "quota-device",
-    }
-
-    first = client.post("/api/v1/compare/start", json=payload, headers=_headers(token))
-    retry = client.post("/api/v1/compare/start", json=payload, headers=_headers(token))
-
-    assert first.status_code == 200, first.text
-    assert first.json() == {"limit": 100, "used": 1, "remaining": 99}
-    assert retry.status_code == 200, retry.text
-    assert retry.json() == first.json()
-    with SessionLocal() as db:
-        count = db.scalar(
-            select(func.count(ComparisonRecord.id)).where(
-                ComparisonRecord.trace_id == payload["trace_id"]
-            )
-        )
-        record = db.execute(
-            select(ComparisonRecord).where(
-                ComparisonRecord.trace_id == payload["trace_id"]
-            )
-        ).scalar_one()
-    assert count == 1
-    assert record.user_id == user_id
-    assert record.status == "running"
-    assert record.business_type == "ecom"
-    assert record.device_id == "quota-device"
-
-
-def test_compare_start_rejects_101st_beijing_day_attempt(client) -> None:
-    token, user_id = _login(client)
-    now = datetime.now(CN_TZ).replace(tzinfo=None)
-    with SessionLocal() as db:
-        db.add_all(
-            [
-                ComparisonRecord(
-                    user_id=user_id,
-                    trace_id=f"quota-full-{user_id}-{index}",
-                    status="failed",
-                    created_at=now,
-                )
-                for index in range(99)
-            ]
-        )
-        db.add(
-            ComparisonRecord(
-                user_id=user_id,
-                trace_id=f"quota-yesterday-{user_id}",
-                status="success",
-                created_at=now - timedelta(days=1),
-            )
-        )
-        db.commit()
-
-    final_allowed_trace = f"quota-final-allowed-{user_id}"
-    allowed = client.post(
-        "/api/v1/compare/start",
-        json={"trace_id": final_allowed_trace, "business_type": "food"},
-        headers=_headers(token),
-    )
-    assert allowed.status_code == 200, allowed.text
-    assert allowed.json() == {"limit": 100, "used": 100, "remaining": 0}
-
-    rejected_trace = f"quota-rejected-{user_id}"
-    response = client.post(
-        "/api/v1/compare/start",
-        json={"trace_id": rejected_trace, "business_type": "food"},
-        headers=_headers(token),
-    )
-
-    assert response.status_code == 429
-    assert response.json()["detail"] == "今日已比价超过100次，请明天再试"
-    with SessionLocal() as db:
-        assert db.scalar(
-            select(func.count(ComparisonRecord.id)).where(
-                ComparisonRecord.trace_id == rejected_trace
-            )
-        ) == 0

tests/test_coupon_claim_event.py

@@ -1,54 +0,0 @@
-"""逐次单券事件不能被同设备同日的每日去重记录串场。"""
-
-from sqlalchemy import delete, select
-
-from app.admin.repositories.coupon_data import _point_scores_by_trace, coupon_point_details
-from app.db.session import SessionLocal
-from app.models.coupon_state import CouponClaimEvent, CouponClaimRecord
-from app.repositories.coupon_state import record_claims
-
-
-def test_same_device_same_day_keeps_scores_for_each_trace() -> None:
-    db = SessionLocal()
-    device = "event-repeat-device"
-    first_trace = "event-repeat-first"
-    second_trace = "event-repeat-second"
-    first_results = [
-        {"coupon_id": "mt-repeat", "name": "美团测试券", "status": "success"},
-        {"coupon_id": "tb-repeat", "name": "淘宝测试券", "status": "failed"},
-    ]
-    second_results = [
-        {"coupon_id": "mt-repeat", "name": "美团测试券", "status": "already_claimed"},
-        {"coupon_id": "tb-repeat", "name": "淘宝测试券", "status": "success"},
-    ]
-    try:
-        record_claims(
-            db, device, None, first_trace, first_results, app_env="dev"
-        )
-        record_claims(
-            db, device, None, second_trace, second_results, app_env="prod"
-        )
-
-        assets = db.execute(
-            select(CouponClaimRecord).where(CouponClaimRecord.device_id == device)
-        ).scalars().all()
-        assert len(assets) == 2
-        assert {row.trace_id for row in assets} == {first_trace}
-
-        events = db.execute(
-            select(CouponClaimEvent).where(CouponClaimEvent.device_id == device)
-        ).scalars().all()
-        assert len(events) == 4
-        assert {row.trace_id for row in events} == {first_trace, second_trace}
-
-        scores = _point_scores_by_trace(db, [first_trace, second_trace])
-        assert scores[first_trace] == {"succeeded": 1, "tried": 2}
-        assert scores[second_trace] == {"succeeded": 2, "tried": 2}
-        assert [row["status"] for row in coupon_point_details(
-            db, trace_id=second_trace
-        )] == ["already_claimed", "success"]
-    finally:
-        db.execute(delete(CouponClaimEvent).where(CouponClaimEvent.device_id == device))
-        db.execute(delete(CouponClaimRecord).where(CouponClaimRecord.device_id == device))
-        db.commit()
-        db.close()

tests/test_coupon_point_score.py

@@ -13,7 +13,7 @@ from app.admin.repositories.coupon_data import (
 )
 from app.admin.security import create_admin_token
 from app.db.session import SessionLocal
-from app.models.coupon_state import CouponClaimEvent, CouponSession
+from app.models.coupon_state import CouponClaimRecord, CouponSession
 
 
 def test_point_scores_by_trace() -> None:
@@ -22,14 +22,14 @@ def test_point_scores_by_trace() -> None:
     trace = "point-score-trace"
     try:
         db.add_all([
-            CouponClaimEvent(
-                trace_id=trace,
+            CouponClaimRecord(
                 device_id="score-device",
                 coupon_id=f"mt-score-{status}",
                 claim_date=date(2020, 1, 2),
                 status=status,
                 coupon_name=f"测试点位-{status}",
                 reason="测试失败" if status == "failed" else None,
+                trace_id=trace,
             )
             for status in ("success", "already_claimed", "failed", "skipped")
         ])
@@ -53,12 +53,12 @@ def test_skipped_detail_does_not_create_a_score() -> None:
     db = SessionLocal()
     trace = "point-score-skipped"
     try:
-        db.add(CouponClaimEvent(
-            trace_id=trace,
+        db.add(CouponClaimRecord(
             device_id="score-device-skipped",
             coupon_id="mt-score-skipped-only",
             claim_date=date(2020, 1, 2),
             status="skipped",
+            trace_id=trace,
         ))
         db.flush()
 
@@ -87,12 +87,12 @@ def test_coupon_data_report_returns_scores_without_embedding_details() -> None:
             started_date=report_date,
         ))
         db.add_all([
-            CouponClaimEvent(
-                trace_id=trace,
+            CouponClaimRecord(
                 device_id="score-report-device",
                 coupon_id=f"mt-report-{status}",
                 claim_date=report_date,
                 status=status,
+                trace_id=trace,
             )
             for status in ("success", "failed")
         ])
@@ -128,14 +128,14 @@ def test_coupon_point_details_endpoint() -> None:
                 role="super_admin",
             )
         token, _expires_at = create_admin_token(admin_id=admin.id, role=admin.role)
-        db.add(CouponClaimEvent(
-            trace_id=trace,
+        db.add(CouponClaimRecord(
             device_id="point-details-endpoint-device",
             coupon_id="mt-point-details-endpoint",
             coupon_name="接口测试券",
             claim_date=date(2020, 1, 5),
             status="failed",
             reason="接口测试失败",
+            trace_id=trace,
         ))
         db.commit()
 
@@ -156,6 +156,6 @@ def test_coupon_point_details_endpoint() -> None:
         }
     finally:
         db.rollback()
-        db.execute(delete(CouponClaimEvent).where(CouponClaimEvent.trace_id == trace))
+        db.execute(delete(CouponClaimRecord).where(CouponClaimRecord.trace_id == trace))
         db.commit()
         db.close()

tests/test_coupon_slots.py

@@ -7,7 +7,7 @@ from sqlalchemy import delete, select
 
 from app.admin.repositories.coupon_data import coupon_slot_report
 from app.db.session import SessionLocal
-from app.models.coupon_state import CouponClaimEvent, CouponClaimRecord, CouponSession
+from app.models.coupon_state import CouponClaimRecord, CouponSession
 from app.repositories.coupon_state import record_claims, session_app_env
 
 
@@ -49,7 +49,6 @@ def test_record_claims_stamps_app_env() -> None:
         assert row.app_env == "prod"
         assert row.status == "already_claimed"
     finally:
-        db.execute(delete(CouponClaimEvent).where(CouponClaimEvent.trace_id == "t-stamp"))
         db.execute(delete(CouponClaimRecord).where(CouponClaimRecord.device_id == dev))
         db.commit()
         db.close()