feat(auth): 发码防刷统一走设备维度 — 删 IP 那道 + 阈值 10→5

- /sms/send 去掉路由上的 IP 维度限流(rate_limit 依赖):统一由设备(device_id)那道兜
  (产品决议:IP 那道会风控同 IP 的测试号,而测试号已豁免设备那道)。
- 设备发码限流阈值 10 → 5(与登录一致)。
- 同步 sms.py 防刷分层注释。
⚠️ 取舍:device_id 客户端可伪造/轮换,脚本轮换 id 可绕过发码限流;挡脚本狂发改主要靠极光控制台侧。

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

.env.example

@@ -18,7 +18,7 @@ JWT_ACCESS_TOKEN_EXPIRE_MINUTES=120
 # refresh token 有效期(天),默认 30 天
 JWT_REFRESH_TOKEN_EXPIRE_DAYS=30
 
-# ===== 极光一键登录 / 短信 =====
+# ===== 极光一键登录 =====
 # 控制台 → 应用设置 → 应用信息 拿到
 JG_APP_KEY=
 JG_MASTER_SECRET=
@@ -27,43 +27,7 @@ JG_PRIVATE_KEY_PATH=./secrets/jverify_rsa_private.pem
 JG_VERIFY_ENDPOINT=https://api.verification.jpush.cn/v1/web/loginTokenVerify
 JG_REQUEST_TIMEOUT_SEC=15
 
-# ===== 厂商直推(无障碍保护存活告警)=====
-# 敏感密钥只放 .env / 服务器环境变量,不要提交到 git。
-ANDROID_PACKAGE_NAME=com.jishisongfu.shaguabijia
-PUSH_REQUEST_TIMEOUT_SEC=15
-PUSH_TIME_TO_LIVE_SEC=86400
-
-HONOR_PUSH_APP_ID=
-HONOR_PUSH_CLIENT_ID=
-HONOR_PUSH_CLIENT_SECRET=
-HONOR_PUSH_TOKEN_ENDPOINT=https://iam.developer.honor.com/auth/token
-HONOR_PUSH_SEND_ENDPOINT_TEMPLATE=https://push-api.cloud.honor.com/api/v1/{app_id}/sendMessage
-
-VIVO_PUSH_APP_ID=
-VIVO_PUSH_APP_KEY=
-VIVO_PUSH_APP_SECRET=
-VIVO_PUSH_AUTH_ENDPOINT=https://api-push.vivo.com.cn/message/auth
-VIVO_PUSH_SEND_ENDPOINT=https://api-push.vivo.com.cn/message/send
-# vivo 未上架测试时可用 push_mode=1; 上架正式推送改为 0。
-VIVO_PUSH_MODE=1
-VIVO_PUSH_NOTIFY_TYPE=4
-VIVO_PUSH_CATEGORY=DEVICE_REMINDER
-
-XIAOMI_PUSH_APP_SECRET=
-XIAOMI_PUSH_SEND_ENDPOINT=https://api.xmpush.xiaomi.com/v3/message/regid
-XIAOMI_PUSH_CHANNEL_ID=
-XIAOMI_PUSH_TEMPLATE_ID=
-XIAOMI_PUSH_TEMPLATE_TITLE=
-XIAOMI_PUSH_TEMPLATE_DESCRIPTION=
-# 可选: JSON 字符串，支持 {title}/{alert} 占位符，例如 {"title":"{title}","content":"{alert}"}
-XIAOMI_PUSH_TEMPLATE_PARAM_JSON=
-
-OPPO_PUSH_APP_KEY=
-OPPO_PUSH_MASTER_SECRET=
-OPPO_PUSH_AUTH_ENDPOINT=https://api.push.oppomobile.com/server/v1/auth
-OPPO_PUSH_SEND_ENDPOINT=https://api.push.oppomobile.com/server/v1/message/notification/unicast
-
-# ===== 无障碍保护存活监控(推送 + pull 后置兜底)=====
+# ===== 无障碍保护存活监控(pull 后置检测;本期不接推送)=====
 HEARTBEAT_MONITOR_ENABLED=true
 HEARTBEAT_TIMEOUT_MINUTES=10
 HEARTBEAT_SCAN_INTERVAL_SEC=60
@@ -94,13 +58,6 @@ MT_CPS_DEFAULT_SID=sgbjia
 # 线上国内服务器留空(=直连)。留空且本机直连失败时 /feed、/coupons、/top-sales 会返回空。
 MT_CPS_PROXY=
 
-# ===== 京东联盟 CPS =====
-# 京东联盟/京东宙斯开放平台创建应用后填写。AUTH_KEY 是工具商授权 key,自有应用可留空。
-JD_UNION_APP_KEY=
-JD_UNION_APP_SECRET=
-JD_UNION_SITE_ID=
-JD_UNION_AUTH_KEY=
-
 # ===== Pricebot 上游 (领券/比价业务透传目标) =====
 # 客户端调本服务的 /api/v1/coupon/step 等,我们透传到 pricebot-backend。
 # 本地开发用 localhost:8000。生产部署改成内网地址(如 http://pricebot.internal:8000)。
@@ -125,9 +82,8 @@ INTERNAL_API_SECRET=
 # 逗号分隔,生产留空(只让 app 调,不开放 web)。本地开发可加 http://localhost:5173 之类
 CORS_ALLOW_ORIGINS=
 
-# ===== 微信开放平台 App + 微信支付(登录 / 商家转账到零钱 / 提现)=====
-# WECHAT_APP_ID/WECHAT_APP_SECRET 来自微信开放平台移动应用,用于 App 微信一键登录(code 换 openid)。
-# mch/序列号/公钥ID 来自微信支付商户平台,仅提现/转账需要。
+# ===== 微信支付(商家转账到零钱 / 提现)=====
+# appid/secret 来自微信开放平台移动应用;mch/序列号/公钥ID 来自微信支付商户平台。
 # 证书 .pem 放 secrets/(已 gitignore)。
 WECHAT_APP_ID=wxxxxxxxxxxxxxxxxx
 WECHAT_APP_SECRET=your_app_secret

alembic/versions/7db22acee504_merge_invite_cash_analytics_device_heads.py

@@ -1,26 +0,0 @@
-"""merge invite_cash + analytics + device heads
-
-Revision ID: 7db22acee504
-Revises: c2874d2bf705, device_first_protected_at, invite_cash_compare_reward
-Create Date: 2026-06-27 03:06:52.594401
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '7db22acee504'
-down_revision: Union[str, Sequence[str], None] = ('c2874d2bf705', 'device_first_protected_at', 'invite_cash_compare_reward')
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    pass
-
-
-def downgrade() -> None:
-    pass

alembic/versions/device_first_protected_at.py

@@ -1,31 +0,0 @@
-"""device_liveness 加 first_protected_at(首次开无障碍时刻)
-
-Revision ID: device_first_protected_at
-Revises: bcfcaf07152b
-Create Date: 2026-06-25 00:00:00.000000
-
-admin 设备存活页要展示「首次无障碍开启时间」。touch_heartbeat 在 ever_protected 首次翻 true
-时记一次(后续心跳不覆盖)。仅新增可空列,SQLite 原生支持 add_column、不用 batch;downgrade
-的 drop_column 在 SQLite 走 batch_alter_table 兜底。老设备无此时刻 → 留 NULL(无法准确回填)。
-"""
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-revision: str = "device_first_protected_at"
-down_revision: Union[str, Sequence[str], None] = "bcfcaf07152b"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.add_column(
-        "device_liveness",
-        sa.Column("first_protected_at", sa.DateTime(timezone=True), nullable=True),
-    )
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("device_liveness") as batch_op:
-        batch_op.drop_column("first_protected_at")

alembic/versions/direct_vendor_push_fields.py

@@ -1,30 +0,0 @@
-"""add direct vendor push fields
-
-Revision ID: direct_vendor_push_fields
-Revises: jd_cps_order_fields
-Create Date: 2026-07-01 16:30:00.000000
-"""
-from __future__ import annotations
-
-from alembic import op
-import sqlalchemy as sa
-
-
-revision = "direct_vendor_push_fields"
-down_revision = "jd_cps_order_fields"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("device_liveness") as batch_op:
-        batch_op.add_column(sa.Column("push_vendor", sa.String(length=32), nullable=True))
-        batch_op.add_column(sa.Column("push_token", sa.String(length=256), nullable=True))
-        batch_op.create_index("ix_device_liveness_push_vendor", ["push_vendor"])
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("device_liveness") as batch_op:
-        batch_op.drop_index("ix_device_liveness_push_vendor")
-        batch_op.drop_column("push_token")
-        batch_op.drop_column("push_vendor")

alembic/versions/invite_cash_compare_reward.py

@@ -1,88 +0,0 @@
-"""invite cash account isolation + compare reward tracking (🅱-1)
-
-Revision ID: invite_cash_compare_reward
-Revises: feedback_review_fields
-Create Date: 2026-06-23 00:00:00.000000
-
-邀请功能 v2 账户隔离 + 比价发奖追踪:
-  - coin_account 加 invite_cash_balance_cents(邀请奖励金独立余额,与金币兑换的 cash 物理隔离)
-  - withdraw_order 加 source(标记提现扣哪个账户,退款退回对应账户;旧单默认 coin_cash)
-  - invite_relation 加比价发奖追踪三列(好友比价多次只发一次)
-  - 新增 invite_cash_transaction 表(邀请奖励金独立流水账本)
-
-加列均 NOT NULL + server_default,存量行自动填默认值,安全。
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'invite_cash_compare_reward'
-down_revision: Union[str, Sequence[str], None] = 'feedback_review_fields'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # 1. 邀请奖励金独立余额(与金币兑换的 cash_balance_cents 物理隔离;红线:两本账不可累加)
-    op.add_column(
-        'coin_account',
-        sa.Column('invite_cash_balance_cents', sa.Integer(), nullable=False, server_default='0'),
-    )
-    # 2. 提现单标记账户来源:coin_cash / invite_cash,退款退回对应账户(旧单默认 coin_cash)
-    op.add_column(
-        'withdraw_order',
-        sa.Column('source', sa.String(length=16), nullable=False, server_default='coin_cash'),
-    )
-    # 3. 邀请关系加比价发奖追踪(好友"下载+登录+比价一次"→ 给邀请人发奖,只发一次)
-    op.add_column(
-        'invite_relation',
-        sa.Column('compare_reward_granted', sa.Boolean(), nullable=False, server_default=sa.false()),
-    )
-    op.add_column(
-        'invite_relation',
-        sa.Column('compare_reward_cents', sa.Integer(), nullable=False, server_default='0'),
-    )
-    op.add_column(
-        'invite_relation',
-        sa.Column('compare_rewarded_at', sa.DateTime(timezone=True), nullable=True),
-    )
-    # 4. 邀请奖励金独立流水表(结构同 cash_transaction;balance_after 记 invite_cash_balance_cents)
-    op.create_table(
-        'invite_cash_transaction',
-        sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-        sa.Column('user_id', sa.Integer(), nullable=False),
-        sa.Column('amount_cents', sa.Integer(), nullable=False),
-        sa.Column('balance_after_cents', sa.Integer(), nullable=False),
-        sa.Column('biz_type', sa.String(length=32), nullable=False),
-        sa.Column('ref_id', sa.String(length=64), nullable=True),
-        sa.Column('remark', sa.String(length=128), nullable=True),
-        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
-        sa.ForeignKeyConstraint(['user_id'], ['user.id']),
-        sa.PrimaryKeyConstraint('id'),
-    )
-    op.create_index('ix_invite_cash_transaction_user_id', 'invite_cash_transaction', ['user_id'])
-    op.create_index('ix_invite_cash_transaction_created_at', 'invite_cash_transaction', ['created_at'])
-    # 提现退款幂等:一个提现单只退一次(partial unique，对齐 cash_transaction 的 withdraw_refund 去重)
-    op.create_index(
-        'ux_invite_cash_txn_refund_ref',
-        'invite_cash_transaction',
-        ['ref_id'],
-        unique=True,
-        sqlite_where=sa.text("biz_type = 'invite_withdraw_refund' AND ref_id IS NOT NULL"),
-        postgresql_where=sa.text("biz_type = 'invite_withdraw_refund' AND ref_id IS NOT NULL"),
-    )
-
-
-def downgrade() -> None:
-    op.drop_index('ux_invite_cash_txn_refund_ref', table_name='invite_cash_transaction')
-    op.drop_index('ix_invite_cash_transaction_created_at', table_name='invite_cash_transaction')
-    op.drop_index('ix_invite_cash_transaction_user_id', table_name='invite_cash_transaction')
-    op.drop_table('invite_cash_transaction')
-    op.drop_column('invite_relation', 'compare_rewarded_at')
-    op.drop_column('invite_relation', 'compare_reward_cents')
-    op.drop_column('invite_relation', 'compare_reward_granted')
-    op.drop_column('withdraw_order', 'source')
-    op.drop_column('coin_account', 'invite_cash_balance_cents')

alembic/versions/jd_cps_order_fields.py

@@ -1,56 +0,0 @@
-"""add jd cps order fields
-
-Revision ID: jd_cps_order_fields
-Revises: 7db22acee504
-Create Date: 2026-06-28 20:30:00.000000
-"""
-from __future__ import annotations
-
-from alembic import op
-import sqlalchemy as sa
-
-
-revision = "jd_cps_order_fields"
-down_revision = "7db22acee504"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("cps_order") as batch_op:
-        batch_op.add_column(
-            sa.Column("platform", sa.String(length=20), nullable=False, server_default="meituan")
-        )
-        batch_op.add_column(sa.Column("external_order_id", sa.String(length=128), nullable=True))
-        batch_op.add_column(sa.Column("external_row_id", sa.String(length=128), nullable=True))
-        batch_op.add_column(sa.Column("estimated_commission_cents", sa.Integer(), nullable=True))
-        batch_op.add_column(sa.Column("actual_commission_cents", sa.Integer(), nullable=True))
-        batch_op.add_column(sa.Column("jd_valid_code", sa.String(length=16), nullable=True))
-        batch_op.add_column(sa.Column("settle_month", sa.String(length=16), nullable=True))
-        batch_op.add_column(sa.Column("site_id", sa.String(length=128), nullable=True))
-        batch_op.add_column(sa.Column("position_id", sa.String(length=128), nullable=True))
-        batch_op.add_column(sa.Column("pid", sa.String(length=128), nullable=True))
-        batch_op.add_column(sa.Column("sub_union_id", sa.String(length=128), nullable=True))
-        batch_op.create_index("ix_cps_order_platform", ["platform"])
-        batch_op.create_index("ix_cps_order_external_order_id", ["external_order_id"])
-        batch_op.create_index("ix_cps_order_external_row_id", ["external_row_id"])
-        batch_op.create_index("ix_cps_order_jd_valid_code", ["jd_valid_code"])
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("cps_order") as batch_op:
-        batch_op.drop_index("ix_cps_order_jd_valid_code")
-        batch_op.drop_index("ix_cps_order_external_row_id")
-        batch_op.drop_index("ix_cps_order_external_order_id")
-        batch_op.drop_index("ix_cps_order_platform")
-        batch_op.drop_column("sub_union_id")
-        batch_op.drop_column("pid")
-        batch_op.drop_column("position_id")
-        batch_op.drop_column("site_id")
-        batch_op.drop_column("settle_month")
-        batch_op.drop_column("jd_valid_code")
-        batch_op.drop_column("actual_commission_cents")
-        batch_op.drop_column("estimated_commission_cents")
-        batch_op.drop_column("external_row_id")
-        batch_op.drop_column("external_order_id")
-        batch_op.drop_column("platform")

app/admin/main.py

@@ -23,7 +23,6 @@ from app.admin.routers.comparison import router as comparison_router
 from app.admin.routers.config import router as config_router
 from app.admin.routers.cps import router as cps_router
 from app.admin.routers.dashboard import router as dashboard_router
-from app.admin.routers.device_liveness import router as device_liveness_router
 from app.admin.routers.ops_stat_config import router as ops_stat_config_router
 from app.admin.routers.event_logs import router as event_logs_router
 from app.admin.routers.feedback import router as feedback_router
@@ -85,7 +84,6 @@ def health() -> dict[str, str]:
 
 admin_app.include_router(auth_router)
 admin_app.include_router(dashboard_router)
-admin_app.include_router(device_liveness_router)
 admin_app.include_router(ops_stat_config_router)
 admin_app.include_router(ops_marquee_seed_router)
 admin_app.include_router(users_router)

app/admin/repositories/ad_audit.py

@@ -4,9 +4,9 @@
 - 看视频:每条 granted = 1 份,第 N 份 = 该用户 granted 的 reward_video **账号累计**顺序号
   (与 ad_reward.grant_ad_reward 里 `_granted_cumulative + 1` 一致;LT 因子不按天重置,
   故复算时要把当日序号叠加上该用户在本日**之前**的累计已发份数)。
-- 信息流:**每条 granted = 1 份**(与 ad_feed_reward.grant_feed_reward 同口径:看满一份即发该条
-  满额,**不按 unit_count 逐份累加**),LT 序号 = 该用户 granted **条数**账号累计
-  (与 ad_feed_reward.granted_unit_total 的 COUNT 一致;不按天重置,复算需叠加本日之前的累计条数)。
+- 信息流:每条按 unit_count 份逐份累加,LT 序号 = 该用户 granted 份数**账号累计**
+  (与 ad_feed_reward._unit_reward_total 的 existing_units 一致;同样不按天重置,
+  复算需叠加本日之前的累计份数)。
 
 非 granted(capped/ecpm_missing)不占用份序号、应发恒 0,据此校验闸口是否确实没发。
 """
@@ -108,18 +108,14 @@ def _reward_video_rows(
     return rows
 
 
-def _feed_prior_granted_count(
+def _feed_prior_granted_units(
     db: Session, *, date: str, user_id: int | None
 ) -> dict[int, int]:
-    """各用户在 date **之前** granted 的信息流**条数**累计,作为当日复算的 LT 序号起点。
-
-    与发奖侧 ad_feed_reward.granted_unit_total(COUNT status=granted)对齐:一条广告 = 1 份,
-    LT 按账号累计**条数**递进。**不再用 SUM(unit_count)**——那是「一条按时长折多份」的过时口径,
-    与现行发奖(每条 1 份)漂移,会让 unit_count>1 的记录复算虚高、对账恒「不符」。"""
+    """各用户在 date **之前** granted 的信息流份数累计,作为当日复算的 LT 序号起点。"""
     stmt = (
         select(
             AdFeedRewardRecord.user_id,
-            func.count(),
+            func.coalesce(func.sum(AdFeedRewardRecord.unit_count), 0),
         )
         .where(
             AdFeedRewardRecord.reward_date < date,
@@ -148,11 +144,10 @@ def _feed_scene_matches(rec: AdFeedRewardRecord, scene: str | None) -> bool:
 def _feed_rows(
     db: Session, *, date: str, user_id: int | None, scene: str | None = None
 ) -> list[dict]:
-    """信息流记录复算。**每条 granted = 1 份**(与发奖同口径,不按 unit_count 累加),
-    LT 序号沿用账号累计**条数**(含本日之前)。
+    """信息流记录复算。granted 记录逐份累加,LT 序号沿用账号累计份数(含本日之前)。
 
-    **关键:LT 因子账号累计按全表 granted 条数累计(feed+draw 共享同一发奖池/上限),不按 ad_type 拆分**——
-    故无论 scene 怎么筛展示,这里都遍历当日**全部**信息流记录维持 granted_count 累加;scene 只决定
+    **关键:LT 因子账号累计按全表 unit 累计(feed+draw 共享同一发奖池/上限),不按 ad_type 拆分**——
+    故无论 scene 怎么筛展示,这里都遍历当日**全部**信息流记录维持 granted_units 累加;scene 只决定
     哪些行被**留下展示**(由 _feed_scene_matches 判断),不影响累计基线,保证复算序号与正式发奖一致。
     """
     stmt = (
@@ -163,20 +158,23 @@ def _feed_rows(
     if user_id is not None:
         stmt = stmt.where(AdFeedRewardRecord.user_id == user_id)
 
-    # 本日之前的累计**条数**做起点,与发奖侧 granted_unit_total(COUNT granted)对齐
-    granted_count: dict[int, int] = _feed_prior_granted_count(db, date=date, user_id=user_id)
+    # 本日之前的累计份数做起点,与 _unit_reward_total 的 existing_units(累计)对齐
+    granted_units: dict[int, int] = _feed_prior_granted_units(db, date=date, user_id=user_id)
     rows: list[dict] = []
     for rec in db.execute(stmt).scalars():
         keep = _feed_scene_matches(rec, scene)  # 累计照常推进,这里只决定是否展示本行
         if rec.status == "granted":
-            # 一条广告 = 1 份(与 grant_feed_reward 同口径:看满一份即发该条满额,不按 unit_count 累加)。
-            # nth = 账号累计第几**条**(含本日之前),与发奖侧 granted_unit_total+1 对齐;累计照常推进
-            # (即便 scene 不匹配不展示也要 +1,保证序号与正式发奖一致)。
-            nth = granted_count.get(rec.user_id, 0) + 1
-            granted_count[rec.user_id] = nth
+            existing = granted_units.get(rec.user_id, 0)
+            units = rec.unit_count
+            granted_units[rec.user_id] = existing + units
             if not keep:
                 continue
-            expected = rewards.calculate_ad_reward_coin(rec.ecpm_raw, nth)
+            expected = sum(
+                rewards.calculate_ad_reward_coin(rec.ecpm_raw, existing + offset)
+                for offset in range(1, units + 1)
+            )
+            start = existing + 1 if units > 0 else None
+            end = existing + units if units > 0 else None
             rows.append({
                 "scene": "feed",
                 "ad_type": rec.ad_type or "feed",
@@ -190,11 +188,11 @@ def _feed_rows(
                 "status": rec.status,
                 "ecpm": rec.ecpm_raw,
                 "ecpm_factor": rewards.ad_ecpm_factor(rewards.parse_ecpm_yuan(rec.ecpm_raw)),
-                "units": 1,
-                "lt_index_start": nth,
-                "lt_index_end": nth,
-                "lt_factor_start": rewards.ad_lt_factor(nth),
-                "lt_factor_end": rewards.ad_lt_factor(nth),
+                "units": units,
+                "lt_index_start": start,
+                "lt_index_end": end,
+                "lt_factor_start": rewards.ad_lt_factor(start) if start else None,
+                "lt_factor_end": rewards.ad_lt_factor(end) if end else None,
                 "expected_coin": expected,
                 "actual_coin": rec.coin,
                 "matched": expected == rec.coin,

app/admin/repositories/ad_revenue.py

@@ -20,14 +20,13 @@ report_date / reward_date 归日。
 """
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from datetime import date as _date
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.admin.repositories import ad_audit
-from app.admin.repositories import stats as admin_stats
 from app.core import rewards
 from app.models.ad_ecpm import AdEcpmRecord
 from app.models.user import User
@@ -36,7 +35,7 @@ from app.models.user import User
 def _cn_hour(dt: datetime) -> int:
     """created_at(UTC 口径)→ 北京时间小时(0–23)。naive 当 UTC 处理(sqlite),tz-aware 直接换算(pg)。"""
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=UTC)
     return dt.astimezone(rewards.CN_TZ).hour
 
 
@@ -85,20 +84,14 @@ def ad_revenue_report(
     date_to: str,
     user_id: int | None = None,
     ad_type: str | None = None,
-    feed_scene: str | None = None,
     granularity: str = "day",
     limit: int = 500,
-    offset: int = 0,
-    sort: str = "time",
 ) -> dict:
     """日期区间(北京时间,闭区间)**逐条广告事件**列表 + 发奖对账。单日时 date_from==date_to。
 
     每个 item = 一次广告事件(展示与发奖按 ad_session_id 合并;信息流展示 / 发奖各自成行)。
-    ad_type: None=全部 / reward_video / feed / draw。feed_scene: None=全部 /
-    comparison / coupon / welfare,作为全局筛选(同时作用于明细、合计与 daily/hourly 趋势)。
-    granularity=hour 时每行带北京小时(由各自时间算),并额外返回全量 hourly 序列。
-    事件按时间倒序(新→旧)排列;limit/offset 对排序后的全量做分页切片(items 为当前页),
-    total 与 total_* / daily / hourly 在全量上统计,不受分页影响。
+    ad_type: None=全部 / reward_video / feed / draw。granularity=hour 时每行带北京小时(由各自时间算)。
+    limit 只截断 items(事件明细),total 与 total_* / daily 在全量上统计,数字始终可信。
     """
     by_hour = granularity == "hour"
 
@@ -207,17 +200,7 @@ def ad_revenue_report(
             "reward_detail": _reward_detail(row),
         })
 
-    # 「场景」作为全局筛选(与 user_id/ad_type 一致):同时作用于明细、合计与 daily/hourly 趋势。
-    # feed_scene 仅信息流 / Draw 有值,激励视频与旧数据为 None;选中后只保留该场景事件。
-    if feed_scene is not None:
-        events = [e for e in events if e.get("feed_scene") == feed_scene]
-
-    # 排序:time=按时间倒序(新→旧);ecpm=按 eCPM 数值倒序(eCPM 原值是字符串「分」,转数值排;
-    # 纯发奖行用其发奖采用的 eCPM,缺失/非法计 0 排末尾)。
-    if sort == "ecpm":
-        events.sort(key=lambda e: rewards.parse_ecpm_fen(e["ecpm"]), reverse=True)
-    else:
-        events.sort(key=lambda e: (e["report_date"], e["created_at"]), reverse=True)
+    events.sort(key=lambda e: (e["report_date"], e["user_id"], e["created_at"]))
 
     # 补手机号(admin 展示用,完整不脱敏,与用户 / 钱包 / 比价记录页一致):批量一次查,避免 N+1。
     uids = {e["user_id"] for e in events}
@@ -255,60 +238,14 @@ def ad_revenue_report(
         for d in sorted(daily_map.values(), key=lambda x: x["date"])
     ]
 
-    # 按小时汇总(全量,不受分页 limit/offset 影响):供前端按小时趋势图(单日 granularity=hour 时用)。
-    # 只在 by_hour 下聚合(此时每个 event 带 hour);否则空。前端按天趋势仍用 daily。
-    hourly: list[dict] = []
-    if by_hour:
-        hour_map: dict[int, dict] = {}
-        for e in events:
-            h = e["hour"]
-            if h is None:
-                continue
-            hd = hour_map.get(h)
-            if hd is None:
-                hd = {"hour": h, "impressions": 0, "revenue_yuan": 0.0,
-                      "expected_coin": 0, "actual_coin": 0}
-                hour_map[h] = hd
-            hd["impressions"] += e["impressions"]
-            hd["revenue_yuan"] += e["revenue_yuan"]
-            hd["expected_coin"] += e["expected_coin"]
-            hd["actual_coin"] += e["actual_coin"]
-        hourly = [
-            {**hd, "revenue_yuan": round(hd["revenue_yuan"], 6)}
-            for hd in sorted(hour_map.values(), key=lambda x: x["hour"])
-        ]
-
-    # 分广告类型小计(按 ad_type:展示条数 + 预估收益;eCPM 由前端用 收益÷展示×1000 算)。
-    # 基于全量(已按 feed_scene 过滤)events;前端只取 draw / reward_video 两类展示。
-    type_map: dict[str, dict] = {}
-    for e in events:
-        t = type_map.get(e["ad_type"])
-        if t is None:
-            t = {"impressions": 0, "revenue_yuan": 0.0}
-            type_map[e["ad_type"]] = t
-        t["impressions"] += e["impressions"]
-        t["revenue_yuan"] += e["revenue_yuan"]
-    type_stats = {
-        k: {"impressions": v["impressions"], "revenue_yuan": round(v["revenue_yuan"], 6)}
-        for k, v in type_map.items()
-    }
-
-    # DAU:复用大盘「今日活跃」口径(stats.today_dau,last_login_at)。该口径只能算今日,
-    # 故仅当查询=今日单天时给值;历史 / 多天区间返回 None,前端显示「-」。
-    is_today = date_from == date_to == rewards.cn_today().isoformat()
-    dau = admin_stats.today_dau(db) if is_today else None
-
     return {
         "total": len(events),
-        "truncated": len(events) > offset + limit,
+        "truncated": len(events) > limit,
         "total_impressions": total_impressions,
         "total_revenue_yuan": total_revenue_yuan,
         "total_expected_coin": total_expected_coin,
         "total_actual_coin": total_actual_coin,
         "mismatch_count": mismatch_count,
         "daily": daily,
-        "hourly": hourly,
-        "type_stats": type_stats,
-        "dau": dau,
-        "items": events[offset:offset + limit],
+        "items": events[:limit],
     }

app/admin/repositories/cps.py

@@ -7,29 +7,23 @@ from __future__ import annotations
 
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal, InvalidOperation
-from typing import Any
 from uuid import uuid4
 
 from sqlalchemy import desc, func, select
 from sqlalchemy.orm import Session
 
 from app.admin.repositories.queries import _as_utc, offset_paginate
-from app.integrations import jd_union, meituan
+from app.integrations import meituan
 from app.repositories import cps_link as cps_link_repo
 from app.models.cps_activity import CpsActivity
 from app.models.cps_group import CpsGroup
-from app.models.cps_link import CpsClick, CpsLink
+from app.models.cps_link import CpsClick
 from app.models.cps_order import CpsOrder
 from app.models.cps_wx_user import CpsWxUser
 
 # 美团订单状态:取消(4)/风控(5)不计佣金;结算(6)为佣金真正到账
 _INVALID_STATUS = {"4", "5"}
 _SETTLED_STATUS = "6"
-_JD_INVALID_CODES = {
-    "2", "3", "4", "5", "6", "7", "8", "9", "11", "13", "14", "19", "20", "21",
-    "22", "23", "25", "26", "27", "28", "29", "30", "31", "34", "35", "36",
-}
-_JD_UNPAID_CODES = {"15"}
 
 # CPS 点击时序按北京时区分桶(运营看的是北京时间)
 _BJ_TZ = timezone(timedelta(hours=8))
@@ -51,58 +45,8 @@ def _yuan_to_cents(v: object) -> int | None:
 
 def _ts_to_dt(ts: object) -> datetime | None:
     """秒级时间戳 → tz-aware UTC datetime(绝对时刻,前端按北京展示)。"""
-    if ts is None:
+    if not ts:
         return None
-    if isinstance(ts, datetime):
-        return ts if ts.tzinfo else ts.replace(tzinfo=_BJ_TZ).astimezone(timezone.utc)
-    s = str(ts).strip()
-    if not s or s.lower() == "null":
-        return None
-    try:
-        seconds = float(Decimal(s))
-    except (InvalidOperation, ValueError):
-        return None
-    if seconds == 0:
-        return None
-    # 美团文档是秒级时间戳，这里顺手兼容毫秒/微秒，避免上游格式变化导致时间再次落空。
-    if abs(seconds) > 10_000_000_000_000:
-        seconds /= 1_000_000
-    elif abs(seconds) > 10_000_000_000:
-        seconds /= 1_000
-    try:
-        return datetime.fromtimestamp(seconds, tz=timezone.utc)
-    except (OverflowError, OSError, ValueError):
-        return None
-
-
-def _jd_dt_to_utc(value: object) -> datetime | None:
-    """京东时间字符串(北京时间) → UTC aware datetime。"""
-    if value is None:
-        return None
-    s = str(value).strip()
-    if not s:
-        return None
-    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d"):
-        try:
-            dt = datetime.strptime(s, fmt)
-            return dt.replace(tzinfo=_BJ_TZ).astimezone(timezone.utc)
-        except ValueError:
-            continue
-    return None
-
-
-def _text(value: object) -> str | None:
-    if value is None:
-        return None
-    s = str(value).strip()
-    return s or None
-
-
-def _pick(row: dict[str, Any], *keys: str) -> Any:
-    for key in keys:
-        if key in row and row[key] is not None:
-            return row[key]
-    return None
     try:
         return datetime.fromtimestamp(int(ts), tz=timezone.utc)
     except (ValueError, OSError, TypeError):
@@ -305,80 +249,6 @@ def _map_order_fields(r: dict) -> dict:
     }
 
 
-def _jd_order_key(r: dict[str, Any]) -> str | None:
-    row_id = _text(_pick(r, "id", "rowId", "orderRowId"))
-    if row_id:
-        return f"jd:{row_id}"
-    order_id = _text(_pick(r, "orderId", "parentOrderId"))
-    sku_id = _text(_pick(r, "skuId"))
-    if order_id and sku_id:
-        return f"jd:{order_id}:{sku_id}"
-    if order_id:
-        return f"jd:{order_id}"
-    return None
-
-
-def _map_jd_order_fields(r: dict[str, Any]) -> dict:
-    """京东 order.row.query 单条订单行 → CpsOrder 字段。"""
-    sku_name = _text(_pick(r, "skuName", "goodsName", "productName"))
-    if sku_name and len(sku_name) > 500:
-        sku_name = sku_name[:500]
-    valid_code = _text(_pick(r, "validCode", "valid_code"))
-    actual_fee = _yuan_to_cents(_pick(r, "actualFee", "actual_fee"))
-    estimate_fee = _yuan_to_cents(_pick(r, "estimateFee", "estimate_fee"))
-    commission = actual_fee if actual_fee not in (None, 0) else estimate_fee
-    order_time = _jd_dt_to_utc(_pick(r, "orderTime", "order_time"))
-    return {
-        "platform": "jd",
-        "external_order_id": _text(_pick(r, "orderId", "parentOrderId")),
-        "external_row_id": _text(_pick(r, "id", "rowId", "orderRowId")),
-        "sid": _text(_pick(r, "subUnionId", "sub_union_id")),
-        "act_id": None,
-        "biz_line": None,
-        "trade_type": None,
-        "pay_price_cents": _yuan_to_cents(
-            _pick(r, "actualCosPrice", "estimateCosPrice", "price")
-        ),
-        "commission_cents": commission,
-        "commission_rate": _text(_pick(r, "commissionRate", "commission_rate")),
-        "refund_price_cents": None,
-        "refund_profit_cents": None,
-        "estimated_commission_cents": estimate_fee,
-        "actual_commission_cents": actual_fee,
-        "mt_status": None,
-        "jd_valid_code": valid_code,
-        "invalid_reason": None if _is_jd_valid_code(valid_code) else f"validCode={valid_code}",
-        "product_name": sku_name,
-        "settle_month": _text(_pick(r, "payMonth", "settleMonth", "pay_month")),
-        "site_id": _text(_pick(r, "siteId", "site_id")),
-        "position_id": _text(_pick(r, "positionId", "position_id")),
-        "pid": _text(_pick(r, "pid")),
-        "sub_union_id": _text(_pick(r, "subUnionId", "sub_union_id")),
-        "pay_time": order_time,
-        "mt_update_time": _jd_dt_to_utc(_pick(r, "modifyTime", "updateTime", "modify_time"))
-        or order_time,
-        "raw": r,
-    }
-
-
-def _is_jd_valid_code(valid_code: str | None) -> bool:
-    code = str(valid_code).strip() if valid_code is not None else ""
-    return bool(code and code not in _JD_INVALID_CODES and code not in _JD_UNPAID_CODES)
-
-
-def is_jd_order_valid(order: CpsOrder) -> bool:
-    return _is_jd_valid_code(order.jd_valid_code)
-
-
-def effective_commission_cents(order: CpsOrder) -> int:
-    if order.platform == "jd":
-        if order.actual_commission_cents not in (None, 0):
-            return order.actual_commission_cents or 0
-        if order.estimated_commission_cents is not None:
-            return order.estimated_commission_cents or 0
-    return order.commission_cents or 0
-
-
 def reconcile_orders(
     db: Session, *, start_time: int, end_time: int,
     query_time_type: int = 1, sid: str | None = None, max_pages: int = 200,
@@ -404,11 +274,6 @@ def reconcile_orders(
                 continue
             fetched += 1
             fields = _map_order_fields(r)
-            fields.setdefault("platform", "meituan")
-            fields.setdefault("external_order_id", order_id)
-            fields.setdefault("external_row_id", None)
-            fields.setdefault("estimated_commission_cents", fields.get("commission_cents"))
-            fields.setdefault("actual_commission_cents", None)
             existing = db.execute(
                 select(CpsOrder).where(CpsOrder.order_id == order_id)
             ).scalar_one_or_none()
@@ -426,56 +291,6 @@ def reconcile_orders(
     return {"fetched": fetched, "inserted": inserted, "updated": updated, "pages": pages}
 
 
-def reconcile_jd_orders(
-    db: Session, *, start_time: datetime, end_time: datetime,
-    query_time_type: int = 3, max_pages: int = 100,
-) -> dict:
-    """调京东 order.row.query 拉单 → 按订单行 upsert。
-
-    京东单次查询窗口最多 1 小时,这里按北京自然时间切窗并逐页拉取。
-    """
-    fetched = inserted = updated = pages = 0
-    cur = start_time
-    while cur < end_time:
-        win_end = min(cur + timedelta(hours=1), end_time)
-        page = 1
-        while page <= max_pages:
-            resp = jd_union.query_order_rows(
-                start_time=cur,
-                end_time=win_end,
-                query_time_type=query_time_type,
-                page_index=page,
-                page_size=200,
-            )
-            rows = resp.get("rows") or []
-            has_more = bool(resp.get("has_more"))
-            if not rows:
-                break
-            pages += 1
-            for r in rows:
-                order_id = _jd_order_key(r)
-                if not order_id:
-                    continue
-                fetched += 1
-                fields = _map_jd_order_fields(r)
-                existing = db.execute(
-                    select(CpsOrder).where(CpsOrder.order_id == order_id)
-                ).scalar_one_or_none()
-                if existing is None:
-                    db.add(CpsOrder(order_id=order_id, **fields))
-                    inserted += 1
-                else:
-                    for k, v in fields.items():
-                        setattr(existing, k, v)
-                    updated += 1
-            if not has_more or len(rows) < 200:
-                break
-            page += 1
-        cur = win_end
-    db.commit()
-    return {"fetched": fetched, "inserted": inserted, "updated": updated, "pages": pages}
-
-
 def list_orders(
     db: Session, *, sid: str | None = None, mt_status: str | None = None,
     limit: int = 20, cursor: int | None = None,
@@ -709,90 +524,3 @@ def group_wx_users(db: Session, *, group_id: int, limit: int = 200) -> list[dict
     ]
     result.sort(key=lambda x: x["first_seen"], reverse=True)
     return result[:limit]
-
-
-def group_day_users(
-    db: Session, *, group_id: int, start: datetime, end: datetime, limit: int = 200,
-) -> list[dict]:
-    """该群某天(北京)以用户为单位的领券/点击 + 每人 visit 过的券。
-
-    时间窗为半开区间 [start, end)(end=次日 00:00),避免午夜双计。只统计 openid 非空
-    (可归属到人)的点击 —— 匿名点击(美团/京东 302 多为匿名)不计入。券名 = 该点击 link
-    对应活动名;活动被硬删则兜底 活动#{id}。copy=领券次数、visit=点击次数;coupons 仅
-    取 visit 事件按活动分组、按次数倒序(合计 = visit_count)。排序:领券 desc、再点击 desc。
-    与 group_wx_users 同风格(Python 侧聚合,跨 PG/SQLite 无方言坑)。
-
-    注:每日明细行的 click_pv/copy_pv 计全部点击(含匿名、UV 按 ip,ua);本函数只计 openid
-    用户,故各用户求和 <= 当天行总数,二者口径不同、不必相等。
-    """
-    rows = db.execute(
-        select(CpsClick.openid, CpsClick.event_type, CpsClick.link_id)
-        .where(CpsClick.group_id == group_id)
-        .where(CpsClick.clicked_at >= _as_utc(start))
-        .where(CpsClick.clicked_at < _as_utc(end))
-        .where(CpsClick.openid.is_not(None))
-    ).all()
-    if not rows:
-        return []
-
-    # link_id -> activity_id -> 券名(活动名)
-    link_ids = {r.link_id for r in rows}
-    link_to_act = dict(
-        db.execute(
-            select(CpsLink.id, CpsLink.activity_id).where(CpsLink.id.in_(link_ids))
-        ).all()
-    )
-    act_ids = {aid for aid in link_to_act.values() if aid is not None}
-    act_name = (
-        dict(
-            db.execute(
-                select(CpsActivity.id, CpsActivity.name).where(CpsActivity.id.in_(act_ids))
-            ).all()
-        )
-        if act_ids
-        else {}
-    )
-
-    def _coupon_name(link_id: int) -> str:
-        aid = link_to_act.get(link_id)
-        if aid is None:
-            return f"链接#{link_id}"
-        return act_name.get(aid) or f"活动#{aid}"
-
-    stat: dict[str, dict] = {}
-    for openid, event_type, link_id in rows:
-        s = stat.setdefault(openid, {"copy": 0, "visit": 0, "coupons": {}})
-        if event_type == "copy":
-            s["copy"] += 1
-        else:
-            s["visit"] += 1
-            name = _coupon_name(link_id)
-            s["coupons"][name] = s["coupons"].get(name, 0) + 1
-
-    openids = list(stat.keys())
-    users = {
-        u.openid: u
-        for u in db.execute(
-            select(CpsWxUser).where(CpsWxUser.openid.in_(openids))
-        ).scalars().all()
-    }
-
-    result = [
-        {
-            "openid": openid,
-            "nickname": users[openid].nickname if openid in users else None,
-            "headimgurl": users[openid].headimgurl if openid in users else None,
-            "copy_count": s["copy"],
-            "visit_count": s["visit"],
-            "coupons": [
-                {"name": name, "count": cnt}
-                # 次数倒序;同次数按券名升序兜底,保证 PG 无 ORDER BY 行序下输出稳定
-                for name, cnt in sorted(
-                    s["coupons"].items(), key=lambda kv: (-kv[1], kv[0])
-                )
-            ],
-        }
-        for openid, s in stat.items()
-    ]
-    result.sort(key=lambda x: (x["copy_count"], x["visit_count"]), reverse=True)
-    return result[:limit]

app/admin/repositories/queries.py

@@ -8,17 +8,15 @@ from __future__ import annotations
 from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
 
-from sqlalchemy import Select, asc, case, desc, func, or_, select
+from sqlalchemy import Select, asc, desc, func, or_, select
 from sqlalchemy.orm import Session
 
 from app.core import rewards
-from app.core.config import settings
 from app.models.ad_feed_reward import AdFeedRewardRecord
 from app.models.ad_reward import AdRewardRecord
 from app.models.admin import AdminAuditLog
 from app.models.analytics_event import AnalyticsEvent
 from app.models.comparison import ComparisonRecord
-from app.models.device import DeviceLiveness
 from app.models.feedback import Feedback
 from app.models.onboarding import OnboardingCompletion
 from app.models.price_report import PriceReport
@@ -202,156 +200,6 @@ def list_onboarding_devices(db: Session, *, limit: int = 500) -> list[dict]:
     ]
 
 
-def _heartbeat_seconds_ago(last: datetime | None) -> int | None:
-    """距上次心跳的秒数(兼容 SQLite 取回的 naive datetime,按 UTC 处理)。None = 从没心跳。"""
-    if last is None:
-        return None
-    if last.tzinfo is None:
-        last = last.replace(tzinfo=timezone.utc)
-    return int((datetime.now(timezone.utc) - last).total_seconds())
-
-
-def _device_model_from_id(device_id: str) -> str:
-    """从 device_id(格式 device_<机型>_<hash>)解析机型;不规范则回退原 id。"""
-    parts = device_id.split("_")
-    if len(parts) >= 3 and parts[0] == "device":
-        return "_".join(parts[1:-1]).replace("_", " ")
-    return device_id
-
-
-def _attach_device_derived(devices: list[DeviceLiveness]) -> None:
-    """给每台设备瞬态挂 device_model / online / display_state / offline_seconds(供 schema 读)。
-
-    在线判定:开过无障碍(ever_protected)且距上次心跳 ≤ HEARTBEAT_TIMEOUT_MINUTES。
-    从没开过无障碍(ever_protected=False)= never(不算掉线,避免把装了没用的设备误报掉线)。
-    offline_seconds 仅 offline 时给值(=掉线时长),在线/从未启用为 None。"""
-    timeout_sec = max(1, int(settings.HEARTBEAT_TIMEOUT_MINUTES)) * 60
-    for d in devices:
-        d.device_model = _device_model_from_id(d.device_id)
-        secs = _heartbeat_seconds_ago(d.last_heartbeat_at)
-        if not d.ever_protected:
-            d.online = False
-            d.display_state = "never"
-            d.offline_seconds = None
-        elif secs is not None and secs <= timeout_sec:
-            d.online = True
-            d.display_state = "online"
-            d.offline_seconds = None
-        else:
-            d.online = False
-            d.display_state = "offline"
-            d.offline_seconds = secs
-
-
-def _attach_device_user_info(db: Session, devices: list[DeviceLiveness]) -> None:
-    """给每台设备瞬态挂归属用户 phone/nickname(同 _attach_user_info,供 admin schema 读)。"""
-    uids = {d.user_id for d in devices}
-    if not uids:
-        return
-    rows = db.execute(
-        select(User.id, User.phone, User.nickname).where(User.id.in_(uids))
-    ).all()
-    umap = {uid: (phone, nick) for uid, phone, nick in rows}
-    for d in devices:
-        phone, nick = umap.get(d.user_id, (None, None))
-        d.phone = phone
-        d.nickname = nick
-
-
-def _liveness_cutoff() -> datetime:
-    """掉线判定分界:此刻 - HEARTBEAT_TIMEOUT_MINUTES。心跳早于它 = 掉线(同 list_overdue 口径)。"""
-    timeout_min = max(1, int(settings.HEARTBEAT_TIMEOUT_MINUTES))
-    return datetime.now(timezone.utc) - timedelta(minutes=timeout_min)
-
-
-def list_device_liveness(
-    db: Session,
-    *,
-    status: str | None = None,
-    device_id: str | None = None,
-    phone: str | None = None,
-    user_id: int | None = None,
-    sort_by: str = "status",
-    sort_order: str = "desc",
-    limit: int = 20,
-    cursor: int | None = None,
-) -> tuple[list[DeviceLiveness], int | None, int]:
-    """设备存活列表(admin 全量)。按 在线情况(online/offline/never)/ 设备id(包含)/
-    归属用户(手机号前缀 或 user_id)筛,offset 分页。join user 取 phone/nickname,派生
-    device_model/online/display_state/offline_seconds 挂行上。
-    默认排序 status=掉线置顶(offline → online → never;掉线组内掉得最久在前)。"""
-    cutoff = _liveness_cutoff()
-    stmt = select(DeviceLiveness)
-    # 在线情况派生筛选(口径同 _attach_device_derived:ever_protected + 心跳是否过阈值)
-    if status == "online":
-        stmt = stmt.where(
-            DeviceLiveness.ever_protected.is_(True),
-            DeviceLiveness.last_heartbeat_at.is_not(None),
-            DeviceLiveness.last_heartbeat_at >= cutoff,
-        )
-    elif status == "offline":
-        stmt = stmt.where(
-            DeviceLiveness.ever_protected.is_(True),
-            DeviceLiveness.last_heartbeat_at.is_not(None),
-            DeviceLiveness.last_heartbeat_at < cutoff,
-        )
-    elif status == "never":
-        stmt = stmt.where(DeviceLiveness.ever_protected.is_(False))
-    if device_id and device_id.strip():
-        stmt = stmt.where(DeviceLiveness.device_id.like(f"%{device_id.strip()}%"))
-    if user_id is not None:
-        stmt = stmt.where(DeviceLiveness.user_id == user_id)
-    if phone:
-        stmt = stmt.where(
-            DeviceLiveness.user_id.in_(select(User.id).where(User.phone.like(f"{phone}%")))
-        )
-
-    if sort_by in ("last_heartbeat_at", "created_at"):
-        col = (
-            DeviceLiveness.last_heartbeat_at
-            if sort_by == "last_heartbeat_at"
-            else DeviceLiveness.created_at
-        )
-        order_fn = asc if sort_order == "asc" else desc
-        id_order = asc(DeviceLiveness.id) if sort_order == "asc" else desc(DeviceLiveness.id)
-        sort_clause: tuple = (order_fn(col), id_order)
-    else:
-        # 默认「掉线置顶」:offline(0) → online(1) → never(2);掉线组内按心跳最旧(掉得最久)在前
-        rank = case(
-            (DeviceLiveness.ever_protected.is_(False), 2),
-            (DeviceLiveness.last_heartbeat_at < cutoff, 0),
-            else_=1,
-        )
-        sort_clause = (asc(rank), asc(DeviceLiveness.last_heartbeat_at), desc(DeviceLiveness.id))
-
-    items, next_cursor, total = offset_paginate(db, stmt, sort_clause, limit=limit, cursor=cursor)
-    _attach_device_user_info(db, items)
-    _attach_device_derived(items)
-    return items, next_cursor, total
-
-
-def device_liveness_stats(db: Session) -> dict:
-    """顶部卡片:总设备数 + 在线 / 已掉线 / 未启用(按心跳阈值派生,口径同列表)。"""
-    cutoff = _liveness_cutoff()
-
-    def _count(*conds) -> int:
-        return int(db.execute(select(func.count(DeviceLiveness.id)).where(*conds)).scalar_one())
-
-    total = int(db.execute(select(func.count(DeviceLiveness.id))).scalar_one())
-    never = _count(DeviceLiveness.ever_protected.is_(False))
-    online = _count(
-        DeviceLiveness.ever_protected.is_(True),
-        DeviceLiveness.last_heartbeat_at.is_not(None),
-        DeviceLiveness.last_heartbeat_at >= cutoff,
-    )
-    offline = _count(
-        DeviceLiveness.ever_protected.is_(True),
-        DeviceLiveness.last_heartbeat_at.is_not(None),
-        DeviceLiveness.last_heartbeat_at < cutoff,
-    )
-    return {"total": total, "online": online, "offline": offline, "never": never}
-
-
 def list_all_coin_transactions(
     db: Session,
     *,

app/admin/repositories/stats.py

@@ -5,46 +5,20 @@ user.last_login_at / comparison_record.status / withdraw_order.status)要加索
 """
 from __future__ import annotations
 
-from datetime import date, datetime, time, timedelta, timezone
-from decimal import Decimal, InvalidOperation
+from datetime import datetime, timedelta, timezone
 
 from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.models.ad_feed_reward import AdFeedRewardRecord
 from app.models.ad_reward import AdRewardRecord
-from app.models.analytics_event import AnalyticsEvent
 from app.models.comparison import ComparisonRecord
-from app.models.coupon_state import CouponPromptEngagement
-from app.models.cps_order import CpsOrder
 from app.models.feedback import Feedback
-from app.models.savings import SavingsRecord
 from app.models.signin import SigninBoostRecord, SigninRecord
 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")
-COUPON_REWARD_BIZ_TYPES = ("coupon", "coupon_reward")
-COMPARISON_REWARD_BIZ_TYPES = ("comparison", "compare_reward", "comparison_reward")
-EXCLUDED_REWARD_BIZ_TYPES = ("invite_inviter", "invite_invitee", "admin_grant")
-UNCLASSIFIED_FEED_BIZ_TYPES = ("feed_ad_reward",)
-REGULAR_TASK_EXCLUDED_BIZ_TYPES = (
-    *REWARD_VIDEO_BIZ_TYPES,
-    *COUPON_REWARD_BIZ_TYPES,
-    *COMPARISON_REWARD_BIZ_TYPES,
-    *EXCLUDED_REWARD_BIZ_TYPES,
-    *UNCLASSIFIED_FEED_BIZ_TYPES,
-)
-MEITUAN_CPS_INVALID_STATUSES = ("4", "5")
-MEITUAN_CPS_SETTLED_STATUS = "6"
-COMPARE_START_EVENT = "real_compare_start"
-COUPON_START_EVENT = "real_coupon_start"
-JD_CPS_INVALID_CODES = {
-    "2", "3", "4", "5", "6", "7", "8", "9", "11", "13", "14", "19", "20", "21",
-    "22", "23", "25", "26", "27", "28", "29", "30", "31", "34", "35", "36",
-}
-JD_CPS_UNPAID_CODES = {"15"}
 
 
 def _beijing_today_start_utc() -> datetime:
@@ -54,130 +28,20 @@ def _beijing_today_start_utc() -> datetime:
     return start_bj.astimezone(timezone.utc)
 
 
-def today_dau(db: Session) -> int:
-    """今日活跃用户数(DAU):登录 + 开始比价 + 开始领券,按用户去重。
-
-    广告收益报表复用这个函数;历史窗口 DAU 由 dashboard_overview 的 period 口径另算。
-    """
-    today_bj = datetime.now(_BEIJING).date()
+def dashboard_overview(db: Session) -> dict:
     today_start = _beijing_today_start_utc()
-    tomorrow_start = today_start + timedelta(days=1)
-    login_user_ids = _id_set(
-        db,
-        select(User.id).where(User.last_login_at >= today_start, User.last_login_at < tomorrow_start),
-    )
-    compare_start_user_ids = _event_user_ids(
-        db, (COMPARE_START_EVENT,), today_start, tomorrow_start
-    )
-    coupon_event_user_ids = _event_user_ids(
-        db, (COUPON_START_EVENT,), today_start, tomorrow_start
-    )
-    coupon_claim_user_ids = _id_set(
-        db,
-        select(CouponPromptEngagement.user_id).where(
-            CouponPromptEngagement.engage_date == today_bj,
-            CouponPromptEngagement.engage_type == "claim_started",
-        ),
-    )
-    return len(login_user_ids | compare_start_user_ids | coupon_event_user_ids | coupon_claim_user_ids)
-
-
-def _default_period_end() -> date:
-    """新版大盘不含今日,默认窗口结束日=北京时间昨天。"""
-    return datetime.now(_BEIJING).date() - timedelta(days=1)
-
-
-def _normalize_period(date_from: date | None, date_to: date | None) -> tuple[date, date]:
-    end = date_to or _default_period_end()
-    start = date_from or end
-    if start > end:
-        start, end = end, start
-    return start, end
-
-
-def _period_bounds(date_from: date, date_to: date) -> tuple[datetime, datetime, datetime, datetime]:
-    """返回同一北京自然日窗口的 UTC aware 边界和北京 naive 边界。
-
-    user.created_at / last_login_at 是 UTC aware 口径;比较/金币等历史上有北京 naive
-    写入,所以两套边界同时保留。
-    """
-    start_bj = datetime.combine(date_from, time.min, tzinfo=_BEIJING)
-    end_bj = datetime.combine(date_to + timedelta(days=1), time.min, tzinfo=_BEIJING)
-    start_utc = start_bj.astimezone(timezone.utc)
-    end_utc = end_bj.astimezone(timezone.utc)
-    return (
-        start_utc,
-        end_utc,
-        start_bj.replace(tzinfo=None),
-        end_bj.replace(tzinfo=None),
-    )
-
-
-def _date_range(date_from: date, date_to: date) -> list[date]:
-    days = (date_to - date_from).days
-    return [date_from + timedelta(days=i) for i in range(days + 1)]
-
-
-def _id_set(db: Session, stmt) -> set[int]:
-    return {int(v) for v in db.execute(stmt).scalars().all() if v is not None}
-
-
-def _event_user_ids(
-    db: Session, event_names: tuple[str, ...], start_utc: datetime, end_utc: datetime
-) -> set[int]:
-    return _id_set(
-        db,
-        select(AnalyticsEvent.user_id).where(
-            AnalyticsEvent.user_id.is_not(None),
-            AnalyticsEvent.event.in_(event_names),
-            AnalyticsEvent.created_at >= start_utc,
-            AnalyticsEvent.created_at < end_utc,
-        ),
-    )
-
-
-def _commission_rate_percent(raw: str | None) -> Decimal | None:
-    """美团 commissionRate 原值: "300"=3%, "10"=0.1%;也兼容 "3%"。"""
-    if raw is None:
-        return None
-    s = str(raw).strip()
-    if not s:
-        return None
-    try:
-        if s.endswith("%"):
-            return Decimal(s[:-1])
-        val = Decimal(s)
-    except (InvalidOperation, ValueError):
-        return None
-    return val / Decimal("100")
-
-
-def _jd_valid_order(order: CpsOrder) -> bool:
-    code = str(order.jd_valid_code).strip() if order.jd_valid_code is not None else ""
-    return bool(code and code not in JD_CPS_INVALID_CODES and code not in JD_CPS_UNPAID_CODES)
-
-
-def dashboard_overview(
-    db: Session, *, date_from: date | None = None, date_to: date | None = None
-) -> dict:
-    today_start = _beijing_today_start_utc()
-    period_from, period_to = _normalize_period(date_from, date_to)
-    start_utc, end_utc, start_local, end_local = _period_bounds(period_from, period_to)
 
     def _count(model, *conds) -> int:
         stmt = select(func.count(model.id))
         if conds:
             stmt = stmt.where(*conds)
-        return int(db.execute(stmt).scalar_one())
+        return db.execute(stmt).scalar_one()
 
     def _sum(col, *conds) -> int:
         stmt = select(func.coalesce(func.sum(col), 0))
         if conds:
             stmt = stmt.where(*conds)
-        return int(db.execute(stmt).scalar_one())
-
-    def _user_id_set(stmt) -> set[int]:
-        return {int(v) for v in db.execute(stmt).scalars().all() if v is not None}
+        return db.execute(stmt).scalar_one()
 
     # ===== 用户 =====
     by_status = dict(
@@ -197,279 +61,6 @@ def dashboard_overview(
     comparison_total = _count(ComparisonRecord)
     comparison_success = _count(ComparisonRecord, ComparisonRecord.status == "success")
     success_rate = round(comparison_success / comparison_total, 4) if comparison_total else 0.0
-    period_comparison_conds = (
-        ComparisonRecord.created_at >= start_local,
-        ComparisonRecord.created_at < end_local,
-    )
-    period_comparison_total = _count(ComparisonRecord, *period_comparison_conds)
-    period_comparison_success = _count(
-        ComparisonRecord,
-        *period_comparison_conds,
-        ComparisonRecord.status == "success",
-    )
-    period_comparison_success_rate = (
-        round(period_comparison_success / period_comparison_total, 4)
-        if period_comparison_total
-        else 0.0
-    )
-    period_saved_positive_count = _count(
-        ComparisonRecord,
-        *period_comparison_conds,
-        ComparisonRecord.status == "success",
-        ComparisonRecord.saved_amount_cents > 0,
-    )
-    period_saved_positive_sum = _sum(
-        ComparisonRecord.saved_amount_cents,
-        *period_comparison_conds,
-        ComparisonRecord.status == "success",
-        ComparisonRecord.saved_amount_cents > 0,
-    )
-    period_avg_saved_cents = (
-        round(period_saved_positive_sum / period_saved_positive_count)
-        if period_saved_positive_count
-        else None
-    )
-    period_avg_duration_ms = db.execute(
-        select(func.avg(ComparisonRecord.total_ms)).where(
-            *period_comparison_conds,
-            ComparisonRecord.total_ms.is_not(None),
-            ComparisonRecord.total_ms > 0,
-        )
-    ).scalar_one()
-    period_avg_duration_ms = (
-        round(float(period_avg_duration_ms))
-        if period_avg_duration_ms is not None
-        else None
-    )
-
-    ordered_exists = (
-        select(SavingsRecord.id)
-        .where(
-            SavingsRecord.user_id == ComparisonRecord.user_id,
-            SavingsRecord.source == "compare",
-            SavingsRecord.shop_name.is_not(None),
-            SavingsRecord.shop_name == ComparisonRecord.store_name,
-        )
-        .exists()
-    )
-    period_ordered_count = _count(
-        ComparisonRecord,
-        *period_comparison_conds,
-        ComparisonRecord.store_name.is_not(None),
-        ordered_exists,
-    )
-
-    # ===== 日期窗口用户 =====
-    period_new_user_ids = _user_id_set(
-        select(User.id).where(User.created_at >= start_utc, User.created_at < end_utc)
-    )
-    login_user_ids = _user_id_set(
-        select(User.id).where(User.last_login_at >= start_utc, User.last_login_at < end_utc)
-    )
-    compare_start_user_ids = _event_user_ids(
-        db, (COMPARE_START_EVENT,), start_utc, end_utc
-    )
-    coupon_event_user_ids = _event_user_ids(
-        db, (COUPON_START_EVENT,), start_utc, end_utc
-    )
-    coupon_claim_user_ids = _user_id_set(
-        select(CouponPromptEngagement.user_id).where(
-            CouponPromptEngagement.engage_date >= period_from,
-            CouponPromptEngagement.engage_date <= period_to,
-            CouponPromptEngagement.engage_type == "claim_started",
-        )
-    )
-    period_active_user_ids = (
-        login_user_ids | compare_start_user_ids | coupon_event_user_ids | coupon_claim_user_ids
-    )
-    period_retained_new_user_ids = period_new_user_ids & period_active_user_ids
-    period_retention_rate = (
-        round(len(period_retained_new_user_ids) / len(period_new_user_ids), 4)
-        if period_new_user_ids
-        else None
-    )
-    trend_points: list[dict] = []
-    for cur_date in _date_range(period_from, period_to):
-        day_start_utc, day_end_utc, day_start_local, day_end_local = _period_bounds(
-            cur_date, cur_date
-        )
-        daily_comparison_conds = (
-            ComparisonRecord.created_at >= day_start_local,
-            ComparisonRecord.created_at < day_end_local,
-        )
-        daily_login_user_ids = _user_id_set(
-            select(User.id).where(
-                User.last_login_at >= day_start_utc,
-                User.last_login_at < day_end_utc,
-            )
-        )
-        daily_compare_start_user_ids = _event_user_ids(
-            db, (COMPARE_START_EVENT,), day_start_utc, day_end_utc
-        )
-        daily_coupon_event_user_ids = _event_user_ids(
-            db, (COUPON_START_EVENT,), day_start_utc, day_end_utc
-        )
-        daily_coupon_claim_user_ids = _user_id_set(
-            select(CouponPromptEngagement.user_id).where(
-                CouponPromptEngagement.engage_date == cur_date,
-                CouponPromptEngagement.engage_type == "claim_started",
-            )
-        )
-        trend_points.append(
-            {
-                "date": cur_date,
-                "active_users": len(
-                    daily_login_user_ids
-                    | daily_compare_start_user_ids
-                    | daily_coupon_event_user_ids
-                    | daily_coupon_claim_user_ids
-                ),
-                "new_users": _count(
-                    User,
-                    User.created_at >= day_start_utc,
-                    User.created_at < day_end_utc,
-                ),
-                "comparisons": _count(ComparisonRecord, *daily_comparison_conds),
-            }
-        )
-
-    period_coin_conds = (
-        CoinTransaction.created_at >= start_local,
-        CoinTransaction.created_at < end_local,
-        CoinTransaction.amount > 0,
-    )
-    period_reward_video_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type.in_(REWARD_VIDEO_BIZ_TYPES),
-    )
-    period_feed_ad_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type == "feed_ad_reward",
-    )
-    period_feed_ad_conds = (
-        AdFeedRewardRecord.created_at >= start_utc,
-        AdFeedRewardRecord.created_at < end_utc,
-        AdFeedRewardRecord.status == "granted",
-    )
-    period_coupon_feed_coin_total = _sum(
-        AdFeedRewardRecord.coin,
-        *period_feed_ad_conds,
-        AdFeedRewardRecord.feed_scene == "coupon",
-    )
-    period_comparison_feed_coin_total = _sum(
-        AdFeedRewardRecord.coin,
-        *period_feed_ad_conds,
-        AdFeedRewardRecord.feed_scene == "comparison",
-    )
-    period_signin_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type == "signin",
-    )
-    period_signin_boost_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type == "signin_boost",
-    )
-    period_task_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type.like("task_%"),
-    )
-    period_coupon_reward_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type.in_(COUPON_REWARD_BIZ_TYPES),
-    ) + period_coupon_feed_coin_total
-    period_comparison_reward_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type.in_(COMPARISON_REWARD_BIZ_TYPES),
-    ) + period_comparison_feed_coin_total
-    period_regular_task_coin_total = _sum(
-        CoinTransaction.amount,
-        *period_coin_conds,
-        CoinTransaction.biz_type.notin_(REGULAR_TASK_EXCLUDED_BIZ_TYPES),
-    )
-    period_classified_coin_total = (
-        period_coupon_reward_coin_total
-        + period_comparison_reward_coin_total
-        + period_reward_video_coin_total
-        + period_regular_task_coin_total
-    )
-    period_cps_orders = list(
-        db.execute(
-            select(CpsOrder).where(
-                CpsOrder.pay_time >= start_utc,
-                CpsOrder.pay_time < end_utc,
-            )
-        ).scalars()
-    )
-    period_meituan_orders = [
-        o for o in period_cps_orders if (o.platform or "meituan") == "meituan"
-    ]
-    period_meituan_valid_orders = [
-        o for o in period_meituan_orders if o.mt_status not in MEITUAN_CPS_INVALID_STATUSES
-    ]
-    period_jd_orders = [o for o in period_cps_orders if o.platform == "jd"]
-    period_jd_valid_orders = [o for o in period_jd_orders if _jd_valid_order(o)]
-    period_jd_invalid_orders = [
-        o for o in period_jd_orders if o.jd_valid_code and not _jd_valid_order(o)
-    ]
-    period_meituan_hit_count = 0
-    period_meituan_miss_count = 0
-    period_meituan_unknown_rate_count = 0
-    for order in period_meituan_valid_orders:
-        rate = _commission_rate_percent(order.commission_rate)
-        if rate is None:
-            period_meituan_unknown_rate_count += 1
-        elif rate < Decimal("1"):
-            period_meituan_miss_count += 1
-        else:
-            period_meituan_hit_count += 1
-    period_meituan_hit_denominator = period_meituan_hit_count + period_meituan_miss_count
-    period_meituan_hit_rate = (
-        round(period_meituan_hit_count / period_meituan_hit_denominator, 4)
-        if period_meituan_hit_denominator
-        else None
-    )
-
-    total_reward_video_coin_total = _sum(
-        CoinTransaction.amount,
-        CoinTransaction.amount > 0,
-        CoinTransaction.biz_type.in_(REWARD_VIDEO_BIZ_TYPES),
-    )
-    total_coupon_reward_coin_total = _sum(
-        CoinTransaction.amount,
-        CoinTransaction.amount > 0,
-        CoinTransaction.biz_type.in_(COUPON_REWARD_BIZ_TYPES),
-    ) + _sum(
-        AdFeedRewardRecord.coin,
-        AdFeedRewardRecord.status == "granted",
-        AdFeedRewardRecord.feed_scene == "coupon",
-    )
-    total_comparison_reward_coin_total = _sum(
-        CoinTransaction.amount,
-        CoinTransaction.amount > 0,
-        CoinTransaction.biz_type.in_(COMPARISON_REWARD_BIZ_TYPES),
-    ) + _sum(
-        AdFeedRewardRecord.coin,
-        AdFeedRewardRecord.status == "granted",
-        AdFeedRewardRecord.feed_scene == "comparison",
-    )
-    total_regular_task_coin_total = _sum(
-        CoinTransaction.amount,
-        CoinTransaction.amount > 0,
-        CoinTransaction.biz_type.notin_(REGULAR_TASK_EXCLUDED_BIZ_TYPES),
-    )
-    total_classified_coin_total = (
-        total_coupon_reward_coin_total
-        + total_comparison_reward_coin_total
-        + total_reward_video_coin_total
-        + total_regular_task_coin_total
-    )
 
     return {
         "users": {
@@ -478,15 +69,15 @@ def dashboard_overview(
             "disabled": by_status.get("disabled", 0),
             "deleted": by_status.get("deleted", 0),
             "new_today": _count(User, User.created_at >= today_start),
-            "dau": today_dau(db),
+            "dau": _count(User, User.last_login_at >= today_start),
         },
         "coins": {
-            # 累计发放金币按大盘 4 个展示分类加总;未分类/运营手动/邀请奖励不进入本指标。
-            "granted_total": total_classified_coin_total,
+            # 累计发放金币(coin_transaction 里所有 amount>0 之和;负数是兑换/扣减不计)
+            "granted_total": _sum(CoinTransaction.amount, CoinTransaction.amount > 0),
             "reward_video_coin_total": _sum(
                 CoinTransaction.amount,
                 CoinTransaction.amount > 0,
-                CoinTransaction.biz_type.in_(REWARD_VIDEO_BIZ_TYPES),
+                CoinTransaction.biz_type.in_(("reward_video", "ad_reward")),
             ),
             "reward_video_watch_count": _count(
                 AdRewardRecord,
@@ -514,10 +105,6 @@ def dashboard_overview(
                 CoinTransaction.biz_type == "signin_boost",
             ),
             "signin_boost_watch_count": _count(SigninBoostRecord),
-            "task_coin_total": total_regular_task_coin_total,
-            "coupon_reward_coin_total": total_coupon_reward_coin_total,
-            "comparison_reward_coin_total": total_comparison_reward_coin_total,
-            "regular_task_coin_total": total_regular_task_coin_total,
         },
         "cash": {
             "withdraw_success_cents": _sum(
@@ -532,73 +119,7 @@ def dashboard_overview(
             "success": comparison_success,
             "success_rate": success_rate,
         },
-        "period": {
-            "date_from": period_from,
-            "date_to": period_to,
-            "users": {
-                "new": len(period_new_user_ids),
-                "active": len(period_active_user_ids),
-                "retained_new_users": len(period_retained_new_user_ids),
-                "retention_rate": period_retention_rate,
-                "retention_note": (
-                    "口径:登录(last_login_at)+开始比价(real_compare_start)+"
-                    "开始领券(real_coupon_start/claim_started),按用户去重"
-                ),
-            },
-            "comparison": {
-                "total": period_comparison_total,
-                "success": period_comparison_success,
-                "success_rate": period_comparison_success_rate,
-                "ordered": period_ordered_count,
-                "average_duration_ms": period_avg_duration_ms,
-                "average_saved_cents": period_avg_saved_cents,
-            },
-            "coins": {
-                "granted_total": period_classified_coin_total,
-                "reward_video_coin_total": period_reward_video_coin_total,
-                "feed_ad_coin_total": period_feed_ad_coin_total,
-                "signin_coin_total": period_signin_coin_total,
-                "signin_boost_coin_total": period_signin_boost_coin_total,
-                "task_coin_total": period_task_coin_total,
-                "coupon_reward_coin_total": period_coupon_reward_coin_total,
-                "comparison_reward_coin_total": period_comparison_reward_coin_total,
-                "regular_task_coin_total": period_regular_task_coin_total,
-            },
-            "cash": {
-                "withdraw_success_cents": _sum(
-                    WithdrawOrder.amount_cents,
-                    WithdrawOrder.status == "success",
-                    WithdrawOrder.created_at >= start_local,
-                    WithdrawOrder.created_at < end_local,
-                ),
-            },
-            "trend": trend_points,
-        },
-        "feedback": {
-            "new": _count(Feedback, Feedback.status.in_(("pending", "new"))),
-        },
-        "cps": {
-            "available": True,
-            "note": "美团/JD CPS 读 cps_order 对账订单;淘宝佣金暂空",
-            "meituan_order_count": len(period_meituan_valid_orders),
-            "meituan_commission_cents": sum(
-                o.commission_cents or 0 for o in period_meituan_valid_orders
-            ),
-            "meituan_hit_count": period_meituan_hit_count,
-            "meituan_miss_count": period_meituan_miss_count,
-            "meituan_unknown_rate_count": period_meituan_unknown_rate_count,
-            "meituan_hit_rate": period_meituan_hit_rate,
-            "jd_order_count": len(period_jd_valid_orders),
-            # 数据大盘京东 CPS 只看实际佣金,不再用预估佣金兜底。
-            "jd_commission_cents": sum(
-                o.actual_commission_cents or 0 for o in period_jd_valid_orders
-            ),
-            "jd_actual_commission_cents": sum(
-                o.actual_commission_cents or 0 for o in period_jd_valid_orders
-            ),
-            "jd_estimated_commission_cents": sum(
-                o.estimated_commission_cents or 0 for o in period_jd_valid_orders
-            ),
-            "jd_invalid_count": len(period_jd_invalid_orders),
-        },
+        "feedback": {"new": _count(Feedback, Feedback.status.in_(("pending", "new")))},
+        # CPS 收入数据源未接(referral-link 只换链接,转化/佣金未回收)→ 前端显示"待接入"。
+        "cps": {"available": False, "note": "CPS 转化数据未接入(P2)"},
     }

app/admin/routers/ad_revenue.py

@@ -11,13 +11,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query
 
 from app.admin.deps import AdminDb, get_current_admin
 from app.admin.repositories import ad_revenue
-from app.admin.schemas.ad_revenue import (
-    AdRevenueDaily,
-    AdRevenueHourly,
-    AdRevenueReportOut,
-    AdRevenueRow,
-    AdRevenueTypeStat,
-)
+from app.admin.schemas.ad_revenue import AdRevenueDaily, AdRevenueReportOut, AdRevenueRow
 from app.core.rewards import cn_today
 
 router = APIRouter(
@@ -49,21 +43,10 @@ def get_ad_revenue_report(
         str | None,
         Query(description="reward_video / feed / draw;不传=全部类型"),
     ] = None,
-    feed_scene: Annotated[
-        str | None,
-        Query(
-            description="comparison(比价) / coupon(领券) / welfare(福利);不传=全部场景。"
-            "全局筛选,同时影响明细 / 合计 / 趋势"
-        ),
-    ] = None,
     granularity: Annotated[
         str, Query(description="day=按天 / hour=按小时(北京时间);区间>1 天建议用 day")
     ] = "day",
-    limit: Annotated[int, Query(ge=1, le=1000, description="每页条数(分页大小)")] = 500,
-    offset: Annotated[int, Query(ge=0, description="分页偏移(已跳过的条数)=(页码-1)×每页条数")] = 0,
-    sort: Annotated[
-        str, Query(description="排序:time=时间倒序(默认) / ecpm=按 eCPM 数值倒序")
-    ] = "time",
+    limit: Annotated[int, Query(ge=1, le=1000)] = 500,
 ) -> AdRevenueReportOut:
     today = cn_today()
     d_from = _parse_day(date_from, field="date_from", default=today)
@@ -75,16 +58,12 @@ def get_ad_revenue_report(
 
     result = ad_revenue.ad_revenue_report(
         db, date_from=d_from.isoformat(), date_to=d_to.isoformat(),
-        user_id=user_id, ad_type=ad_type, feed_scene=feed_scene,
-        granularity=granularity, limit=limit, offset=offset, sort=sort,
+        user_id=user_id, ad_type=ad_type, granularity=granularity, limit=limit,
     )
     return AdRevenueReportOut(
         date_from=d_from.isoformat(),
         date_to=d_to.isoformat(),
         daily=[AdRevenueDaily(**d) for d in result["daily"]],
-        hourly=[AdRevenueHourly(**h) for h in result["hourly"]],
-        type_stats={k: AdRevenueTypeStat(**v) for k, v in result["type_stats"].items()},
-        dau=result["dau"],
         total=result["total"],
         truncated=result["truncated"],
         total_impressions=result["total_impressions"],

app/admin/routers/cps.py

@@ -1,13 +1,13 @@
-"""admin CPS 分发与对账:群/活动管理 + 生成落地页短链 + 联盟订单对账 + 统计。
+"""admin CPS 分发与对账:群/活动管理 + 生成落地页短链 + 美团订单对账 + 统计。
 
 平台:meituan(actId+sid 转链 + query_order 对账) / taobao(整段淘口令) / jd(链接)。
-淘宝暂未接 API → 只统计点击(咱落地页 PV/UV + 淘宝复制),对账字段显示 "-"。
+淘宝/京东无 API → 只统计点击(咱落地页 PV/UV + 淘宝复制),对账字段显示 "-"。
 群/活动管理 = operator;订单对账(涉佣金) = finance;只读列表/统计 = 登录即可。
 """
 from __future__ import annotations
 
 import time
-from datetime import date as _date, datetime, time as _dt_time, timedelta, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Annotated
 
 from fastapi import APIRouter, Depends, File, HTTPException, Query, Request, UploadFile
@@ -34,7 +34,6 @@ from app.admin.schemas.cps import (
 from app.core import media
 from app.core.config import settings
 from app.integrations import meituan
-from app.integrations.jd_union import JdUnionError
 from app.integrations.meituan import MeituanCpsError
 from app.models.admin import AdminUser
 from app.models.cps_activity import CpsActivity
@@ -341,108 +340,24 @@ def generate_referral_links(
 
 
 # ───────────── 订单对账 ─────────────
-_BEIJING = timezone(timedelta(hours=8))
-
-
-def _parse_day(value: str | None, *, field: str) -> _date | None:
-    if value is None:
-        return None
-    try:
-        return _date.fromisoformat(value)
-    except ValueError as e:
-        raise HTTPException(status_code=422, detail=f"{field} 需为 YYYY-MM-DD") from e
-
-
-def _reconcile_range_to_ts(
-    date_from: _date | None, date_to: _date | None, days: int
-) -> tuple[int, int]:
-    if date_from is None and date_to is None:
-        now = int(time.time())
-        return now - days * 86400, now
-
-    start_day = date_from or date_to
-    end_day = date_to or date_from
-    if start_day is None or end_day is None:
-        raise HTTPException(status_code=422, detail="日期参数不完整")
-    if start_day > end_day:
-        start_day, end_day = end_day, start_day
-    if (end_day - start_day).days + 1 > 90:
-        raise HTTPException(status_code=422, detail="美团订单查询最长 90 天")
-
-    start_dt = datetime.combine(start_day, _dt_time.min, tzinfo=_BEIJING)
-    end_dt = datetime.combine(end_day + timedelta(days=1), _dt_time.min, tzinfo=_BEIJING)
-    return int(start_dt.timestamp()), int(end_dt.timestamp())
-
-
-def _reconcile_range_to_bj_dt(
-    date_from: _date | None, date_to: _date | None, days: int
-) -> tuple[datetime, datetime]:
-    start_ts, end_ts = _reconcile_range_to_ts(date_from, date_to, days)
-    return (
-        datetime.fromtimestamp(start_ts, tz=_BEIJING),
-        datetime.fromtimestamp(end_ts, tz=_BEIJING),
-    )
-
-
-def _merge_reconcile_result(total: dict, current: dict) -> None:
-    for key in ("fetched", "inserted", "updated", "pages"):
-        total[key] = int(total.get(key, 0)) + int(current.get(key, 0))
-
-
-@router.post("/orders/reconcile", response_model=CpsReconcileResult, summary="拉取联盟订单对账")
+@router.post("/orders/reconcile", response_model=CpsReconcileResult, summary="拉取美团订单对账")
 def reconcile_orders(
     request: Request,
     admin: Annotated[AdminUser, Depends(require_role("finance"))],
     db: AdminDb,
-    date_from: Annotated[str | None, Query(description="起始日 YYYY-MM-DD")] = None,
-    date_to: Annotated[str | None, Query(description="结束日 YYYY-MM-DD")] = None,
-    days: Annotated[int, Query(ge=1, le=90, description="未传日期时默认拉近 N 天")] = 7,
+    days: Annotated[int, Query(ge=1, le=90)] = 7,
     sid: Annotated[str | None, Query(max_length=64)] = None,
-    query_time_type: Annotated[int, Query(ge=1, le=3)] = 1,
-    platform: Annotated[str, Query(pattern="^(all|meituan|jd)$")] = "all",
 ) -> CpsReconcileResult:
-    parsed_from = _parse_day(date_from, field="date_from")
-    parsed_to = _parse_day(date_to, field="date_to")
-    result = {"fetched": 0, "inserted": 0, "updated": 0, "pages": 0}
+    now = int(time.time())
     try:
-        if platform in {"all", "meituan"}:
-            start_ts, end_ts = _reconcile_range_to_ts(parsed_from, parsed_to, days)
-            mt_result = cps_repo.reconcile_orders(
-                db,
-                start_time=start_ts,
-                end_time=end_ts,
-                query_time_type=query_time_type if query_time_type in (1, 2) else 2,
-                sid=sid,
-            )
-            _merge_reconcile_result(result, mt_result)
-        if platform in {"all", "jd"}:
-            if sid:
-                raise HTTPException(status_code=422, detail="京东订单刷新不支持 sid 筛选")
-            start_dt, end_dt = _reconcile_range_to_bj_dt(parsed_from, parsed_to, days)
-            jd_result = cps_repo.reconcile_jd_orders(
-                db,
-                start_time=start_dt,
-                end_time=end_dt,
-                query_time_type=query_time_type,
-            )
-            _merge_reconcile_result(result, jd_result)
+        result = cps_repo.reconcile_orders(
+            db, start_time=now - days * 86400, end_time=now, sid=sid,
+        )
     except MeituanCpsError as e:
         raise HTTPException(status_code=502, detail=f"美团拉单失败: {e}") from e
-    except JdUnionError as e:
-        raise HTTPException(status_code=502, detail=f"京东拉单失败: {e}") from e
     write_audit(
         db, admin, action="cps.order.reconcile", target_type="cps_order", target_id=None,
-        detail={
-            "platform": platform,
-            "date_from": date_from,
-            "date_to": date_to,
-            "days": days,
-            "sid": sid,
-            "query_time_type": query_time_type,
-            **result,
-        },
-        ip=get_client_ip(request),
-        commit=True,
+        detail={"days": days, "sid": sid, **result}, ip=get_client_ip(request), commit=True,
     )
     return CpsReconcileResult(**result)
 
@@ -553,7 +468,7 @@ def group_daily(
     while cur <= last:
         cp = click_points[idx] if idx < len(click_points) else None
         row = {
-            "date": cur.strftime("%Y-%m-%d"),
+            "date": cur.strftime("%m-%d"),
             "click_pv": cp["click_pv"] if cp else 0,
             "click_uv": cp["click_uv"] if cp else 0,
             "copy_pv": cp["copy_pv"] if cp else 0,
@@ -581,28 +496,3 @@ def group_wx_users(group_id: int, db: AdminDb) -> dict:
     if group is None:
         raise HTTPException(status_code=404, detail="群不存在")
     return {"users": cps_repo.group_wx_users(db, group_id=group_id)}
-
-
-@router.get("/groups/{group_id}/day-users", summary="某天该群按用户的领券/点击 + 每人点过的券")
-def group_day_users(
-    group_id: int,
-    db: AdminDb,
-    date: Annotated[str, Query(description="北京日期 YYYY-MM-DD")],
-) -> dict:
-    group = cps_repo.get_group(db, group_id)
-    if group is None:
-        raise HTTPException(status_code=404, detail="群不存在")
-    bj = timezone(timedelta(hours=8))
-    try:
-        day0 = datetime.strptime(date, "%Y-%m-%d").replace(tzinfo=bj)
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail="date 格式应为 YYYY-MM-DD") from e
-    start = day0.replace(hour=0, minute=0, second=0, microsecond=0)
-    end = start + timedelta(days=1)
-    users = cps_repo.group_day_users(db, group_id=group_id, start=start, end=end)
-    return {
-        "group_id": group.id,
-        "group_name": group.name,
-        "date": date,
-        "users": users,
-    }

app/admin/routers/dashboard.py

@@ -1,9 +1,7 @@
 """admin 数据大盘(只读聚合)。"""
 from __future__ import annotations
 
-from datetime import date
-
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends
 
 from app.admin.deps import AdminDb, get_current_admin
 from app.admin.repositories import stats
@@ -17,11 +15,5 @@ router = APIRouter(
 
 
 @router.get("/overview", response_model=DashboardOverview, summary="大盘核心指标")
-def overview(
-    db: AdminDb,
-    date_from: date | None = Query(None, description="北京时间自然日起始日 YYYY-MM-DD"),
-    date_to: date | None = Query(None, description="北京时间自然日结束日 YYYY-MM-DD"),
-) -> DashboardOverview:
-    return DashboardOverview.model_validate(
-        stats.dashboard_overview(db, date_from=date_from, date_to=date_to)
-    )
+def overview(db: AdminDb) -> DashboardOverview:
+    return DashboardOverview.model_validate(stats.dashboard_overview(db))

app/admin/routers/device_liveness.py

@@ -1,63 +0,0 @@
-"""admin 设备存活监控(只读):列设备心跳/在线掉线 + 顶部统计卡片。
-
-数据源 device_liveness 表(心跳 last_heartbeat_at + liveness_state + kill_alert_pending,
-见 app/models/device.py)。在线/掉线、掉线时长由 repo 按 HEARTBEAT_TIMEOUT_MINUTES 阈值派生。
-纯读:无写、无审计。任意登录管理员可看(同大盘/设备管理,无角色门)。
-"""
-from __future__ import annotations
-
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Query
-
-from app.admin.deps import AdminDb, get_current_admin
-from app.admin.repositories import queries
-from app.admin.schemas.common import CursorPage
-from app.admin.schemas.device import DeviceLivenessItem, DeviceLivenessStats
-
-router = APIRouter(
-    prefix="/admin/api/device-liveness",
-    tags=["admin-device-liveness"],
-    dependencies=[Depends(get_current_admin)],
-)
-
-
-@router.get("/stats", response_model=DeviceLivenessStats, summary="设备存活统计(顶部卡片)")
-def device_stats(db: AdminDb) -> DeviceLivenessStats:
-    return DeviceLivenessStats(**queries.device_liveness_stats(db))
-
-
-@router.get(
-    "",
-    response_model=CursorPage[DeviceLivenessItem],
-    summary="设备存活列表(在线情况/设备id/归属用户 筛选 + 排序 + 分页,默认掉线置顶)",
-)
-def list_devices(
-    db: AdminDb,
-    status: Annotated[str | None, Query(pattern="^(online|offline|never)$")] = None,
-    device_id: Annotated[str | None, Query(max_length=128)] = None,
-    phone: Annotated[str | None, Query(max_length=20)] = None,
-    user_id: Annotated[int | None, Query()] = None,
-    sort_by: Annotated[
-        str, Query(pattern="^(status|last_heartbeat_at|created_at)$")
-    ] = "status",
-    sort_order: Annotated[str, Query(pattern="^(asc|desc)$")] = "desc",
-    limit: Annotated[int, Query(ge=1, le=100)] = 20,
-    cursor: Annotated[int | None, Query()] = None,
-) -> CursorPage[DeviceLivenessItem]:
-    items, next_cursor, total = queries.list_device_liveness(
-        db,
-        status=status,
-        device_id=device_id,
-        phone=phone,
-        user_id=user_id,
-        sort_by=sort_by,
-        sort_order=sort_order,
-        limit=limit,
-        cursor=cursor,
-    )
-    return CursorPage(
-        items=[DeviceLivenessItem.model_validate(d) for d in items],
-        next_cursor=next_cursor,
-        total=total,
-    )

app/admin/schemas/ad_revenue.py

@@ -40,7 +40,7 @@ class AdRevenueRecord(BaseModel):
 
 
 class AdRevenueDaily(BaseModel):
-    """按日期汇总的一天(供前端按天趋势图;全量,不受分页影响)。"""
+    """按日期汇总的一天(供前端按天趋势图;全量,不受 limit 影响)。"""
 
     date: str = Field(..., description="北京时间 YYYY-MM-DD")
     impressions: int = Field(..., description="当天展示条数合计")
@@ -49,23 +49,6 @@ class AdRevenueDaily(BaseModel):
     actual_coin: int = Field(..., description="当天实发金币合计")
 
 
-class AdRevenueHourly(BaseModel):
-    """按北京小时(0–23)汇总的一小时(供前端按小时趋势图;全量,不受分页影响,单日 granularity=hour 时非空)。"""
-
-    hour: int = Field(..., description="北京时间小时 0–23")
-    impressions: int = Field(..., description="该小时展示条数合计")
-    revenue_yuan: float = Field(..., description="该小时预估收益合计(元)")
-    expected_coin: int = Field(..., description="该小时应发金币合计")
-    actual_coin: int = Field(..., description="该小时实发金币合计")
-
-
-class AdRevenueTypeStat(BaseModel):
-    """按广告类型(ad_type)的小计:展示条数 + 预估收益(eCPM 由前端用 收益÷展示×1000 算)。"""
-
-    impressions: int = Field(..., description="该类型展示条数合计")
-    revenue_yuan: float = Field(..., description="该类型预估收益合计(元)")
-
-
 class AdRevenueRow(BaseModel):
     """一次广告事件(逐条一行):激励视频展示与发奖按 ad_session_id 合并;信息流展示 / 发奖各自成行。"""
 
@@ -108,20 +91,8 @@ class AdRevenueReportOut(BaseModel):
     date_from: str = Field(..., description="报表起始日期(北京时间 YYYY-MM-DD)")
     date_to: str = Field(..., description="报表结束日期(北京时间 YYYY-MM-DD,闭区间;单日时与 date_from 相同)")
     daily: list[AdRevenueDaily] = Field(..., description="按日期汇总序列(全量,供按天趋势图)")
-    hourly: list[AdRevenueHourly] = Field(
-        default_factory=list,
-        description="按小时汇总序列(全量,供按小时趋势图;按天查询时为空)",
-    )
-    type_stats: dict[str, AdRevenueTypeStat] = Field(
-        default_factory=dict,
-        description="按广告类型(ad_type)小计 {ad_type: {impressions, revenue_yuan}};前端取 draw / reward_video 做分类大盘",
-    )
-    dau: int | None = Field(
-        None,
-        description="今日活跃用户数(复用大盘口径,last_login_at);**仅查询=今日单天时有值**,历史/多天为 null",
-    )
-    total: int = Field(..., description="广告事件总数(全量,不受分页影响;= 当前筛选下的分页总条数)")
-    truncated: bool = Field(..., description="当前页之后是否还有更多事件(len(events) > offset + limit)")
+    total: int = Field(..., description="广告事件总数(全量,不受 limit 影响)")
+    truncated: bool = Field(..., description="明细是否被 limit 截断")
     total_impressions: int = Field(..., description="全量展示条数合计")
     total_revenue_yuan: float = Field(..., description="全量收益合计(元)")
     total_expected_coin: int = Field(..., description="全量应发金币合计")

app/admin/schemas/cps.py

@@ -1,7 +1,7 @@
 """admin CPS 分发与对账 schemas。金额统一「分」(cents),前端 yuan() 展示。
 
-平台:meituan(actId+sid 转链对账) / taobao(淘口令,只统计点击) / jd(链接 + 订单 API 对账)。
-对账类字段对淘宝为 None → 前端显示 "-"(暂未对账)。
+平台:meituan(actId+sid 转链对账) / taobao(淘口令,只统计点击) / jd(链接,只统计点击)。
+对账类字段对淘宝/京东为 None → 前端显示 "-"(无法对账)。
 """
 from __future__ import annotations
 
@@ -116,22 +116,15 @@ class CpsOrderOut(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
     id: int
-    platform: str = "meituan"
     order_id: str
-    external_order_id: str | None = None
-    external_row_id: str | None = None
     sid: str | None = None
     act_id: str | None = None
     pay_price_cents: int | None = None
     commission_cents: int | None = None
-    estimated_commission_cents: int | None = None
-    actual_commission_cents: int | None = None
     commission_rate: str | None = None
     mt_status: str | None = None
-    jd_valid_code: str | None = None
     invalid_reason: str | None = None
     product_name: str | None = None
-    settle_month: str | None = None
     pay_time: datetime | None = None
 
 

app/admin/schemas/dashboard.py

@@ -1,8 +1,6 @@
 """admin 大盘 schemas(对应 stats.dashboard_overview 的嵌套结构)。"""
 from __future__ import annotations
 
-from datetime import date
-
 from pydantic import BaseModel
 
 
@@ -40,56 +38,6 @@ class DashboardComparison(BaseModel):
     success_rate: float
 
 
-class DashboardPeriodUsers(BaseModel):
-    new: int
-    active: int
-    retained_new_users: int
-    retention_rate: float | None = None
-    retention_note: str
-
-
-class DashboardPeriodComparison(BaseModel):
-    total: int
-    success: int
-    success_rate: float
-    ordered: int
-    average_duration_ms: int | None = None
-    average_saved_cents: int | None = None
-
-
-class DashboardPeriodCoins(BaseModel):
-    granted_total: int
-    reward_video_coin_total: int = 0
-    feed_ad_coin_total: int = 0
-    signin_coin_total: int = 0
-    signin_boost_coin_total: int = 0
-    task_coin_total: int = 0
-    coupon_reward_coin_total: int = 0
-    comparison_reward_coin_total: int = 0
-    regular_task_coin_total: int = 0
-
-
-class DashboardPeriodCash(BaseModel):
-    withdraw_success_cents: int
-
-
-class DashboardTrendPoint(BaseModel):
-    date: date
-    active_users: int
-    new_users: int
-    comparisons: int
-
-
-class DashboardPeriod(BaseModel):
-    date_from: date
-    date_to: date
-    users: DashboardPeriodUsers
-    comparison: DashboardPeriodComparison
-    coins: DashboardPeriodCoins
-    cash: DashboardPeriodCash
-    trend: list[DashboardTrendPoint] = []
-
-
 class DashboardFeedback(BaseModel):
     new: int
 
@@ -97,17 +45,6 @@ class DashboardFeedback(BaseModel):
 class DashboardCps(BaseModel):
     available: bool
     note: str
-    meituan_order_count: int = 0
-    meituan_commission_cents: int = 0
-    meituan_hit_count: int = 0
-    meituan_miss_count: int = 0
-    meituan_unknown_rate_count: int = 0
-    meituan_hit_rate: float | None = None
-    jd_order_count: int = 0
-    jd_commission_cents: int = 0
-    jd_actual_commission_cents: int = 0
-    jd_estimated_commission_cents: int = 0
-    jd_invalid_count: int = 0
 
 
 class DashboardOverview(BaseModel):
@@ -115,6 +52,5 @@ class DashboardOverview(BaseModel):
     coins: DashboardCoins
     cash: DashboardCash
     comparison: DashboardComparison
-    period: DashboardPeriod
     feedback: DashboardFeedback
     cps: DashboardCps

app/admin/schemas/device.py

@@ -1,56 +0,0 @@
-"""admin 设备存活监控 schemas(只读)。
-
-数据源 device_liveness 表(见 app/models/device.py)。online / display_state /
-offline_seconds 为后端按 HEARTBEAT_TIMEOUT_MINUTES 阈值派生的瞬态字段(非 DB 列),
-在 repo 里算好挂到行上,供 from_attributes 读出。
-"""
-from __future__ import annotations
-
-from datetime import datetime
-
-from pydantic import BaseModel, ConfigDict
-
-
-class DeviceLivenessItem(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int
-    user_id: int
-    # join user 取(瞬态;理论上 user 恒存在,留空仅防脏数据)
-    phone: str | None = None
-    nickname: str | None = None
-
-    device_id: str
-    device_model: str | None = None      # 由 device_id 解析(device_<机型>_<hash>);非 DB 列
-    platform: str
-    app_version: str | None = None
-    registration_id: str | None = None  # 旧极光字段,仅兼容历史数据
-    push_vendor: str | None = None
-    push_token: str | None = None
-
-    ever_protected: bool                 # 是否开过无障碍(=该设备对功能有意义)
-    first_protected_at: datetime | None = None   # 首次开无障碍时刻(老设备为 null)
-    last_heartbeat_at: datetime | None = None
-    last_report_protection_on: bool      # 心跳里上报的无障碍开关(恒 true,仅观测)
-    liveness_state: str                  # unknown / alive / silent(当前未用) / notified
-    notified_at: datetime | None = None
-    kill_alert_pending: bool             # 掉线召回待客户端 ack(与 state 解耦)
-    created_at: datetime
-    updated_at: datetime
-
-    # ===== 后端派生(非 DB 列)=====
-    online: bool = False                 # ever_protected 且距上次心跳 ≤ 阈值
-    # 显示态:online=在线 / offline=已掉线 / never=从未启用(没开过无障碍)
-    display_state: str = "never"
-    # 掉线时长(秒):仅 offline 时有值;在线 / 从未启用为 None
-    offline_seconds: int | None = None
-
-
-class DeviceLivenessStats(BaseModel):
-    """顶部卡片:总设备数 + 在线 / 已掉线 / 未启用(按心跳阈值派生的 operator 口径,
-    不暴露内部状态机 unknown/alive/silent/notified)。"""
-
-    total: int
-    online: int
-    offline: int
-    never: int

app/api/v1/ad.py

@@ -411,7 +411,6 @@ def feed_reward(payload: FeedRewardIn, user: CurrentUser, db: DbSession) -> Feed
         app_env=payload.app_env,
         our_code_id=payload.our_code_id,
         aborted=payload.aborted,
-        display_coin=payload.display_coin,
     )
     logger.info(
         "feed ad reward user_id=%d event=%s status=%s units=%d coin=%d",

app/api/v1/auth.py

@@ -2,7 +2,6 @@
 
 路由前缀 `/api/v1/auth`,包含:
   POST /jverify-login         极光一键登录(loginToken → 手机号 → 注册即登录 → 签 JWT)
-  POST /wechat-login          微信 App 授权登录(code → openid → 注册即登录 → 签 JWT)
   POST /sms/send              发短信验证码(mock 阶段任意 6 位通过)
   POST /sms/login             手机号 + 验证码登录
   POST /refresh               用 refresh_token 换新的 token 对
@@ -21,7 +20,6 @@ from app.core.ratelimit import enforce_rate_limit, rate_limit
 from app.core.security import TokenError, decode_token, issue_token_pair
 from app.integrations.jiguang import JiguangError, mask_phone, verify_and_get_phone
 from app.integrations.sms import SmsError, send_code, verify_code
-from app.integrations.wechat_login import WechatLoginError, code_to_userinfo
 from app.repositories import onboarding as onboarding_repo
 from app.repositories import user as user_repo
 from app.schemas.auth import (
@@ -34,7 +32,6 @@ from app.schemas.auth import (
     TokenPair,
     TokenWithUser,
     UserOut,
-    WechatLoginRequest,
 )
 
 logger = logging.getLogger("shagua.auth")
@@ -87,40 +84,6 @@ def jverify_login(req: JverifyLoginRequest, db: DbSession) -> TokenWithUser:
     return _login_response(user, onboarding_completed=completed)
 
 
-# ===================== 微信一键登录 =====================
-
-@router.post(
-    "/wechat-login",
-    response_model=TokenWithUser,
-    summary="微信一键登录",
-    dependencies=[Depends(rate_limit(20, 60, "wechat-login"))],
-)
-def wechat_login(req: WechatLoginRequest, db: DbSession) -> TokenWithUser:
-    try:
-        info = code_to_userinfo(req.code)
-    except WechatLoginError as e:
-        logger.warning("wechat_login failed: %s", e)
-        raise HTTPException(status_code=502, detail=str(e)) from e
-
-    user = user_repo.upsert_user_for_wechat_login(
-        db,
-        openid=info["openid"],
-        nickname=info.get("nickname"),
-        avatar_url=info.get("avatar_url"),
-    )
-    if user.status != "active":
-        raise HTTPException(status_code=403, detail="account disabled")
-
-    completed = onboarding_repo.is_completed(db, user_id=user.id, device_id=req.device_id)
-    logger.info(
-        "wechat_login ok user_id=%d openid=%s*** onboarded=%s",
-        user.id,
-        info["openid"][:6],
-        completed,
-    )
-    return _login_response(user, onboarding_completed=completed)
-
-
 # ===================== 短信登录 =====================
 
 @router.post(

app/api/v1/compare.py

@@ -26,7 +26,6 @@ import httpx
 from fastapi import APIRouter, HTTPException, Request, status
 
 from app.core.config import settings
-from app.core.pricebot_client import get_pricebot_client
 from app.core.pricebot_router import pick_pricebot
 
 logger = logging.getLogger("shagua.compare")
@@ -66,10 +65,10 @@ async def _passthrough(request: Request, upstream_path: str) -> dict[str, Any]:
     )
 
     try:
-        client = get_pricebot_client()
-        resp = await client.post(
-            url, content=raw, headers={"Content-Type": "application/json"}, timeout=timeout
-        )
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            resp = await client.post(
+                url, content=raw, headers={"Content-Type": "application/json"}
+            )
     except httpx.RequestError as e:
         logger.error("[pricebot] request failed: %s", e)
         raise HTTPException(

app/api/v1/compare_record.py

@@ -21,7 +21,6 @@ from app.api.deps import CurrentUser, DbSession
 from app.db.session import SessionLocal
 from app.models.comparison import ComparisonRecord
 from app.repositories import comparison as crud_compare
-from app.repositories import invite as crud_invite
 from app.services.pricebot_llm_calls import fetch_llm_calls
 from app.schemas.compare_record import (
     CompareStatsOut,
@@ -53,18 +52,6 @@ def report_record(
     # 任务做,不阻塞上报响应(顺带给 pricebot 落盘留足余量)。upsert 已 commit,后台用
     # 独立 session 按 record id 回填 llm_calls + 派生 llm_call_count/retry_count。
     background_tasks.add_task(_backfill_llm_calls, rec.id, rec.trace_id)
-    # 邀请 v2 发奖:被邀请人完成一次【成功】比价 → 给邀请人发邀请奖励金(幂等,只发一次)。
-    # best-effort:发奖异常不影响比价上报本身(rec 已 commit),只 log;邀请人补偿靠后续对账。
-    if rec.status == "success":
-        try:
-            reward = crud_invite.try_reward_on_compare(db, user.id)
-            if reward.status == "granted":
-                logger.info(
-                    "invite compare reward granted inviter=%s invitee=%s cents=%s",
-                    reward.inviter_user_id, user.id, reward.reward_cents,
-                )
-        except Exception as e:  # noqa: BLE001 best-effort,发奖失败不阻塞上报
-            logger.warning("invite compare reward failed invitee=%s: %s", user.id, e)
     logger.info(
         "compare record user=%s trace=%s biz=%s status=%s saved=%s (llm_calls backfill queued)",
         user.id,

app/api/v1/coupon.py

@@ -20,7 +20,6 @@ from fastapi.concurrency import run_in_threadpool
 
 from app.api.deps import CurrentUser, DbSession
 from app.core.config import settings
-from app.core.pricebot_client import get_pricebot_client
 from app.core.pricebot_router import pick_pricebot
 from app.db.session import SessionLocal
 from app.repositories import coupon_state as coupon_repo
@@ -142,10 +141,10 @@ async def coupon_step(
     )
 
     try:
-        client = get_pricebot_client()
-        resp = await client.post(
-            url, content=raw, headers={"Content-Type": "application/json"}, timeout=timeout
-        )
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            resp = await client.post(
+                url, content=raw, headers={"Content-Type": "application/json"}
+            )
     except httpx.RequestError as e:
         logger.error("[pricebot] request failed: %s", e)
         raise HTTPException(

app/api/v1/device.py

@@ -1,22 +1,19 @@
 """设备注册 / 心跳 endpoint(无障碍保护存活检测)。
 
 路由前缀 /api/v1/device,需 Bearer 鉴权(设备绑登录用户)。
-  POST /register   注册设备 / 更新厂商 push token(App 前台、拿到 push token 时调)
+  POST /register   注册设备 / 更新 registration_id(App 前台、拿到 push token 时调)
   POST /heartbeat  上报心跳(无障碍服务存活时周期调,刷新存活)
-  POST /push-test  开发验收:延迟发送厂商通道测试推送
 
-后端 heartbeat_monitor_worker 据此发现心跳超时的设备并厂商直推告警。
+后端 heartbeat_monitor_worker 据此发现心跳超时的设备并极光推送告警。
 见 spec: spec/accessibility-liveness-push.md。
 """
 from __future__ import annotations
 
 import logging
-import time
 
-from fastapi import APIRouter, BackgroundTasks, HTTPException, status
+from fastapi import APIRouter
 
 from app.api.deps import CurrentUser, DbSession
-from app.integrations import vendor_push
 from app.repositories import device as device_repo
 from app.schemas.device import (
     DeviceOut,
@@ -25,8 +22,6 @@ from app.schemas.device import (
     LivenessAckRequest,
     LivenessOut,
     OkResponse,
-    PushTestOut,
-    PushTestRequest,
 )
 
 logger = logging.getLogger("shagua.device")
@@ -34,37 +29,6 @@ logger = logging.getLogger("shagua.device")
 router = APIRouter(prefix="/api/v1/device", tags=["device"])
 
 
-def _send_push_test_after_delay(
-    push_vendor: str,
-    push_token: str,
-    delay_seconds: int,
-    user_id: int,
-    device_id: str,
-) -> None:
-    if delay_seconds > 0:
-        time.sleep(delay_seconds)
-    try:
-        vendor_push.send_accessibility_disabled(
-            push_vendor,
-            push_token,
-            title="测试推送",
-            alert="这是一条厂商通道测试推送。收到它说明 App 被划掉后仍可通过系统通知栏触达。",
-        )
-        logger.info(
-            "push test sent user_id=%d device_id=%s delay=%ds",
-            user_id,
-            device_id,
-            delay_seconds,
-        )
-    except vendor_push.VendorPushError as e:
-        logger.warning(
-            "push test failed user_id=%d device_id=%s error=%s",
-            user_id,
-            device_id,
-            e,
-        )
-
-
 @router.post("/register", response_model=DeviceOut, summary="注册设备/更新推送token")
 def register_device(
     req: DeviceRegisterRequest,
@@ -76,17 +40,13 @@ def register_device(
         user_id=user.id,
         device_id=req.device_id,
         registration_id=req.registration_id,
-        push_vendor=req.push_vendor,
-        push_token=req.push_token,
         platform=req.platform,
         app_version=req.app_version,
     )
     logger.info(
-        "device register user_id=%d device_id=%s vendor=%s token=%s legacy_reg=%s",
+        "device register user_id=%d device_id=%s reg=%s",
         user.id,
         req.device_id,
-        req.push_vendor,
-        bool(req.push_token),
         bool(req.registration_id),
     )
     return DeviceOut.model_validate(device)
@@ -104,59 +64,10 @@ def report_heartbeat(
         device_id=req.device_id,
         accessibility_enabled=req.accessibility_enabled,
         registration_id=req.registration_id,
-        push_vendor=req.push_vendor,
-        push_token=req.push_token,
     )
     return OkResponse()
 
 
-@router.post("/push-test", response_model=PushTestOut, summary="延迟发送厂商通道测试推送")
-def request_push_test(
-    req: PushTestRequest,
-    background_tasks: BackgroundTasks,
-    user: CurrentUser,
-    db: DbSession,
-) -> PushTestOut:
-    """开发验收用:App 内点一次,服务端延迟发厂商直推,验证离线通道。"""
-    push_vendor = req.push_vendor.strip() if req.push_vendor else None
-    push_token = req.push_token.strip() if req.push_token else None
-    if push_vendor and push_token:
-        device_repo.register_or_update(
-            db,
-            user_id=user.id,
-            device_id=req.device_id,
-            registration_id=req.registration_id,
-            push_vendor=push_vendor,
-            push_token=push_token,
-        )
-    else:
-        device = device_repo.get_device(db, user_id=user.id, device_id=req.device_id)
-        push_vendor = device.push_vendor if device is not None else None
-        push_token = device.push_token if device is not None else None
-
-    if not push_vendor or not push_token:
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="push vendor token not ready",
-        )
-
-    background_tasks.add_task(
-        _send_push_test_after_delay,
-        push_vendor,
-        push_token,
-        req.delay_seconds,
-        user.id,
-        req.device_id,
-    )
-    logger.info(
-        "push test scheduled user_id=%d device_id=%s delay=%ds",
-        user.id,
-        req.device_id,
-        req.delay_seconds,
-    )
-    return PushTestOut(delay_seconds=req.delay_seconds, has_push_token=True)
-
-
 @router.get("/liveness", response_model=LivenessOut, summary="查询本机掉线告警(后置检测)")
 def get_liveness(
     device_id: str,

app/api/v1/invite.py

@@ -38,7 +38,7 @@ logger = logging.getLogger("shagua.invite")
 router = APIRouter(prefix="/api/v1/invite", tags=["invite"])
 
 _BIND_MESSAGES = {
-    "success": "邀请绑定成功",
+    "success": "邀请绑定成功,金币已到账",
     "already_bound": "你已绑定过邀请人",
     "invalid_code": "邀请码无效",
     "self_invite": "不能填写自己的邀请码",
@@ -84,8 +84,6 @@ def _parse_device_model(ua: str) -> str:
 def my_invite(user: CurrentUser, db: DbSession) -> InviteInfoOut:
     code = invite_repo.ensure_code(db, user)
     invited, coins = invite_repo.get_stats(db, user.id)
-    reward_balance, reward_withdrawn = invite_repo.get_reward_stats(db, user.id)
-    days_left, is_fresh_round, countdown_text = invite_repo.compute_invite_countdown(user.created_at)
     sep = "&" if "?" in settings.INVITE_LANDING_URL else "?"
     share_url = f"{settings.INVITE_LANDING_URL}{sep}ref={code}"
     return InviteInfoOut(
@@ -93,11 +91,6 @@ def my_invite(user: CurrentUser, db: DbSession) -> InviteInfoOut:
         share_url=share_url,
         invited_count=invited,
         coins_earned=coins,
-        reward_balance_cents=reward_balance,
-        reward_withdrawn_cents=reward_withdrawn,
-        countdown_days_left=days_left,
-        countdown_is_fresh_round=is_fresh_round,
-        countdown_text=countdown_text,
     )
 
 
@@ -161,7 +154,7 @@ def landing_track(
     return LandingTrackOut(status="ok")
 
 
-@router.post("/bind", response_model=BindInviteOut, summary="绑定邀请人(注册即生效,绑定不发奖)")
+@router.post("/bind", response_model=BindInviteOut, summary="绑定邀请人(注册即生效,双方发金币)")
 def bind_invite(
     req: BindInviteIn, user: CurrentUser, db: DbSession, request: Request
 ) -> BindInviteOut:

app/api/v1/wallet.py

@@ -200,8 +200,7 @@ def withdraw(req: WithdrawRequest, user: CurrentUser, db: DbSession) -> Withdraw
         raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="wechat pay not configured")
     try:
         order = crud_wallet.create_withdraw(
-            db, user.id, req.amount_cents, source=req.source,
-            user_name=req.user_name, out_bill_no=req.out_bill_no,
+            db, user.id, req.amount_cents, user_name=req.user_name, out_bill_no=req.out_bill_no
         )
     except crud_wallet.InvalidWithdrawAmountError as e:
         raise HTTPException(
@@ -275,11 +274,10 @@ def withdraw_status(
 def withdraw_orders(
     user: CurrentUser,
     db: DbSession,
-    source: str | None = Query(None, description="按账户来源过滤:coin_cash / invite_cash;不传=全部"),
     limit: int = Query(20, ge=1, le=100),
     cursor: int | None = Query(None, description="上一页末条 id"),
 ) -> WithdrawOrderPage:
-    items, next_cursor = crud_wallet.list_withdraw_orders(db, user.id, source=source, limit=limit, cursor=cursor)
+    items, next_cursor = crud_wallet.list_withdraw_orders(db, user.id, limit=limit, cursor=cursor)
     return WithdrawOrderPage(
         items=[WithdrawOrderOut.model_validate(it) for it in items],
         next_cursor=next_cursor,

app/core/config.py

@@ -9,7 +9,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Literal
 
-from pydantic import model_validator
+from pydantic import Field, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 _PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
@@ -59,51 +59,14 @@ class Settings(BaseSettings):
             return []
         return [ip.strip() for ip in self.ADMIN_IP_ALLOWLIST.split(",") if ip.strip()]
 
-    # ===== 极光一键登录 / 短信 =====
+    # ===== 极光 =====
     JG_APP_KEY: str = ""
     JG_MASTER_SECRET: str = ""
     JG_PRIVATE_KEY_PATH: str = "./secrets/jverify_rsa_private.pem"
     JG_VERIFY_ENDPOINT: str = "https://api.verification.jpush.cn/v1/web/loginTokenVerify"
     JG_REQUEST_TIMEOUT_SEC: int = 15
 
-    # ===== 厂商直推(无障碍保护存活告警)=====
-    ANDROID_PACKAGE_NAME: str = "com.jishisongfu.shaguabijia"
-    PUSH_REQUEST_TIMEOUT_SEC: int = 15
-    PUSH_TIME_TO_LIVE_SEC: int = 86400
-
-    HONOR_PUSH_APP_ID: str = ""
-    HONOR_PUSH_CLIENT_ID: str = ""
-    HONOR_PUSH_CLIENT_SECRET: str = ""
-    HONOR_PUSH_TOKEN_ENDPOINT: str = "https://iam.developer.honor.com/auth/token"
-    HONOR_PUSH_SEND_ENDPOINT_TEMPLATE: str = (
-        "https://push-api.cloud.honor.com/api/v1/{app_id}/sendMessage"
-    )
-
-    VIVO_PUSH_APP_ID: str = ""
-    VIVO_PUSH_APP_KEY: str = ""
-    VIVO_PUSH_APP_SECRET: str = ""
-    VIVO_PUSH_AUTH_ENDPOINT: str = "https://api-push.vivo.com.cn/message/auth"
-    VIVO_PUSH_SEND_ENDPOINT: str = "https://api-push.vivo.com.cn/message/send"
-    VIVO_PUSH_MODE: int = 1                  # 0=正式推送,1=测试推送(未上架 vivo 时用)
-    VIVO_PUSH_NOTIFY_TYPE: int = 4           # 1=无,2=响铃,3=振动,4=响铃+振动
-    VIVO_PUSH_CATEGORY: str = "DEVICE_REMINDER"
-
-    XIAOMI_PUSH_APP_SECRET: str = ""
-    XIAOMI_PUSH_SEND_ENDPOINT: str = "https://api.xmpush.xiaomi.com/v3/message/regid"
-    XIAOMI_PUSH_CHANNEL_ID: str = ""
-    XIAOMI_PUSH_TEMPLATE_ID: str = ""
-    XIAOMI_PUSH_TEMPLATE_TITLE: str = ""
-    XIAOMI_PUSH_TEMPLATE_DESCRIPTION: str = ""
-    XIAOMI_PUSH_TEMPLATE_PARAM_JSON: str = ""
-
-    OPPO_PUSH_APP_KEY: str = ""
-    OPPO_PUSH_MASTER_SECRET: str = ""
-    OPPO_PUSH_AUTH_ENDPOINT: str = "https://api.push.oppomobile.com/server/v1/auth"
-    OPPO_PUSH_SEND_ENDPOINT: str = (
-        "https://api.push.oppomobile.com/server/v1/message/notification/unicast"
-    )
-
-    # 无障碍保护存活监控后台任务(推送 + pull 后置兜底)
+    # 无障碍保护存活监控后台任务(pull 后置检测;本期不接推送)
     HEARTBEAT_MONITOR_ENABLED: bool = True       # 总开关
     HEARTBEAT_TIMEOUT_MINUTES: int = 10          # 多久没心跳算掉线(≈3 个客户端心跳周期)
     HEARTBEAT_SCAN_INTERVAL_SEC: int = 60        # 扫描周期
@@ -150,21 +113,6 @@ class Settings(BaseSettings):
         """美团 CPS 凭证齐全(缺则接口返空,而非 502)。"""
         return bool(self.MT_CPS_APP_KEY and self.MT_CPS_APP_SECRET)
 
-    # ===== 京东联盟 CPS =====
-    # app_key/app_secret 来自京东联盟应用;site_id 是推广管理里的 APP/网站 ID;
-    # auth_key 是工具商授权 key,自有应用查询可留空。
-    JD_UNION_APP_KEY: str = ""
-    JD_UNION_APP_SECRET: str = ""
-    JD_UNION_SITE_ID: str = ""
-    JD_UNION_AUTH_KEY: str = ""
-    JD_UNION_GATEWAY: str = "https://api.jd.com/routerjson"
-    JD_UNION_TIMEOUT_SEC: int = 15
-
-    @property
-    def jd_union_configured(self) -> bool:
-        """京东联盟订单查询凭证齐全。"""
-        return bool(self.JD_UNION_APP_KEY and self.JD_UNION_APP_SECRET)
-
     # ===== 微信服务号(网页授权) =====
     # CPS 落地页在微信内拿用户 openid(base 静默)/昵称头像(userinfo),做用户级群统计。
     # ⚠️ 区别于 WECHAT_APP_ID(那是 App 移动应用,用于微信支付);这是【已认证服务号】。
@@ -324,7 +272,7 @@ class Settings(BaseSettings):
         return self.APP_ENV == "prod"
 
     @model_validator(mode="after")
-    def _enforce_prod_secrets(self) -> Settings:
+    def _enforce_prod_secrets(self) -> "Settings":
         """prod 下强校验 JWT secret,弱/默认/空即启动报错(fail-fast,挡住 token 被伪造)。
 
         只校验两个签发凭证:App 用户的 JWT_SECRET_KEY、后台的 ADMIN_JWT_SECRET——它们沿用默认值

app/core/heartbeat_monitor_worker.py

@@ -1,7 +1,7 @@
 """无障碍保护存活监控后台任务。
 
 周期扫描「曾经保护过、当前 alive、心跳超时」的设备 = App 被彻底杀掉/无障碍已停(心跳断了),
-**命中即在服务器终端打印告警并尝试厂商直推**;并把状态机
+**命中即在服务器终端打印告警**(本期先不接推送,工程量大,用终端打印代替真实通知);并把状态机
 推进到 notified 防每轮重复打印(心跳恢复时由 repositories.device.touch_heartbeat 重置回 alive)。
 结构仿 withdraw_reconcile_worker(单实例锁 + asyncio 轮询 + 优雅退出)。
 
@@ -22,7 +22,6 @@ from sqlalchemy.exc import SQLAlchemyError
 
 from app.core.config import settings
 from app.db.session import SessionLocal
-from app.integrations import vendor_push
 from app.repositories import device as device_repo
 
 logger = logging.getLogger("shagua.heartbeat_monitor")
@@ -72,66 +71,32 @@ def _silent_seconds(last: datetime | None) -> int | None:
     """距上次心跳的秒数(兼容 sqlite 取回的 naive datetime)。"""
     if last is None:
         return None
-    ref = datetime.now(timezone.utc) if last.tzinfo is not None else datetime.utcnow()  # noqa: UP017
+    ref = datetime.now(timezone.utc) if last.tzinfo is not None else datetime.utcnow()
     return int((ref - last).total_seconds())
 
 
 def _scan_once(timeout_minutes: int) -> dict:
-    """扫描一轮:找出心跳超时(App 被彻底杀掉/无障碍已停)的设备并召回。
+    """扫描一轮:找出心跳超时(App 被彻底杀掉/无障碍已停)的设备,在**服务器终端打印**告警代替真实推送。
 
-    有 push_vendor + push_token 时先发厂商直推,无 token 或推送失败时仍置
-    kill_alert_pending,客户端下次进 App 继续走后置提醒兜底。
+    本期不接推送(极光/厂商通道工程量大),只做服务端掉线检测:命中即 logger.warning 打印到终端,
+    并把状态机推进到 notified 防每轮重复打印(心跳恢复时 touch_heartbeat 会重置回 alive)。
     """
     notified = 0
-    pushed = 0
-    push_failed = 0
     with SessionLocal() as db:
         overdue = device_repo.list_overdue(db, timeout_minutes=timeout_minutes)
         for device in overdue:
             silent = _silent_seconds(device.last_heartbeat_at)
             logger.warning(
                 "[掉线检测] user_id=%s device_id=%s 已 %s 秒无心跳(阈值 %d 分钟)"
-                " → 判定 App 已被杀/无障碍已停。",
+                " → 判定 App 已被杀/无障碍已停。【已置 kill_alert_pending: 用户下次进 App 将弹「开启自启动」引导(后置检测);推送本期未接】",
                 device.user_id,
                 device.device_id,
                 silent if silent is not None else "?",
                 timeout_minutes,
             )
-            if device.push_vendor and device.push_token:
-                try:
-                    vendor_push.send_accessibility_disabled(
-                        device.push_vendor,
-                        device.push_token,
-                    )
-                    pushed += 1
-                    logger.info(
-                        "[掉线检测] push sent user_id=%s device_id=%s vendor=%s",
-                        device.user_id,
-                        device.device_id,
-                        device.push_vendor,
-                    )
-                except vendor_push.VendorPushError as e:
-                    push_failed += 1
-                    logger.warning(
-                        "[掉线检测] push failed user_id=%s device_id=%s error=%s",
-                        device.user_id,
-                        device.device_id,
-                        e,
-                    )
-            else:
-                logger.info(
-                    "[掉线检测] device has no push vendor/token, skip push user_id=%s device_id=%s",
-                    device.user_id,
-                    device.device_id,
-                )
             device_repo.mark_notified(db, device_id_pk=device.id)
             notified += 1
-        return {
-            "checked": len(overdue),
-            "notified": notified,
-            "pushed": pushed,
-            "push_failed": push_failed,
-        }
+        return {"checked": len(overdue), "notified": notified}
 
 
 async def _run_loop() -> None:

app/core/pricebot_client.py

@@ -1,35 +0,0 @@
-"""透传到 pricebot 的共享 httpx.AsyncClient 单例。
-
-为什么不能每请求新建(coupon.py / compare.py 老写法 async with httpx.AsyncClient(...)):
-  ① 每次构造都重建一套 SSL 上下文(httpx.create_ssl_context 加载 certifi CA),实测
-     ~1s+/次;而 pricebot 是纯 http 透传,根本用不到 TLS → 纯浪费,且每帧重交一次。
-  ② trust_env 默认 True 会读进程 HTTP_PROXY,把 http://localhost:8000 这条本地透传整个
-     塞进本机代理(如 Clash 7897),恒定再多几秒。
-单例:启动只建一次(SSL/连接池一次性),keep-alive 复用 TCP,每帧降到个位数 ms。
-trust_env=False:对齐 integrations/meituan.py 的既有约定,不被进程代理误导,直连 pricebot。
-"""
-from __future__ import annotations
-
-import httpx
-
-_client: httpx.AsyncClient | None = None
-
-
-def get_pricebot_client() -> httpx.AsyncClient:
-    """取透传单例。lifespan 启动会预热;未预热(如测试态)懒建兜底。
-
-    超时不在此固化(coupon 30s / compare 60s 不同),由调用点 client.post(timeout=...) 传。
-    懒建无 await,asyncio 单线程下不会有并发竞态。
-    """
-    global _client
-    if _client is None:
-        _client = httpx.AsyncClient(trust_env=False)
-    return _client
-
-
-async def aclose_pricebot_client() -> None:
-    """lifespan 关停时调,优雅关连接池。"""
-    global _client
-    if _client is not None:
-        await _client.aclose()
-        _client = None

app/core/rewards.py

@@ -113,9 +113,10 @@ PRICE_REPORT_REWARD_COINS: int = 1000
 FEEDBACK_REWARD_MAX_COINS: int = 10000
 
 
-# ===== 邀请好友(绑定即生效,绑定只建归因关系、双方都不发钱)=====
-# v3(冰 2026-06-26):废除 v1 的"绑定双方各发金币"——被邀请人无奖励、邀请人改比价后发现金
-# (见下方 INVITE_COMPARE_REWARD_CENTS)。原 INVITE_INVITER_COINS / INVITE_INVITEE_COINS 已删。
+# ===== 邀请好友(注册即生效,邀请人 + 被邀请人各发金币)=====
+# 10000 金币 = 1 元,双方各得 1 元。MVP 先用固定常量(不走 app_config)。
+INVITE_INVITER_COINS: int = 10000
+INVITE_INVITEE_COINS: int = 10000
 # "新用户闸":被邀请人必须在注册后此窗口内绑定才发奖(挡存量老用户互相填码薅羊毛)。
 # 自动绑(剪贴板)在首次注册登录后几秒内发生;留 72h 给手动填码兜底。
 INVITE_NEW_USER_WINDOW_HOURS: int = 72
@@ -126,13 +127,6 @@ INVITE_NEW_USER_WINDOW_HOURS: int = 72
 INVITE_FP_WINDOW_DAYS: int = 7
 
 
-# ===== 邀请好友 v2(好友"下载+登录+比价一次"→ 给邀请人发邀请奖励金·现金)=====
-# v2 新规则:不再注册即发金币,改"好友完成首次成功比价"才给【邀请人】发奖,发的是【现金·分】
-# 进独立的邀请奖励金账户(coin_account.invite_cash_balance_cents),与金币体系物理隔离。
-# 200 分 = 2 元。⚠️ 金额待产品定准:邀请主页=2元 / 福利入口=3.5元 不一致,定后改此处。
-INVITE_COMPARE_REWARD_CENTS: int = 200
-
-
 # ===== 看激励视频 / 信息流广告发金币 =====
 # eCPM 取自穿山甲 SDK getShowEcpm().getEcpm(),官方口径单位是【分/千次展示】(不是元!
 # csjplatform 文档原文"通过 getEcpm 获取的单位是分")。计算时先 ÷100 转成元;

app/integrations/jd_union.py

@@ -1,163 +0,0 @@
-"""京东联盟 OpenAPI 客户端。
-
-当前只接数据大盘需要的订单明细接口:
-`jd.union.open.order.row.query`。京东要求订单查询时间窗最长 1 小时,
-调用方负责切窗分页。
-"""
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-import httpx
-
-from app.core.config import settings
-
-logger = logging.getLogger(__name__)
-
-_BEIJING = timezone(timedelta(hours=8))
-
-
-class JdUnionError(RuntimeError):
-    """京东联盟 API 调用失败。"""
-
-
-def _parse_json_maybe(value: Any) -> Any:
-    if not isinstance(value, str):
-        return value
-    text = value.strip()
-    if not text:
-        return value
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        return value
-
-
-def _sign(params: dict[str, Any], secret: str) -> str:
-    pieces = [secret]
-    for key in sorted(k for k in params if k != "sign"):
-        value = params[key]
-        if value is None:
-            continue
-        pieces.append(f"{key}{value}")
-    pieces.append(secret)
-    raw = "".join(pieces)
-    return hashlib.md5(raw.encode("utf-8")).hexdigest().upper()
-
-
-def _unwrap_response(data: dict[str, Any]) -> dict[str, Any]:
-    if "error_response" in data:
-        err = data["error_response"] or {}
-        msg = err.get("zh_desc") or err.get("en_desc") or err.get("msg") or err
-        raise JdUnionError(f"京东 API 错误: {msg}")
-
-    body: Any = data
-    for key, value in data.items():
-        if key.endswith("_responce") or key.endswith("_response"):
-            body = value
-            break
-
-    body = _parse_json_maybe(body)
-    if not isinstance(body, dict):
-        raise JdUnionError("京东 API 返回格式异常")
-
-    result = body.get("queryResult", body.get("result", body))
-    result = _parse_json_maybe(result)
-    if not isinstance(result, dict):
-        raise JdUnionError("京东 API 业务结果格式异常")
-
-    code = str(result.get("code", result.get("resultCode", "200")))
-    if code not in {"0", "200"}:
-        msg = result.get("message") or result.get("msg") or result.get("resultMsg") or result
-        raise JdUnionError(f"京东 API 业务错误: {msg}")
-    return result
-
-
-def call(method: str, payload: dict[str, Any], *, version: str = "1.0") -> dict[str, Any]:
-    if not settings.jd_union_configured:
-        raise JdUnionError("京东联盟凭证未配置")
-
-    biz_json = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
-    params: dict[str, Any] = {
-        "method": method,
-        "app_key": settings.JD_UNION_APP_KEY,
-        "timestamp": datetime.now(_BEIJING).strftime("%Y-%m-%d %H:%M:%S"),
-        "format": "json",
-        "v": version,
-        "sign_method": "md5",
-        "360buy_param_json": biz_json,
-    }
-    params["sign"] = _sign(params, settings.JD_UNION_APP_SECRET)
-
-    try:
-        with httpx.Client(timeout=settings.JD_UNION_TIMEOUT_SEC, trust_env=False) as client:
-            resp = client.post(settings.JD_UNION_GATEWAY, data=params)
-            resp.raise_for_status()
-            data = resp.json()
-    except httpx.HTTPError as e:
-        raise JdUnionError(f"京东 API 网络错误: {e}") from e
-    except json.JSONDecodeError as e:
-        raise JdUnionError("京东 API 返回非 JSON") from e
-
-    return _unwrap_response(data)
-
-
-def _extract_rows(result: dict[str, Any]) -> tuple[list[dict[str, Any]], bool]:
-    payload = _parse_json_maybe(result.get("data", result.get("result", result)))
-    has_more = bool(result.get("hasMore") or result.get("has_more"))
-
-    if isinstance(payload, dict):
-        for key in ("orderRowResp", "orderRows", "orderList", "orders", "list", "rows"):
-            rows = _parse_json_maybe(payload.get(key))
-            if isinstance(rows, list):
-                return [r for r in rows if isinstance(r, dict)], bool(
-                    payload.get("hasMore") or payload.get("has_more") or has_more
-                )
-        return [], bool(payload.get("hasMore") or payload.get("has_more") or has_more)
-    if isinstance(payload, list):
-        return [r for r in payload if isinstance(r, dict)], has_more
-    return [], has_more
-
-
-def query_order_rows(
-    *,
-    start_time: datetime,
-    end_time: datetime,
-    query_time_type: int = 3,
-    page_index: int = 1,
-    page_size: int = 200,
-) -> dict[str, Any]:
-    """查询京东 CPS 订单行。
-
-    query_time_type: 1 下单时间, 2 完成时间, 3 更新时间。
-    start_time/end_time 用北京时间展示给京东;调用方需保证窗口不超过 1 小时。
-    """
-    start_bj = start_time.astimezone(_BEIJING)
-    end_bj = end_time.astimezone(_BEIJING)
-    if end_bj <= start_bj:
-        return {"rows": [], "has_more": False}
-    if end_bj - start_bj > timedelta(hours=1):
-        raise JdUnionError("京东订单查询单次时间窗不能超过 1 小时")
-
-    order_req: dict[str, Any] = {
-        "pageIndex": page_index,
-        "pageSize": min(max(page_size, 1), 200),
-        "type": query_time_type,
-        "startTime": start_bj.strftime("%Y-%m-%d %H:%M:%S"),
-        "endTime": end_bj.strftime("%Y-%m-%d %H:%M:%S"),
-    }
-    if settings.JD_UNION_AUTH_KEY:
-        order_req["key"] = settings.JD_UNION_AUTH_KEY
-    result = call("jd.union.open.order.row.query", {"orderReq": order_req})
-    rows, has_more = _extract_rows(result)
-    logger.info(
-        "jd.union.open.order.row.query fetched rows=%s page=%s has_more=%s",
-        len(rows),
-        page_index,
-        has_more,
-    )
-    return {"rows": rows, "has_more": has_more, "raw": result}

app/integrations/vendor_push.py

@@ -1,380 +0,0 @@
-"""厂商直推集成。
-
-服务端不再经由 JPush Push API 发送无障碍召回通知,而是按客户端上报的
-push_vendor + push_token 分发到各手机厂商的服务端 API。
-"""
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import time
-import uuid
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any
-
-import httpx
-
-from app.core.config import settings
-
-logger = logging.getLogger("shagua.vendor_push")
-
-TYPE_ACCESSIBILITY_DISABLED = "accessibility_disabled"
-SUPPORTED_VENDORS = frozenset({"honor", "vivo", "xiaomi", "oppo"})
-
-
-class VendorPushError(Exception):
-    """厂商推送调用失败。"""
-
-
-@dataclass
-class _CachedToken:
-    value: str
-    expires_at: float
-
-
-_token_cache: dict[str, _CachedToken] = {}
-
-
-def normalize_vendor(push_vendor: str | None) -> str | None:
-    if not push_vendor:
-        return None
-    vendor = push_vendor.strip().lower()
-    aliases = {
-        "hihonor": "honor",
-        "荣耀": "honor",
-        "mi": "xiaomi",
-        "小米": "xiaomi",
-        "oneplus": "oppo",
-        "realme": "oppo",
-    }
-    return aliases.get(vendor, vendor)
-
-
-def send_accessibility_disabled(
-    push_vendor: str,
-    push_token: str,
-    *,
-    title: str = "保护已关闭",
-    alert: str = "傻瓜比价的无障碍保护被关了，点此重新开启，继续帮你自动比价省钱。",
-) -> dict[str, Any]:
-    """按厂商 token 向单台设备发送无障碍掉线通知。"""
-    vendor = normalize_vendor(push_vendor)
-    token = push_token.strip() if push_token else ""
-    if not vendor or vendor not in SUPPORTED_VENDORS:
-        raise VendorPushError(f"unsupported push vendor: {push_vendor}")
-    if not token:
-        raise VendorPushError("push token is empty")
-
-    dispatch: dict[str, Callable[[str, str, str], dict[str, Any]]] = {
-        "honor": _send_honor,
-        "vivo": _send_vivo,
-        "xiaomi": _send_xiaomi,
-        "oppo": _send_oppo,
-    }
-    return dispatch[vendor](token, title, alert)
-
-
-def _extras() -> dict[str, str]:
-    return {"type": TYPE_ACCESSIBILITY_DISABLED}
-
-
-def _require(value: str, name: str) -> str:
-    if not value:
-        raise VendorPushError(f"{name} not configured")
-    return value
-
-
-def _request_json(
-    method: str,
-    url: str,
-    *,
-    expected_status: tuple[int, ...] = (200,),
-    **kwargs: Any,
-) -> dict[str, Any]:
-    try:
-        resp = httpx.request(
-            method,
-            url,
-            timeout=settings.PUSH_REQUEST_TIMEOUT_SEC,
-            **kwargs,
-        )
-    except httpx.HTTPError as e:
-        raise VendorPushError(f"push http error: {e}") from e
-
-    if resp.status_code not in expected_status:
-        logger.error("vendor push http failed url=%s http=%s body=%s", url, resp.status_code, resp.text[:500])
-        raise VendorPushError(f"push http {resp.status_code}")
-    try:
-        return resp.json()
-    except ValueError as e:
-        raise VendorPushError(f"push invalid json: {resp.text[:200]}") from e
-
-
-def _request_form(
-    method: str,
-    url: str,
-    *,
-    expected_status: tuple[int, ...] = (200,),
-    **kwargs: Any,
-) -> dict[str, Any]:
-    try:
-        resp = httpx.request(
-            method,
-            url,
-            timeout=settings.PUSH_REQUEST_TIMEOUT_SEC,
-            **kwargs,
-        )
-    except httpx.HTTPError as e:
-        raise VendorPushError(f"push http error: {e}") from e
-
-    if resp.status_code not in expected_status:
-        logger.error("vendor push http failed url=%s http=%s body=%s", url, resp.status_code, resp.text[:500])
-        raise VendorPushError(f"push http {resp.status_code}")
-    try:
-        return resp.json()
-    except ValueError as e:
-        raise VendorPushError(f"push invalid json: {resp.text[:200]}") from e
-
-
-def _cache_get(key: str) -> str | None:
-    cached = _token_cache.get(key)
-    if cached and cached.expires_at > time.time() + 60:
-        return cached.value
-    return None
-
-
-def _cache_put(key: str, value: str, expires_in: int | float | None) -> str:
-    ttl = int(expires_in or 3600)
-    _token_cache[key] = _CachedToken(value=value, expires_at=time.time() + max(60, ttl - 60))
-    return value
-
-
-def _honor_access_token() -> str:
-    cache_key = "honor"
-    cached = _cache_get(cache_key)
-    if cached:
-        return cached
-    client_id = _require(settings.HONOR_PUSH_CLIENT_ID, "HONOR_PUSH_CLIENT_ID")
-    client_secret = _require(settings.HONOR_PUSH_CLIENT_SECRET, "HONOR_PUSH_CLIENT_SECRET")
-    data = _request_form(
-        "POST",
-        settings.HONOR_PUSH_TOKEN_ENDPOINT,
-        data={
-            "grant_type": "client_credentials",
-            "client_id": client_id,
-            "client_secret": client_secret,
-        },
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-    )
-    token = data.get("access_token")
-    if not token:
-        raise VendorPushError(f"honor auth failed: {data}")
-    return _cache_put(cache_key, str(token), data.get("expires_in"))
-
-
-def _send_honor(token: str, title: str, alert: str) -> dict[str, Any]:
-    app_id = _require(settings.HONOR_PUSH_APP_ID, "HONOR_PUSH_APP_ID")
-    access_token = _honor_access_token()
-    payload = {
-        "data": json.dumps(_extras(), ensure_ascii=False),
-        "notification": {"title": title, "body": alert},
-        "android": {
-            "ttl": f"{settings.PUSH_TIME_TO_LIVE_SEC}s",
-            "targetUserType": 1,
-            "notification": {
-                "title": title,
-                "body": alert,
-                "clickAction": {"type": 3},
-                "importance": "NORMAL",
-            },
-        },
-        "token": [token],
-    }
-    data = _request_json(
-        "POST",
-        settings.HONOR_PUSH_SEND_ENDPOINT_TEMPLATE.format(app_id=app_id),
-        json=payload,
-        headers={
-            "Content-Type": "application/json; charset=UTF-8",
-            "Authorization": f"Bearer {access_token}",
-            "timestamp": str(int(time.time() * 1000)),
-        },
-    )
-    code = data.get("code")
-    if code is not None and int(code) != 200:
-        raise VendorPushError(f"honor push failed: {data}")
-    return data
-
-
-def _vivo_auth_token() -> str:
-    cache_key = "vivo"
-    cached = _cache_get(cache_key)
-    if cached:
-        return cached
-    app_id = _require(settings.VIVO_PUSH_APP_ID, "VIVO_PUSH_APP_ID")
-    app_key = _require(settings.VIVO_PUSH_APP_KEY, "VIVO_PUSH_APP_KEY")
-    app_secret = _require(settings.VIVO_PUSH_APP_SECRET, "VIVO_PUSH_APP_SECRET")
-    timestamp = str(int(time.time() * 1000))
-    sign = hashlib.md5(f"{app_id}{app_key}{timestamp}{app_secret}".encode()).hexdigest()  # noqa: S324
-    data = _request_json(
-        "POST",
-        settings.VIVO_PUSH_AUTH_ENDPOINT,
-        json={
-            "appId": app_id,
-            "appKey": app_key,
-            "timestamp": timestamp,
-            "sign": sign,
-        },
-        headers={"Content-Type": "application/json"},
-    )
-    if int(data.get("result", -1)) != 0:
-        raise VendorPushError(f"vivo auth failed: {data}")
-    token = data.get("authToken")
-    if not token:
-        raise VendorPushError(f"vivo auth missing authToken: {data}")
-    return _cache_put(cache_key, str(token), 24 * 3600)
-
-
-def _send_vivo(token: str, title: str, alert: str) -> dict[str, Any]:
-    app_id = _require(settings.VIVO_PUSH_APP_ID, "VIVO_PUSH_APP_ID")
-    auth_token = _vivo_auth_token()
-    body: dict[str, Any] = {
-        "appId": app_id,
-        "regId": token,
-        "notifyType": settings.VIVO_PUSH_NOTIFY_TYPE,
-        "title": title,
-        "content": alert,
-        "timeToLive": settings.PUSH_TIME_TO_LIVE_SEC,
-        "skipType": 1,
-        "requestId": uuid.uuid4().hex,
-        "pushMode": settings.VIVO_PUSH_MODE,
-        "clientCustomMap": _extras(),
-    }
-    if settings.VIVO_PUSH_CATEGORY:
-        body["category"] = settings.VIVO_PUSH_CATEGORY
-    data = _request_json(
-        "POST",
-        settings.VIVO_PUSH_SEND_ENDPOINT,
-        json=body,
-        headers={
-            "Content-Type": "application/json",
-            "authToken": auth_token,
-        },
-    )
-    if int(data.get("result", -1)) != 0:
-        raise VendorPushError(f"vivo push failed: {data}")
-    return data
-
-
-def _send_xiaomi(token: str, title: str, alert: str) -> dict[str, Any]:
-    app_secret = _require(settings.XIAOMI_PUSH_APP_SECRET, "XIAOMI_PUSH_APP_SECRET")
-    message_title = settings.XIAOMI_PUSH_TEMPLATE_TITLE.strip() or title
-    message_description = settings.XIAOMI_PUSH_TEMPLATE_DESCRIPTION.strip() or alert
-    body = {
-        "registration_id": token,
-        "restricted_package_name": settings.ANDROID_PACKAGE_NAME,
-        "title": message_title,
-        "description": message_description,
-        "payload": json.dumps(_extras(), ensure_ascii=False),
-        "pass_through": "0",
-        "notify_type": "-1",
-        "time_to_live": str(settings.PUSH_TIME_TO_LIVE_SEC * 1000),
-        "extra.notify_effect": "1",
-    }
-    if settings.XIAOMI_PUSH_CHANNEL_ID:
-        body["extra.channel_id"] = settings.XIAOMI_PUSH_CHANNEL_ID.strip()
-    if settings.XIAOMI_PUSH_TEMPLATE_ID:
-        body["extra.template_id"] = settings.XIAOMI_PUSH_TEMPLATE_ID.strip()
-    if settings.XIAOMI_PUSH_TEMPLATE_PARAM_JSON:
-        body["extra.template_param"] = _xiaomi_template_param(title, alert)
-    data = _request_form(
-        "POST",
-        settings.XIAOMI_PUSH_SEND_ENDPOINT,
-        data=body,
-        headers={"Authorization": f"key={app_secret}"},
-    )
-    code = data.get("code")
-    if code not in (0, "0", None):
-        raise VendorPushError(f"xiaomi push failed: {data}")
-    if str(data.get("result", "ok")).lower() not in ("ok", "success"):
-        raise VendorPushError(f"xiaomi push failed: {data}")
-    return data
-
-
-def _xiaomi_template_param(title: str, alert: str) -> str:
-    rendered = (
-        settings.XIAOMI_PUSH_TEMPLATE_PARAM_JSON
-        .replace("{title}", title)
-        .replace("{alert}", alert)
-    )
-    try:
-        payload = json.loads(rendered)
-    except ValueError as e:
-        raise VendorPushError("XIAOMI_PUSH_TEMPLATE_PARAM_JSON invalid json") from e
-    if not isinstance(payload, dict):
-        raise VendorPushError("XIAOMI_PUSH_TEMPLATE_PARAM_JSON must be a json object")
-    for key, value in payload.items():
-        if not isinstance(key, str) or not isinstance(value, str):
-            raise VendorPushError("xiaomi template params must be string key-value pairs")
-        if not value.strip() or len(value) > 128:
-            raise VendorPushError("xiaomi template param value length must be 1-128")
-    return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
-
-
-def _oppo_auth_token() -> str:
-    cache_key = "oppo"
-    cached = _cache_get(cache_key)
-    if cached:
-        return cached
-    app_key = _require(settings.OPPO_PUSH_APP_KEY, "OPPO_PUSH_APP_KEY")
-    master_secret = _require(settings.OPPO_PUSH_MASTER_SECRET, "OPPO_PUSH_MASTER_SECRET")
-    timestamp = str(int(time.time() * 1000))
-    sign = hashlib.sha256(f"{app_key}{timestamp}{master_secret}".encode()).hexdigest()
-    data = _request_form(
-        "POST",
-        settings.OPPO_PUSH_AUTH_ENDPOINT,
-        data={
-            "app_key": app_key,
-            "timestamp": timestamp,
-            "sign": sign,
-        },
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-    )
-    if int(data.get("code", -1)) != 0:
-        raise VendorPushError(f"oppo auth failed: {data}")
-    token = (data.get("data") or {}).get("auth_token") or data.get("auth_token")
-    if not token:
-        raise VendorPushError(f"oppo auth missing auth_token: {data}")
-    return _cache_put(cache_key, str(token), 24 * 3600)
-
-
-def _send_oppo(token: str, title: str, alert: str) -> dict[str, Any]:
-    auth_token = _oppo_auth_token()
-    ttl_hours = max(1, min(72, settings.PUSH_TIME_TO_LIVE_SEC // 3600))
-    message = {
-        "target_type": 2,
-        "target_value": token,
-        "notification": {
-            "app_message_id": f"accessibility_disabled_{uuid.uuid4().hex}",
-            "title": title,
-            "content": alert,
-            "click_action_type": 0,
-            "off_line": True,
-            "off_line_ttl": ttl_hours,
-            "action_parameters": json.dumps(_extras(), ensure_ascii=False),
-        },
-    }
-    data = _request_form(
-        "POST",
-        settings.OPPO_PUSH_SEND_ENDPOINT,
-        data={
-            "auth_token": auth_token,
-            "message": json.dumps(message, ensure_ascii=False),
-        },
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-    )
-    if int(data.get("code", -1)) != 0:
-        raise VendorPushError(f"oppo push failed: {data}")
-    return data

app/integrations/wechat_login.py

@@ -1,89 +0,0 @@
-"""微信开放平台 App 登录集成。
-
-客户端只把微信 SDK 回调拿到的临时 code 传给服务端;AppSecret、access_token
-与用户 openid 都留在服务端处理,避免敏感凭证落到 APK 里。
-"""
-from __future__ import annotations
-
-import certifi
-import httpx
-
-from app.core.config import settings
-
-_API_BASE = "https://api.weixin.qq.com"
-
-
-class WechatLoginError(Exception):
-    """微信授权换取用户信息失败。"""
-
-
-def _ensure_configured() -> None:
-    if not settings.WECHAT_APP_ID or not settings.WECHAT_APP_SECRET:
-        raise WechatLoginError("wechat app not configured")
-
-
-def _http_client() -> httpx.Client:
-    return httpx.Client(verify=certifi.where())
-
-
-def code_to_userinfo(code: str) -> dict:
-    """用授权 code 换 openid/unionid,尽力补昵称头像。
-
-    返回字段:
-      - openid: 同一开放平台移动应用下的用户唯一标识
-      - unionid: 同一开放平台主体下的用户唯一标识,微信可能不返回
-      - nickname/avatar_url: sns/userinfo 可用时返回,失败不阻断登录
-      - raw: userinfo 原始响应,便于排障
-    """
-    _ensure_configured()
-    try:
-        with _http_client() as client:
-            token_resp = client.get(
-                f"{_API_BASE}/sns/oauth2/access_token",
-                params={
-                    "appid": settings.WECHAT_APP_ID,
-                    "secret": settings.WECHAT_APP_SECRET,
-                    "code": code,
-                    "grant_type": "authorization_code",
-                },
-                timeout=settings.WXPAY_REQUEST_TIMEOUT_SEC,
-            )
-        token_data = token_resp.json()
-    except Exception as e:  # noqa: BLE001
-        raise WechatLoginError("微信授权请求失败,请稍后重试") from e
-    if "openid" not in token_data or "access_token" not in token_data:
-        raise WechatLoginError(f"微信授权失败: {token_data.get('errmsg', token_data)}")
-
-    openid = token_data["openid"]
-    unionid = token_data.get("unionid")
-    nickname = None
-    avatar_url = None
-    raw: dict = {}
-
-    try:
-        with _http_client() as client:
-            info_resp = client.get(
-                f"{_API_BASE}/sns/userinfo",
-                params={
-                    "access_token": token_data["access_token"],
-                    "openid": openid,
-                    "lang": "zh_CN",
-                },
-                timeout=settings.WXPAY_REQUEST_TIMEOUT_SEC,
-            )
-        raw = info_resp.json()
-        if "errcode" not in raw:
-            nickname = raw.get("nickname") or None
-            avatar_url = raw.get("headimgurl") or None
-            unionid = unionid or raw.get("unionid")
-    except Exception:  # noqa: BLE001
-        # openid 已拿到即可登录;昵称头像只是展示增强。
-        pass
-
-    return {
-        "openid": openid,
-        "unionid": unionid,
-        "nickname": nickname,
-        "avatar_url": avatar_url,
-        "raw": raw,
-    }

app/main.py

@@ -49,7 +49,6 @@ from app.core.daily_exchange_worker import (
     stop_daily_exchange_worker,
 )
 from app.core.logging import setup_logging
-from app.core.pricebot_client import aclose_pricebot_client, get_pricebot_client
 from app.core.withdraw_reconcile_worker import (
     start_withdraw_reconcile_worker,
     stop_withdraw_reconcile_worker,
@@ -69,7 +68,6 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
         settings.APP_DEBUG,
         settings.DATABASE_URL.split("://", 1)[0],
     )
-    get_pricebot_client()  # 预热透传 client:把建 SSL 上下文的一次性成本付在启动,首个领券请求即热
     reconcile_task = start_withdraw_reconcile_worker()
     heartbeat_task = start_heartbeat_monitor()
     daily_exchange_task = start_daily_exchange_worker()
@@ -79,7 +77,6 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
         await stop_heartbeat_monitor(heartbeat_task)
         await stop_withdraw_reconcile_worker(reconcile_task)
         await stop_daily_exchange_worker(daily_exchange_task)
-        await aclose_pricebot_client()
         logger.info("shutting down")
 
 

app/models/__init__.py

@@ -19,7 +19,6 @@ from app.models.coupon_state import (  # noqa: F401
     CouponDailyCompletion,
     CouponPromptEngagement,
 )
-from app.models.cps_order import CpsOrder  # noqa: F401
 from app.models.feedback import Feedback  # noqa: F401
 from app.models.invite import InviteRelation  # noqa: F401
 from app.models.invite_fingerprint import InviteFingerprint  # noqa: F401
@@ -39,6 +38,5 @@ from app.models.wallet import (  # noqa: F401
     CashTransaction,
     CoinAccount,
     CoinTransaction,
-    InviteCashTransaction,
     WithdrawOrder,
 )

app/models/cps_order.py

@@ -1,13 +1,11 @@
 """CPS 对账订单(cps_order)。
 
-从联盟 API 按时间窗拉回、按平台落库的 CPS 订单明细。字段最初对齐美团 query_order,
-后续兼容京东订单报表:
+从美团联盟 query_order 按时间窗拉回、按 sid 归群的订单明细。字段对齐 query_order
 实测返回:
   - payPrice / profit 是「元」字符串 → 入库统一转「分」(与全站口径一致)
   - payTime / updateTime 是秒级时间戳 → 入库转 tz-aware datetime
   - status: 2付款 3完成 4取消 5风控 6结算(取消/风控不计佣金)
-order_id 全局唯一,reconcile 按它 upsert(订单状态会变,重复拉则更新)。京东订单用
-`jd:<row_id>` 前缀避免与美团订单号碰撞。
+order_id 全局唯一,reconcile 按它 upsert(订单状态会变,重复拉则更新)。
 """
 from __future__ import annotations
 
@@ -24,13 +22,8 @@ class CpsOrder(Base):
     __tablename__ = "cps_order"
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    # 平台:meituan / jd。历史数据迁移默认 meituan。
-    platform: Mapped[str] = mapped_column(String(20), default="meituan", index=True, nullable=False)
-    # 平台订单号/行号包装后的全局唯一键,upsert 幂等。
+    # 美团订单号(加密串),全局唯一,upsert 幂等键。
     order_id: Mapped[str] = mapped_column(String(64), unique=True, index=True, nullable=False)
-    # 平台原始订单号/行号。京东一笔订单多 SKU 时可按行号区分。
-    external_order_id: Mapped[str | None] = mapped_column(String(128), index=True, nullable=True)
-    external_row_id: Mapped[str | None] = mapped_column(String(128), index=True, nullable=True)
     # 渠道追踪位 = 群 sid(历史无 sid 订单为空)。按它归群聚合。
     sid: Mapped[str | None] = mapped_column(String(64), index=True, nullable=True)
     act_id: Mapped[str | None] = mapped_column(String(64), index=True, nullable=True)
@@ -42,21 +35,11 @@ class CpsOrder(Base):
     commission_rate: Mapped[str | None] = mapped_column(String(16), nullable=True)  # "300"=3% "10"=0.1%
     refund_price_cents: Mapped[int | None] = mapped_column(Integer, nullable=True)
     refund_profit_cents: Mapped[int | None] = mapped_column(Integer, nullable=True)
-    # 通用佣金拆分。美团只有预估 profit;京东有预估/实际佣金。
-    estimated_commission_cents: Mapped[int | None] = mapped_column(Integer, nullable=True)
-    actual_commission_cents: Mapped[int | None] = mapped_column(Integer, nullable=True)
 
     # 美团订单状态: 2付款 3完成 4取消 5风控 6结算
     mt_status: Mapped[str | None] = mapped_column(String(8), index=True, nullable=True)
-    # 京东订单有效码(validCode),用于判断是否有效/已完成。
-    jd_valid_code: Mapped[str | None] = mapped_column(String(16), index=True, nullable=True)
     invalid_reason: Mapped[str | None] = mapped_column(String(128), nullable=True)
     product_name: Mapped[str | None] = mapped_column(String(512), nullable=True)
-    settle_month: Mapped[str | None] = mapped_column(String(16), nullable=True)
-    site_id: Mapped[str | None] = mapped_column(String(128), nullable=True)
-    position_id: Mapped[str | None] = mapped_column(String(128), nullable=True)
-    pid: Mapped[str | None] = mapped_column(String(128), nullable=True)
-    sub_union_id: Mapped[str | None] = mapped_column(String(128), nullable=True)
 
     pay_time: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True), index=True, nullable=True
@@ -76,6 +59,5 @@ class CpsOrder(Base):
     def __repr__(self) -> str:  # pragma: no cover
         return (
             f"<CpsOrder id={self.id} order_id={self.order_id!r} "
-            f"platform={self.platform!r} sid={self.sid!r} "
-            f"status={self.mt_status or self.jd_valid_code} profit_cents={self.commission_cents}>"
+            f"sid={self.sid!r} status={self.mt_status} profit_cents={self.commission_cents}>"
         )

app/models/device.py

@@ -1,9 +1,9 @@
-"""设备表(无障碍保护存活检测 + 厂商直推)。
+"""设备表(无障碍保护存活检测 + 极光推送)。
 
 每条 = 一个用户的一台设备(per-install,device_id 由客户端 DeviceId.get() 生成)。
 客户端的无障碍服务存活时周期上报心跳刷新 last_heartbeat_at;App 前台/登录时上报
-push_vendor + push_token(厂商推送目标)。后端 heartbeat_monitor_worker 扫描「曾经保护过、
-现在心跳超时」的设备,通过厂商直推提醒用户重开无障碍。
+registration_id(极光推送目标)。后端 heartbeat_monitor_worker 扫描「曾经保护过、
+现在心跳超时」的设备,通过极光推送提醒用户重开无障碍。
 
 liveness_state 状态机(防刷屏,一次掉线只推一条):
   unknown → alive(收到 service 心跳)→ silent/notified(扫描发现超时并已推送)
@@ -30,7 +30,7 @@ from app.db.base import Base
 
 class DeviceLiveness(Base):
     # 表名不叫 device:device 易被当成「设备信息(品牌/型号/系统)」表;本表实为**无障碍存活监控状态**
-    # (心跳 last_heartbeat_at + liveness_state + kill_alert_pending + 厂商推送目标),故名 device_liveness。
+    # (心跳 last_heartbeat_at + liveness_state + kill_alert_pending + 推送目标 registration_id),故名 device_liveness。
     __tablename__ = "device_liveness"
     __table_args__ = (
         UniqueConstraint("user_id", "device_id", name="uq_device_liveness_user_device"),
@@ -42,12 +42,8 @@ class DeviceLiveness(Base):
     )
     # 客户端 DeviceId.get() 生成的 per-install id(如 device_Pixel_ab12cd34)
     device_id: Mapped[str] = mapped_column(String(128), index=True, nullable=False)
-    # 旧极光推送 registration id,仅为兼容历史客户端/数据保留;新链路使用 push_vendor + push_token。
+    # 极光推送 registration id;拿到才填(JCollectionAuth 同意后才下发)
     registration_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
-    # 厂商推送类型:honor/vivo/xiaomi/oppo 等;客户端按实际 SDK token 来源上报。
-    push_vendor: Mapped[str | None] = mapped_column(String(32), nullable=True)
-    # 厂商 push token / regId / registration_id;不同厂商命名不同,后端统一存这里。
-    push_token: Mapped[str | None] = mapped_column(String(256), nullable=True)
     platform: Mapped[str] = mapped_column(String(16), nullable=False, default="android")
     app_version: Mapped[str | None] = mapped_column(String(32), nullable=True)
 
@@ -55,11 +51,6 @@ class DeviceLiveness(Base):
     ever_protected: Mapped[bool] = mapped_column(
         Boolean, nullable=False, default=False
     )
-    # 首次开无障碍(首次收到 accessibility_enabled 心跳)的时刻;ever_protected 第一次翻 true 时记一次,
-    # 后续心跳不覆盖。老设备(迁移前已 protected)无此值 → NULL。
-    first_protected_at: Mapped[datetime | None] = mapped_column(
-        DateTime(timezone=True), nullable=True
-    )
     # 最近一次 service 心跳时间(存活证明);超时即视为保护掉线
     last_heartbeat_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True), index=True, nullable=True

app/models/invite.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, false, func
+from sqlalchemy import DateTime, ForeignKey, Integer, String, func
 from sqlalchemy.orm import Mapped, mapped_column
 
 from app.db.base import Base
@@ -35,20 +35,6 @@ class InviteRelation(Base):
     inviter_coin: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     invitee_coin: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
 
-    # ===== v2 比价发奖追踪(好友"下载+登录+比价一次"→ 给邀请人发邀请奖励金)=====
-    # 是否已因"好友完成比价"发过奖:好友比价多次只发一次(防重复发,与 invitee 唯一约束双保险)
-    compare_reward_granted: Mapped[bool] = mapped_column(
-        Boolean, nullable=False, default=False, server_default=false()
-    )
-    # 实发给邀请人的邀请奖励金(分);未发为 0
-    compare_reward_cents: Mapped[int] = mapped_column(
-        Integer, nullable=False, default=0, server_default="0"
-    )
-    # 发奖时间(未发为 None)
-    compare_rewarded_at: Mapped[datetime | None] = mapped_column(
-        DateTime(timezone=True), nullable=True
-    )
-
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), server_default=func.now(), index=True, nullable=False
     )

app/models/wallet.py

@@ -25,11 +25,6 @@ class CoinAccount(Base):
     )
     coin_balance: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     cash_balance_cents: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-    # 邀请奖励金余额(分)——与金币兑换来的 cash_balance_cents **物理隔离**(产品红线:
-    # 邀请奖励金 ≠ 看广告/金币现金,两本账不可累加)。好友比价发奖入账、提现出账走它。
-    invite_cash_balance_cents: Mapped[int] = mapped_column(
-        Integer, nullable=False, default=0, server_default="0"
-    )
     # 累计赚取的金币(只增不减),用于"历史总收益"类展示
     total_coin_earned: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
 
@@ -113,11 +108,6 @@ class WithdrawOrder(Base):
     # 商户单号(我们生成,微信查单的 out_bill_no),唯一
     out_bill_no: Mapped[str] = mapped_column(String(64), unique=True, index=True, nullable=False)
     amount_cents: Mapped[int] = mapped_column(Integer, nullable=False)
-    # 这笔提现扣的是哪个账户:coin_cash(金币兑换的现金) / invite_cash(邀请奖励金)。
-    # 退款时据此退回**对应**账户,两本账不串。旧单默认 coin_cash。
-    source: Mapped[str] = mapped_column(
-        String(16), nullable=False, default="coin_cash", server_default="coin_cash"
-    )
     # 提现实名(微信达额转账要求):审核后异步打款时要用,发起提现时存下,可空
     user_name: Mapped[str | None] = mapped_column(String(64), nullable=True)
     # 归一化状态:reviewing(待审核) / pending(打款在途) / success / failed(打款失败已退) / rejected(审核拒绝已退)
@@ -210,41 +200,3 @@ class CashTransaction(Base):
 
     def __repr__(self) -> str:  # pragma: no cover
         return f"<CashTransaction id={self.id} user_id={self.user_id} cents={self.amount_cents}>"
-
-
-class InviteCashTransaction(Base):
-    """邀请奖励金流水(单位:分)。与 cash_transaction(金币兑换现金)**物理隔离**——
-    产品红线:邀请奖励金 ≠ 看广告/金币现金,两本账不可累加、各自提现。
-    入账=好友比价发奖(invite_reward),出账=提现(invite_withdraw)/退款(invite_withdraw_refund)。
-    结构与 cash_transaction 同构,balance_after_cents 记的是 coin_account.invite_cash_balance_cents。"""
-
-    __tablename__ = "invite_cash_transaction"
-    __table_args__ = (
-        # 提现退款幂等:一个提现单只退一次(同 cash_transaction 的 withdraw_refund 去重)
-        Index(
-            "ux_invite_cash_txn_refund_ref",
-            "ref_id",
-            unique=True,
-            sqlite_where=text("biz_type = 'invite_withdraw_refund' AND ref_id IS NOT NULL"),
-            postgresql_where=text("biz_type = 'invite_withdraw_refund' AND ref_id IS NOT NULL"),
-        ),
-    )
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    user_id: Mapped[int] = mapped_column(
-        Integer, ForeignKey("user.id"), index=True, nullable=False
-    )
-    # 正数=入账(发奖),负数=出账(提现)
-    amount_cents: Mapped[int] = mapped_column(Integer, nullable=False)
-    balance_after_cents: Mapped[int] = mapped_column(Integer, nullable=False)
-    # 业务类型:invite_reward / invite_withdraw / invite_withdraw_refund
-    biz_type: Mapped[str] = mapped_column(String(32), nullable=False)
-    ref_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
-    remark: Mapped[str | None] = mapped_column(String(128), nullable=True)
-
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), server_default=func.now(), index=True, nullable=False
-    )
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"<InviteCashTransaction id={self.id} user_id={self.user_id} cents={self.amount_cents}>"

app/repositories/ad_ecpm.py

@@ -53,16 +53,11 @@ def create_ecpm_record(
         db.commit()
     except IntegrityError:
         db.rollback()
-        # 撞唯一约束 uq_ad_ecpm_record_session(全局按 ad_session_id、不含 user_id):并发同会话重复上报,
-        # 或同一 ad_session_id 已被先到的上报占用。本接口 fire-and-forget、best-effort —— 丢一条不影响业务
-        # (穿山甲后台才是结算权威),绝不向客户端抛 500。兜底查找须与唯一约束**同口径**(只按 ad_session_id、
-        # 不带 user_id):否则不同 user 上报了同一 ad_session_id 时,带 user_id 的查找会漏掉那条别人的记录 →
-        # 旧逻辑在此 raise 成 500(本应静默吞掉)。
-        existing = _find_by_session_global(db, ad_session_id)
-        if existing is not None:
-            return existing
-        # 极少:rollback 后既存记录又查不到(并发删除 / 竞态)。吞掉、返回未入库的内存对象(调用方不读返回值)。
-        return rec
+        if ad_session_id:
+            existing = find_by_session(db, user_id=user_id, ad_session_id=ad_session_id)
+            if existing is not None:
+                return existing
+        raise
     db.refresh(rec)
     return rec
 
@@ -81,20 +76,6 @@ def find_by_session(
     ).scalar_one_or_none()
 
 
-def _find_by_session_global(db: Session, ad_session_id: str | None) -> AdEcpmRecord | None:
-    """按 ad_session_id **全局**查找(与唯一约束 uq_ad_ecpm_record_session 同口径,不含 user_id)。
-
-    仅 create_ecpm_record 撞约束后兜底用:此时撞的是全局会话约束,既存记录可能属于**另一个 user**,
-    带 user_id 的 find_by_session 会漏掉它、导致误判「查无 → raise 500」。其它业务查「某 user 的某次
-    展示 eCPM」仍用 find_by_session(带 user_id,语义更准),不走这里。
-    """
-    if not ad_session_id:
-        return None
-    return db.execute(
-        select(AdEcpmRecord).where(AdEcpmRecord.ad_session_id == ad_session_id)
-    ).scalar_one_or_none()
-
-
 def count_today(db: Session, user_id: int) -> int:
     """该用户今日(北京时间)上报的 eCPM 条数,排查/对账辅助用。"""
     return db.execute(

app/repositories/ad_feed_reward.py

@@ -73,19 +73,16 @@ def grant_feed_reward(
     app_env: str | None = None,
     our_code_id: str | None = None,
     aborted: bool = False,
-    display_coin: int = 0,
 ) -> AdFeedRewardRecord:
     """**每条**信息流广告(客户端每条各上报一次)结算奖励。client_event_id 幂等,同号重试不重复发。
 
-    发奖规则(所见即所得, 2026-06-27 用户拍板「显示多少给多少」):优先**直接发客户端小球显示的金币
-    display_coin**;防刷钳到本条「1 份满额」(eCPM 已钳 AD_ECPM_MAX_FEN, 因子2 按账号累计已发条数取档),
-    合法显示(实际因子2 × 进度 p ≤ 1 份)不被砍, 只挡伪造天价值。旧客户端不传 display_coin 时退回
-    「看满 10 秒发整份」(兼容不断币)。因子2(LT)由**客户端**按 granted 行 COUNT(拉自 /feed-reward/units)
-    算进 display_coin, 后端只记 granted 行让该计数自增, 不再服务端重算份值。
+    发奖规则:**一条广告 = 一个单次公式值**(rewards.calculate_ad_reward_coin),因子2(LT)按账号累计
+    **条**数递进;看满一份时长(unit_count>=1, 即 ≥10 秒)才发,**不逐份累加**。
     - aborted=True(用户中途 ✕ 关闭这条):本条不发,记 status='closed_early'。
-    - display_coin 为 0 且时长不足一份:记 status='too_short' 不发(不计 LT / 当日上限)。
+    - 时长不足 10 秒(unit_count==0):记 status='too_short' 不发。
     - 命中当日条数上限:记 status='capped' 不发。
-    duration_seconds 落库留痕(unit_count 字段), 旧端兼容路径据它判是否满 1 份。
+    duration_seconds 是**这一条**的观看秒数。服务端两道硬闸防刷:时长钳到 FEED_MAX_DURATION_SECONDS、
+    eCPM 在 calculate_ad_reward_coin 内钳到 AD_ECPM_MAX_FEN;叠加每日 get_ad_daily_limit 条数上限。
     feed_scene:点位场景(comparison/coupon/welfare),仅归类落库,不参与计算。
     ad_type:广告形态(feed 信息流 / draw Draw 信息流),仅归类落库;**每日上限与因子2(LT)仍按本表
     全表 unit 累计(feed+draw 共享同一发奖池/上限),不按 ad_type 拆分**。
@@ -142,26 +139,14 @@ def grant_feed_reward(
         )
         return _commit_record(db, rec, client_event_id)
 
-    # 所见即所得(用户 2026-06-27「显示多少给多少」): 优先发**客户端小球显示**的金币 display_coin,
-    # 钳到本条「1 份满额」防刷(eCPM 已钳 AD_ECPM_MAX_FEN; 合法显示=因子2×p≤1份, 不会被砍)。
-    # 因子2(LT)按账号累计已发条数(granted 行 COUNT), 第 existing_ads+1 条。
-    existing_ads = granted_unit_total(db, user_id)
-    unit_cap = rewards.calculate_ad_reward_coin(ecpm, existing_ads + 1)
-    if display_coin > 0:
-        coin = min(display_coin, unit_cap)              # 新端: 所见即所得(直接发小球显示金币)
-    elif unit_count >= 1:
-        coin = unit_cap                                 # 旧端没传 display_coin: 退回「看满 1 份发整份」(兼容)
-    else:
-        coin = 0
-
-    # 显示金币为 0 且没满一份 → 不发, 记 too_short 留痕(不写 granted 行 → 不计 LT / 当日上限)。
-    if coin <= 0:
+    # 整场总时长不足 10 秒,凑不满一份 → 不发,记 too_short 留痕。
+    if unit_count == 0:
         rec = AdFeedRewardRecord(
             client_event_id=client_event_id,
             user_id=user_id,
             reward_date=today,
             duration_seconds=safe_duration,
-            unit_count=unit_count,
+            unit_count=0,
             ad_session_id=ad_session_id,
             ecpm_raw=ecpm,
             adn=adn,
@@ -176,11 +161,15 @@ def grant_feed_reward(
         )
         return _commit_record(db, rec, client_event_id)
 
-    crud_wallet.grant_coins(
-        db, user_id, coin,
-        biz_type="feed_ad_reward", ref_id=client_event_id,
-        remark="信息流广告奖励",
-    )
+    # 一条广告 = 一个「单次公式值」(因子2 按账号累计**条**数, 即第 existing_ads+1 条);看满一份(unit_count>=1)即发,不逐份累加。
+    existing_ads = granted_unit_total(db, user_id)
+    coin = rewards.calculate_ad_reward_coin(ecpm, existing_ads + 1)
+    if coin > 0:
+        crud_wallet.grant_coins(
+            db, user_id, coin,
+            biz_type="feed_ad_reward", ref_id=client_event_id,
+            remark="信息流广告奖励",
+        )
     rec = AdFeedRewardRecord(
         client_event_id=client_event_id,
         user_id=user_id,

app/repositories/device.py

@@ -21,23 +21,17 @@ def register_or_update(
     *,
     user_id: int,
     device_id: str,
-    registration_id: str | None = None,
-    push_vendor: str | None = None,
-    push_token: str | None = None,
+    registration_id: str | None,
     platform: str = "android",
     app_version: str | None = None,
 ) -> DeviceLiveness:
-    """注册设备或更新其厂商 push token / 元信息。upsert by (user_id, device_id)。"""
-    normalized_vendor = _normalize_push_vendor(push_vendor)
-    normalized_token = push_token.strip() if push_token else None
+    """注册设备或更新其 registration_id / 元信息。upsert by (user_id, device_id)。"""
     device = _get(db, user_id=user_id, device_id=device_id)
     if device is None:
         device = DeviceLiveness(
             user_id=user_id,
             device_id=device_id,
             registration_id=registration_id,
-            push_vendor=normalized_vendor,
-            push_token=normalized_token,
             platform=platform or "android",
             app_version=app_version,
         )
@@ -45,10 +39,6 @@ def register_or_update(
     else:
         if registration_id:
             device.registration_id = registration_id
-        if normalized_vendor:
-            device.push_vendor = normalized_vendor
-        if normalized_token:
-            device.push_token = normalized_token
         if platform:
             device.platform = platform
         if app_version:
@@ -64,9 +54,7 @@ def touch_heartbeat(
     user_id: int,
     device_id: str,
     accessibility_enabled: bool,
-    registration_id: str | None = None,
-    push_vendor: str | None = None,
-    push_token: str | None = None,
+    registration_id: str | None,
 ) -> DeviceLiveness:
     """处理一次心跳(心跳也能自注册)。
 
@@ -81,17 +69,9 @@ def touch_heartbeat(
 
     if registration_id:
         device.registration_id = registration_id
-    normalized_vendor = _normalize_push_vendor(push_vendor)
-    normalized_token = push_token.strip() if push_token else None
-    if normalized_vendor:
-        device.push_vendor = normalized_vendor
-    if normalized_token:
-        device.push_token = normalized_token
     device.last_report_protection_on = accessibility_enabled
 
     if accessibility_enabled:
-        if not device.ever_protected:
-            device.first_protected_at = now  # 首次开无障碍记一次,后续心跳不覆盖
         device.last_heartbeat_at = now
         device.ever_protected = True
         device.liveness_state = "alive"
@@ -105,7 +85,7 @@ def touch_heartbeat(
 def list_overdue(db: Session, *, timeout_minutes: int) -> list[DeviceLiveness]:
     """掉线设备:曾经保护过、当前 alive、心跳超时。
 
-    即使没有厂商 token 也要检出,后续由 kill_alert_pending 走客户端进 App 后兜底提醒。
+    本期只做终端打印检测、不推送 → 不再要求有 registration_id(没接极光 token 的设备也要检出)。
     """
     cutoff = datetime.now(timezone.utc) - timedelta(minutes=timeout_minutes)
     stmt = select(DeviceLiveness).where(
@@ -142,27 +122,3 @@ def ack_kill_alert(db: Session, *, user_id: int, device_id: str) -> None:
     if device is not None and device.kill_alert_pending:
         device.kill_alert_pending = False
         db.commit()
-
-
-def has_push_target(device: DeviceLiveness | None) -> bool:
-    """是否已有厂商直推所需的 vendor + token。"""
-    return bool(device and device.push_vendor and device.push_token)
-
-
-def _normalize_push_vendor(push_vendor: str | None) -> str | None:
-    if not push_vendor:
-        return None
-    vendor = push_vendor.strip().lower()
-    aliases = {
-        "honor": "honor",
-        "hihonor": "honor",
-        "荣耀": "honor",
-        "vivo": "vivo",
-        "xiaomi": "xiaomi",
-        "mi": "xiaomi",
-        "小米": "xiaomi",
-        "oppo": "oppo",
-        "oneplus": "oppo",
-        "realme": "oppo",
-    }
-    return aliases.get(vendor, vendor)

app/repositories/invite.py

@@ -1,14 +1,13 @@
-"""好友邀请 CRUD(注册即生效,绑定只建归因关系、双方都不发钱)。
-
-发奖规则(v3,冰 2026-06-26 拍板):
-  - 绑定时双方都不发钱(被邀请人无奖励、邀请人不发金币)。
-  - 邀请人的钱由 try_reward_on_compare 在好友"成功比价一次"后发 2 元邀请奖励金(防刷)。
-  - v1 的"绑定双方各发金币"已废;invite_relation 的 inviter_coin/invitee_coin 列保留恒 0(待清)。
+"""好友邀请 CRUD(注册即生效,邀请人 + 被邀请人各发金币)。
 
 防重复发奖三道(仿 ad_reward / 提现的资金安全思路):
   1. invitee_user_id 唯一 → 一个被邀请人只能被绑定一次(幂等键)。
   2. 自邀屏蔽 → inviter == invitee 直接拒。
   3. 现成的手机号唯一(每个被邀请人 = 一个真实手机号账号)= 天然限制刷量规模。
+
+发金币复用 wallet.grant_coins(grant 只 flush 不 commit),与建关系记录在**同一事务**
+commit,保证"建关系 + 双方加金币"原子。奖励额 = rewards.INVITE_INVITER_COINS /
+INVITE_INVITEE_COINS。
 """
 from __future__ import annotations
 
@@ -35,30 +34,6 @@ def _gen_code() -> str:
     return "".join(secrets.choice(_CODE_ALPHABET) for _ in range(_CODE_LEN))
 
 
-# ===== v2 邀请倒计时(7 天 1 轮,锚点=注册日,自然日差,东八区)=====
-# 中国不用夏令时,固定 +8 偏移即可(不依赖 tzdata,Windows 本地联调也稳)。
-_CST = timezone(timedelta(hours=8))
-
-
-def compute_invite_countdown(register_at: datetime) -> tuple[int, bool, str]:
-    """按 7 天 1 轮算邀请页倒计时。
-
-    锚点 = 用户注册日(user.created_at),按东八区自然日差算
-    (跨自然日才减、同日多次登录不减,天然满足)。返回:
-      (本轮剩余天数 1..7, 是否刚进入新一轮[非首轮第1天], 展示文案)。
-    """
-    reg = register_at if register_at.tzinfo else register_at.replace(tzinfo=timezone.utc)
-    days_since = max(0, (datetime.now(_CST).date() - reg.astimezone(_CST).date()).days)
-    day_in_cycle = days_since % 7                            # 0..6(本轮第几天,0-based)
-    days_left = 7 - day_in_cycle                             # 7..1(第1天=7、第7天=1)
-    is_fresh_round = days_since >= 7 and day_in_cycle == 0   # 非首轮的第1天
-    if is_fresh_round:
-        text = "恭喜您进入新一轮邀请！\n距离本轮结束还有7天"
-    else:
-        text = f"距本轮结束还有{days_left}天"
-    return days_left, is_fresh_round, text
-
-
 def ensure_code(db: Session, user: User) -> str:
     """保证 user 有邀请码(懒生成),返回它。唯一约束碰撞则换码重试。
 
@@ -115,17 +90,15 @@ def _is_new_user(user: User) -> bool:
 class BindResult:
     status: str                          # success / already_bound / invalid_code / self_invite / not_eligible
     relation: InviteRelation | None = None
-    invitee_coin: int = 0                # v3 起恒 0(绑定不再发金币);保留字段兼容响应
+    invitee_coin: int = 0                # 本次给被邀请人发的金币(success 时 >0)
 
 
 def bind(
     db: Session, *, invitee: User, invite_code: str, channel: str = "clipboard"
 ) -> BindResult:
-    """把 invitee 绑定到 invite_code 对应的邀请人,注册即生效。
+    """把 invitee 绑定到 invite_code 对应的邀请人,注册即生效 + 双方发金币。
 
-    v3 发奖(冰 2026-06-26 拍板):绑定双方都不发钱——被邀请人无奖励,邀请人改"好友成功比价一次
-    才发 2 元邀请奖励金"(见 try_reward_on_compare,防刷)。绑定只建归因关系 + 跑防刷闸。
-    幂等:已绑过 → already_bound。
+    幂等:invitee 已被绑过 → already_bound(不重复发奖)。
     """
     # 幂等:已绑过直接返回(不重复发奖)
     existing = _relation_of_invitee(db, invitee.id)
@@ -141,18 +114,27 @@ def bind(
     if not _is_new_user(invitee):
         return BindResult("not_eligible")
 
-    # v3(冰 2026-06-26 拍板):绑定双方都不发钱。被邀请人不再发新人金币(去掉拉新即时激励);
-    # 邀请人的钱由 try_reward_on_compare 在好友成功比价后发 2 元邀请奖励金(防刷)。
+    inviter_coin = rewards.INVITE_INVITER_COINS
+    invitee_coin = rewards.INVITE_INVITEE_COINS
+
     rel = InviteRelation(
         inviter_user_id=inviter.id,
         invitee_user_id=invitee.id,
         channel=(channel or "clipboard")[:16],
         status="effective",
-        inviter_coin=0,                 # v1 金币线已停用,列保留恒 0(待清)
-        invitee_coin=0,                 # v3:被邀请人绑定不再发金币
+        inviter_coin=inviter_coin,
+        invitee_coin=invitee_coin,
     )
     db.add(rel)
-    # 绑定不发任何金币(邀请人改比价发现金、被邀请人无奖励),仅建归因关系。
+    # 双方发金币(同事务,与建关系一起 commit)。ref_id 互指对方便于对账。
+    crud_wallet.grant_coins(
+        db, inviter.id, inviter_coin,
+        biz_type="invite_inviter", ref_id=str(invitee.id), remark="邀请好友奖励",
+    )
+    crud_wallet.grant_coins(
+        db, invitee.id, invitee_coin,
+        biz_type="invite_invitee", ref_id=str(inviter.id), remark="新人受邀奖励",
+    )
     try:
         db.commit()
     except IntegrityError:
@@ -163,62 +145,16 @@ def bind(
             return BindResult("already_bound", existing)
         raise
     except Exception:
-        # 其它 commit 失败(DB 故障 / PG 序列化冲突等):显式回滚,保证建关系原子,
-        # 不依赖 get_db 关闭时的隐式回滚,语义更硬。
+        # 其它 commit 失败(DB 故障 / PG 序列化冲突等):显式回滚,保证"建关系 + 双方发币"
+        # 原子(要么全成要么全无),不依赖 get_db 关闭时的隐式回滚,语义更硬。
         db.rollback()
         raise
     db.refresh(rel)
-    return BindResult("success", rel)
-
-
-@dataclass
-class CompareRewardResult:
-    status: str                    # granted / no_relation / already_granted / inviter_inactive
-    inviter_user_id: int | None = None
-    reward_cents: int = 0
-
-
-def try_reward_on_compare(db: Session, invitee_user_id: int) -> CompareRewardResult:
-    """被邀请人完成一次成功比价时调用:若其有邀请关系且尚未发过比价奖,给【邀请人】发邀请奖励金。
-
-    v2 发奖规则核心(替代 v1 的"注册即发金币"):好友"下载+登录+比价一次"→ 邀请人得 2 元现金。
-    幂等:compare_reward_granted 标记保证好友比价多次只发一次。无邀请关系 / 已发过 / 邀请人失效
-    → 空操作。发奖(grant_invite_cash 入账独立账户)+ 置标记同事务 commit,保证原子。
-    """
-    rel = _relation_of_invitee(db, invitee_user_id)
-    if rel is None:
-        return CompareRewardResult("no_relation")
-    if rel.compare_reward_granted:
-        return CompareRewardResult("already_granted", rel.inviter_user_id)
-
-    inviter = db.get(User, rel.inviter_user_id)
-    if inviter is None or inviter.status != "active":
-        # 邀请人注销 / 封禁:本次不发、不置标记,待其恢复后下次比价再试(保守,不吞奖励)
-        return CompareRewardResult("inviter_inactive", rel.inviter_user_id)
-
-    reward = rewards.INVITE_COMPARE_REWARD_CENTS
-    rel.compare_reward_granted = True
-    rel.compare_reward_cents = reward
-    rel.compare_rewarded_at = datetime.now(timezone.utc)
-    # 发邀请奖励金到邀请人的独立账户(与金币隔离),ref_id 指向被邀请人便于对账
-    crud_wallet.grant_invite_cash(
-        db, inviter.id, reward,
-        biz_type="invite_reward", ref_id=str(invitee_user_id), remark="好友比价奖励",
-    )
-    try:
-        db.commit()
-    except Exception:
-        db.rollback()
-        raise
-    return CompareRewardResult("granted", inviter.id, reward)
+    return BindResult("success", rel, invitee_coin)
 
 
 def get_stats(db: Session, inviter_id: int) -> tuple[int, int]:
-    """返回 (已成功邀请人数, 累计从邀请获得的金币)。
-
-    金币口径(inviter_coin 之和)自 v3 起恒 0(邀请人收益改走邀请奖励金,见 get_reward_stats /
-    try_reward_on_compare);保留返回位兼容旧响应字段 coins_earned。
-    """
+    """返回 (已成功邀请人数, 累计从邀请获得的金币)。"""
     count = db.execute(
         select(func.count())
         .select_from(InviteRelation)
@@ -231,26 +167,6 @@ def get_stats(db: Session, inviter_id: int) -> tuple[int, int]:
     return int(count), int(coins)
 
 
-def get_reward_stats(db: Session, inviter_id: int) -> tuple[int, int]:
-    """v2 邀请奖励金战绩:(可提现余额/分, 累计提现成功/分)。
-
-    余额 = coin_account.invite_cash_balance_cents;累计提现 = 该用户 source=invite_cash 且
-    status=success 的提现单金额之和(成功打款才算)。供 /invite/me 提现板块展示。
-    """
-    from app.models.wallet import CoinAccount, WithdrawOrder
-    balance = db.execute(
-        select(CoinAccount.invite_cash_balance_cents).where(CoinAccount.user_id == inviter_id)
-    ).scalar_one_or_none()
-    withdrawn = db.execute(
-        select(func.coalesce(func.sum(WithdrawOrder.amount_cents), 0)).where(
-            WithdrawOrder.user_id == inviter_id,
-            WithdrawOrder.source == "invite_cash",
-            WithdrawOrder.status == "success",
-        )
-    ).scalar_one()
-    return int(balance or 0), int(withdrawn)
-
-
 def _mask_phone(phone: str) -> str:
     """手机号脱敏:138****8888。前端拿不到完整号,展示被邀请人时在此兜底名字。
 
@@ -294,7 +210,7 @@ def get_invitees(
         items.append({
             "display_name": u.nickname or u.wechat_nickname or _mask_phone(u.phone),
             "avatar_url": u.avatar_url or u.wechat_avatar_url or None,
-            "coins": rel.inviter_coin,      # v3 起恒 0(邀请人收益改走邀请奖励金)
+            "coins": rel.inviter_coin,
             "invited_at": rel.created_at,
         })
     has_more = offset + len(rows) < int(total)

app/repositories/user.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 
 import secrets
 import string
-import hashlib
 from datetime import datetime, timezone
 
 from sqlalchemy import select
@@ -71,21 +70,6 @@ def get_user_by_phone(db: Session, phone: str) -> User | None:
     return db.execute(stmt).scalar_one_or_none()
 
 
-def get_user_by_wechat_openid(db: Session, openid: str) -> User | None:
-    stmt = select(User).where(User.wechat_openid == openid)
-    return db.execute(stmt).scalar_one_or_none()
-
-
-def _wechat_placeholder_phone(openid: str) -> str:
-    """给纯微信注册用户生成内部登录号。
-
-    当前 user.phone 非空唯一,而微信 App 授权不会返回手机号。这里生成一个不可能
-    命中手机号正则的内部值,只用于满足既有表结构和客户端登录态判断。
-    """
-    digest = hashlib.sha256(openid.encode("utf-8")).hexdigest()[:16]
-    return f"wx_{digest}"
-
-
 def upsert_user_for_login(
     db: Session,
     *,
@@ -115,52 +99,6 @@ def upsert_user_for_login(
     return user
 
 
-def upsert_user_for_wechat_login(
-    db: Session,
-    *,
-    openid: str,
-    nickname: str | None = None,
-    avatar_url: str | None = None,
-) -> User:
-    """微信 App 登录:openid 已存在则回到原账号,不存在则注册新账号。
-
-    如果用户之前在提现页绑定过微信,该 openid 已在 user.wechat_openid 上,因此会
-    直接登录到同一账号;新微信用户则创建 register_channel=wechat 的账号。
-    """
-    user = get_user_by_wechat_openid(db, openid)
-    now = datetime.now(timezone.utc)
-    if user is None:
-        phone = _wechat_placeholder_phone(openid)
-        # 极小概率 hash 前缀碰撞时,后缀追加随机段兜底。
-        if get_user_by_phone(db, phone) is not None:
-            phone = f"wx_{secrets.token_hex(8)}"
-        user = User(
-            phone=phone,
-            username=_gen_unique_username(db),
-            nickname=nickname or _gen_nickname(),
-            avatar_url=avatar_url,
-            register_channel="wechat",
-            wechat_openid=openid,
-            wechat_nickname=nickname,
-            wechat_avatar_url=avatar_url,
-            last_login_at=now,
-        )
-        db.add(user)
-    else:
-        user.last_login_at = now
-        if nickname:
-            user.wechat_nickname = nickname
-            if not user.nickname:
-                user.nickname = nickname
-        if avatar_url:
-            user.wechat_avatar_url = avatar_url
-            if not user.avatar_url:
-                user.avatar_url = avatar_url
-    db.commit()
-    db.refresh(user)
-    return user
-
-
 def update_nickname(db: Session, user: User, *, nickname: str) -> User:
     user.nickname = nickname
     db.commit()

app/repositories/wallet.py

@@ -24,7 +24,6 @@ from app.models.wallet import (
     CashTransaction,
     CoinAccount,
     CoinTransaction,
-    InviteCashTransaction,
     WechatTransferAuthorization,
     WithdrawOrder,
 )
@@ -167,36 +166,6 @@ def grant_cash(
     return acc, txn
 
 
-def grant_invite_cash(
-    db: Session,
-    user_id: int,
-    amount_cents: int,
-    *,
-    biz_type: str,
-    ref_id: str | None = None,
-    remark: str | None = None,
-) -> tuple[CoinAccount, InviteCashTransaction]:
-    """邀请奖励金变动入口(正数入账 / 负数出账)。更新 invite_cash_balance_cents + 写
-    invite_cash_transaction,不 commit。与金币兑换的 cash_balance_cents **物理隔离**
-    (产品红线:邀请奖励金 ≠ 金币现金,两本账不可累加)。返回 (account, transaction),
-    调用方负责 commit。不在此校验扣成负——由调用方按业务保护。"""
-    acc = get_or_create_account(db, user_id, commit=False)
-    acc.invite_cash_balance_cents += amount_cents
-
-    txn = InviteCashTransaction(
-        user_id=user_id,
-        amount_cents=amount_cents,
-        balance_after_cents=acc.invite_cash_balance_cents,
-        biz_type=biz_type,
-        ref_id=ref_id,
-        remark=remark,
-        created_at=datetime.now(rewards.CN_TZ).replace(tzinfo=None),
-    )
-    db.add(txn)
-    db.flush()
-    return acc, txn
-
-
 def list_coin_transactions(
     db: Session,
     user_id: int,
@@ -442,43 +411,33 @@ def refund_reviewing_withdraws_on_unbind(db: Session, user_id: int) -> int:
 _OUT_BILL_NO_RE = re.compile(r"^[0-9A-Za-z_-]{8,32}$")
 
 
-def _balance_col(source: str):
-    """提现账户来源 → CoinAccount 余额列。invite_cash=邀请奖励金;否则金币兑换的现金。
-    两账户物理隔离,提现扣款/退款都按 source 走对应列,互不串。"""
-    return (
-        CoinAccount.invite_cash_balance_cents
-        if source == "invite_cash"
-        else CoinAccount.cash_balance_cents
-    )
+def _try_deduct_cash(db: Session, user_id: int, amount_cents: int) -> bool:
+    """原子扣减现金:仅当余额足够时扣,返回是否成功。
 
-
-def _try_deduct_cash(db: Session, user_id: int, amount_cents: int, source: str = "coin_cash") -> bool:
-    """原子扣减指定账户余额:仅当余额足够时扣,返回是否成功。
-
-    用带条件的 UPDATE(`WHERE <col> >= amount`)避免"读-判断-写"竞态——并发/重试时不会两次
-    都通过余额检查导致超额扣款(SQLite 串行写、Postgres 行级,均安全)。source 决定扣
-    cash_balance_cents(coin_cash) 还是 invite_cash_balance_cents(invite_cash)。
+    用带条件的 UPDATE(`WHERE cash_balance_cents >= amount`)避免"读-判断-写"竞态——
+    并发/重试时不会两次都通过余额检查导致超额扣款(SQLite 串行写、Postgres 行级,均安全)。
     """
-    col = _balance_col(source)
     res = db.execute(
         update(CoinAccount)
-        .where(CoinAccount.user_id == user_id, col >= amount_cents)
-        .values({col: col - amount_cents})
+        .where(
+            CoinAccount.user_id == user_id,
+            CoinAccount.cash_balance_cents >= amount_cents,
+        )
+        .values(cash_balance_cents=CoinAccount.cash_balance_cents - amount_cents)
     )
     return res.rowcount == 1
 
 
-def _add_cash(db: Session, user_id: int, amount_cents: int, source: str = "coin_cash") -> int:
-    """原子增加指定账户余额(退款用),返回加后余额。source 决定退回哪个账户(两账户隔离)。"""
-    col = _balance_col(source)
+def _add_cash(db: Session, user_id: int, amount_cents: int) -> int:
+    """原子增加现金(退款用),返回加后余额。"""
     db.execute(
         update(CoinAccount)
         .where(CoinAccount.user_id == user_id)
-        .values({col: col + amount_cents})
+        .values(cash_balance_cents=CoinAccount.cash_balance_cents + amount_cents)
     )
     db.flush()
     bal = db.execute(
-        select(col).where(CoinAccount.user_id == user_id)
+        select(CoinAccount.cash_balance_cents).where(CoinAccount.user_id == user_id)
     ).scalar_one()
     return bal
 
@@ -497,15 +456,11 @@ def _refund_withdraw(
     """
     if order.status in ("failed", "rejected"):
         return  # 防重复退款(并发/对账与查单/重复拒绝同时触发)
-    # 账户隔离:按 order.source 退回对应账户 + 写对应退款流水表
-    is_invite = order.source == "invite_cash"
-    txn_model = InviteCashTransaction if is_invite else CashTransaction
-    refund_biz = "invite_withdraw_refund" if is_invite else "withdraw_refund"
     refunded_txn_id = db.execute(
-        select(txn_model.id).where(
-            txn_model.user_id == order.user_id,
-            txn_model.biz_type == refund_biz,
-            txn_model.ref_id == order.out_bill_no,
+        select(CashTransaction.id).where(
+            CashTransaction.user_id == order.user_id,
+            CashTransaction.biz_type == "withdraw_refund",
+            CashTransaction.ref_id == order.out_bill_no,
         ).limit(1)
     ).scalar_one_or_none()
     if refunded_txn_id is not None:
@@ -513,13 +468,13 @@ def _refund_withdraw(
         order.fail_reason = reason[:256]
         db.commit()
         return
-    bal = _add_cash(db, order.user_id, order.amount_cents, order.source)
+    bal = _add_cash(db, order.user_id, order.amount_cents)
     db.add(
-        txn_model(
+        CashTransaction(
             user_id=order.user_id,
             amount_cents=order.amount_cents,
             balance_after_cents=bal,
-            biz_type=refund_biz,
+            biz_type="withdraw_refund",
             ref_id=order.out_bill_no,
             # 用户可见文案区分"未成功(自动退)"vs"审核未通过";技术原因记在 order.fail_reason
             remark=(
@@ -537,13 +492,13 @@ def _refund_withdraw(
         db.commit()
     except IntegrityError:
         # 并发退款兜底:唯一退款流水已被另一事务写入时,回滚本事务的加钱和流水,
-        # 再把订单状态补到终态。这样无论拒绝/查单/对账怎么并发,金额最多退一次。
+        # 再把订单状态补到终态。这样无论拒绝/查单/对账怎么并发,现金最多退一次。
         db.rollback()
         refunded_txn_id = db.execute(
-            select(txn_model.id).where(
-                txn_model.user_id == user_id,
-                txn_model.biz_type == refund_biz,
-                txn_model.ref_id == out_bill_no,
+            select(CashTransaction.id).where(
+                CashTransaction.user_id == user_id,
+                CashTransaction.biz_type == "withdraw_refund",
+                CashTransaction.ref_id == out_bill_no,
             ).limit(1)
         ).scalar_one_or_none()
         if refunded_txn_id is None:
@@ -607,7 +562,6 @@ def create_withdraw(
     user_id: int,
     amount_cents: int,
     *,
-    source: str = "coin_cash",
     user_name: str | None = None,
     out_bill_no: str | None = None,
 ) -> WithdrawOrder:
@@ -654,23 +608,20 @@ def create_withdraw(
     # 账户须存在(原子扣款的 UPDATE 不会建账户)
     get_or_create_account(db, user_id, commit=True)
 
-    # #1 原子扣款:余额不足时影响行数为 0(按 source 扣对应账户)
-    if not _try_deduct_cash(db, user_id, amount_cents, source):
+    # #1 原子扣款:余额不足时影响行数为 0
+    if not _try_deduct_cash(db, user_id, amount_cents):
         db.rollback()
         raise InsufficientCashError
 
-    is_invite = source == "invite_cash"
-    txn_model = InviteCashTransaction if is_invite else CashTransaction
-    withdraw_biz = "invite_withdraw" if is_invite else "withdraw"
     bal = db.execute(
-        select(_balance_col(source)).where(CoinAccount.user_id == user_id)
+        select(CoinAccount.cash_balance_cents).where(CoinAccount.user_id == user_id)
     ).scalar_one()
     db.add(
-        txn_model(
+        CashTransaction(
             user_id=user_id,
             amount_cents=-amount_cents,
             balance_after_cents=bal,
-            biz_type=withdraw_biz,
+            biz_type="withdraw",
             ref_id=out_bill_no,
             remark="提现到微信零钱(待审核)",
             created_at=datetime.now(rewards.CN_TZ).replace(tzinfo=None),
@@ -680,7 +631,6 @@ def create_withdraw(
         user_id=user_id,
         out_bill_no=out_bill_no,
         amount_cents=amount_cents,
-        source=source,
         user_name=user_name,
         status="reviewing",
     )
@@ -1057,12 +1007,10 @@ def reconcile_pending_withdraws(db: Session, *, older_than_minutes: int = 15) ->
 
 
 def list_withdraw_orders(
-    db: Session, user_id: int, *, source: str | None = None, limit: int = 20, cursor: int | None = None
+    db: Session, user_id: int, *, limit: int = 20, cursor: int | None = None
 ) -> tuple[list[WithdrawOrder], int | None]:
-    """提现单分页(按 id 倒序,游标式)。source 非空时只返回该账户来源的单(coin_cash / invite_cash)。"""
+    """提现单分页(按 id 倒序,游标式)。"""
     stmt = select(WithdrawOrder).where(WithdrawOrder.user_id == user_id)
-    if source is not None:
-        stmt = stmt.where(WithdrawOrder.source == source)
     if cursor is not None:
         stmt = stmt.where(WithdrawOrder.id < cursor)
     stmt = stmt.order_by(WithdrawOrder.id.desc()).limit(limit)

app/schemas/ad.py

@@ -167,11 +167,6 @@ class FeedRewardIn(BaseModel):
     aborted: bool = Field(
         False, description="用户中途 ✕ 关闭广告(未走完比价):整场不发,记 closed_early"
     )
-    display_coin: int = Field(
-        0, ge=0,
-        description="客户端金币小球**本条显示**的金币(所见即所得):后端直接发这个数,钳到本条最大 1 份"
-        "满额防刷。缺省 0 = 旧客户端不传,退回服务端「看满 10 秒发整份」",
-    )
 
 
 class FeedRewardOut(BaseModel):

app/schemas/auth.py

@@ -67,14 +67,6 @@ class JverifyLoginRequest(BaseModel):
     )
 
 
-class WechatLoginRequest(BaseModel):
-    code: str = Field(..., min_length=1, description="微信 SDK SendAuth.Resp 返回的一次性授权 code")
-    device_id: str = Field(
-        "", max_length=64,
-        description="硬件级设备标识(Android ANDROID_ID),用于新手引导按 设备+账号 去重;空=按未完成处理",
-    )
-
-
 # ===== 短信验证码 =====
 
 class SmsSendRequest(BaseModel):

app/schemas/compare_record.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 
 # ===== 上报请求 =====
@@ -21,36 +21,8 @@ class ComparisonItemIn(BaseModel):
 
     name: str
     qty: int = 1
-    # specs 仅供比价记录展示(admin-web 详情 / app 记录页都按字符串数组渲染并 join)。
-    # pricebot(2026-06-27 嵌套规格统一)起 calibration 的 specs 可能是规格对象
-    # [{name, qty, sub_specs}] 而非字符串 → 下面的 before-validator 统一拍平成可读字符串,
-    # 兼容新旧两种输入、保持 list[str] 契约不变(下游零改动)。
-    # ⚠️ 两个坑都踩过, 必须"拍平"而非别的: ① 直接声明 list[str] 不拍平 → 对象 specs 整条
-    # 422 被拒、不入库(同下方 platform_results list→dict 同类事故); ② 仅放宽成裸 list 又会让
-    # 下游 join 出 "[object Object]"/对象 toString 的乱码。
     specs: list[str] | None = None
 
-    @field_validator("specs", mode="before")
-    @classmethod
-    def _flatten_specs(cls, v: object) -> object:
-        """pricebot 规格对象 [{name, qty, sub_specs}] → 可读字符串数组; 字符串元素原样保留;
-        非 list 原样交还(让 pydantic 照常报类型错)。嵌套规格拼成 '主项(子1,子2)'。"""
-        if not isinstance(v, list):
-            return v
-        out: list[str] = []
-        for it in v:
-            if isinstance(it, str):
-                s = it
-            elif isinstance(it, dict):
-                name = str(it.get("name") or "").strip()
-                subs = [str(x).strip() for x in (it.get("sub_specs") or []) if str(x).strip()]
-                s = f"{name}({','.join(subs)})" if name and subs else (name or ",".join(subs))
-            else:
-                continue
-            if s:
-                out.append(s)
-        return out
-
 
 class AppliedCouponIn(BaseModel):
     """单笔已用优惠(来自 comparison_results[].applied_coupons)。amount 单位:元、正数。"""
@@ -123,7 +95,6 @@ class ComparisonRecordIn(BaseModel):
     # pricebot done.params.trace_url 原样上报,落库供记录页「复制调试链接」(dir 名含落盘
     # 时分秒前端拼不出,必须由后端透传)。
     trace_url: str | None = Field(None, description="本次比价公网调试链接")
-    total_ms: int | None = Field(None, description="整场比价墙钟耗时(ms)")
 
     # ===== debug 维度(客户端采集上报;旧客户端不带 → None。仅 admin 比价记录页用)=====
     # 必须显式声明,否则 model_dump() 落 raw_payload 时被 pydantic 静默丢弃(同上面 coupon_saved 的坑)。
@@ -173,7 +144,6 @@ class ComparisonRecordOut(BaseModel):
     items: list = []
     comparison_results: list = []
     skipped_dish_names: list = []
-    total_ms: int | None = None
     # 「已下单」(店级):该店名在该用户真实下单(source='compare')里出现过即 True。
     # 由 list_records 动态算出挂在 ORM 实例上(非 DB 列),from_attributes 读出;缺省 False。
     ordered: bool = False

app/schemas/device.py

@@ -3,15 +3,12 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict
 
 
 class DeviceRegisterRequest(BaseModel):
     device_id: str
-    # registration_id 为旧极光字段,新推送链路统一使用 push_vendor + push_token。
     registration_id: str | None = None
-    push_vendor: str | None = None
-    push_token: str | None = None
     platform: str = "android"
     app_version: str | None = None
 
@@ -21,8 +18,6 @@ class HeartbeatRequest(BaseModel):
     source: str = "service"          # service | app
     accessibility_enabled: bool = True
     registration_id: str | None = None
-    push_vendor: str | None = None
-    push_token: str | None = None
 
 
 class DeviceOut(BaseModel):
@@ -31,8 +26,6 @@ class DeviceOut(BaseModel):
     id: int
     device_id: str
     registration_id: str | None
-    push_vendor: str | None
-    push_token: str | None
     ever_protected: bool
     liveness_state: str
     last_heartbeat_at: datetime | None
@@ -53,17 +46,3 @@ class LivenessOut(BaseModel):
 
 class LivenessAckRequest(BaseModel):
     device_id: str
-
-
-class PushTestRequest(BaseModel):
-    device_id: str
-    delay_seconds: int = Field(default=10, ge=0, le=60)
-    push_vendor: str | None = None
-    push_token: str | None = None
-    registration_id: str | None = None
-
-
-class PushTestOut(BaseModel):
-    ok: bool = True
-    delay_seconds: int
-    has_push_token: bool

app/schemas/invite.py

@@ -10,12 +10,7 @@ class InviteInfoOut(BaseModel):
     invite_code: str                # 我的邀请码
     share_url: str                  # 落地页链接(含 ?ref=),前端据此生成二维码 + 复制分享
     invited_count: int              # 已成功邀请人数
-    coins_earned: int               # 累计从邀请获得的金币(v1 口径;v2 邀请人改发奖励金)
-    reward_balance_cents: int = 0   # v2 可提现邀请奖励金(分)
-    reward_withdrawn_cents: int = 0 # v2 累计提现成功的邀请奖励金(分)
-    countdown_days_left: int = 7            # v2 本轮剩余天数(7 天 1 轮)
-    countdown_is_fresh_round: bool = False  # 是否刚进入新一轮(非首轮第1天)
-    countdown_text: str = ""                # 倒计时展示文案(前端直接显示,新轮含换行)
+    coins_earned: int               # 累计从邀请获得的金币
 
 
 class LandingTrackIn(BaseModel):

app/schemas/welfare.py

@@ -16,7 +16,6 @@ class CoinAccountOut(BaseModel):
 
     coin_balance: int = Field(..., description="当前金币余额")
     cash_balance_cents: int = Field(..., description="当前现金余额(分)")
-    invite_cash_balance_cents: int = Field(0, description="邀请奖励金余额(分,与现金隔离)")
     total_coin_earned: int = Field(..., description="累计赚取金币")
 
 
@@ -124,7 +123,6 @@ class UnbindWechatResultOut(BaseModel):
 
 class WithdrawRequest(BaseModel):
     amount_cents: int = Field(..., gt=0, description="提现金额(分)")
-    source: str = Field("coin_cash", description="提现账户:coin_cash(金币现金) / invite_cash(邀请奖励金)")
     user_name: str | None = Field(None, description="实名(达额时微信要求,可空)")
     out_bill_no: str | None = Field(
         None, description="客户端幂等键(商户单号):同号重试不重复转账。不传则服务端生成"
@@ -168,7 +166,6 @@ class WithdrawOrderOut(BaseModel):
     id: int
     out_bill_no: str
     amount_cents: int
-    source: str = Field("coin_cash", description="提现账户:coin_cash / invite_cash")
     status: str = Field(..., description="reviewing(待审核) / pending / success / failed / rejected")
     wechat_state: str | None = None
     fail_reason: str | None = None

data/media/dl.html

@@ -8,231 +8,122 @@
 <style>
   * { margin:0; padding:0; box-sizing:border-box; -webkit-tap-highlight-color:transparent; }
   html,body { height:100%; }
-  button { border:0; background:none; color:inherit; font:inherit; cursor:pointer; }
   body {
-    min-height:100vh;
-    display:flex; align-items:center; justify-content:center;
-    background:#000;
-    font-family:-apple-system,BlinkMacSystemFont,"PingFang SC","Helvetica Neue",sans-serif;
+    font-family:-apple-system,BlinkMacSystemFont,"PingFang SC","Microsoft YaHei",sans-serif;
+    background:linear-gradient(165deg,#FF7A3D 0%,#FF3B30 52%,#E0245E 100%);
+    color:#fff; min-height:100%; display:flex; flex-direction:column;
+    align-items:center; justify-content:center; padding:40px 26px; text-align:center;
+    overflow-x:hidden;
   }
-  /* 设备框：桌面预览成 375×667 卡片；真机（≤430）铺满全屏 */
-  .device {
-    position:relative; flex:0 0 auto;
-    width:375px; height:667px;
-    overflow:hidden; border-radius:32px;
-    background:#FFF4CD;
-    box-shadow:0 20px 60px rgba(0,0,0,.5);
-    color:#fff;
+  .logo {
+    width:104px; height:104px; border-radius:26px; background:#fff;
+    display:flex; align-items:center; justify-content:center; font-size:52px;
+    box-shadow:0 14px 34px rgba(0,0,0,.22); margin-bottom:24px;
   }
-  .download-landing {
-    position:absolute; inset:0; z-index:0; overflow:hidden;
-    background:
-      url('coupon-page-bg.png') center center / cover no-repeat,
-      #FFF4CD;
-    color:#1A1A1A; text-align:center;
-  }
-  .download-content {
-    position:relative; z-index:1; height:100%;
-    padding:82px 20px 0;
-    display:flex; flex-direction:column; align-items:center; overflow:hidden;
-  }
-  .brand-lockup {
-    display:flex; align-items:center; justify-content:center; gap:16px;
-  }
-  .ad-logo {
-    width:53px; height:53px; border-radius:13px; display:block;
-    box-shadow:0 10px 24px rgba(255,179,0,.24);
-  }
-  .ad-title {
-    color:#1A1A1A; font-size:32px; font-weight:800; line-height:1.15;
-    letter-spacing:0; white-space:nowrap;
-  }
-  .ad-subtitle {
-    margin-top:22px; max-width:100%;
-    color:#000; font-size:18px; font-weight:400; line-height:1.25;
-    display:flex; align-items:center; justify-content:center; gap:10px; white-space:nowrap;
-  }
-  .ad-subtitle::before, .ad-subtitle::after {
-    content:""; width:5px; height:5px; border-radius:50%; background:#000; flex:0 0 auto;
-  }
-  .bottom-area {
-    position:relative; z-index:2; width:100%; max-width:266px;
-    margin-top:11px;
-    display:grid; grid-template-columns:1fr; justify-items:stretch; align-content:center; gap:10px;
-  }
-  .download-btn {
-    width:100%; height:39px; border-radius:22px; color:#1A1A1A;
-    font-family:inherit; font-size:14px; line-height:1; font-weight:700; letter-spacing:0;
-    display:flex; align-items:center; justify-content:center;
-  }
-  .download-btn.primary {
-    background:linear-gradient(180deg,#FFE066 0%,#FFC400 100%);
-    box-shadow:inset 0 1px 0 rgba(255,255,255,.82), 0 7px 18px rgba(255,179,0,.24);
-  }
-  .download-btn.secondary {
-    background:#fff; border:1px solid #DDD; color:#1A1A1A; font-size:13px;
-    box-shadow:0 2px 8px rgba(122,79,0,.08);
-  }
-  .download-btn:active { transform:translateY(1px); }
-  /* 底部两条卖点文案，压在背景插画两张卡片下方 */
-  /* 卖点卡：CSS 实体卡片（白底+图标），不再靠底图死框，字自适应（对齐 WeChat.html PR siyi 改版）*/
-  .download-feature-card {
-    position:absolute; z-index:2; pointer-events:none;
-    height:62px; padding:0 10px; border-radius:22px;
-    background:#FFFAEE;
-    box-shadow:inset 0 1px 0 rgba(255,255,255,.86), 0 6px 14px rgba(122,79,0,.08);
-    display:flex; align-items:center; gap:8px; color:#1A1A1A;
-  }
-  .download-feature-card.left  { left:24px;  top:576px; width:146px; }
-  .download-feature-card.right { left:199px; top:576px; width:156px; }
-  .download-feature-icon {
-    width:27px; height:27px; flex:0 0 auto; display:block; color:#FFAE00;
-  }
-  .download-feature-icon svg {
-    display:block; width:100%; height:100%; filter:drop-shadow(0 1px 0 rgba(255,255,255,.7));
-  }
-  .download-feature-copy {
-    min-width:0; flex:1 1 auto; text-align:left; white-space:nowrap; letter-spacing:0;
-  }
-  .download-feature-title {
-    display:block; font-size:13px; font-weight:800; line-height:1.12; letter-spacing:0;
-  }
-  .download-feature-desc {
-    display:block; margin-top:5px; color:#5A3A00; font-size:10px; font-weight:400; line-height:1.1;
+  h1 { font-size:30px; font-weight:800; letter-spacing:1px; }
+  .slogan { margin-top:12px; font-size:16px; line-height:1.7; opacity:.95; max-width:300px; }
+  .feats { margin-top:26px; display:flex; flex-direction:column; gap:12px; width:100%; max-width:320px; }
+  .feat { background:rgba(255,255,255,.16); border-radius:14px; padding:13px 16px; font-size:15px; display:flex; align-items:center; gap:10px; }
+  .feat b { font-weight:700; }
+  .btn {
+    margin-top:34px; width:100%; max-width:320px; border:none; cursor:pointer;
+    background:#fff; color:#FF3B30; font-size:19px; font-weight:800;
+    padding:17px 0; border-radius:999px; box-shadow:0 10px 26px rgba(0,0,0,.22);
+    display:flex; align-items:center; justify-content:center; gap:9px;
   }
+  .btn:active { transform:translateY(1px); opacity:.92; }
+  .hint { margin-top:16px; font-size:13px; opacity:.85; }
+  .foot { margin-top:30px; font-size:12px; opacity:.6; line-height:1.6; max-width:320px; }
+
   /* 微信内"去浏览器打开"引导蒙层 */
-  .download-guide-layer {
-    position:absolute; inset:0; z-index:30; display:none;
-    background:rgba(0,0,0,.85); color:#fff;   /* 半透明黑：透出底层（新版）下载页，隐约可见 */
-  }
-  .download-guide-layer.show { display:block; }
-  .download-guide-arrow {
-    position:absolute; top:17px; right:9px; width:80px; height:60px;
-  }
-  .download-guide-arrow-svg {
-    display:block; width:100%; height:100%; overflow:hidden; shape-rendering:geometricPrecision;
-  }
-  .download-guide-title {
-    position:absolute; top:129px; right:16px; width:218px; margin:0;
-    color:#fff; font-size:17px; font-weight:800; line-height:1.32; letter-spacing:0;
-    text-align:right; text-shadow:0 2px 8px rgba(0,0,0,.36);
-  }
-  .download-guide-title .guide-dots { color:#FFD95A; letter-spacing:4px; }
-  .download-guide-title .guide-highlight { color:#FFD95A; white-space:nowrap; }
-  .download-guide-title .guide-final {
-    display:block; margin-top:10px; color:rgba(255,255,255,.94);
-    font-size:13px; font-weight:700; line-height:1.38;
-  }
-  .download-guide-title .guide-target { color:#FFD95A; white-space:nowrap; }
-  .guide-dismiss {
-    position:absolute; bottom:30px; left:0; right:0; text-align:center;
-    font-size:14px; color:#fff; opacity:.75;
-  }
-  .toast {
-    position:absolute; left:50%; bottom:118px; z-index:20;
-    transform:translateX(-50%) translateY(12px);
-    padding:9px 14px; border-radius:12px; background:rgba(0,0,0,.78);
-    color:#fff; font-size:14px; opacity:0; pointer-events:none;
-    transition:opacity .2s ease, transform .2s ease;
-  }
-  .toast.show { opacity:1; transform:translateX(-50%) translateY(0); }
-  @media (max-width:430px) {
-    /* 真机:宽满屏、高按 375:667 锁比例(不拉伸变形),顶对齐、底部留白用底色填。
-       这样底图(含价格卡)与卖点卡片同处 667 坐标基准,卡片用回 top:576,不再相互错位/遮挡。 */
-    body { align-items:flex-start; background:#FFF4CD; }
-    .device { width:100vw; height:calc(100vw * 667 / 375); border-radius:0; box-shadow:none; }
+  #wxmask {
+    display:none; position:fixed; inset:0; z-index:9999;
+    background:rgba(0,0,0,.86); padding:18px;
   }
+  #wxmask.show { display:block; }
+  .arrow { position:absolute; top:8px; right:14px; width:120px; }
+  .wxtip { position:absolute; top:150px; right:18px; left:18px; text-align:right; }
+  .wxtip .big { font-size:21px; font-weight:800; line-height:1.5; }
+  .wxtip .big em { color:#FFD24D; font-style:normal; }
+  .wxtip .sub { margin-top:14px; font-size:15px; line-height:1.8; opacity:.9; }
+  .wxsteps { margin-top:26px; text-align:left; background:rgba(255,255,255,.1); border-radius:14px; padding:18px 18px; font-size:15px; line-height:2; }
+  .wxsteps .n { display:inline-block; width:22px; height:22px; line-height:22px; text-align:center; border-radius:50%; background:#FFD24D; color:#333; font-weight:800; font-size:13px; margin-right:8px; }
+  .closebar { position:absolute; bottom:30px; left:0; right:0; text-align:center; font-size:14px; opacity:.7; }
 </style>
 </head>
 <body>
-<main class="device" aria-label="傻瓜比价下载页">
-  <section class="download-landing" aria-label="傻瓜比价下载页">
-    <div class="download-content">
-      <div class="brand-lockup">
-        <img class="ad-logo" src="sb-brand.png" alt="傻瓜比价">
-        <h1 class="ad-title">傻瓜比价</h1>
-      </div>
-      <p class="ad-subtitle">跨平台比价，用傻瓜</p>
-      <div class="bottom-area" aria-label="下载入口">
-        <button class="download-btn primary"  id="dlbtn"  type="button">应用商店下载</button>
-        <button class="download-btn secondary" id="dlbtn2" type="button">官网下载</button>
-      </div>
-    </div>
-    <div class="download-feature-card left" aria-label="优惠券轻松领，羊毛全都不错过">
-      <span class="download-feature-icon" aria-hidden="true">
-        <svg viewBox="0 0 40 32" focusable="false">
-          <path d="M5 5h30a3 3 0 0 1 3 3v5.2a4.8 4.8 0 0 0 0 9.6V24a3 3 0 0 1-3 3H5a3 3 0 0 1-3-3v-1.2a4.8 4.8 0 0 0 0-9.6V8a3 3 0 0 1 3-3Z" fill="currentColor"/>
-          <path d="M20 10v12" fill="none" stroke="#FFF7CF" stroke-width="3" stroke-linecap="round"/>
-        </svg>
-      </span>
-      <span class="download-feature-copy">
-        <span class="download-feature-title">优惠券轻松领</span>
-        <span class="download-feature-desc">羊毛全都不错过</span>
-      </span>
-    </div>
-    <div class="download-feature-card right" aria-label="一键全网找底价，再也不用费力切屏">
-      <span class="download-feature-icon" aria-hidden="true">
-        <svg viewBox="0 0 40 32" focusable="false">
-          <rect x="5" y="16" width="8" height="11" rx="2" fill="currentColor"/>
-          <rect x="16" y="9" width="8" height="18" rx="2" fill="currentColor"/>
-          <rect x="27" y="3" width="8" height="24" rx="2" fill="currentColor"/>
-        </svg>
-      </span>
-      <span class="download-feature-copy">
-        <span class="download-feature-title">一键全网找底价</span>
-        <span class="download-feature-desc">再也不用费力切屏</span>
-      </span>
-    </div>
-  </section>
+  <div class="logo">🛒</div>
+  <h1>傻瓜比价</h1>
+  <div class="slogan">买什么都先比一比<br>自动帮你找全网最低价</div>
 
-  <!-- 微信内引导：跳出微信去浏览器 -->
-  <div class="download-guide-layer" id="wxGuide" role="dialog" aria-modal="true" aria-labelledby="wxGuideTitle">
-    <div class="download-guide-arrow" aria-hidden="true">
-      <svg class="download-guide-arrow-svg" viewBox="0 0 80 60" focusable="false">
-        <path d="M0 60 C16 32 39 15 66 15" fill="none" stroke="#FFD95A" stroke-width="5.5" stroke-linecap="round"/>
-        <path d="M59 5 L77 14 L63 31" fill="none" stroke="#FFD95A" stroke-width="7" stroke-linecap="round" stroke-linejoin="round"/>
-      </svg>
-    </div>
-    <h2 class="download-guide-title" id="wxGuideTitle">
-      点击右上角 <span class="guide-dots">···</span><br>
-      选择「<span class="guide-highlight">在浏览器打开</span>」
-      <span class="guide-final">在浏览器里按提示<span class="guide-target">去应用商店下载</span></span>
-    </h2>
-    <div class="guide-dismiss" id="wxGuideDismiss">我知道了 ✕</div>
+  <div class="feats">
+    <div class="feat">🍔 <span>点外卖前一键比价,<b>美团/京东/淘宝</b>到手价一目了然</span></div>
+    <div class="feat">🎟️ <span>自动领遍各平台<b>红包券</b>,能省的一分不漏</span></div>
+    <div class="feat">💰 <span>省下的钱看得见,还能<b>赚金币提现</b></span></div>
   </div>
 
-  <div class="toast" id="toast" role="status" aria-live="polite"></div>
-</main>
+  <button class="btn" id="dlbtn">🏪 打开应用商店下载</button>
+  <div class="hint" id="hint">Android 安卓版 · 应用商店安全下载</div>
+
+  <div class="foot">
+    将前往应用商店下载,安全放心。<br>
+    本页为内部测试页。
+  </div>
+
+  <!-- 微信内引导:跳出微信去浏览器 -->
+  <div id="wxmask">
+    <svg class="arrow" viewBox="0 0 120 130" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path d="M30 120 C 30 70, 55 40, 95 28" stroke="#FFD24D" stroke-width="6" stroke-linecap="round" fill="none" stroke-dasharray="2 13"/>
+      <path d="M95 28 L 78 30 M95 28 L 92 46" stroke="#FFD24D" stroke-width="6" stroke-linecap="round"/>
+    </svg>
+    <div class="wxtip">
+      <div class="big">点击右上角 <em>···</em><br>选择「<em>在浏览器打开</em>」</div>
+      <div class="sub">微信里无法直接下载安装包<br>需在系统浏览器中完成下载</div>
+      <div class="wxsteps">
+        <div><span class="n">1</span>点右上角的 ··· 菜单</div>
+        <div><span class="n">2</span>选择「在浏览器打开」</div>
+        <div><span class="n">3</span>在浏览器里按提示去应用商店下载</div>
+      </div>
+    </div>
+    <div class="closebar" id="wxclose">我知道了 ✕</div>
+  </div>
 
 <script>
-  // ===== 应用商店跳转：用包名（App 唯一标识）定位到傻瓜比价的商店下载页 =====
-  // 主：market:// 唤起手机自带应用市场（华为/小米/OV）；兜底：应用宝网页（任何浏览器都能开）。
+  // 应用商店跳转:用包名(App 唯一标识 = 身份证号)定位到傻瓜比价的商店下载页。
+  // 主:market:// 唤起手机自带应用市场(华为/小米/OV);兜底:应用宝网页(任何浏览器都能开)。
   var PKG = "com.jishisongfu.shaguabijia";
   var MARKET_URL = "market://details?id=" + PKG;
   var YYB_URL = "https://a.app.qq.com/o/simple.jsp?pkgname=" + PKG;
   var ua = navigator.userAgent || "";
   var isWeChat = /MicroMessenger/i.test(ua);
   var isIOS = /iPhone|iPad|iPod/i.test(ua);
-  var ref = new URLSearchParams(location.search).get("ref");  // 邀请码（来自二维码 URL ?ref=）
+  var isAndroid = /Android/i.test(ua);
+  var ref = new URLSearchParams(location.search).get("ref");  // 邀请码(来自二维码 URL ?ref=)
 
-  // ===== 指纹归因兜底：页面加载即上报访问者指纹，后端存 invite_fingerprint 表 =====
-  // 当 APK 首启读剪贴板失败（被覆盖）时，客户端用 (IP+屏幕+UA 机型) 反查 7 天内最近一条 → 撞出原邀请人。
-  // 任何失败都 silent，不影响下载主流程。
+  // 【任务 3】指纹归因兜底:页面加载即上报访问者指纹,后端存 invite_fingerprint 表。
+  // 当 APK 首启读剪贴板失败(被覆盖)时,客户端会用 (IP+屏幕+UA 解析的手机型号) 反查
+  // 本表 7 天内最近一条匹配 → 撞库出原邀请人 → 走原 bind 流程。
+  // 任何失败都 silent(不影响下载主流程);后端 invalid_code/no_ip 也只返 200。
   if (ref) {
-    // screen 报【物理像素】= CSS 像素 × devicePixelRatio，跟 Android dm.widthPixels 对齐，否则撞不上库。
+    // screen 报【物理像素】= CSS 像素 × devicePixelRatio,跟 Android dm.widthPixels(物理像素)对齐。
+    // 不同设备 DPR 不同(常见 2/2.5/3/3.5),CSS 像素直接报会跟客户端不对齐 → 撞不上库。
     var _dpr = window.devicePixelRatio || 1;
     var _sw = Math.round(screen.width * _dpr);
     var _sh = Math.round(screen.height * _dpr);
     fetch("/api/v1/invite/landing-track", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ref: ref, screen: _sw + "x" + _sh }),
-    }).catch(function () {});  // silent，绝不阻断下载
+      body: JSON.stringify({
+        ref: ref,
+        screen: _sw + "x" + _sh,
+        // IP / UA 服务端从 HTTP 头自动拿,无需 JS 上报
+      }),
+    }).catch(function () {});  // silent,绝不阻断下载
   }
 
-  // ===== 把邀请码写进剪贴板，APK 首启读出完成归因（deferred deeplink）=====
-  // 浏览器要求：必须在用户点击手势里调用 + HTTPS 下才允许写。
-  function legacyCopy(payload) {                 // 老 webview / 无 clipboard API 兜底
+  // 把邀请码写进剪贴板,APK 首启时读出来完成归因(deferred deeplink 的关键一步)。
+  // 浏览器要求:必须在用户点击手势里调用 + HTTPS 下才允许写。
+  function legacyCopy(payload) {                // 老 webview / 无 clipboard API 兜底
     try {
       var ta = document.createElement("textarea");
       ta.value = payload; ta.style.position = "fixed"; ta.style.top = "-1000px"; ta.style.opacity = "0";
@@ -240,48 +131,50 @@
       document.execCommand("copy"); document.body.removeChild(ta);
     } catch (e) {}
   }
-  function copyInviteCode() {                    // 返回 Promise，完成后才下载，避免异步写入被打断
+  function copyInviteCode() {                   // 返回 Promise(完成后才下载,避免异步写入被打断)
     if (!ref) return Promise.resolve();
     var payload = "SGBJ_INVITE:" + ref;
-    legacyCopy(payload);                          // 同步兜底：在用户手势内立刻 execCommand 写一次（最可靠）
+    legacyCopy(payload);                         // 同步兜底:在用户手势内立刻 execCommand 写一次(最可靠)
     if (navigator.clipboard && navigator.clipboard.writeText) {
-      return navigator.clipboard.writeText(payload).catch(function () {});
+      return navigator.clipboard.writeText(payload).catch(function () {});  // 现代 API 锦上添花,失败无妨
     }
     return Promise.resolve();
   }
-  // 跳应用商店：先 market:// 唤起自带商店；2.5s 内页面没切后台 → 兜底跳应用宝网页，不让用户卡死。
+  // 跳应用商店:先尝试 market:// 唤起手机自带商店;若 2.5s 内页面没切到后台
+  //(= 没有商店接管 market://),兜底跳应用宝网页下载页,不让用户卡死。
   function openStore() {
     var jumped = false;
-    document.addEventListener("visibilitychange", function () { if (document.hidden) jumped = true; });
-    window.addEventListener("pagehide", function () { jumped = true; });
-    window.addEventListener("blur", function () { jumped = true; });
-    window.location.href = MARKET_URL;
-    setTimeout(function () { if (!jumped) window.location.href = YYB_URL; }, 2500);
+    function markJumped() { jumped = true; }           // 页面切到后台 = 商店已唤起
+    document.addEventListener("visibilitychange", function () {
+      if (document.hidden) jumped = true;
+    });
+    window.addEventListener("pagehide", markJumped);
+    window.addEventListener("blur", markJumped);
+    window.location.href = MARKET_URL;                 // 唤起自带应用市场
+    setTimeout(function () {
+      if (!jumped) window.location.href = YYB_URL;     // 没唤起 → 应用宝网页兜底
+    }, 2500);
   }
 
-  // ===== 微信内引导蒙层 =====
-  var wxGuide = document.getElementById("wxGuide");
-  function showWxGuide() { wxGuide.classList.add("show"); }
-  function hideWxGuide() { wxGuide.classList.remove("show"); }
-  document.getElementById("wxGuideDismiss").addEventListener("click", hideWxGuide);
-  if (isWeChat) showWxGuide();   // 微信里一进页面就提示去浏览器（微信内下载必被拦）
+  var hint = document.getElementById("hint");
+  if (isIOS) hint.textContent = "检测到 iPhone · iOS 版请前往 App Store";
 
-  function showToast(text) {
-    var toast = document.getElementById("toast");
-    toast.textContent = text; toast.classList.add("show");
-    clearTimeout(showToast.timer);
-    showToast.timer = setTimeout(function () { toast.classList.remove("show"); }, 1400);
-  }
+  var mask = document.getElementById("wxmask");
+  function showMask(){ mask.classList.add("show"); }
+  function hideMask(){ mask.classList.remove("show"); }
+  document.getElementById("wxclose").addEventListener("click", hideMask);
 
-  // ===== 下载按钮：微信内引导去浏览器；iOS 提示；安卓写邀请码 + 跳应用商店 =====
-  function handleDownload() {
-    if (isWeChat) { showWxGuide(); return; }
-    if (isIOS)    { alert("iOS 版即将上线，请前往 App Store 搜索「傻瓜比价」"); return; }
-    copyInviteCode();   // 先把邀请码写进剪贴板（供 App 首启归因），链路丢了还有 landing-track 指纹兜底
+  // 微信里一进页面就提示去浏览器打开(下载在微信内必被拦)
+  if (isWeChat) showMask();
+
+  document.getElementById("dlbtn").addEventListener("click", function(){
+    if (isWeChat) { showMask(); return; }           // 微信内:引导去浏览器
+    if (isIOS)    { alert("iOS 版即将上线,请前往 App Store 搜索「傻瓜比价」"); return; }
+    // 安卓浏览器:先把邀请码写进剪贴板(legacyCopy 同步写、最可靠),再跳应用商店。
+    // 剪贴板供 App 首启归因;链路长易丢时由指纹兜底(已上报 landing-track)接住。
+    copyInviteCode();
     openStore();
-  }
-  document.getElementById("dlbtn").addEventListener("click", handleDownload);
-  document.getElementById("dlbtn2").addEventListener("click", handleDownload);
+  });
 </script>
 </body>
 </html>

docs/api/admin-ad-revenue-report.md

@@ -27,11 +27,8 @@
   | `date_to` | string | =`date_from` | 结束日 北京时间 `YYYY-MM-DD`,**闭区间**;单日时与 `date_from` 相同 |
   | `user_id` | int | 全部 | 只看某用户;不传=所有用户 |
   | `ad_type` | string | 全部 | `reward_video` / `feed` / `draw`;不传=全部类型 |
-  | `feed_scene` | string | 全部 | `comparison`(比价)/ `coupon`(领券)/ `welfare`(福利);**全局筛选**,同时作用于明细 / 合计 / `daily`·`hourly` 趋势;不传=全部场景 |
   | `granularity` | string | `day` | `day`=按天 / `hour`=按小时(聚合键再加北京时间小时 0–23);**区间>1 天建议用 day** |
-  | `limit` | int(1~1000) | 500 | **每页条数**(分页大小);`total`/`total_*`/`daily`/`hourly` 按全量统计不受分页影响 |
-  | `offset` | int(≥0) | 0 | 分页偏移(已跳过条数)=(页码−1)×`limit` |
-  | `sort` | string | `time` | 明细排序:`time`=按时间倒序(新→旧) / `ecpm`=按 eCPM 数值倒序 |
+  | `limit` | int(1~1000) | 500 | **展示**明细组数(截断;`total`/`total_*`/`daily` 按全量统计不受影响) |
 
   约束:`date_to` 不早于 `date_from`、区间最长 **92 天**、日期须 `YYYY-MM-DD`,否则 `422`。
 
@@ -39,18 +36,15 @@
   | 字段 | 类型 | 说明 |
   |---|---|---|
   | `date_from` / `date_to` | string | 报表起止日期(闭区间) |
-  | `daily` | `AdRevenueDaily[]` | 按日期汇总序列(全量,供按天趋势图;不受分页影响) |
-  | `hourly` | `AdRevenueHourly[]` | 按小时汇总序列(全量,供按小时趋势图;**仅 `granularity=hour` 时非空**;不受分页影响) |
-  | `type_stats` | `{[ad_type]: AdRevenueTypeStat}` | 按广告类型(`ad_type`)小计(全量);前端取 `draw` / `reward_video` 做分类大盘 |
-  | `dau` | int \| null | 今日活跃用户数(复用大盘口径 `last_login_at`,今日登录过);**仅查询=今日单天时有值**,历史/多天为 `null` |
-  | `total` | int | 当前筛选下的**分页总条数**(全量,不受分页影响;= 前端分页器 total) |
-  | `truncated` | bool | 当前页之后是否还有更多事件(`len(events) > offset + limit`) |
+  | `daily` | `AdRevenueDaily[]` | 按日期汇总序列(全量,供按天趋势图;不受 `limit` 影响) |
+  | `total` | int | 聚合组**总数**(全量,不受 `limit` 影响) |
+  | `truncated` | bool | 明细是否被 `limit` 截断 |
   | `total_impressions` | int | 全量展示条数合计 |
   | `total_revenue_yuan` | float | 全量收益合计(元) |
   | `total_expected_coin` | int | 全量应发金币合计 |
   | `total_actual_coin` | int | 全量实发金币合计 |
   | `mismatch_count` | int | 应发≠实发的组数(=0 说明全部按公式发放) |
-  | `items` | `AdRevenueRow[]` | 逐条广告事件(**按时间倒序:新→旧**);`limit`/`offset` 对全量做分页切片,返回当前页 |
+  | `items` | `AdRevenueRow[]` | 聚合明细(按 日期→用户→类型→代码位 排序) |
 
 ### AdRevenueDaily(`daily[]` — 按天趋势)
 | 字段 | 类型 | 说明 |
@@ -61,21 +55,6 @@
 | `expected_coin` | int | 当天应发金币合计 |
 | `actual_coin` | int | 当天实发金币合计 |
 
-### AdRevenueHourly(`hourly[]` — 按小时趋势,仅 `granularity=hour` 时非空)
-| 字段 | 类型 | 说明 |
-|---|---|---|
-| `hour` | int | 北京时间小时 0–23 |
-| `impressions` | int | 该小时展示条数合计 |
-| `revenue_yuan` | float | 该小时预估收益合计(元) |
-| `expected_coin` | int | 该小时应发金币合计 |
-| `actual_coin` | int | 该小时实发金币合计 |
-
-### AdRevenueTypeStat(`type_stats[ad_type]` — 分广告类型小计,供大盘第二行)
-| 字段 | 类型 | 说明 |
-|---|---|---|
-| `impressions` | int | 该类型展示条数合计 |
-| `revenue_yuan` | float | 该类型预估收益合计(元);eCPM 由前端用 收益÷展示×1000 算 |
-
 ### AdRevenueRow(`items[]`)
 | 字段 | 类型 | 说明 |
 |---|---|---|

docs/guides/邀请功能-实现原理与本地测试.md

@@ -37,7 +37,7 @@ B 安装并首启 App
         └─ POST /api/v1/invite/bind { invite_code, channel="clipboard" }
         ↓
 后端 repositories/invite.py bind()
-  └─ 过四道防线 → 建 invite_relation(邀请金币已下线,不写金币流水)
+  └─ 过四道防线 → 建 invite_relation + 给 A、B 各发金币(同事务原子提交)
 ```
 
 手动填码这条:B 在邀请页输码 → `InviteRepository.bindManual()` → `POST /bind { channel="manual" }` → 同一个 `bind()`。
@@ -52,20 +52,20 @@ B 安装并首启 App
 |---|---|
 | 端点 | `app/api/v1/invite.py`:`GET /api/v1/invite/me`(返回 `invite_code` + `share_url` + 战绩)、`POST /api/v1/invite/bind`(绑定,`channel` = `clipboard` / `manual`)。**均需 Bearer 鉴权**。 |
 | share_url 构造 | `invite.py` 的 `my_invite`:`settings.INVITE_LANDING_URL + "?ref=" + code`。`INVITE_LANDING_URL` 在 `app/core/config.py`(默认 `https://app-api.shaguabijia.com/media/dl.html`)。 |
-| 业务逻辑 | `app/repositories/invite.py`:`ensure_code`(懒生成 6 位邀请码,去混淆字符集,唯一约束碰撞则换码)/ `resolve_inviter`(邀请码→邀请人,大小写不敏感)/ `bind`(下面详述)/ `get_stats`(已邀人数 + 兼容累计金币字段,当前恒为 0)。 |
+| 业务逻辑 | `app/repositories/invite.py`:`ensure_code`(懒生成 6 位邀请码,去混淆字符集,唯一约束碰撞则换码)/ `resolve_inviter`(邀请码→邀请人,大小写不敏感)/ `bind`(下面详述)/ `get_stats`(已邀人数 + 累计金币)。 |
 | 数据模型 | `app/models/invite.py` 的 `InviteRelation`(`inviter_user_id` / `invitee_user_id` / `channel` / `status` / `inviter_coin` / `invitee_coin` / `created_at`)+ `app/models/user.py` 的 `User.invite_code` 列。 |
 | 迁移 | `alembic/versions/invite_code_and_relation.py`:给 `user` 加 `invite_code`(唯一索引)+ 建 `invite_relation` 表。`down_revision = 11a1d08c6f55`。 |
 | 收发模型 | `app/schemas/invite.py`:`InviteInfoOut` / `BindInviteIn` / `BindInviteOut`。 |
-| 新人窗口 | `app/core/rewards.py`:`INVITE_NEW_USER_WINDOW_HOURS`(72)。邀请金币已下线,不再配置邀请金币常量。 |
+| 奖励常量 | `app/core/rewards.py`:`INVITE_INVITER_COINS` / `INVITE_INVITEE_COINS`(各 10000 = 1 元)、`INVITE_NEW_USER_WINDOW_HOURS`(72)。 |
 
 **`bind()` 的四道防线(防重复 / 防刷,看 `repositories/invite.py`):**
 
-1. **被邀请人唯一**:`invitee_user_id` 唯一约束 → 一个 B 只能被绑一次(幂等键,重复返回 `already_bound`,不重复绑定)。
+1. **被邀请人唯一**:`invitee_user_id` 唯一约束 → 一个 B 只能被绑一次(幂等键,重复返回 `already_bound`,不重复发奖)。
 2. **自邀屏蔽**:`inviter == invitee` → `self_invite`。
-3. **新人闸**:`_is_new_user`(B 的 `created_at` 在 `INVITE_NEW_USER_WINDOW_HOURS` = 72h 内)才生效,挡存量老用户互相填码刷关系 → 否则 `not_eligible`。
+3. **新人闸**:`_is_new_user`(B 的 `created_at` 在 `INVITE_NEW_USER_WINDOW_HOURS` = 72h 内)才发奖,挡存量老用户互相填码薅羊毛 → 否则 `not_eligible`。
 4. **手机号唯一**(天然限量):每个 B = 一个真实手机号账号。
 
-邀请金币已下线:`bind()` 只记录绑定关系,不再写 `coin_transaction`;响应里的金币字段保留兼容旧客户端,当前恒为 0。
+发金币复用 `repositories/wallet.py` 的 `grant_coins`,与建关系记录在**同一事务**提交,保证"建关系 + 双方加金币"原子。
 
 ### 3.2 前端(shaguabijia-app-android)
 
@@ -120,7 +120,7 @@ B 安装并首启 App
 ### 4.4 测试硬约束 / 坑(都是机制,不是 bug)
 
 - **B 必须用新手机号**:`invitee_user_id` 唯一,一个 B 只能绑一次;反复测要换号(或手删 `invite_relation` 那行 + 回滚金币)。
-- **72h 新人闸**:B 注册后 72 小时内绑定才生效(刚注册肯定满足)。
+- **72h 新人闸**:B 注册后 72 小时内绑才发奖(刚注册肯定满足)。
 - **A ≠ B**:自邀被屏蔽。
 - **B 从点下载到首启 App 之间别复制别的东西**:剪贴板会被覆盖 → 归因丢(剪贴板 deferred deeplink 的固有脆弱性)。
 - **笔记本 IP 别变**:debug 包把 `BASE_URL` 的 IP 烧死在编译期,DHCP 一换就连不上 → 给笔记本固定个 LAN IP。

h5/shared/api.js

@@ -1,52 +0,0 @@
-/**
- * SGApi —— H5 调 app-server 后端的薄封装。
- *
- * 同源：H5 由 app-server 的 /media/h5/ 托管，后端在 /api/v1，同 host:port → 用相对路径、无 CORS。
- * 鉴权：JWT Bearer。token 经 SGBridge.getToken() 从原生取(原生持登录态)；浏览器调试走 bridge 的 mock token。
- * 401：交原生拉登录(requestLogin)兜底，本次请求按失败 reject；正式的 refresh 重试策略阶段2 再补。
- *
- * 依赖 shared/bridge.js 先加载(取 token)。
- */
-(function (global) {
-  'use strict';
-
-  var BASE = '/api/v1';
-
-  function authHeaders() {
-    var t = (global.SGBridge && global.SGBridge.getToken()) || '';
-    var h = { 'Content-Type': 'application/json' };
-    if (t) h['Authorization'] = 'Bearer ' + t;
-    return h;
-  }
-
-  function handle(res) {
-    if (res.status === 401) {
-      // 未授权：拉原生登录(异步)，本次请求按失败处理，调用方自行决定是否重试
-      if (global.SGBridge) global.SGBridge.requestLogin();
-      return Promise.reject(new Error('unauthorized'));
-    }
-    if (!res.ok) {
-      return res.text().then(function (t) {
-        return Promise.reject(new Error('http ' + res.status + ' ' + t));
-      });
-    }
-    // 204 / 空体兜底
-    return res.text().then(function (t) { return t ? JSON.parse(t) : null; });
-  }
-
-  /** GET /api/v1<path>。path 以 / 开头，如 '/savings/battle'。 */
-  function apiGet(path) {
-    return fetch(BASE + path, { method: 'GET', headers: authHeaders() }).then(handle);
-  }
-
-  /** POST /api/v1<path>，body 自动 JSON 序列化。 */
-  function apiPost(path, body) {
-    return fetch(BASE + path, {
-      method: 'POST',
-      headers: authHeaders(),
-      body: JSON.stringify(body || {}),
-    }).then(handle);
-  }
-
-  global.SGApi = { base: BASE, get: apiGet, post: apiPost };
-})(window);

h5/shared/bridge.js

@@ -1,162 +0,0 @@
-/**
- * SGBridge —— 傻瓜比价 H5 ↔ Android 原生 的桥。
- *
- * 背景：四个主 tab(首页/福利/记录/我的)由原生 Compose 改造为 WebView 加载本工程 H5。
- * H5 只负责"画 + 取后端数据"；凡需要原生能力(登录态 / 跳转 / 跳外卖 App / 比价领券 /
- * 权限 / 定位 / Toast / 激励视频)，一律经本桥调用原生。
- *
- * 协议两个方向：
- *  ① H5 → 原生：Android 端 WebView.addJavascriptInterface(obj, "SGBridgeNative")。
- *     obj 方法都是【同步】：查询类返回 String(JSON 或纯串)，动作类无返回。
- *  ② 原生 → H5：原生执行 evaluateJavascript("window.SGBridge._emit('<event>', '<json>')")。
- *     事件：onAuthChange(登录态变) / onBalanceChange(余额变) / onSigninChange(签到态变) / onResume(回前台刷新)。
- *
- * 离线兜底：浏览器里(无 SGBridgeNative)走 MOCK，便于不装 App 直接在本地 server 调样式 / 渲染。
- * 与原生实现对应：见 shaguabijia-app-android 的 SGBridge.kt(方法名逐个对齐本文件)。
- */
-(function (global) {
-  'use strict';
-
-  var native = global.SGBridgeNative || null;
-  var hasNative = !!native;
-
-  // ---- 离线 MOCK(仅无原生时生效，便于浏览器调试渲染；真机一律走 native) ----
-  var MOCK = {
-    authState: { loggedIn: true, userId: 1, nickname: '冰', avatarUrl: '', phone: '188****8888' },
-    token: 'mock-token-for-browser-debug',
-    deviceId: 'browser-debug-device',
-    appVersion: '0.0.0-debug',
-  };
-
-  function safeParse(s, fallback) {
-    try { return s ? JSON.parse(s) : fallback; } catch (e) { return fallback; }
-  }
-
-  // ====== 查询类(同步返回) ======
-
-  /** 当前登录态 + 用户基本信息 → {loggedIn, userId, nickname, avatarUrl, phone}。 */
-  function getAuthState() {
-    if (hasNative && native.getAuthState) return safeParse(native.getAuthState(), { loggedIn: false });
-    return MOCK.authState;
-  }
-
-  /** 后端鉴权用的 access token(空串=未登录)。原生持登录态，H5 调后端前取它拼 Bearer。 */
-  function getToken() {
-    if (hasNative && native.getToken) return native.getToken() || '';
-    return MOCK.token;
-  }
-
-  /** 设备唯一标识(心跳 / 领券状态查询等用)。 */
-  function getDeviceId() {
-    if (hasNative && native.getDeviceId) return native.getDeviceId() || '';
-    return MOCK.deviceId;
-  }
-
-  /** App 版本号。 */
-  function getAppVersion() {
-    if (hasNative && native.getAppVersion) return native.getAppVersion() || '';
-    return MOCK.appVersion;
-  }
-
-  /** 已安装的目标电商/外卖 App 包名数组(原生 InstalledApps 探测)。H5 选平台弹窗据此判真实装机态。 */
-  function getInstalledApps() {
-    if (hasNative && native.getInstalledApps) return safeParse(native.getInstalledApps(), []);
-    // MOCK(浏览器无原生):给主流已装,便于本地预览选平台弹窗正常显示"有"。
-    return ['com.sankuai.meituan', 'com.taobao.taobao', 'com.jingdong.app.mall', 'me.ele'];
-  }
-
-  /** 今日是否已领券(置灰「去领取」→「去查看」)。原生读 CompareButtonState(SP 按天);无桥默认 false。 */
-  function getCouponClaimedToday() {
-    if (hasNative && native.getCouponClaimedToday) return !!native.getCouponClaimedToday();
-    return false;
-  }
-
-  // ====== 动作类(无返回；异步结果走事件) ======
-
-  /** 跳原生页。route 取值对齐安卓 Routes(invite / settings / feedback / withdrawal / compareRecords / reportFlow / guideVideo / compareResult / coinHistory / cashHistory / welfareRules ...)。 */
-  function navigate(route) {
-    if (hasNative && native.navigate) native.navigate(route);
-    else console.log('[SGBridge mock] navigate →', route);
-  }
-
-  /** 拉起极光一键登录。结果异步经 onAuthChange 事件回来(不在此函数返回)。 */
-  function requestLogin() {
-    if (hasNative && native.requestLogin) native.requestLogin();
-    else console.log('[SGBridge mock] requestLogin');
-  }
-
-  /** 原生居中 Toast。 */
-  function toast(msg) {
-    if (hasNative && native.toast) native.toast(String(msg));
-    else console.log('[SGBridge mock] toast →', msg);
-  }
-
-  /** 跳美团/外卖 App(deeplink 优先；空则原生按包名启动，未装可跳应用商店)。 */
-  function openMeituan(deeplink) {
-    if (hasNative && native.openMeituan) native.openMeituan(deeplink || '');
-    else console.log('[SGBridge mock] openMeituan →', deeplink);
-  }
-
-  /** 触发 agent 比价流程(原生起无障碍引擎)。 */
-  function startCompare() {
-    if (hasNative && native.startCompare) native.startCompare();
-    else console.log('[SGBridge mock] startCompare');
-  }
-
-  /** 触发一键领券(原生先校验悬浮窗/无障碍权限，再起前台服务)。platforms: string[]。 */
-  function startCouponClaim(platforms) {
-    var json = JSON.stringify(platforms || []);
-    if (hasNative && native.startCouponClaim) native.startCouponClaim(json);
-    else console.log('[SGBridge mock] startCouponClaim →', json);
-  }
-
-  /** 按候选包名拉起对应平台 App。照原生 HomePicker 点击跳转:原生在该平台一组候选包里取首个可
-   *  getLaunchIntentForPackage 的拉起(NEW_TASK|CLEAR_TASK 冷启到平台首页)。packages: string[](一个平台一组候选包,任一可拉即拉)。 */
-  function launchApp(packages) {
-    var json = JSON.stringify(packages || []);
-    if (hasNative && native.launchApp) native.launchApp(json);
-    else console.log('[SGBridge mock] launchApp →', json);
-  }
-
-  // ====== 原生 → H5 事件总线 ======
-
-  var listeners = {}; // event → [fn]
-
-  /** 订阅原生事件。返回取消订阅函数。 */
-  function on(event, fn) {
-    (listeners[event] || (listeners[event] = [])).push(fn);
-    return function off() {
-      listeners[event] = (listeners[event] || []).filter(function (f) { return f !== fn; });
-    };
-  }
-
-  /** 供原生回调：window.SGBridge._emit('onAuthChange', '{...}')。payload 可为 JSON 串或对象。 */
-  function _emit(event, payload) {
-    var data = typeof payload === 'string' ? safeParse(payload, payload) : payload;
-    (listeners[event] || []).forEach(function (fn) {
-      try { fn(data); } catch (e) { console.error('[SGBridge] listener error', event, e); }
-    });
-  }
-
-  global.SGBridge = {
-    hasNative: hasNative,
-    // 查询
-    getAuthState: getAuthState,
-    getToken: getToken,
-    getDeviceId: getDeviceId,
-    getAppVersion: getAppVersion,
-    getInstalledApps: getInstalledApps,
-    getCouponClaimedToday: getCouponClaimedToday,
-    // 动作
-    navigate: navigate,
-    requestLogin: requestLogin,
-    toast: toast,
-    openMeituan: openMeituan,
-    startCompare: startCompare,
-    startCouponClaim: startCouponClaim,
-    launchApp: launchApp,
-    // 事件
-    on: on,
-    _emit: _emit,
-  };
-})(window);

tests/test_ad_reward.py

@@ -305,12 +305,11 @@ def test_feed_reward_grants_by_10_second_units(client) -> None:
         "duration_seconds": 30,
         "adn": "pangle",
         "slot_id": "slot_feed",
-        "display_coin": 4,
     }
     r = client.post("/api/v1/ad/feed-reward", json=payload, headers=_auth(token))
     assert r.status_code == 200, r.text
     body = r.json()
-    expected = 4
+    expected = sum(calculate_ad_reward_coin("200", i) for i in range(1, 4))
     assert body["granted"] is True
     assert body["status"] == "granted"
     assert body["unit_count"] == 3

tests/test_admin_read.py

@@ -64,9 +64,7 @@ def test_dashboard_overview(admin_client: TestClient, admin_token: str) -> None:
     assert data["users"]["total"] >= 1
     assert data["coins"]["granted_total"] >= 5000
     assert "success_rate" in data["comparison"]
-    assert data["cps"]["available"] is True
-    assert "meituan_order_count" in data["cps"]
-    assert "jd_order_count" in data["cps"]
+    assert data["cps"]["available"] is False
 
 
 def test_user_list_and_detail(admin_client: TestClient, admin_token: str) -> None:

tests/test_auth.py

@@ -68,64 +68,6 @@ def test_sms_login_and_me_flow(client) -> None:
     assert r.json()["ok"] is True
 
 
-def test_wechat_login_creates_and_reuses_user(client, monkeypatch) -> None:
-    """微信 code 登录:新 openid 注册,同 openid 重登回同一账号。"""
-    monkeypatch.setattr(
-        "app.api.v1.auth.code_to_userinfo",
-        lambda code: {
-            "openid": "openid_login_1",
-            "unionid": "union_1",
-            "nickname": "微信用户A",
-            "avatar_url": "https://wx/avatar-a.png",
-            "raw": {},
-        },
-    )
-
-    r = client.post("/api/v1/auth/wechat-login", json={"code": "code-a", "device_id": "dev-wx"})
-    assert r.status_code == 200, r.text
-    first = r.json()
-    assert first["user"]["register_channel"] == "wechat"
-    assert first["user"]["phone"].startswith("wx_")
-    assert first["user"]["nickname"] == "微信用户A"
-
-    r = client.post("/api/v1/auth/wechat-login", json={"code": "code-b", "device_id": "dev-wx"})
-    assert r.status_code == 200, r.text
-    second = r.json()
-    assert second["user"]["id"] == first["user"]["id"]
-
-
-def test_wechat_login_uses_existing_bound_user(client, monkeypatch) -> None:
-    """如果该微信已在提现页绑定过,微信登录应回到原手机号账号。"""
-    from app.db.session import SessionLocal
-    from app.repositories import user as user_repo
-
-    db = SessionLocal()
-    try:
-        user = user_repo.upsert_user_for_login(db, phone="13600136010", register_channel="sms")
-        user.wechat_openid = "openid_bound_1"
-        db.commit()
-        uid = user.id
-    finally:
-        db.close()
-
-    monkeypatch.setattr(
-        "app.api.v1.auth.code_to_userinfo",
-        lambda code: {
-            "openid": "openid_bound_1",
-            "unionid": None,
-            "nickname": "绑定微信",
-            "avatar_url": None,
-            "raw": {},
-        },
-    )
-
-    r = client.post("/api/v1/auth/wechat-login", json={"code": "code-bound", "device_id": "dev-wx"})
-    assert r.status_code == 200, r.text
-    body = r.json()
-    assert body["user"]["id"] == uid
-    assert body["user"]["phone"] == "13600136010"
-
-
 def test_sms_send_too_frequent(client) -> None:
     phone = "13900139000"
     assert client.post("/api/v1/auth/sms/send", json={"phone": phone}).status_code == 200

tests/test_compare_record.py

@@ -44,7 +44,6 @@ def _food_payload(trace_id: str) -> dict:
         "skipped_dish_names": ["黑牛肉卷"],
         "total_dish_count": 3,
         "information": "在美团找到同店,到手价 ¥123.50",
-        "total_ms": 12345,
     }
 
 
@@ -72,8 +71,6 @@ def test_report_and_derive(client) -> None:
     assert d["information"] == "在美团找到同店,到手价 ¥123.50"
     assert d["store_name"] == "海底捞(朝阳店)"
     assert d["total_dish_count"] == 3
-    assert d["total_ms"] == 12345
-    assert d["raw_payload"]["total_ms"] == 12345
     assert d["skipped_dish_count"] == 1
     assert d["skipped_dish_names"] == ["黑牛肉卷"]
     assert len(d["comparison_results"]) == 3

tests/test_cps_admin.py

@@ -1,253 +0,0 @@
-"""admin CPS 端点测试:每日明细 date 格式 + 按天按用户领券下钻(/day-users)。"""
-from __future__ import annotations
-
-from datetime import date, datetime, timedelta, timezone
-
-import pytest
-from fastapi.testclient import TestClient
-
-from app.admin.main import admin_app
-from app.admin.repositories import admin_user as admin_repo
-from app.admin.repositories import cps as cps_repo
-from app.db.session import SessionLocal
-from app.models.cps_link import CpsClick
-from app.models.cps_order import CpsOrder
-from app.models.cps_wx_user import CpsWxUser
-from app.repositories import cps_link as cps_link_repo
-
-_BJ = timezone(timedelta(hours=8))
-
-
-@pytest.fixture()
-def admin_client() -> TestClient:
-    return TestClient(admin_app)
-
-
-@pytest.fixture()
-def admin_token() -> str:
-    db = SessionLocal()
-    try:
-        if admin_repo.get_by_username(db, "cps_test_admin") is None:
-            admin_repo.create_admin(
-                db, username="cps_test_admin", password="cps-pass", role="super_admin"
-            )
-    finally:
-        db.close()
-    c = TestClient(admin_app)
-    r = c.post("/admin/api/auth/login", json={"username": "cps_test_admin", "password": "cps-pass"})
-    return r.json()["access_token"]
-
-
-def _auth(token: str) -> dict:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def _seed_cps_day(day_bj: date) -> tuple[int, str]:
-    """造淘宝群 + 2 个活动(券) + 2 条 link + day_bj 当天点击(含匿名 + 次日各 1) + 授权画像。
-
-    o_user(本群唯一):券A visit×3、券B visit×2、copy×2 → visit_count=5、copy_count=2。
-    另造 1 条匿名 visit(openid=None)与 1 条次日 visit,均不应计入当天该用户聚合。
-    clicked_at 统一存 tz-aware UTC(SQLite DateTime 按字段渲染、忽略 tzinfo;
-    转 UTC 后字段即 UTC 墙钟,与 repo 侧 _as_utc 比较口径一致)。返回 (group_id, openid)。
-    """
-    db = SessionLocal()
-    try:
-        gid = cps_repo.create_group(db, name="下钻测试群", platforms=["taobao"]).id
-        openid = f"od_user_{gid}"  # 按群唯一,规避 CpsWxUser.openid 唯一约束跨用例冲突
-        a1 = cps_repo.create_activity(db, name="618神券", platform="taobao", payload="tkl-1")
-        a2 = cps_repo.create_activity(db, name="买一送一", platform="taobao", payload="tkl-2")
-        link1 = cps_link_repo.create_link(
-            db, group_id=gid, activity_id=a1.id, sid=None, target_url="t1", platform="taobao"
-        )
-        link2 = cps_link_repo.create_link(
-            db, group_id=gid, activity_id=a2.id, sid=None, target_url="t2", platform="taobao"
-        )
-        db.add(CpsWxUser(openid=openid, nickname="张三", headimgurl="https://h/1"))
-        db.commit()
-
-        def at(hour: int) -> datetime:
-            return datetime(day_bj.year, day_bj.month, day_bj.day, hour, tzinfo=_BJ).astimezone(
-                timezone.utc
-            )
-
-        for _ in range(3):
-            db.add(CpsClick(link_id=link1.id, group_id=gid, sid=None,
-                            event_type="visit", openid=openid, clicked_at=at(10)))
-        for _ in range(2):
-            db.add(CpsClick(link_id=link2.id, group_id=gid, sid=None,
-                            event_type="visit", openid=openid, clicked_at=at(11)))
-        for _ in range(2):
-            db.add(CpsClick(link_id=link1.id, group_id=gid, sid=None,
-                            event_type="copy", openid=openid, clicked_at=at(12)))
-        # 匿名点击 — 不计入
-        db.add(CpsClick(link_id=link1.id, group_id=gid, sid=None,
-                        event_type="visit", openid=None, clicked_at=at(13)))
-        # 次日点击 — 验证时间窗,不计入当天
-        nxt = (datetime(day_bj.year, day_bj.month, day_bj.day, 10, tzinfo=_BJ)
-               + timedelta(days=1)).astimezone(timezone.utc)
-        db.add(CpsClick(link_id=link1.id, group_id=gid, sid=None,
-                        event_type="visit", openid=openid, clicked_at=nxt))
-        db.commit()
-        return gid, openid
-    finally:
-        db.close()
-
-
-def test_daily_date_is_full_iso(admin_client: TestClient, admin_token: str) -> None:
-    """/daily 每行 date 改为 YYYY-MM-DD(10 字符、两个连字符),不再是 MM-DD。"""
-    gid, _ = _seed_cps_day(date(2026, 6, 25))
-    r = admin_client.get(
-        f"/admin/api/cps/groups/{gid}/daily", params={"days": 3}, headers=_auth(admin_token)
-    )
-    assert r.status_code == 200, r.text
-    rows = r.json()["rows"]
-    assert rows, "应有按天补零行"
-    for row in rows:
-        assert len(row["date"]) == 10 and row["date"].count("-") == 2, row["date"]
-
-
-def test_day_users_aggregates(admin_client: TestClient, admin_token: str) -> None:
-    """当天该群:仅授权用户;领券=copy、点击=visit;coupons=visit 券×次数倒序、合计=点击次数。"""
-    gid, openid = _seed_cps_day(date(2026, 6, 25))
-    r = admin_client.get(
-        f"/admin/api/cps/groups/{gid}/day-users",
-        params={"date": "2026-06-25"},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    body = r.json()
-    assert body["group_id"] == gid
-    assert body["date"] == "2026-06-25"
-    users = body["users"]
-    assert len(users) == 1  # 匿名不计、次日不计
-    u = users[0]
-    assert u["openid"] == openid
-    assert u["nickname"] == "张三"
-    assert u["headimgurl"] == "https://h/1"
-    assert u["copy_count"] == 2
-    assert u["visit_count"] == 5
-    assert [c["name"] for c in u["coupons"]] == ["618神券", "买一送一"]
-    assert [c["count"] for c in u["coupons"]] == [3, 2]
-    assert sum(c["count"] for c in u["coupons"]) == u["visit_count"]
-
-
-def test_day_users_group_not_found(admin_client: TestClient, admin_token: str) -> None:
-    r = admin_client.get(
-        "/admin/api/cps/groups/999999/day-users",
-        params={"date": "2026-06-25"},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 404
-
-
-def test_day_users_bad_date(admin_client: TestClient, admin_token: str) -> None:
-    gid, _ = _seed_cps_day(date(2026, 6, 25))
-    r = admin_client.get(
-        f"/admin/api/cps/groups/{gid}/day-users",
-        params={"date": "2026/06/25"},  # 非 YYYY-MM-DD
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 400
-
-
-def test_day_users_requires_auth(admin_client: TestClient) -> None:
-    r = admin_client.get(
-        "/admin/api/cps/groups/1/day-users", params={"date": "2026-06-25"}
-    )
-    assert r.status_code == 401
-
-
-def test_day_users_empty_when_no_clicks(admin_client: TestClient, admin_token: str) -> None:
-    gid, _ = _seed_cps_day(date(2026, 6, 25))
-    r = admin_client.get(
-        f"/admin/api/cps/groups/{gid}/day-users",
-        params={"date": "2026-06-20"},  # 该群当天无任何点击
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200
-    assert r.json()["users"] == []
-
-
-def test_day_users_cross_year(admin_client: TestClient, admin_token: str) -> None:
-    """跨年:YYYY-MM-DD 才能精确定位 12-31(MM-DD 会丢年份);次日(次年 01-01)不计入。"""
-    gid, openid = _seed_cps_day(date(2025, 12, 31))
-    r = admin_client.get(
-        f"/admin/api/cps/groups/{gid}/day-users",
-        params={"date": "2025-12-31"},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    users = r.json()["users"]
-    assert len(users) == 1
-    assert users[0]["openid"] == openid
-    assert users[0]["visit_count"] == 5  # 次年 01-01 那条被时间窗排除
-
-
-def test_jd_reconcile_updates_dashboard(
-    admin_client: TestClient, admin_token: str, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """京东拉单:按订单行入库;大盘只统计有效 validCode 的佣金。"""
-
-    def fake_query_order_rows(**kwargs):
-        start = kwargs["start_time"].astimezone(_BJ)
-        if start.hour != 10 or kwargs["page_index"] != 1:
-            return {"rows": [], "has_more": False}
-        return {
-            "rows": [
-                {
-                    "id": "pytest-jd-row-valid",
-                    "orderId": "pytest-jd-order-1",
-                    "skuId": "sku-1",
-                    "skuName": "京东测试商品",
-                    "orderTime": "2026-06-25 10:10:00",
-                    "modifyTime": "2026-06-25 10:20:00",
-                    "validCode": "16",
-                    "estimateCosPrice": "19.90",
-                    "estimateFee": "1.23",
-                    "actualFee": "2.34",
-                    "commissionRate": "10.00",
-                },
-                {
-                    "id": "pytest-jd-row-invalid",
-                    "orderId": "pytest-jd-order-2",
-                    "skuId": "sku-2",
-                    "skuName": "京东无效订单",
-                    "orderTime": "2026-06-25 10:15:00",
-                    "modifyTime": "2026-06-25 10:25:00",
-                    "validCode": "4",
-                    "estimateCosPrice": "9.90",
-                    "estimateFee": "0.50",
-                    "commissionRate": "5.00",
-                },
-            ],
-            "has_more": False,
-        }
-
-    monkeypatch.setattr("app.integrations.jd_union.query_order_rows", fake_query_order_rows)
-    r = admin_client.post(
-        "/admin/api/cps/orders/reconcile",
-        params={
-            "platform": "jd",
-            "date_from": "2026-06-25",
-            "date_to": "2026-06-25",
-            "query_time_type": 1,
-        },
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    assert r.json()["fetched"] == 2
-
-    with SessionLocal() as db:
-        rows = db.query(CpsOrder).filter(CpsOrder.platform == "jd").all()
-        assert len([o for o in rows if o.order_id.startswith("jd:pytest-jd-row")]) == 2
-
-    overview = admin_client.get(
-        "/admin/api/stats/overview",
-        params={"date_from": "2026-06-25", "date_to": "2026-06-25"},
-        headers=_auth(admin_token),
-    )
-    assert overview.status_code == 200, overview.text
-    cps = overview.json()["cps"]
-    assert cps["jd_order_count"] >= 1
-    assert cps["jd_commission_cents"] >= 234
-    assert cps["jd_invalid_count"] >= 1

tests/test_device_push.py

@@ -1,317 +0,0 @@
-from __future__ import annotations
-
-import json
-from datetime import datetime, timedelta, timezone
-
-from fastapi.testclient import TestClient
-
-from app.api.v1 import device as device_api
-from app.core import heartbeat_monitor_worker
-from app.db.session import SessionLocal
-from app.integrations import vendor_push
-from app.models.device import DeviceLiveness
-from app.repositories import user as user_repo
-
-
-class _Resp:
-    status_code = 200
-    text = "{}"
-
-    def __init__(self, data: dict) -> None:
-        self._data = data
-
-    def json(self) -> dict:
-        return self._data
-
-
-def test_xiaomi_accessibility_payload(monkeypatch) -> None:
-    captured: dict = {}
-
-    def _fake_request(method, url, **kwargs):  # noqa: ANN001
-        captured.update(method=method, url=url, **kwargs)
-        return _Resp({"code": 0, "result": "ok", "data": {"id": "xm-msg"}})
-
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_APP_SECRET", "xiaomi-secret")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_CHANNEL_ID", "")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_ID", "")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_TITLE", "")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_DESCRIPTION", "")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_PARAM_JSON", "")
-    monkeypatch.setattr(vendor_push.httpx, "request", _fake_request)
-
-    data = vendor_push.send_accessibility_disabled("xiaomi", "xm-regid")
-
-    assert data["data"]["id"] == "xm-msg"
-    assert captured["method"] == "POST"
-    assert captured["url"] == vendor_push.settings.XIAOMI_PUSH_SEND_ENDPOINT
-    assert captured["headers"]["Authorization"] == "key=xiaomi-secret"
-    body = captured["data"]
-    assert body["registration_id"] == "xm-regid"
-    assert body["restricted_package_name"] == "com.jishisongfu.shaguabijia"
-    assert json.loads(body["payload"]) == {"type": "accessibility_disabled"}
-    assert "extra.channel_id" not in body
-
-
-def test_xiaomi_payload_with_channel_and_template(monkeypatch) -> None:
-    captured: dict = {}
-
-    def _fake_request(method, url, **kwargs):  # noqa: ANN001
-        captured.update(method=method, url=url, **kwargs)
-        return _Resp({"code": 0, "result": "ok", "data": {"id": "xm-msg"}})
-
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_APP_SECRET", "xiaomi-secret")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_CHANNEL_ID", "130")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_ID", "1001")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_TITLE", "{$app_name$}提醒")
-    monkeypatch.setattr(vendor_push.settings, "XIAOMI_PUSH_TEMPLATE_DESCRIPTION", "{$content$}")
-    monkeypatch.setattr(
-        vendor_push.settings,
-        "XIAOMI_PUSH_TEMPLATE_PARAM_JSON",
-        '{"app_name":"傻瓜比价","content":"{alert}"}',
-    )
-    monkeypatch.setattr(vendor_push.httpx, "request", _fake_request)
-
-    vendor_push.send_accessibility_disabled(
-        "xiaomi",
-        "xm-regid",
-        title="测试标题",
-        alert="测试内容",
-    )
-
-    body = captured["data"]
-    assert body["title"] == "{$app_name$}提醒"
-    assert body["description"] == "{$content$}"
-    assert body["extra.channel_id"] == "130"
-    assert body["extra.template_id"] == "1001"
-    assert body["extra.template_param"] == '{"app_name":"傻瓜比价","content":"测试内容"}'
-
-
-def test_vivo_auth_and_send_payload(monkeypatch) -> None:
-    vendor_push._token_cache.clear()
-    calls: list[dict] = []
-
-    def _fake_request(method, url, **kwargs):  # noqa: ANN001
-        calls.append({"method": method, "url": url, **kwargs})
-        if url == vendor_push.settings.VIVO_PUSH_AUTH_ENDPOINT:
-            return _Resp({"result": 0, "authToken": "vivo-auth"})
-        return _Resp({"result": 0, "taskId": "vivo-task"})
-
-    monkeypatch.setattr(vendor_push.settings, "VIVO_PUSH_APP_ID", "106072775")
-    monkeypatch.setattr(vendor_push.settings, "VIVO_PUSH_APP_KEY", "vivo-key")
-    monkeypatch.setattr(vendor_push.settings, "VIVO_PUSH_APP_SECRET", "vivo-secret")
-    monkeypatch.setattr(vendor_push.httpx, "request", _fake_request)
-
-    data = vendor_push.send_accessibility_disabled("vivo", "vivo-regid")
-
-    assert data["taskId"] == "vivo-task"
-    assert calls[0]["url"] == vendor_push.settings.VIVO_PUSH_AUTH_ENDPOINT
-    assert calls[0]["json"]["appId"] == "106072775"
-    assert calls[0]["json"]["sign"]
-    assert calls[1]["url"] == vendor_push.settings.VIVO_PUSH_SEND_ENDPOINT
-    assert calls[1]["headers"]["authToken"] == "vivo-auth"
-    body = calls[1]["json"]
-    assert body["regId"] == "vivo-regid"
-    assert body["pushMode"] == vendor_push.settings.VIVO_PUSH_MODE
-    assert body["clientCustomMap"] == {"type": "accessibility_disabled"}
-
-
-def test_oppo_auth_and_send_payload(monkeypatch) -> None:
-    vendor_push._token_cache.clear()
-    calls: list[dict] = []
-
-    def _fake_request(method, url, **kwargs):  # noqa: ANN001
-        calls.append({"method": method, "url": url, **kwargs})
-        if url == vendor_push.settings.OPPO_PUSH_AUTH_ENDPOINT:
-            return _Resp({"code": 0, "data": {"auth_token": "oppo-auth"}})
-        return _Resp({"code": 0, "data": {"message_id": "oppo-msg"}})
-
-    monkeypatch.setattr(vendor_push.settings, "OPPO_PUSH_APP_KEY", "oppo-key")
-    monkeypatch.setattr(vendor_push.settings, "OPPO_PUSH_MASTER_SECRET", "oppo-master")
-    monkeypatch.setattr(vendor_push.httpx, "request", _fake_request)
-
-    data = vendor_push.send_accessibility_disabled("oppo", "oppo-regid")
-
-    assert data["data"]["message_id"] == "oppo-msg"
-    assert calls[0]["data"]["app_key"] == "oppo-key"
-    assert calls[0]["data"]["sign"]
-    message = json.loads(calls[1]["data"]["message"])
-    assert calls[1]["data"]["auth_token"] == "oppo-auth"
-    assert message["target_type"] == 2
-    assert message["target_value"] == "oppo-regid"
-    assert json.loads(message["notification"]["action_parameters"]) == {
-        "type": "accessibility_disabled"
-    }
-
-
-def test_honor_auth_and_send_payload(monkeypatch) -> None:
-    vendor_push._token_cache.clear()
-    calls: list[dict] = []
-
-    def _fake_request(method, url, **kwargs):  # noqa: ANN001
-        calls.append({"method": method, "url": url, **kwargs})
-        if url == vendor_push.settings.HONOR_PUSH_TOKEN_ENDPOINT:
-            return _Resp({"access_token": "honor-access", "expires_in": 3600})
-        return _Resp({"code": 200, "message": "successful!", "data": {"sendResult": True}})
-
-    monkeypatch.setattr(vendor_push.settings, "HONOR_PUSH_APP_ID", "104559789")
-    monkeypatch.setattr(vendor_push.settings, "HONOR_PUSH_CLIENT_ID", "honor-client")
-    monkeypatch.setattr(vendor_push.settings, "HONOR_PUSH_CLIENT_SECRET", "honor-secret")
-    monkeypatch.setattr(vendor_push.httpx, "request", _fake_request)
-
-    data = vendor_push.send_accessibility_disabled("honor", "honor-token")
-
-    assert data["code"] == 200
-    assert calls[0]["data"]["client_id"] == "honor-client"
-    assert calls[1]["headers"]["Authorization"] == "Bearer honor-access"
-    assert calls[1]["headers"]["timestamp"]
-    assert calls[1]["url"].endswith("/api/v1/104559789/sendMessage")
-    body = calls[1]["json"]
-    assert body["token"] == ["honor-token"]
-    assert body["android"]["targetUserType"] == 1
-    assert body["android"]["notification"]["clickAction"] == {"type": 3}
-    assert json.loads(body["data"]) == {"type": "accessibility_disabled"}
-
-
-def _seed_overdue_device(
-    *,
-    phone: str,
-    device_id: str,
-    push_vendor: str | None,
-    push_token: str | None,
-) -> int:
-    with SessionLocal() as db:
-        user = user_repo.upsert_user_for_login(db, phone=phone, register_channel="sms")
-        device = DeviceLiveness(
-            user_id=user.id,
-            device_id=device_id,
-            push_vendor=push_vendor,
-            push_token=push_token,
-            platform="android",
-            ever_protected=True,
-            last_heartbeat_at=datetime.now(timezone.utc) - timedelta(minutes=30),  # noqa: UP017
-            last_report_protection_on=True,
-            liveness_state="alive",
-            kill_alert_pending=False,
-        )
-        db.add(device)
-        db.commit()
-        db.refresh(device)
-        return device.id
-
-
-def _login(client: TestClient, phone: str) -> str:
-    client.post("/api/v1/auth/sms/send", json={"phone": phone})
-    r = client.post("/api/v1/auth/sms/login", json={"phone": phone, "code": "123456"})
-    assert r.status_code == 200, r.text
-    return r.json()["access_token"]
-
-
-def _auth(token: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def test_heartbeat_monitor_pushes_overdue_device(monkeypatch) -> None:
-    device_pk = _seed_overdue_device(
-        phone="13900009001",
-        device_id="dev-push-honor",
-        push_vendor="honor",
-        push_token="honor-token-1",
-    )
-    calls: list[tuple[str, str]] = []
-
-    def _fake_send(push_vendor: str, push_token: str) -> dict:
-        calls.append((push_vendor, push_token))
-        return {"msg_id": "m1"}
-
-    monkeypatch.setattr(
-        heartbeat_monitor_worker.vendor_push,
-        "send_accessibility_disabled",
-        _fake_send,
-    )
-
-    result = heartbeat_monitor_worker._scan_once(timeout_minutes=10)
-
-    assert result["pushed"] >= 1
-    assert ("honor", "honor-token-1") in calls
-    with SessionLocal() as db:
-        device = db.get(DeviceLiveness, device_pk)
-        assert device is not None
-        assert device.liveness_state == "notified"
-        assert device.kill_alert_pending is True
-
-
-def test_heartbeat_monitor_skips_push_without_vendor_token(monkeypatch) -> None:
-    device_pk = _seed_overdue_device(
-        phone="13900009002",
-        device_id="dev-push-no-token",
-        push_vendor=None,
-        push_token=None,
-    )
-
-    def _fake_send(push_vendor: str, push_token: str) -> dict:
-        raise AssertionError(f"should not push without token: {push_vendor}/{push_token}")
-
-    monkeypatch.setattr(
-        heartbeat_monitor_worker.vendor_push,
-        "send_accessibility_disabled",
-        _fake_send,
-    )
-
-    result = heartbeat_monitor_worker._scan_once(timeout_minutes=10)
-
-    assert result["checked"] >= 1
-    with SessionLocal() as db:
-        device = db.get(DeviceLiveness, device_pk)
-        assert device is not None
-        assert device.liveness_state == "notified"
-        assert device.kill_alert_pending is True
-
-
-def test_push_test_endpoint_schedules_vendor_push(client: TestClient, monkeypatch) -> None:
-    token = _login(client, "13900009003")
-    calls: list[tuple[str, str, str, str]] = []
-
-    def _fake_send(push_vendor: str, push_token: str, *, title: str, alert: str) -> dict:
-        calls.append((push_vendor, push_token, title, alert))
-        return {"msg_id": "m-test"}
-
-    monkeypatch.setattr(device_api.vendor_push, "send_accessibility_disabled", _fake_send)
-
-    r = client.post(
-        "/api/v1/device/push-test",
-        json={
-            "device_id": "dev-push-test",
-            "push_vendor": "honor",
-            "push_token": "honor-test-token",
-            "delay_seconds": 0,
-        },
-        headers=_auth(token),
-    )
-
-    assert r.status_code == 200, r.text
-    assert r.json() == {
-        "ok": True,
-        "delay_seconds": 0,
-        "has_push_token": True,
-    }
-    assert calls == [
-        (
-            "honor",
-            "honor-test-token",
-            "测试推送",
-            "这是一条厂商通道测试推送。收到它说明 App 被划掉后仍可通过系统通知栏触达。",
-        )
-    ]
-
-
-def test_push_test_endpoint_requires_vendor_token(client: TestClient) -> None:
-    token = _login(client, "13900009004")
-
-    r = client.post(
-        "/api/v1/device/push-test",
-        json={"device_id": "dev-push-test-no-token", "delay_seconds": 0},
-        headers=_auth(token),
-    )
-
-    assert r.status_code == 409
-    assert r.json()["detail"] == "push vendor token not ready"

tests/test_health.py

@@ -14,7 +14,6 @@ def test_openapi_loads(client) -> None:
     paths = resp.json()["paths"]
     # auth endpoints 都注册了
     assert "/api/v1/auth/jverify-login" in paths
-    assert "/api/v1/auth/wechat-login" in paths
     assert "/api/v1/auth/sms/send" in paths
     assert "/api/v1/auth/sms/login" in paths
     assert "/api/v1/auth/refresh" in paths

tests/test_invite.py

@@ -1,4 +1,4 @@
-"""好友邀请测试:邀请码、绑定(双方不发钱)、幂等、自邀/无效码屏蔽、指纹兜底归因。
+"""好友邀请测试:邀请码、绑定、双方发金币、幂等、自邀/无效码屏蔽、指纹兜底归因。
 
 用 sms mock 登录拿 token(同 test_welfare),再跑邀请闭环。
 """
@@ -10,6 +10,8 @@ from sqlalchemy import select
 
 from app.core.rewards import (
     INVITE_FP_WINDOW_DAYS,
+    INVITE_INVITEE_COINS,
+    INVITE_INVITER_COINS,
     INVITE_NEW_USER_WINDOW_HOURS,
 )
 from app.db.session import SessionLocal
@@ -54,8 +56,8 @@ def test_invite_me_returns_stable_code(client) -> None:
     assert _my_code(client, token) == body["invite_code"]
 
 
-def test_bind_flow_no_coins_either_side(client) -> None:
-    """v3:B 用 A 的码绑定 → 双方都不发钱(被邀请人无奖励、邀请人改比价后发现金)。"""
+def test_bind_flow_both_get_coins(client) -> None:
+    """B 用 A 的码绑定 → 双方各得 1 万金币;A 战绩 +1。"""
     a = _login(client, "13800002002")
     b = _login(client, "13800002003")
     a_code = _my_code(client, a)
@@ -67,16 +69,16 @@ def test_bind_flow_no_coins_either_side(client) -> None:
     assert r.status_code == 200, r.text
     res = r.json()
     assert res["status"] == "success"
-    assert res["coins_awarded"] == 0
+    assert res["coins_awarded"] == INVITE_INVITEE_COINS
 
-    # 绑定后双方金币都不增(邀请人收益改走"好友比价发 2 元邀请奖励金")
-    assert _coin_balance(client, b) == 0
-    assert _coin_balance(client, a) == 0
+    # 双方金币到账
+    assert _coin_balance(client, b) == INVITE_INVITEE_COINS
+    assert _coin_balance(client, a) == INVITE_INVITER_COINS
 
-    # A 的战绩:已邀 1 人;金币口径收益恒 0(邀请人收益走邀请奖励金,见 try_reward_on_compare)
+    # A 的战绩:已邀 1 人,累计获得 = 邀请人那份
     r = client.get("/api/v1/invite/me", headers=_auth(a))
     assert r.json()["invited_count"] == 1
-    assert r.json()["coins_earned"] == 0
+    assert r.json()["coins_earned"] == INVITE_INVITER_COINS
 
 
 def test_bind_idempotent_no_double_reward(client) -> None:
@@ -215,9 +217,9 @@ def test_bind_by_fingerprint_success(client) -> None:
     )
     assert r2.status_code == 200, r2.text
     assert r2.json()["status"] == "success"
-    # v3:绑定双方都不发钱(被邀请人无奖励、邀请人改比价发现金)
-    assert _coin_balance(client, a) == 0
-    assert _coin_balance(client, b) == 0
+    # 双方各发金币
+    assert _coin_balance(client, a) == INVITE_INVITER_COINS
+    assert _coin_balance(client, b) == INVITE_INVITEE_COINS
 
 
 def test_bind_by_fingerprint_not_found(client) -> None:
@@ -320,8 +322,7 @@ def test_invitees_basic(client) -> None:
     names = {it["display_name"] for it in body["items"]}
     assert names == expected_names
     assert all(it["avatar_url"] is None for it in body["items"])
-    # v2:绑定时邀请人那份为 0(收益改"好友比价才发奖"),故每条 coins 字段=0
-    assert all(it["coins"] == 0 for it in body["items"])
+    assert all(it["coins"] == INVITE_INVITER_COINS for it in body["items"])
 
 
 def test_invitees_order_desc(client) -> None:

tests/test_invite_cash_withdraw.py

@@ -1,193 +0,0 @@
-"""邀请奖励金提现账户隔离测试:提现扣 invite_cash 账户、退款退回 invite_cash、与金币现金不串、
-/invite/me 返回奖励金战绩、提现单 source 过滤。复用 test_withdraw 的 wxpay monkeypatch 模式。
-"""
-from __future__ import annotations
-
-from sqlalchemy import select
-
-from app.db.session import SessionLocal
-from app.models.user import User
-from app.models.wallet import CoinAccount, InviteCashTransaction
-from app.repositories import wallet as crud_wallet
-
-
-def _login(client, phone: str) -> str:
-    client.post("/api/v1/auth/sms/send", json={"phone": phone})
-    r = client.post("/api/v1/auth/sms/login", json={"phone": phone, "code": "123456"})
-    assert r.status_code == 200, r.text
-    return r.json()["access_token"]
-
-
-def _auth(token: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def _patch_userinfo(monkeypatch, openid: str) -> None:
-    monkeypatch.setattr(
-        "app.integrations.wxpay.code_to_userinfo",
-        lambda code: {"openid": openid, "nickname": None, "avatar_url": None, "raw": {}},
-    )
-
-
-def _seed_balances(client, token: str, phone: str, *, cash: int = 0, invite_cash: int = 0) -> None:
-    """访问 /account 触发建账户,再 DB 直接灌两个账户余额(没有"加钱"接口,正常靠兑换/发奖)。"""
-    client.get("/api/v1/wallet/account", headers=_auth(token))
-    db = SessionLocal()
-    try:
-        user = db.execute(select(User).where(User.phone == phone)).scalar_one()
-        acc = db.get(CoinAccount, user.id)
-        acc.cash_balance_cents = cash
-        acc.invite_cash_balance_cents = invite_cash
-        db.commit()
-    finally:
-        db.close()
-
-
-def _balances(client, token: str) -> tuple[int, int]:
-    j = client.get("/api/v1/wallet/account", headers=_auth(token)).json()
-    return j["cash_balance_cents"], j["invite_cash_balance_cents"]
-
-
-def _reject(bill: str, reason: str = "测试拒绝") -> None:
-    db = SessionLocal()
-    try:
-        crud_wallet.reject_withdraw(db, bill, reason)
-    finally:
-        db.close()
-
-
-def test_invite_cash_withdraw_deducts_invite_account(client, monkeypatch) -> None:
-    """source=invite_cash 提现 → 扣 invite_cash_balance_cents,不动 cash;流水落 invite_cash_transaction。"""
-    _patch_userinfo(monkeypatch, "openid_ic_1")
-    token = _login(client, "13800004001")
-    _seed_balances(client, token, "13800004001", cash=300, invite_cash=500)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 200, "source": "invite_cash"},
-        headers=_auth(token),
-    )
-    assert r.status_code == 200, r.text
-    assert r.json()["status"] == "reviewing"
-
-    cash, invite_cash = _balances(client, token)
-    assert invite_cash == 300       # 扣了邀请奖励金
-    assert cash == 300              # 金币现金没动
-
-    db = SessionLocal()
-    try:
-        user = db.execute(select(User).where(User.phone == "13800004001")).scalar_one()
-        txns = db.execute(
-            select(InviteCashTransaction).where(
-                InviteCashTransaction.user_id == user.id,
-                InviteCashTransaction.biz_type == "invite_withdraw",
-            )
-        ).scalars().all()
-        assert len(txns) == 1 and txns[0].amount_cents == -200
-    finally:
-        db.close()
-    orders = client.get("/api/v1/wallet/withdraw-orders", headers=_auth(token)).json()["items"]
-    assert orders[0]["source"] == "invite_cash"
-
-
-def test_invite_cash_reject_refunds_invite_account(client, monkeypatch) -> None:
-    """拒绝 invite_cash 提现 → 退回 invite_cash,不串金币现金;退款流水落 invite_cash_transaction。"""
-    _patch_userinfo(monkeypatch, "openid_ic_2")
-    token = _login(client, "13800004002")
-    _seed_balances(client, token, "13800004002", cash=0, invite_cash=500)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 200, "source": "invite_cash"},
-        headers=_auth(token),
-    )
-    bill = r.json()["out_bill_no"]
-    cash, invite_cash = _balances(client, token)
-    assert invite_cash == 300 and cash == 0    # 扣后
-
-    _reject(bill)
-
-    cash, invite_cash = _balances(client, token)
-    assert invite_cash == 500    # 退回邀请奖励金
-    assert cash == 0             # 没串进现金
-
-    db = SessionLocal()
-    try:
-        user = db.execute(select(User).where(User.phone == "13800004002")).scalar_one()
-        refunds = db.execute(
-            select(InviteCashTransaction).where(
-                InviteCashTransaction.user_id == user.id,
-                InviteCashTransaction.biz_type == "invite_withdraw_refund",
-            )
-        ).scalars().all()
-        assert len(refunds) == 1 and refunds[0].amount_cents == 200
-    finally:
-        db.close()
-
-
-def test_two_accounts_withdraw_independent(client, monkeypatch) -> None:
-    """两账户各提各的不串:先提 invite_cash(拒绝结清),再提 cash,各扣各账户。
-    注:一个用户同一时间只能一个活跃提现单(跨账户),故第二笔需先结清第一笔。"""
-    _patch_userinfo(monkeypatch, "openid_ic_3")
-    token = _login(client, "13800004003")
-    _seed_balances(client, token, "13800004003", cash=400, invite_cash=500)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r1 = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 200, "source": "invite_cash"},
-        headers=_auth(token),
-    )
-    _reject(r1.json()["out_bill_no"])    # 退回 invite_cash + 结清活跃单
-    r2 = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 100, "source": "coin_cash"},
-        headers=_auth(token),
-    )
-    assert r2.json()["status"] == "reviewing"
-
-    cash, invite_cash = _balances(client, token)
-    assert invite_cash == 500    # 已退回
-    assert cash == 300           # 扣了 cash 100
-
-
-def test_invite_me_returns_reward_stats(client) -> None:
-    """/invite/me 返回 reward_balance_cents(可提现奖励金)。"""
-    token = _login(client, "13800004004")
-    _seed_balances(client, token, "13800004004", invite_cash=350)
-    j = client.get("/api/v1/invite/me", headers=_auth(token)).json()
-    assert j["reward_balance_cents"] == 350
-    assert j["reward_withdrawn_cents"] == 0
-
-
-def test_withdraw_orders_source_filter(client, monkeypatch) -> None:
-    """/wallet/withdraw-orders?source=invite_cash 只返回邀请奖励金提现单。"""
-    _patch_userinfo(monkeypatch, "openid_ic_5")
-    token = _login(client, "13800004005")
-    _seed_balances(client, token, "13800004005", cash=400, invite_cash=500)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r1 = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 200, "source": "invite_cash"},
-        headers=_auth(token),
-    )
-    _reject(r1.json()["out_bill_no"])    # 结清,才能提第二笔
-    client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 100, "source": "coin_cash"},
-        headers=_auth(token),
-    )
-
-    all_orders = client.get("/api/v1/wallet/withdraw-orders", headers=_auth(token)).json()["items"]
-    invite_orders = client.get(
-        "/api/v1/wallet/withdraw-orders", params={"source": "invite_cash"}, headers=_auth(token)
-    ).json()["items"]
-    coin_orders = client.get(
-        "/api/v1/wallet/withdraw-orders", params={"source": "coin_cash"}, headers=_auth(token)
-    ).json()["items"]
-    assert len(all_orders) == 2
-    assert len(invite_orders) == 1 and invite_orders[0]["source"] == "invite_cash"
-    assert len(coin_orders) == 1 and coin_orders[0]["source"] == "coin_cash"

tests/test_invite_compare_reward.py

@@ -1,114 +0,0 @@
-"""邀请 v3 比价发奖测试:好友完成成功比价 → 邀请人得邀请奖励金(独立账户),幂等只发一次,
-账户隔离不串金币/现金。被邀请人绑定不得任何奖励由 test_invite.py 覆盖。
-"""
-from __future__ import annotations
-
-from sqlalchemy import select
-
-from app.core.rewards import INVITE_COMPARE_REWARD_CENTS
-from app.db.session import SessionLocal
-from app.models.wallet import CoinAccount, InviteCashTransaction
-from app.repositories.user import get_user_by_phone
-
-
-def _login(client, phone: str) -> str:
-    client.post("/api/v1/auth/sms/send", json={"phone": phone})
-    r = client.post("/api/v1/auth/sms/login", json={"phone": phone, "code": "123456"})
-    assert r.status_code == 200, r.text
-    return r.json()["access_token"]
-
-
-def _auth(token: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def _my_code(client, token: str) -> str:
-    return client.get("/api/v1/invite/me", headers=_auth(token)).json()["invite_code"]
-
-
-def _bind(client, token: str, code: str):
-    return client.post("/api/v1/invite/bind", json={"invite_code": code}, headers=_auth(token))
-
-
-def _report_compare(client, token: str, trace_id: str, status: str = "success"):
-    return client.post(
-        "/api/v1/compare/record",
-        json={"trace_id": trace_id, "status": status},
-        headers=_auth(token),
-    )
-
-
-def _invite_cash(phone: str) -> int:
-    """被试用户的邀请奖励金余额(分)。专用查询端点见小步3,这里直接查 DB。"""
-    with SessionLocal() as db:
-        u = get_user_by_phone(db, phone)
-        acc = db.get(CoinAccount, u.id) if u else None
-        return acc.invite_cash_balance_cents if acc else 0
-
-
-def test_compare_reward_granted_to_inviter(client) -> None:
-    """B 被 A 邀请后完成一次成功比价 → A 得邀请奖励金 2 元(独立账户),B 不得该奖。"""
-    a = _login(client, "13800003001")
-    b = _login(client, "13800003002")
-    _bind(client, b, _my_code(client, a))
-
-    assert _invite_cash("13800003001") == 0                            # 发奖前
-
-    r = _report_compare(client, b, "trace-reward-1")
-    assert r.status_code == 200, r.text
-
-    assert _invite_cash("13800003001") == INVITE_COMPARE_REWARD_CENTS  # 邀请人到账
-    assert _invite_cash("13800003002") == 0                            # 被邀请人不得此奖
-
-
-def test_compare_reward_idempotent(client) -> None:
-    """好友比价多次 → 只发一次(compare_reward_granted 幂等)。"""
-    a = _login(client, "13800003003")
-    b = _login(client, "13800003004")
-    _bind(client, b, _my_code(client, a))
-
-    _report_compare(client, b, "trace-idem-1")
-    _report_compare(client, b, "trace-idem-2")    # 第二次比价(不同 trace)
-    _report_compare(client, b, "trace-idem-1")    # 重复上报同 trace
-
-    assert _invite_cash("13800003003") == INVITE_COMPARE_REWARD_CENTS  # 仍只发一次
-
-
-def test_compare_no_relation_no_reward(client) -> None:
-    """没有邀请关系的人比价 → 不发奖(没人是他的邀请人)。"""
-    x = _login(client, "13800003005")
-    r = _report_compare(client, x, "trace-norel-1")
-    assert r.status_code == 200, r.text
-    assert _invite_cash("13800003005") == 0
-
-
-def test_compare_failed_no_reward(client) -> None:
-    """失败的比价(status=failed)不触发发奖。"""
-    a = _login(client, "13800003006")
-    b = _login(client, "13800003007")
-    _bind(client, b, _my_code(client, a))
-
-    _report_compare(client, b, "trace-fail-1", status="failed")
-    assert _invite_cash("13800003006") == 0
-
-
-def test_compare_reward_isolated_from_coin_cash(client) -> None:
-    """账户隔离:邀请奖励金进 invite_cash,不串 cash_balance_cents;流水落 invite_cash_transaction。"""
-    a = _login(client, "13800003008")
-    b = _login(client, "13800003009")
-    _bind(client, b, _my_code(client, a))
-    _report_compare(client, b, "trace-iso-1")
-
-    with SessionLocal() as db:
-        ua = get_user_by_phone(db, "13800003008")
-        acc = db.get(CoinAccount, ua.id)
-        assert acc.invite_cash_balance_cents == INVITE_COMPARE_REWARD_CENTS  # 奖励金到账
-        assert acc.cash_balance_cents == 0                                   # 没串进金币现金
-        txns = db.execute(
-            select(InviteCashTransaction).where(
-                InviteCashTransaction.user_id == ua.id,
-                InviteCashTransaction.biz_type == "invite_reward",
-            )
-        ).scalars().all()
-        assert len(txns) == 1
-        assert txns[0].amount_cents == INVITE_COMPARE_REWARD_CENTS

tests/test_welfare.py

@@ -46,12 +46,7 @@ def test_account_auto_created_empty(client) -> None:
     r = client.get("/api/v1/wallet/account", headers=_auth(token))
     assert r.status_code == 200, r.text
     body = r.json()
-    assert body == {
-        "coin_balance": 0,
-        "cash_balance_cents": 0,
-        "invite_cash_balance_cents": 0,    # v2 账户隔离新增(邀请奖励金,与现金隔离)
-        "total_coin_earned": 0,
-    }
+    assert body == {"coin_balance": 0, "cash_balance_cents": 0, "total_coin_earned": 0}
 
 
 def test_signin_flow(client) -> None:

tools/meituan_playground.py

@@ -52,8 +52,7 @@ def call_raw(path: str, body_obj: dict) -> dict:
     }
     url = f"{settings.MT_CPS_HOST}{path}"
     t0 = time.time()
-    # trust_env=False: 美团是国内域名,强制直连绕开本机代理(代理会掐断 TLS 握手,报 SSL EOF)
-    resp = httpx.post(url, content=body, headers=headers, timeout=settings.MT_CPS_TIMEOUT_SEC, trust_env=False)
+    resp = httpx.post(url, content=body, headers=headers, timeout=settings.MT_CPS_TIMEOUT_SEC)
     ms = int((time.time() - t0) * 1000)
     try:
         j = resp.json()