Merge main into feat/aliyun-sms-verify

冲突仅 app/api/v1/auth.py::sms_login,合并两侧改动:
  - 保留(本分支)阿里云 provider 的 verify_code try/except —— 校验降级抛 SmsError 时透出其状态码(503),不误报 400。
  - 保留(main)风控失败事件 record_behavior_event —— 但仅在「验证码错误」(ok 为 False)时记;
    provider 降级 503 已在 try/except 提前 raise,不计入「验证失败」风控。
wechat_bind_phone_sms 的 try/except 自动合并、无冲突(main 未在该处加风控)。

验证:全量 pytest 552 passed / 8 failed(8 个均为合并前已存在、与本次无关)。

.env.example

@@ -81,12 +81,28 @@ HEARTBEAT_TIMEOUT_MINUTES=60
 HEARTBEAT_SCAN_INTERVAL_SEC=60
 
 # ===== 短信 (mock 模式) =====
-# mock = true 时,任意 6 位数字均通过,且 /sms/send 不真发短信(只 log)。
-# 后续接阿里云/腾讯云短信时,改成 false 并填供应商相关 key。
+# mock = true 时,任意 6 位数字均通过,且 /sms/send 不真发短信(只 log)。生产改 false。
 SMS_MOCK=true
 SMS_CODE_TTL_SEC=300
 SMS_SEND_INTERVAL_SEC=60
 
+# ===== 短信提供商(可切换:jiguang 默认 / aliyun 阿里云号码认证)=====
+# jiguang:本服务生成验证码,极光 REST 只负责下发,本地内存校验(复用上面极光 JG_* 凭证)。
+# aliyun :阿里云 dypns 号码认证,阿里云生成+下发+校验(Mode A,核验免费);缺凭证时 /sms/* 返 503。
+#          需在阿里云号码认证控制台开通「融合认证」,并使用系统赠送签名 + 赠送模板。
+SMS_PROVIDER=jiguang
+ALIYUN_SMS_ACCESS_KEY_ID=
+ALIYUN_SMS_ACCESS_KEY_SECRET=
+ALIYUN_SMS_SIGN_NAME=
+ALIYUN_SMS_TEMPLATE_CODE=
+# 方案名:留空=默认方案;若填,发码与校验须一致(本服务已共用同一配置项,不会不匹配)。
+ALIYUN_SMS_SCHEME_NAME=
+ALIYUN_SMS_ENDPOINT=dypnsapi.aliyuncs.com
+ALIYUN_SMS_CODE_LENGTH=6
+ALIYUN_SMS_VALID_TIME_SEC=300
+ALIYUN_SMS_INTERVAL_SEC=60
+ALIYUN_SMS_TIMEOUT_SEC=15
+
 # ===== 测试账号(release 包全流程联调用)=====
 # 配一个固定测试手机号,专供无 SIM 卡 / 不走一键登录时打通全流程:该号登录【免短信验证码】
 # (real 模式下也跳过校验)、每次登录【都重走新手引导】,并有【每日登录上限】防被人猜到号后脚本刷。

app/admin/repositories/ad_audit.py

@@ -12,11 +12,10 @@
 """
 from __future__ import annotations
 
-from sqlalchemy import func, or_, select
+from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.core import rewards
-from app.models.ad_ecpm import AdEcpmRecord
 from app.models.ad_feed_reward import AdFeedRewardRecord
 from app.models.ad_reward import AdRewardRecord
 from app.repositories.ad_feed_reward import FEED_REWARD_UNIT_SECONDS
@@ -56,22 +55,10 @@ def _reward_video_rows(
     if user_id is not None:
         stmt = stmt.where(AdRewardRecord.user_id == user_id)
 
-    records = list(db.execute(stmt).scalars())
-    # S2S 发奖回调本身不携带实际填充的 ADN/底层 rit；按客户端在展示时上报的
-    # ad_session_id 回填。这样“纯发奖”行也能在运营后台追溯到真实广告网络。
-    session_ids = {rec.ad_session_id for rec in records if rec.ad_session_id}
-    impression_by_session = {
-        (rec.user_id, rec.ad_session_id): rec
-        for rec in db.execute(
-            select(AdEcpmRecord).where(AdEcpmRecord.ad_session_id.in_(session_ids))
-        ).scalars()
-    } if session_ids else {}
-
     # 用本日之前的累计份数做起点,当日 granted 在其上继续递增 → 与 _granted_cumulative+1 对齐
     granted_n: dict[int, int] = _prior_granted_counts(db, date=date, user_id=user_id)
     rows: list[dict] = []
-    for rec in records:
-        impression = impression_by_session.get((rec.user_id, rec.ad_session_id))
+    for rec in db.execute(stmt).scalars():
         if rec.status == "granted":
             nth = granted_n.get(rec.user_id, 0) + 1
             granted_n[rec.user_id] = nth
@@ -81,8 +68,6 @@ def _reward_video_rows(
                 "record_id": rec.id,
                 "user_id": rec.user_id,
                 "ad_session_id": rec.ad_session_id,
-                "adn": impression.adn if impression is not None else None,
-                "slot_id": impression.slot_id if impression is not None else None,
                 "app_env": rec.app_env,
                 "our_code_id": rec.our_code_id,
                 "created_at": rec.created_at,
@@ -105,8 +90,6 @@ def _reward_video_rows(
                 "record_id": rec.id,
                 "user_id": rec.user_id,
                 "ad_session_id": rec.ad_session_id,
-                "adn": impression.adn if impression is not None else None,
-                "slot_id": impression.slot_id if impression is not None else None,
                 "app_env": rec.app_env,
                 "our_code_id": rec.our_code_id,
                 "created_at": rec.created_at,
@@ -166,81 +149,6 @@ def _feed_scene_matches(rec: AdFeedRewardRecord, scene: str | None) -> bool:
     return True
 
 
-def _nonblank(value: str | None) -> str | None:
-    value = value.strip() if value else None
-    return value or None
-
-
-def _unique_ad_source(records: list[AdEcpmRecord]) -> tuple[str | None, str | None]:
-    """仅在候选展示记录指向唯一 ADN 时回填来源，绝不把一次多广告流程猜成某一个网络。"""
-    adns = {_nonblank(record.adn) for record in records}
-    adns.discard(None)
-    if len(adns) != 1:
-        return None, None
-
-    slots = {_nonblank(record.slot_id) for record in records}
-    slots.discard(None)
-    return next(iter(adns)), next(iter(slots)) if len(slots) == 1 else None
-
-
-def _feed_source_fallbacks(
-    db: Session, records: list[AdFeedRewardRecord]
-) -> tuple[dict[tuple[int, str], tuple[str | None, str | None]], dict[tuple[int, str, str], tuple[str | None, str | None]]]:
-    """构建信息流来源回填索引。
-
-    新客户端会把 ADN 直接随 feed-reward 上报；旧记录可能缺失。展示收益记录的
-    ``ad_session_id`` 是每条 impressionId，而发奖记录保留的是整场会话 ID，因此先按
-    会话精确匹配；匹配不到时仅允许按 ``user + trace_id + 原始 eCPM`` 回填，且候选 ADN
-    必须唯一。trace 内存在多个网络时保持空值，避免错误归因。
-    """
-    session_ids = {record.ad_session_id for record in records if record.ad_session_id}
-    trace_ids = {record.trace_id for record in records if record.trace_id}
-    if not session_ids and not trace_ids:
-        return {}, {}
-
-    filters = []
-    if session_ids:
-        filters.append(AdEcpmRecord.ad_session_id.in_(session_ids))
-    if trace_ids:
-        filters.append(AdEcpmRecord.trace_id.in_(trace_ids))
-    impressions = list(db.execute(select(AdEcpmRecord).where(or_(*filters))).scalars())
-
-    by_session: dict[tuple[int, str], list[AdEcpmRecord]] = {}
-    by_trace_ecpm: dict[tuple[int, str, str], list[AdEcpmRecord]] = {}
-    for impression in impressions:
-        if impression.ad_session_id:
-            by_session.setdefault((impression.user_id, impression.ad_session_id), []).append(impression)
-        if impression.trace_id:
-            by_trace_ecpm.setdefault(
-                (impression.user_id, impression.trace_id, impression.ecpm_raw), []
-            ).append(impression)
-
-    return (
-        {key: _unique_ad_source(value) for key, value in by_session.items()},
-        {key: _unique_ad_source(value) for key, value in by_trace_ecpm.items()},
-    )
-
-
-def _feed_source(
-    record: AdFeedRewardRecord,
-    *,
-    by_session: dict[tuple[int, str], tuple[str | None, str | None]],
-    by_trace_ecpm: dict[tuple[int, str, str], tuple[str | None, str | None]],
-) -> tuple[str | None, str | None]:
-    """取得本条发奖广告的真实来源；无唯一证据时返回原始空值。"""
-    adn, slot_id = _nonblank(record.adn), _nonblank(record.slot_id)
-    if adn and slot_id:
-        return adn, slot_id
-
-    candidate = by_session.get((record.user_id, record.ad_session_id or ""))
-    if candidate is None and record.trace_id:
-        candidate = by_trace_ecpm.get((record.user_id, record.trace_id, record.ecpm_raw))
-    if candidate is None:
-        return adn, slot_id
-    candidate_adn, candidate_slot_id = candidate
-    return adn or candidate_adn, slot_id or candidate_slot_id
-
-
 def _feed_rows(
     db: Session, *, date: str, user_id: int | None, scene: str | None = None
 ) -> list[dict]:
@@ -259,17 +167,11 @@ def _feed_rows(
     if user_id is not None:
         stmt = stmt.where(AdFeedRewardRecord.user_id == user_id)
 
-    records = list(db.execute(stmt).scalars())
-    by_session, by_trace_ecpm = _feed_source_fallbacks(db, records)
-
     # 本日之前的累计**条数**做起点,与发奖侧 granted_unit_total(COUNT granted)对齐
     granted_count: dict[int, int] = _feed_prior_granted_count(db, date=date, user_id=user_id)
     rows: list[dict] = []
-    for rec in records:
+    for rec in db.execute(stmt).scalars():
         keep = _feed_scene_matches(rec, scene)  # 累计照常推进,这里只决定是否展示本行
-        adn, slot_id = _feed_source(
-            rec, by_session=by_session, by_trace_ecpm=by_trace_ecpm
-        )
         if rec.status == "granted":
             # 一条广告 = 1 份(与 grant_feed_reward 同口径:看满一份即发该条满额,不按 unit_count 累加)。
             # nth = 账号累计第几**条**(含本日之前),与发奖侧 granted_unit_total+1 对齐;累计照常推进
@@ -286,8 +188,6 @@ def _feed_rows(
                 "record_id": rec.id,
                 "user_id": rec.user_id,
                 "ad_session_id": rec.ad_session_id,
-                "adn": adn,
-                "slot_id": slot_id,
                 "trace_id": rec.trace_id,
                 "app_env": rec.app_env,
                 "our_code_id": rec.our_code_id,
@@ -314,8 +214,6 @@ def _feed_rows(
                 "record_id": rec.id,
                 "user_id": rec.user_id,
                 "ad_session_id": rec.ad_session_id,
-                "adn": adn,
-                "slot_id": slot_id,
                 "trace_id": rec.trace_id,
                 "app_env": rec.app_env,
                 "our_code_id": rec.our_code_id,

app/admin/repositories/ad_revenue.py

@@ -22,7 +22,7 @@ report_date / reward_date 归日。
 """
 from __future__ import annotations
 
-from datetime import UTC, datetime, time, timedelta
+from datetime import UTC, datetime, timedelta
 from datetime import date as _date
 
 from sqlalchemy import select
@@ -81,9 +81,9 @@ def _date_range(date_from: str, date_to: str) -> list[str]:
 # ad_feed_reward_record,由 audit 内部按 ad_type 区分(feed 含历史 NULL,draw 仅 ad_type=="draw")。
 _AUDIT_SCENES = {"reward_video", "feed", "draw"}
 
-# GroMore 官方说明第三方 ADN 的 Reporting API 最晚约 13:50 更新。只有 D+1 14:00
-# 之后完成的同步才标记为「API 同步窗口完成」；这不代表覆盖全部 ADN 或最终结算。
-_PANGLE_API_FINAL_SYNC_TIME = time(hour=14)
+# 激励视频未满足有效播放条件时不计客户端预估收益。客户端仍会在 onAdShow
+# 上报 eCPM，随后才在关闭时补报以下终态，因此必须在展示/发奖合并后修正收益。
+_ZERO_REVENUE_REWARD_VIDEO_STATUSES = frozenset({"closed_early", "too_short"})
 
 
 # 发奖复算明细字段(展开下钻看「金币怎么算出来的」)——从 audit 行原样取这些 key。
@@ -96,32 +96,7 @@ _REWARD_DETAIL_KEYS = (
 
 def _reward_detail(row: dict) -> dict:
     """从 audit 行抽出发奖复算明细(给前端展开行渲染因子1/因子2/份数/LT/应发实发)。"""
-    detail = {k: row[k] for k in _REWARD_DETAIL_KEYS}
-    # 发奖明细必须保留自己的广告网络，不能复用整场聚合父行的来源：
-    # 同一次比价/领券可能先后由不同 ADN 填充。
-    detail["adn"] = row.get("adn")
-    detail["slot_id"] = row.get("slot_id")
-    return detail
-
-
-def _as_cn(dt: datetime) -> datetime:
-    """数据库 synced_at → 北京时间；SQLite naive 值按 UTC 处理。"""
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=UTC)
-    return dt.astimezone(rewards.CN_TZ)
-
-
-def _pangle_api_day_complete(day: str, aggregate: dict) -> bool:
-    """某天 API 收益是否已在 D+1 14:00 后同步（仅表示同步窗口完成）。"""
-    synced_at = aggregate.get("synced_at")
-    if aggregate.get("api_revenue_yuan") is None or synced_at is None:
-        return False
-    cutoff = datetime.combine(
-        _date.fromisoformat(day) + timedelta(days=1),
-        _PANGLE_API_FINAL_SYNC_TIME,
-        tzinfo=rewards.CN_TZ,
-    )
-    return _as_cn(synced_at) >= cutoff
+    return {k: row[k] for k in _REWARD_DETAIL_KEYS}
 
 
 def ad_revenue_report(
@@ -211,10 +186,12 @@ def ad_revenue_report(
             "has_impression": True,
             "impressions": 1,
             "ecpm": rec.ecpm_raw,
-            # 客户端 SDK 展示预估收益(元)= 后端留存 getEcpm 元/千次 ÷ 1000。
-            # 这里不能复用发奖防作弊的 ¥500 CPM 钳顶：钳顶只限制金币成本，不改变广告已产生的
-            # 收入估值。onAdShow 已发生即计展示收入，是否看满只影响发奖，不影响广告收入。
-            "revenue_yuan": round(rewards.parse_ecpm_yuan(rec.ecpm_raw) / 1000.0, 6),
+            # 单次展示收益(元)= eCPM元 ÷ 1000(每千次→单次)。eCPM 先钳到 AD_ECPM_MAX_FEN(¥500 CPM)
+            # 再折收益,与发奖口径 [rewards.calculate_ad_reward_coin] 一致(2026-06-29 修:原裸 parse_ecpm_yuan
+            # 不钳,伪造/异常天价 eCPM 会把报表预估收益冲到任意大;金币侧已钳、收益侧漏钳)。
+            "revenue_yuan": round(
+                min(rewards.parse_ecpm_yuan(rec.ecpm_raw), rewards.AD_ECPM_MAX_FEN / 100.0) / 1000.0, 6,
+            ),
             "adn": rec.adn,
             "slot_id": rec.slot_id,
             "sub_rewards": [],
@@ -229,6 +206,11 @@ def ad_revenue_report(
                 "matched": bool(rwd["matched"]),
                 "reward_detail": _reward_detail(rwd),
             })
+            if (
+                rec.ad_type == "reward_video"
+                and rwd["status"] in _ZERO_REVENUE_REWARD_VIDEO_STATUSES
+            ):
+                ev["revenue_yuan"] = 0.0
         else:
             # 纯展示(信息流逐条展示、激励视频缺发奖记录):不计对账,matched=True。
             ev.update({
@@ -262,8 +244,8 @@ def ad_revenue_report(
                 "impressions": 0,
                 "ecpm": row["ecpm"],
                 "revenue_yuan": 0.0,
-                "adn": row.get("adn"),
-                "slot_id": row.get("slot_id"),
+                "adn": None,
+                "slot_id": None,
                 "has_reward": True,
                 "status": row["status"],
                 "expected_coin": int(row["expected_coin"]),
@@ -289,10 +271,10 @@ def ad_revenue_report(
         # 父行 eCPM:组内各条 eCPM(分)均值(展示用,各条不同);无有效值则取代表条
         ecpm_fens = [rewards.parse_ecpm_fen(g["ecpm"]) for g in group if g.get("ecpm")]
         avg_ecpm = str(round(sum(ecpm_fens) / len(ecpm_fens))) if ecpm_fens else rep.get("ecpm")
-        # 主表逐行显示用:这次发奖广告的预估收益之和(发奖侧 eCPM 折算)。只放进
+        # 主表逐行显示用:这次发奖广告的预估收益之和(发奖侧 eCPM 折算,钳顶同展示侧)。只放进
         # row_revenue_yuan 给主表逐行展示,不进 revenue_yuan/合计/趋势——避免与展示侧 total 重复计。
         row_revenue = round(sum(
-            rewards.parse_ecpm_yuan(g["ecpm"]) / 1000.0
+            min(rewards.parse_ecpm_yuan(g["ecpm"]), rewards.AD_ECPM_MAX_FEN / 100.0) / 1000.0
             for g in group if g.get("ecpm")
         ), 6)
         events.append({
@@ -382,15 +364,13 @@ def ad_revenue_report(
         for d in sorted(daily_map.values(), key=lambda x: x["date"])
     ]
 
-    # GroMore 排序价预估 / ADN Reporting API 收益(T+1 入库):汇总 + 按天趋势级展示,
+    # 穿山甲后台收益(GroMore 数据 API,T+1 入库 ad_pangle_daily_revenue):汇总 + 按天趋势级展示,
     # 与上面客户端自报 eCPM 折算的预估并列对照(看 gap)。穿山甲数据**无用户/场景/类型维度**,故仅在
     # 「全量视图」(未按 user_id / ad_type / feed_scene 过滤)给值;一旦带这些过滤,穿山甲数无法对应口径
     # → 置 None,前端显示「-」并提示。逐条事件行不动(仍是客户端预估)。
     pangle_filterable = user_id is None and ad_type is None and feed_scene is None
     total_pangle_revenue_yuan: float | None = None
     total_pangle_api_revenue_yuan: float | None = None
-    pangle_api_revenue_complete = False
-    pangle_latest_synced_at: datetime | None = None
     if pangle_filterable:
         pangle_aggs = ad_pangle_revenue.aggregate_by_date(
             db,
@@ -408,12 +388,6 @@ def ad_revenue_report(
             total_pangle_revenue_yuan = round(sum(a["revenue_yuan"] for a in pangle_aggs), 6)
             api_vals = [a["api_revenue_yuan"] for a in pangle_aggs if a["api_revenue_yuan"] is not None]
             total_pangle_api_revenue_yuan = round(sum(api_vals), 6) if api_vals else None
-            sync_times = [a["synced_at"] for a in pangle_aggs if a["synced_at"] is not None]
-            pangle_latest_synced_at = max(sync_times) if sync_times else None
-            pangle_api_revenue_complete = all(
-                day in by_date and _pangle_api_day_complete(day, by_date[day])
-                for day in _date_range(date_from, date_to)
-            )
 
     # 按小时汇总(全量,不受分页 limit/offset 影响):供前端按小时趋势图(单日 granularity=hour 时用)。
     # 只在 by_hour 下聚合(此时每个 event 带 hour);否则空。前端按天趋势仍用 daily。
@@ -438,50 +412,41 @@ def ad_revenue_report(
             for hd in sorted(hour_map.values(), key=lambda x: x["hour"])
         ]
 
-    def _aggregate_stats(bucket_of) -> dict[str, dict]:
-        """按展示事件聚合收益 / 加权 SDK eCPM，避免前端漏合并历史类型。"""
-        stat_map: dict[str, dict] = {}
-        for e in events:
-            bucket = bucket_of(e)
-            if bucket is None:
-                continue
-            stat = stat_map.setdefault(bucket, {
-                "impressions": 0,
-                "revenue_yuan": 0.0,
-                "ecpm_fen_sum": 0.0,
-            })
-            impressions = int(e["impressions"])
-            stat["impressions"] += impressions
-            stat["revenue_yuan"] += e["revenue_yuan"]
-            # eCPM 必须以每次真实展示为权重；纯发奖父行 impressions=0，不能参与分母或均值。
-            stat["ecpm_fen_sum"] += rewards.parse_ecpm_fen(e["ecpm"]) * impressions
-        return {
-            key: {
-                "impressions": value["impressions"],
-                "revenue_yuan": round(value["revenue_yuan"], 6),
-                "ecpm_yuan": round(
-                    value["ecpm_fen_sum"] / value["impressions"] / 100.0,
-                    6,
-                ) if value["impressions"] else 0.0,
-            }
-            for key, value in stat_map.items()
-        }
+    # 分广告类型小计(按 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()
+    }
 
-    # 原始 ad_type 小计，供明细筛选和排查使用。
-    type_stats = _aggregate_stats(lambda e: e["ad_type"])
-    # 经营看板使用的规范分类：Draw 包含历史 feed；看视频包含福利与提现视频。
-    # 这两个集合与筛选逻辑保持一致，避免只取 draw / reward_video 而漏算历史或提现数据。
-    category_stats = _aggregate_stats(
-        lambda e: (
-            "draw" if e["ad_type"] in {"draw", "feed"}
-            else "video" if e["ad_type"] in {"reward_video", "withdrawal_video"}
-            else None
-        )
-    )
-
-    # 分场景小计，同 type_stats 基于全量 events，供数据大盘「领券广告 / 比价广告」卡使用。
-    # feed_scene 为空的激励视频 / 历史数据不计入任何场景桶。
-    scene_stats = _aggregate_stats(lambda e: e.get("feed_scene"))
+    # 分场景小计(按 feed_scene:展示条数 + 预估收益),同 type_stats 基于全量 events——
+    # 供数据大盘「领券广告 / 比价广告」卡用。此前大盘是在分页 items 里按 feed_scene 现算,
+    # 2026-07-02 起信息流逐条展示行(唯一带收益 + 场景的行)不再进主表 items,现算恒为 0;
+    # 改为服务端在全量上聚合下发(也顺带不受 limit 分页截断影响)。feed_scene 为空(激励视频 /
+    # 旧数据)不计入任何场景桶。
+    scene_map: dict[str, dict] = {}
+    for e in events:
+        sc = e.get("feed_scene")
+        if not sc:
+            continue
+        s = scene_map.get(sc)
+        if s is None:
+            s = {"impressions": 0, "revenue_yuan": 0.0}
+            scene_map[sc] = s
+        s["impressions"] += e["impressions"]
+        s["revenue_yuan"] += e["revenue_yuan"]
+    scene_stats = {
+        k: {"impressions": v["impressions"], "revenue_yuan": round(v["revenue_yuan"], 6)}
+        for k, v in scene_map.items()
+    }
 
     # DAU:复用数据大盘活跃用户口径(登录 + 开始比价 + 开始领券,按用户去重),按所选日期区间
     # 统计(含今日),历史 / 多天区间同样有值。ARPU = 区间预估收益 ÷ 区间活跃用户。全局口径,
@@ -506,11 +471,9 @@ def ad_revenue_report(
         "truncated": len(main_rows) > offset + limit,
         "total_impressions": total_impressions,
         "total_revenue_yuan": total_revenue_yuan,
-        # GroMore 排序价预估 + ADN Reporting API 收益;非全量视图或无数据为 None。
+        # 穿山甲后台收益合计(元):预估 revenue + 收益Api;非全量视图(带 user/类型/场景过滤)或无数据为 None。
         "total_pangle_revenue_yuan": total_pangle_revenue_yuan,
         "total_pangle_api_revenue_yuan": total_pangle_api_revenue_yuan,
-        "pangle_api_revenue_complete": pangle_api_revenue_complete,
-        "pangle_latest_synced_at": pangle_latest_synced_at,
         "pangle_revenue_available": total_pangle_revenue_yuan is not None,
         "total_expected_coin": total_expected_coin,
         "total_actual_coin": total_actual_coin,
@@ -518,7 +481,6 @@ def ad_revenue_report(
         "daily": daily,
         "hourly": hourly,
         "type_stats": type_stats,
-        "category_stats": category_stats,
         "scene_stats": scene_stats,
         "dau": dau,
         "items": main_rows[offset:offset + limit],

app/admin/routers/ad_revenue.py

@@ -99,7 +99,6 @@ def get_ad_revenue_report(
         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()},
-        category_stats={k: AdRevenueTypeStat(**v) for k, v in result["category_stats"].items()},
         scene_stats={k: AdRevenueTypeStat(**v) for k, v in result["scene_stats"].items()},
         dau=result["dau"],
         total=result["total"],
@@ -108,8 +107,6 @@ def get_ad_revenue_report(
         total_revenue_yuan=result["total_revenue_yuan"],
         total_pangle_revenue_yuan=result["total_pangle_revenue_yuan"],
         total_pangle_api_revenue_yuan=result["total_pangle_api_revenue_yuan"],
-        pangle_api_revenue_complete=result["pangle_api_revenue_complete"],
-        pangle_latest_synced_at=result["pangle_latest_synced_at"],
         pangle_revenue_available=result["pangle_revenue_available"],
         total_expected_coin=result["total_expected_coin"],
         total_actual_coin=result["total_actual_coin"],

app/admin/schemas/ad_revenue.py

@@ -40,8 +40,6 @@ class AdRevenueRecord(BaseModel):
     expected_coin: int = Field(..., description="按公式复算应发金币")
     actual_coin: int = Field(..., description="实际入账金币")
     matched: bool = Field(..., description="复算与实发是否一致")
-    adn: str | None = Field(None, description="本条发奖对应的实际填充 ADN 子渠道")
-    slot_id: str | None = Field(None, description="本条发奖对应的底层 mediation rit")
 
 
 class AdRevenueDaily(BaseModel):
@@ -49,12 +47,12 @@ class AdRevenueDaily(BaseModel):
 
     date: str = Field(..., description="北京时间 YYYY-MM-DD")
     impressions: int = Field(..., description="当天展示条数合计")
-    revenue_yuan: float = Field(..., description="当天客户端 SDK 展示预估合计(元;后端留存 eCPM 折算)")
+    revenue_yuan: float = Field(..., description="当天客户端有效预估收益合计(元;eCPM 折算)")
     pangle_revenue_yuan: float | None = Field(
-        None, description="当天 GroMore 排序价预估(元;revenue,非结算收入);非全量视图/无数据为空"
+        None, description="当天穿山甲后台预估收益(元;GroMore revenue);非全量视图/无数据为空"
     )
     pangle_api_revenue_yuan: float | None = Field(
-        None, description="当天 ADN Reporting API 收益(元;GroMore api_revenue);未配/当天/无数据为空"
+        None, description="当天穿山甲收益Api(元;GroMore api_revenue,更接近结算);未配/当天/无数据为空"
     )
     expected_coin: int = Field(..., description="当天应发金币合计")
     actual_coin: int = Field(..., description="当天实发金币合计")
@@ -71,11 +69,10 @@ class AdRevenueHourly(BaseModel):
 
 
 class AdRevenueTypeStat(BaseModel):
-    """展示条数、SDK 展示预估收益与按展示次数加权的 SDK eCPM。"""
+    """按广告类型(ad_type)的小计:展示条数 + 预估收益(eCPM 由前端用 收益÷展示×1000 算)。"""
 
     impressions: int = Field(..., description="该类型展示条数合计")
     revenue_yuan: float = Field(..., description="该类型预估收益合计(元)")
-    ecpm_yuan: float = Field(..., description="按展示次数加权的 SDK eCPM(元/千次)")
 
 
 class AdRevenueRow(BaseModel):
@@ -101,15 +98,15 @@ class AdRevenueRow(BaseModel):
     ecpm: str | None = Field(None, description="eCPM 原始值(分/千次);展示行取展示值,纯发奖行取发奖采用值")
     revenue_yuan: float = Field(
         ...,
-        description="本次 SDK 展示预估收益(元)=后端留存 eCPM 元 ÷ 1000;是否满足发奖条件不改变展示收入预估",
+        description="本次有效展示预估收益(元)= eCPM元 ÷ 1000;纯发奖、激励视频提前关闭/时长不足=0",
     )
     row_revenue_yuan: float | None = Field(
         None,
         description="主表逐行展示用的预估收益(元):一次比价/领券聚合行=该次发奖广告 eCPM 折算之和;"
         "其它行为空(前端回退取 revenue_yuan)。不进合计/趋势,避免与展示侧重复计",
     )
-    adn: str | None = Field(None, description="实际填充 ADN 子渠道(pangle/gdt…);历史或未上报展示来源为空")
-    slot_id: str | None = Field(None, description="底层 mediation rit(非我们配置的广告位 ID);历史或未上报展示来源为空")
+    adn: str | None = Field(None, description="实际填充 ADN 子渠道(pangle/gdt…);纯发奖行为空")
+    slot_id: str | None = Field(None, description="底层 mediation rit(非我们配置的广告位 ID);纯发奖行为空")
     # ── 发奖侧 ──
     has_reward: bool = Field(..., description="是否有发奖记录(激励视频合并行 / 信息流整场发奖行=True;纯展示=False)")
     status: str | None = Field(None, description="发奖状态 granted/closed_early/too_short/…;纯展示为空")
@@ -143,11 +140,7 @@ class AdRevenueReportOut(BaseModel):
     )
     type_stats: dict[str, AdRevenueTypeStat] = Field(
         default_factory=dict,
-        description="按原始广告类型(ad_type)小计，供筛选与排查使用",
-    )
-    category_stats: dict[str, AdRevenueTypeStat] = Field(
-        default_factory=dict,
-        description="按经营分类小计：draw=draw+历史 feed，video=reward_video+withdrawal_video",
+        description="按广告类型(ad_type)小计 {ad_type: {impressions, revenue_yuan}};前端取 draw / reward_video 做分类大盘",
     )
     scene_stats: dict[str, AdRevenueTypeStat] = Field(
         default_factory=dict,
@@ -163,28 +156,20 @@ class AdRevenueReportOut(BaseModel):
     total: int = Field(..., description="广告事件总数(全量,不受分页影响;= 当前筛选下的分页总条数)")
     truncated: bool = Field(..., description="当前页之后是否还有更多事件(len(events) > offset + limit)")
     total_impressions: int = Field(..., description="全量展示条数合计")
-    total_revenue_yuan: float = Field(..., description="全量客户端 SDK 展示预估合计(元;后端留存 eCPM 折算)")
+    total_revenue_yuan: float = Field(..., description="全量客户端有效预估收益合计(元;eCPM 折算)")
     total_pangle_revenue_yuan: float | None = Field(
         None,
-        description="全量 GroMore 排序价预估合计(元;revenue,非结算收入)。GroMore 无用户/类型/场景维度,"
+        description="全量穿山甲后台预估收益合计(元;GroMore revenue)。穿山甲无用户/类型/场景维度,"
         "仅「全量视图」(未按 user_id/ad_type/feed_scene 过滤)时有值,否则为 null",
     )
     total_pangle_api_revenue_yuan: float | None = Field(
         None,
-        description="全量 ADN Reporting API 收益合计(元;GroMore api_revenue,仅已配置回传的 ADN);"
+        description="全量穿山甲收益Api合计(元;GroMore api_revenue,各 ADN 回传、更接近结算);"
         "未配 Reporting / 查当天 / 非全量视图 时为 null",
     )
-    pangle_api_revenue_complete: bool = Field(
-        False,
-        description="所选每一天是否都已在 D+1 14:00 后完成 API 同步窗口；不代表覆盖全部 ADN 或最终结算",
-    )
-    pangle_latest_synced_at: datetime | None = Field(
-        None,
-        description="所选范围穿山甲/GroMore 日报最近同步时间",
-    )
     pangle_revenue_available: bool = Field(
         False,
-        description="本次结果是否带 GroMore/ADN 收益(=全量视图且已同步到数据)。false 时前端显示「-」",
+        description="本次结果是否带穿山甲后台收益(=全量视图且已同步到数据)。false 时前端「穿山甲收益」显示「-」",
     )
     total_expected_coin: int = Field(..., description="全量应发金币合计")
     total_actual_coin: int = Field(..., description="全量实发金币合计")

app/api/v1/ad.py

@@ -289,8 +289,7 @@ def ecpm_report(payload: EcpmReportIn, user: CurrentUser, db: DbSession) -> Ecpm
     """客户端在广告展示后(onAdShow 读 getShowEcpm)上报 eCPM,落库做内部收益统计/对账。
 
     Bearer 鉴权,user_id 取自 JWT(不信 body)。best-effort:落库即 ok,客户端 fire-and-forget,
-    丢一两条不影响发奖业务(收入另由 ADN Reporting API 对账)。eCPM 与发奖(S2S)是两条独立流,
-    不逐条关联。
+    丢一两条不影响业务(穿山甲后台报表是结算权威)。eCPM 与发奖(S2S)是两条独立流,不逐条关联。
     """
     attributed_trace_id = crud_ecpm.attributable_trace_id(
         db,

app/api/v1/auth.py

@@ -292,7 +292,12 @@ def sms_login(req: SmsLoginRequest, request: Request, db: DbSession) -> TokenWit
         detail="登录尝试过于频繁,请稍后再试",
     )
 
-    if not verify_code(req.phone, req.code):
+    try:
+        ok = verify_code(req.phone, req.code)
+    except SmsError as e:  # provider 校验降级(如阿里云接口异常)→ 原样透出其状态码(503),别误报「验证码错误」
+        raise HTTPException(status_code=e.status_code, detail=str(e)) from e
+    if not ok:
+        # 校验码错误才记风控失败事件(provider 降级 503 已在上面提前 raise,不算「验证失败」)
         risk_repo.record_behavior_event(
             db,
             event_type=risk_repo.EVENT_SMS_LOGIN,
@@ -456,7 +461,11 @@ def wechat_bind_phone_sms(
         detail="登录尝试过于频繁,请稍后再试",
     )
 
-    if not verify_code(req.phone, req.code):
+    try:
+        ok = verify_code(req.phone, req.code)
+    except SmsError as e:  # provider 校验降级(如阿里云接口异常)→ 原样透出其状态码(503),别误报「验证码错误」
+        raise HTTPException(status_code=e.status_code, detail=str(e)) from e
+    if not ok:
         raise HTTPException(status_code=400, detail="invalid sms code")
 
     return _finish_wechat_bind(

app/core/config.py

@@ -141,6 +141,31 @@ class Settings(BaseSettings):
     SMS_DAILY_LIMIT_PER_PHONE: int = 10   # 单手机号每日发送上限(防刷 + 控费)
     SMS_MAX_VERIFY_ATTEMPTS: int = 5      # 单个验证码最多校验失败次数,超过即作废(防爆破)
 
+    # ===== 短信提供商(可切换:极光 / 阿里云号码认证)=====
+    # jiguang(默认):本服务生成验证码,极光只负责下发,本地内存校验(自管码,现状不变)。
+    # aliyun:阿里云 dypns 号码认证,阿里云生成+下发+校验(Mode A);缺凭证时 /sms/* 返 503(优雅降级)。
+    SMS_PROVIDER: Literal["jiguang", "aliyun"] = "jiguang"
+    ALIYUN_SMS_ACCESS_KEY_ID: str = ""
+    ALIYUN_SMS_ACCESS_KEY_SECRET: str = ""
+    ALIYUN_SMS_SIGN_NAME: str = ""            # 系统赠送签名(自定义签名下发易失败)
+    ALIYUN_SMS_TEMPLATE_CODE: str = ""        # 赠送模板 CODE(须与赠送签名搭配)
+    ALIYUN_SMS_SCHEME_NAME: str = ""          # 方案名(可空=默认方案);send/check 共用避免不匹配
+    ALIYUN_SMS_ENDPOINT: str = "dypnsapi.aliyuncs.com"
+    ALIYUN_SMS_CODE_LENGTH: int = 6           # 验证码位数(CodeLength 4~8)
+    ALIYUN_SMS_VALID_TIME_SEC: int = 300      # 验证码有效期秒(ValidTime);短信内 min 文案 = //60
+    ALIYUN_SMS_INTERVAL_SEC: int = 60         # 单号发送频控秒(Interval);核验免费
+    ALIYUN_SMS_TIMEOUT_SEC: int = 15          # 阿里云 API 读/连超时秒
+
+    @property
+    def aliyun_sms_configured(self) -> bool:
+        """阿里云短信凭证齐全(缺则 SMS_PROVIDER=aliyun 时 /sms/* 返 503,而非启动崩)。"""
+        return bool(
+            self.ALIYUN_SMS_ACCESS_KEY_ID
+            and self.ALIYUN_SMS_ACCESS_KEY_SECRET
+            and self.ALIYUN_SMS_SIGN_NAME
+            and self.ALIYUN_SMS_TEMPLATE_CODE
+        )
+
     # ===== 测试账号(release 包全流程联调用)=====
     # 配一个固定测试手机号,专供无 SIM 卡 / 不走一键登录时打通全流程:该号登录【免短信验证码】
     # (real 模式下也跳过校验)、每次登录【强制重走新手引导】,并设【每日使用次数上限】防被人
@@ -318,7 +343,7 @@ class Settings(BaseSettings):
     # ===== 穿山甲 GroMore 数据 API(报表收益拉取,T+1)=====
     # ⚠️ 与上面发奖回调的 m-key 是【两套完全不同的凭证】:这三样在穿山甲后台
     # 「接入中心 → GroMore-API → 聚合数据报告 API」文档页领取(user_id / role_id / Security Key),
-    # 仅用于按天拉 GroMore 报表(revenue 排序价预估 + api_revenue ADN Reporting 收益),不参与发奖。
+    # 仅用于按天拉 GroMore 收益报表(revenue 预估收益 + api_revenue 收益Api),不参与发奖。
     # 该 API 只能查【GroMore 聚合代码位】的数据(=我们 useMediation 的口径),非穿山甲 SDK 数据;
     # 且不提供用户/设备维度(官方明确),故收益只能落到 日期×代码位 汇总,不能挂到逐条事件。
     # 子账号(role_id≠user_id)需主账号在「角色管理」授予「查看全部数据」权限,否则查不到

app/integrations/pangle_report.py

@@ -14,8 +14,8 @@
   - 只返回【GroMore 聚合代码位】在 GroMore 内的数据(=我们 useMediation 的口径),
     查不到穿山甲 SDK 自身的数据;
   - **不提供分用户/设备维度**(官方 FAQ 明确拒绝),最细到 日期×应用×代码位×广告源;
-  - `revenue` = 排序价/竞价实时价预估(元,非结算收入);`api_revenue` = 各 ADN 经 Reporting
-    回传、按实时汇率折算账号币种的收益,需后台为该 ADN 配置 Reporting 才有、且不支持当天;
+  - `revenue` = 预估收益(元,所有 ADN 都有);`api_revenue` = 收益Api(各 ADN 经 Reporting
+    回传、按实时汇率折算账号币种,更接近结算),需后台为该 ADN 配置 Reporting 才有、且不支持当天;
   - 「今天」与「今天以前」必须分开查;天级跨度 ≤ 1 个月、不早于 12 个月。
 """
 from __future__ import annotations

app/integrations/sms/__init__.py

@@ -0,0 +1,33 @@
+"""短信验证码服务 —— provider 分派入口。
+
+对外只暴露 `send_code` / `verify_code` / `SmsError`,api 层无需关心用哪个 provider。
+provider 由 `settings.SMS_PROVIDER` 选择(**每次调用读取**,支持运行时切换 + 灰度回退):
+  - `jiguang`(默认):自管码(本服务生成、内存存/校验,极光只发)。见 [jiguang.py](jiguang.py)。
+  - `aliyun`:阿里云号码认证(阿里云生成+下发+校验,Mode A)。见 [aliyun.py](aliyun.py)。
+
+mock(`SMS_MOCK=true`)与各 provider 的行为差异都封在 provider 内部;本层只做路由。
+拆包前本模块是单文件 `sms.py`;拆包后极光逻辑迁入 `jiguang` 子模块,行为零改动。
+"""
+from __future__ import annotations
+
+from app.core.config import settings
+
+from . import aliyun, jiguang
+from .base import SmsError
+
+__all__ = ["SmsError", "send_code", "verify_code"]
+
+
+def _provider():
+    """按配置选 provider 模块(每次调用读 settings,支持运行时切换 / 测试注入)。"""
+    return aliyun if settings.SMS_PROVIDER == "aliyun" else jiguang
+
+
+def send_code(phone: str) -> int:
+    """发送验证码,返回距下次可发的冷却秒数;失败抛 SmsError。委托给当前 provider。"""
+    return _provider().send_code(phone)
+
+
+def verify_code(phone: str, code: str) -> bool:
+    """校验验证码,返回是否通过;provider 异常降级抛 SmsError。委托给当前 provider。"""
+    return _provider().verify_code(phone, code)

app/integrations/sms/aliyun.py

@@ -0,0 +1,193 @@
+"""阿里云号码认证(dypns)短信 provider —— Mode A(阿里云托管验证码)。
+
+与极光(自管码)最大不同:**本服务不生成/不存储验证码**,验证码由阿里云生成+存储+下发+校验。
+  - 发码:调 SendSmsVerifyCode,TemplateParam 用 `{"code":"##code##","min":...}` 占位,阿里云生成。
+  - 校验:调 CheckSmsVerifyCode,阿里云返回 PASS / UNKNOWN。核验免费。
+→ 天然消除极光路径「内存存码、多 worker 不共享」的技术债(发码/校验可落不同 worker,阿里云统一裁决)。
+
+**唯一本地态**:per-phone 连续失败计数(`_verify_attempts`),用于复刻极光「单码失败
+`SMS_MAX_VERIFY_ATTEMPTS` 次即作废」的防爆破语义 —— 刻意与极光一致,避免两 provider 行为不同
+导致排查困惑。其多 worker 降级特性与极光现状同级;另有 API 层登录频控(设备+IP)做硬兜底。
+
+单号发送频控(冷却)交给阿里云 `Interval` 参数(命中→FREQUENCY_FAIL→429),本地不再维护冷却。
+
+SDK 交互隔离在 `_call_send` / `_call_check` 两个薄封装(惰性 import + 惰性建 client,仿 wxpay
+惰性加载),单测 monkeypatch 这两个即可,不触真 SDK / 网络。
+"""
+from __future__ import annotations
+
+import json
+import logging
+import time
+from threading import Lock
+
+from app.core.config import settings
+
+from .base import SmsError, mock_verify
+
+logger = logging.getLogger("shagua.sms.aliyun")
+
+# 阿里云路径唯一本地态:per-phone 连续失败次数(与极光同语义,防爆破)。
+_verify_attempts: dict[str, int] = {}   # phone -> 连续失败次数
+_verify_seen: dict[str, float] = {}     # phone -> 最近触碰 epoch(仅供 GC 老化)
+_lock = Lock()
+_GC_THRESHOLD = 10000                    # 超此阈值,send 时顺手清老于验证码有效期的计数(仿极光 _gc)
+
+# 发码错误码 → (HTTP 码, 用户提示)。未列出的一律 503(供应商不可用)。
+_SEND_ERRORS: dict[str, tuple[int, str]] = {
+    "MOBILE_NUMBER_ILLEGAL": (400, "手机号无效"),
+    "BUSINESS_LIMIT_CONTROL": (429, "今日发送次数过多,请明天再试"),
+    "FREQUENCY_FAIL": (429, "发送过于频繁,请稍后再试"),
+}
+# 需运维介入的配置/开通类错误:打 critical 日志(融合认证未开通 / 参数非法)。
+_SEND_CRITICAL_CODES = frozenset({"FUNCTION_NOT_OPENED", "INVALID_PARAMETERS"})
+
+_client = None  # 惰性构建的 SDK client(模块级缓存)
+
+
+# ============================ 对外:发码 / 校验 ============================
+
+def send_code(phone: str) -> int:
+    """发送验证码(阿里云生成+下发)。
+
+    Returns: 距下次可发的秒数(= ALIYUN_SMS_INTERVAL_SEC,冷却由阿里云 Interval 侧执行)。
+    Raises: SmsError(手机号无效 400 / 过频·天级流控 429 / 未配置·未开通·其他 503)。
+    """
+    if settings.SMS_MOCK:
+        logger.info("[SMS-aliyun-MOCK] to %s**** (不真发)", phone[:3])
+        return settings.ALIYUN_SMS_INTERVAL_SEC
+    if not settings.aliyun_sms_configured:
+        raise SmsError("短信服务未配置(缺阿里云凭证)", status_code=503)
+
+    result = _call_send(phone)  # 传输/SDK 异常在内部抛 SmsError(503)
+
+    if result["success"] and result["code"] == "OK":
+        now = time.time()
+        with _lock:
+            _gc(now)                          # 顺手清老计数(超阈值才扫)
+            _verify_attempts.pop(phone, None)  # 新码 = 新失败预算
+            _verify_seen.pop(phone, None)
+        logger.info("[SMS-aliyun] sent to %s****", phone[:3])
+        return settings.ALIYUN_SMS_INTERVAL_SEC
+
+    code = result["code"]
+    logger.error("[SMS-aliyun] send failed code=%s msg=%s", code, result["message"])
+    if code in _SEND_CRITICAL_CODES:
+        logger.critical("[SMS-aliyun] %s —— 需运维处理(融合认证未开通 / 参数非法)", code)
+    status, msg = _SEND_ERRORS.get(code, (503, "短信服务暂不可用,请稍后重试"))
+    raise SmsError(msg, status_code=status)
+
+
+def verify_code(phone: str, code: str) -> bool:
+    """校验验证码(阿里云裁决)。
+
+    - **mock**:放行任意 N 位数字(provider 无关,同极光)。
+    - **real**:先查本地失败计数(达上限即本地作废,不调阿里云,与极光一致)→ 调 CheckSmsVerifyCode:
+      PASS 清计数返 True(一次性);UNKNOWN 计数 +1 返 False;接口异常抛 SmsError(503)。
+    """
+    if settings.SMS_MOCK:
+        ok = mock_verify(code)
+        logger.info("[SMS-aliyun-MOCK] verify %s for %s****", "ok" if ok else "fail", phone[:3])
+        return ok
+
+    # 失败计数是 best-effort:网络调用不持锁(不能锁跨 IO),故并发下同号可能多放行个位数次。
+    # 无碍——API 层登录频控(设备+IP 5/时)是硬上限,阿里云码有效期 + DuplicatePolicy 亦兜底。
+    with _lock:
+        if _verify_attempts.get(phone, 0) >= settings.SMS_MAX_VERIFY_ATTEMPTS:
+            return False  # 已作废:保持计数(直到 send_code 重置),与极光「达上限即作废」一致
+
+    result = _call_check(phone, code)  # 传输/SDK 异常在内部抛 SmsError(503)
+
+    if not (result["success"] and result["code"] == "OK"):
+        # 接口层失败(非码错):降级 503,别误报「验证码错误」(400),便于区分排查。
+        logger.error("[SMS-aliyun] check failed code=%s msg=%s", result["code"], result["message"])
+        raise SmsError("短信服务暂不可用,请稍后重试", status_code=503)
+
+    if result["verify_result"] == "PASS":
+        with _lock:
+            _verify_attempts.pop(phone, None)  # 验过即清(一次性)
+            _verify_seen.pop(phone, None)
+        return True
+
+    # UNKNOWN:码错 / 过期 → 失败计数 +1(累计到上限即作废)
+    with _lock:
+        _verify_attempts[phone] = _verify_attempts.get(phone, 0) + 1
+        _verify_seen[phone] = time.time()
+    return False
+
+
+def _gc(now: float) -> None:
+    """超阈值时清理老于验证码有效期的失败计数(码早已在阿里云侧失效,计数无意义)。仅持锁调用。"""
+    if len(_verify_attempts) <= _GC_THRESHOLD:
+        return
+    cutoff = now - settings.ALIYUN_SMS_VALID_TIME_SEC
+    for p in [p for p, ts in _verify_seen.items() if ts < cutoff]:
+        _verify_attempts.pop(p, None)
+        _verify_seen.pop(p, None)
+
+
+# ============================ SDK 接缝(单测 monkeypatch 这两个)============================
+
+def _get_client():
+    """惰性构建 dypns SDK client(仿 wxpay 惰性加载:jiguang-only 部署不加载 alibabacloud)。"""
+    global _client
+    if _client is None:
+        from alibabacloud_dypnsapi20170525.client import Client
+        from alibabacloud_tea_openapi import models as open_api_models
+
+        cfg = open_api_models.Config(
+            access_key_id=settings.ALIYUN_SMS_ACCESS_KEY_ID,
+            access_key_secret=settings.ALIYUN_SMS_ACCESS_KEY_SECRET,
+            read_timeout=settings.ALIYUN_SMS_TIMEOUT_SEC * 1000,     # SDK 单位 ms
+            connect_timeout=settings.ALIYUN_SMS_TIMEOUT_SEC * 1000,
+        )
+        cfg.endpoint = settings.ALIYUN_SMS_ENDPOINT
+        _client = Client(cfg)
+    return _client
+
+
+def _call_send(phone: str) -> dict:
+    """调 SendSmsVerifyCode。返回归一化 {success, code, message};import/建 client/调用 任一失败抛 SmsError(503)。"""
+    valid_min = max(1, settings.ALIYUN_SMS_VALID_TIME_SEC // 60)
+    template_param = json.dumps({"code": "##code##", "min": str(valid_min)}, ensure_ascii=False)
+    try:
+        # import + 建 req + 调用 全在 try 内:任一 provider 侧失败都归一成 503(保「provider 出问题→503」不变式)
+        from alibabacloud_dypnsapi20170525 import models as dypns_models
+        req = dypns_models.SendSmsVerifyCodeRequest(
+            phone_number=phone,
+            sign_name=settings.ALIYUN_SMS_SIGN_NAME,
+            template_code=settings.ALIYUN_SMS_TEMPLATE_CODE,
+            template_param=template_param,
+            code_length=settings.ALIYUN_SMS_CODE_LENGTH,
+            valid_time=settings.ALIYUN_SMS_VALID_TIME_SEC,
+            interval=settings.ALIYUN_SMS_INTERVAL_SEC,
+            scheme_name=settings.ALIYUN_SMS_SCHEME_NAME or None,
+        )
+        body = _get_client().send_sms_verify_code(req).body
+    except Exception as e:
+        logger.exception("[SMS-aliyun] send_sms_verify_code 调用异常 phone=%s****", phone[:3])
+        raise SmsError("短信服务暂不可用,请稍后重试", status_code=503) from e
+    return {"success": bool(body.success), "code": body.code, "message": body.message}
+
+
+def _call_check(phone: str, code: str) -> dict:
+    """调 CheckSmsVerifyCode。返回归一化 {success, code, message, verify_result};import/建 client/调用 任一失败抛 SmsError(503)。"""
+    try:
+        # import + 建 req + 调用 全在 try 内:任一 provider 侧失败都归一成 503(保「provider 出问题→503」不变式)
+        from alibabacloud_dypnsapi20170525 import models as dypns_models
+        req = dypns_models.CheckSmsVerifyCodeRequest(
+            phone_number=phone,
+            verify_code=code,
+            scheme_name=settings.ALIYUN_SMS_SCHEME_NAME or None,
+        )
+        body = _get_client().check_sms_verify_code(req).body
+    except Exception as e:
+        logger.exception("[SMS-aliyun] check_sms_verify_code 调用异常 phone=%s****", phone[:3])
+        raise SmsError("短信服务暂不可用,请稍后重试", status_code=503) from e
+    verify_result = getattr(body.model, "verify_result", None) if body.model else None
+    return {
+        "success": bool(body.success),
+        "code": body.code,
+        "message": body.message,
+        "verify_result": verify_result,
+    }

app/integrations/sms/base.py

@@ -0,0 +1,23 @@
+"""短信 provider 共享基座:业务异常 + provider 无关的 mock 校验。
+
+各 provider(jiguang / aliyun)都 `from .base import SmsError`,api 层也从包入口拿到同一个
+`SmsError` —— 保证无论用哪个 provider,异常类型与 HTTP 码映射语义一致。
+"""
+from __future__ import annotations
+
+from app.core.config import settings
+
+
+class SmsError(Exception):
+    """业务异常。`status_code` 决定 api 层翻成哪个 HTTP 码:
+    过频/每日超限 = 429(客户端等会再来),供应商不可用 = 503,手机号无效 = 400。
+    """
+
+    def __init__(self, message: str, status_code: int = 429) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def mock_verify(code: str) -> bool:
+    """mock 模式校验:放行任意 SMS_CODE_LENGTH 位数字(provider 无关,测试/开发便利,不真校验)。"""
+    return len(code) == settings.SMS_CODE_LENGTH and code.isdigit()

app/integrations/sms/jiguang.py

@@ -1,15 +1,15 @@
-"""短信验证码服务。
+"""极光短信 provider(自管码 Mode B)。
 
 两种运行模式由 `SMS_MOCK` 切换:
   - **mock**(开发/测试,默认):不真发短信,验证码打到日志;校验**放行任意 N 位数字**
     (测试/开发便利)。真实校验逻辑(比对存码 / 一次性 / 防爆破)由 real 分支 + 单测覆盖。
-  - **real**(生产 `SMS_MOCK=false`):本服务生成 N 位验证码 → 调极光短信 REST
-    `/v1/messages` 发送(自定义验证码模式,极光只负责发,code 由本服务生成/保管/
+  - **real**(生产 `SMS_MOCK=false` 且 `SMS_PROVIDER=jiguang`):本服务生成 N 位验证码 → 调极光
+    短信 REST `/v1/messages` 发送(自定义验证码模式,极光只负责发,code 由本服务生成/保管/
     校验)→ 鉴权复用极光一键登录的 `JG_APP_KEY`/`JG_MASTER_SECRET`(同一极光应用)。
 
 验证码存储:**进程内存**(单 worker uvicorn 够用)。重启丢失(用户重发即可)。多
-worker / 多机时内存不共享 → 冷却、校验都会失效,届时迁移到 DB/Redis。
-见 docs/待办与技术债.md。
+worker / 多机时内存不共享 → 冷却、校验都会失效,届时迁移到 DB/Redis(或改用 aliyun provider,
+其验证码由阿里云托管、无本地存码)。见 docs/待办与技术债.md。
 
 防刷两层(短信花钱 + `/sms/send` 在登录前无法 JWT 鉴权):
   1. 单号 `SMS_SEND_INTERVAL_SEC` 冷却(本文件)
@@ -34,17 +34,9 @@ import httpx
 
 from app.core.config import settings
 
-logger = logging.getLogger("shagua.sms")
+from .base import SmsError, mock_verify
 
-
-class SmsError(Exception):
-    """业务异常。`status_code` 决定 api 层翻成哪个 HTTP 码:
-    过频/每日超限 = 429(客户端等会再来),供应商不可用 = 503,手机号无效 = 400。
-    """
-
-    def __init__(self, message: str, status_code: int = 429) -> None:
-        super().__init__(message)
-        self.status_code = status_code
+logger = logging.getLogger("shagua.sms.jiguang")
 
 
 @dataclass
@@ -126,7 +118,7 @@ def verify_code(phone: str, code: str) -> bool:
     - **real 模式**:比对本服务存的码,匹配即作废(一次性);失败累计到上限也作废(防爆破)。
     """
     if settings.SMS_MOCK:
-        ok = len(code) == settings.SMS_CODE_LENGTH and code.isdigit()
+        ok = mock_verify(code)
         logger.info("[SMS-MOCK] verify %s for %s****", "ok" if ok else "fail", phone[:3])
         return ok
 

app/models/ad_pangle_revenue.py

@@ -1,15 +1,15 @@
-"""GroMore 天级排序价预估与 ADN Reporting 收益(定时拉取入库)。
+"""穿山甲 GroMore 天级收益报表(后台结算口径,定时拉取入库)。
 
 每行 = GroMore 数据 API 返回的一条「日期 × 应用 × 代码位」聚合收益(`integrations/pangle_report`
-+ `scripts/sync_pangle_revenue` 落库)，与 `ad_ecpm_record`(客户端 SDK eCPM 折算的预估)
-互为对照:
++ `scripts/sync_pangle_revenue` 落库)。**权威/预估收益的来源**,与 `ad_ecpm_record`(客户端自报
+eCPM 折算的预估)互为对照:
 
-- `revenue_yuan` ← 接口 `revenue`(排序价/竞价实时价预估,元,不是结算收入);
-- `api_revenue_yuan` ← 接口 `api_revenue`(各 ADN Reporting 回传收益,元,更接近结算;
+- `revenue_yuan` ← 接口 `revenue`(预估收益,元;排序价×展示/1000,所有 ADN 都有);
+- `api_revenue_yuan` ← 接口 `api_revenue`(收益Api,元;各 ADN 经 Reporting 回传、更接近结算;
   未配置该 ADN 的 Reporting 或查当天时为空)。
 
 ⚠️ 穿山甲不提供分用户/设备维度,故本表最细只到 日期×应用×代码位,**无法挂到逐条广告事件**;
-广告收益报表里只用于汇总/趋势级的 GroMore/ADN 对账,不改逐条行的客户端预估。
+广告收益报表里只用于汇总/趋势级的「穿山甲后台收益」,不改逐条行的客户端预估。
 """
 from __future__ import annotations
 
@@ -51,9 +51,9 @@ class AdPangleDailyRevenue(Base):
     our_code_id: Mapped[str] = mapped_column(String(64), index=True, nullable=False)
     # 广告源(接口 network 数字→名,如 pangle/gdt);"" = 未分广告源的代码位汇总行(当前默认口径)。
     adn: Mapped[str] = mapped_column(String(16), nullable=False, default="")
-    # 排序价/竞价实时价预估(元)← 接口 revenue，非结算收入。
+    # 预估收益(元)← 接口 revenue。
     revenue_yuan: Mapped[float] = mapped_column(Float, nullable=False, default=0.0)
-    # ADN Reporting API 收益(元)← api_revenue;未配 Reporting / 当天等情况不返回 → NULL。
+    # 收益Api(元)← 接口 api_revenue;未配 Reporting / 当天 等情况接口不返回 → NULL。
     api_revenue_yuan: Mapped[float | None] = mapped_column(Float, nullable=True)
     # 预估 eCPM 原值(接口 ecpm,单位元/千次,**与客户端 getEcpm 的「分」不同**),参考用原样存。
     ecpm: Mapped[str | None] = mapped_column(String(32), nullable=True)

app/repositories/ad_ecpm.py

@@ -1,8 +1,8 @@
 """广告 eCPM 上报 CRUD(内部收益统计/对账)。
 
 客户端在广告展示后(onAdShow)读到 eCPM,经鉴权接口上报,这里落库。鉴权接口已确保
-user 存在(JWT),故不做 UnknownUser 校验。best-effort 上报:丢一两条不影响发奖业务;
-汇总收入以 ADN Reporting API 和最终结算单为准。
+user 存在(JWT),故不做 UnknownUser 校验。best-effort 上报:丢一两条不影响业务,
+穿山甲后台报表是结算权威兜底。
 """
 from __future__ import annotations
 
@@ -96,7 +96,7 @@ def create_ecpm_record(
         db.rollback()
         # 撞唯一约束 uq_ad_ecpm_record_session(全局按 ad_session_id、不含 user_id):并发同会话重复上报,
         # 或同一 ad_session_id 已被先到的上报占用。本接口 fire-and-forget、best-effort —— 丢一条不影响业务
-        # (收入另由 ADN Reporting API 对账),绝不向客户端抛 500。兜底查找须与唯一约束**同口径**(只按 ad_session_id、
+        # (穿山甲后台才是结算权威),绝不向客户端抛 500。兜底查找须与唯一约束**同口径**(只按 ad_session_id、
         # 不带 user_id):否则不同 user 上报了同一 ad_session_id 时,带 user_id 的查找会漏掉那条别人的记录 →
         # 旧逻辑在此 raise 成 500(本应静默吞掉)。
         existing = _find_by_session_global(db, ad_session_id)

app/repositories/ad_pangle_revenue.py

@@ -1,13 +1,12 @@
 """穿山甲 GroMore 天级收益 读写(`ad_pangle_daily_revenue` 表)。
 
 `scripts/sync_pangle_revenue` 拉数后调 `upsert_daily_rows` 落库(同一(日期×应用×代码位×广告源)
-幂等覆盖,T+1 订正可重跑);admin 广告收益报表调 `aggregate_by_date` 取 GroMore/ADN 收益做
+幂等覆盖,T+1 订正可重跑);admin 广告收益报表调 `aggregate_by_date` 取「穿山甲后台收益」做
 汇总/趋势级展示。穿山甲无用户维度,故这里不涉及 user_id。
 """
 from __future__ import annotations
 
 from collections.abc import Collection
-from datetime import datetime
 from typing import Any, TypedDict
 
 from sqlalchemy import func, select
@@ -24,7 +23,6 @@ class PangleDateAgg(TypedDict):
     revenue_yuan: float
     api_revenue_yuan: float | None
     impressions: int
-    synced_at: datetime | None
 
 
 def upsert_daily_rows(db: Session, rows: list[dict[str, Any]]) -> dict[str, int]:
@@ -89,7 +87,6 @@ def aggregate_by_date(
             func.sum(AdPangleDailyRevenue.revenue_yuan),
             func.sum(AdPangleDailyRevenue.api_revenue_yuan),
             func.sum(AdPangleDailyRevenue.impressions),
-            func.max(AdPangleDailyRevenue.synced_at),
         )
         .where(
             AdPangleDailyRevenue.report_date >= date_from,
@@ -106,12 +103,11 @@ def aggregate_by_date(
         stmt = stmt.where(AdPangleDailyRevenue.our_code_id.in_(our_code_ids))
 
     out: list[PangleDateAgg] = []
-    for report_date, rev, api_rev, imp, synced_at in db.execute(stmt).all():
+    for report_date, rev, api_rev, imp in db.execute(stmt).all():
         out.append(PangleDateAgg(
             date=report_date,
             revenue_yuan=round(float(rev or 0.0), 6),
             api_revenue_yuan=(round(float(api_rev), 6) if api_rev is not None else None),
             impressions=int(imp or 0),
-            synced_at=synced_at,
         ))
     return out

deploy/pangle-revenue.md

@@ -1,13 +1,13 @@
 # 穿山甲 GroMore 收益拉取 定时任务 — 运维手册
 
-> 对象:维护「每天拉 GroMore / ADN 收益入库」这套定时任务的同事。
+> 对象:维护「每天拉穿山甲后台收益入库」这套定时任务的同事。
 > 🔒 服务器登录信息见**私密交接清单**,不入库。
 
 ## 它是什么
-admin「广告收益报表」里的 GroMore / ADN 收益读的是**本地表 `ad_pangle_daily_revenue` 的快照,不是实时查询**。GroMore 的 T+1 初值约 10:00 可用，但第三方 ADN Reporting 数据可能到 13:50 才更新，所以需要早晚各拉一次。
+admin「广告收益报表」里的「穿山甲后台收益(T+1)」读的是**本地表 `ad_pangle_daily_revenue` 的快照,不是实时查穿山甲**。穿山甲只通过 GroMore 数据 API 给数、且 **T+1**(次日约 10:00 出昨天的数),所以每天得拉一次入库,报表才会往前走。
 
-- 每天 10:30 拉初值、14:30 拉日终值，均由 `scripts/sync_pangle_revenue.py` 以 `--days 3` 回补近 3 天。
-- 维度 = 日期 × 应用(site_id)× 广告位(ad_unit_id);指标 = `revenue`(排序价预估)+ `api_revenue`(ADN Reporting 回传，更接近结算)。
+- 每天 10:30 跑一轮 `scripts/sync_pangle_revenue.py`,默认 `--days 3` 回补近 3 天。
+- 维度 = 日期 × 应用(site_id)× 广告位(ad_unit_id);指标 = `revenue`(预估)+ `api_revenue`(结算口径)。
 - **幂等 upsert**:同一(日期×应用×代码位)重跑只覆盖、不重复,故回补 / 重跑 / catch-up 都安全。
 - 穿山甲无用户/设备维度 → 只能落「汇总/趋势级」,报表带 user_id 过滤时这块收益置空(显示「-」)。
 
@@ -30,15 +30,15 @@ admin「广告收益报表」里的 GroMore / ADN 收益读的是**本地表 `ad
 ```bash
 sudo cp deploy/pangle-revenue.{service,timer} /etc/systemd/system/
 sudo systemctl daemon-reload && sudo systemctl enable --now pangle-revenue.timer
-systemctl list-timers pangle-revenue.timer   # 确认下次触发时间(10:30 或 14:30)
+systemctl list-timers pangle-revenue.timer   # 确认下次触发时间(应是次日 10:30)
 ```
 
 ## 怎么看健康 / 手动跑一次
 ```bash
-journalctl -u pangle-revenue -n 30 --no-pager   # 看日志:拉取区间 / 入库行数 / 新增更新 / 收益合计
-sudo systemctl start pangle-revenue.service     # 立即手动跑一轮
+sudo systemctl start pangle-revenue.service     # 立即手动跑一轮(不等 10:30)
+journalctl -u pangle-revenue -n 30 --no-pager   # 看日志:拉取区间 / 入库行数 / 新增更新 / 预估收益合计
 ```
-成功日志形如:`✅ 完成:接口 N 行 → 入库 M 行(跳过 x),新增 a / 更新 b;排序价预估合计 ¥19.42`。
+成功日志形如:`✅ 完成:接口 N 行 → 入库 M 行(跳过 x),新增 a / 更新 b;预估收益合计 ¥19.42`。
 > 看不到收益、提示 `PANGLE_REPORT_* 未配置`→ 回「上线前置」补 `.env`;报 118 → 子账号没授「查看全部数据」。
 
 ## 本机 Windows 开发(无 systemd)
@@ -57,11 +57,11 @@ sudo systemctl start pangle-revenue.service     # 立即手动跑一轮
 - `--start / --end`:指定闭区间(跨度 ≤ 31 天,接口上限 1 个月,超了报 114)。
 
 ## 注意事项
-- **触发时间**:10:30 提供初值，14:30 覆盖为日终值；报表只把 D+1 14:00 后同步的数据标记为日终。
+- **触发时间**:`OnCalendar=*-*-* 10:30:00`。穿山甲 ~10:00 出数,故别早于 10:00 跑(会拉到空/不全)。
 - **catch-up**:`Persistent=true` 补跑错过的那一轮;叠加 `--days 3`,漏一两天重新触发即自愈。
 - **今天 / 今天以前要分开查**:脚本默认只拉昨天及更早,不混查今天(接口约束),无需关心。
 - **join key 是 `ad_unit_id`(我们配的 104xxx)不是 `code_id`**:`code_id` 是底层各 ADN 代码位,对不上口径;`ad_unit_id='-1'` 是未归因桶。改维度时务必注意(详见脚本头注释)。
-- **`api_revenue` 依赖 ADN Reporting 配置**:未配置的测试应用可能为空或 0；`revenue` 只是排序价估算，不能当结算收入。
+- **`api_revenue` 很稀疏**:测试应用 ADN 没配 Reporting → 全 0,仅 prod 个别位有;`revenue`(预估)才是稳的主力。
 - **DB 无关**:sqlite / postgres 均可(upsert 逐行 select-then-write,不像美团 ETL 需要 PG)。
 - **别和别的触发方式双跑**:本 systemd timer 与「手动 cron / 进程内任务」二选一,虽幂等不会重复入库,纯属多余。
 - **改脚本 / 改部署**:走 git + PR,由有 root 的人部署。

deploy/pangle-revenue.service

@@ -1,5 +1,5 @@
-# 拉 GroMore T+1 天级收益入库 —— 单轮跑,由 timer 每天 10:30、14:30 触发。
-# 落 ad_pangle_daily_revenue 表,供 admin 广告收益报表的 GroMore/ADN 对账区块。
+# 每天拉穿山甲 GroMore T+1 天级收益入库 —— 单轮跑,由 pangle-revenue.timer 每天 10:30 触发。
+# 落 ad_pangle_daily_revenue 表,供 admin 广告收益报表的「穿山甲后台收益(T+1)」区块。
 #
 # 仅用于 Linux 服务器;本机 Windows 开发无 systemd,直接手动跑脚本即可:
 #   .venv\Scripts\python -m scripts.sync_pangle_revenue            # 拉昨天(北京时间)

deploy/pangle-revenue.timer

@@ -1,12 +1,11 @@
-# 每天 10:30 首次拉取、14:30 终值复拉 GroMore T+1 收益(Linux 服务器用)。
+# 每天 10:30 触发一次穿山甲 GroMore T+1 收益拉取入库(Linux 服务器用)。
 # 见 pangle-revenue.service 顶部注释的部署步骤。
 [Unit]
-Description=Run Pangle GroMore daily revenue sync at 10:30 and 14:30
+Description=Run Pangle GroMore daily revenue sync at 10:30
 
 [Timer]
-# 10:30 尽早展示初值；第三方 ADN Reporting 最晚约 13:50 更新，14:30 再拉一次作为日终值。
+# 穿山甲 T+1、次日约 10:00 出数;10:30 触发留 30min 余量。要错开整点扎堆可微调到 10:35。
 OnCalendar=*-*-* 10:30:00
-OnCalendar=*-*-* 14:30:00
 # 服务器宕机/重启后,补跑错过的那一轮(而不是干等次日);叠加 --days 3 回补,漏一两天能自愈。
 Persistent=true
 AccuracySec=1min

docs/integrations/aliyun/CheckSmsVerifyCode.md

@@ -0,0 +1,224 @@
+CheckSmsVerifyCode - 核验验证码
+更新时间：2026年3月19日 20:02:53
+核验短信验证码并返回核验是否成功的结果。
+
+调试
+您可以在OpenAPI Explorer中直接运行该接口，免去您计算签名的困扰。运行成功后，OpenAPI Explorer可以自动生成SDK代码示例。
+
+ 调试 
+授权信息
+下表是API对应的授权信息，可以在RAM权限策略语句的Action元素中使用，用来给RAM用户或RAM角色授予调用此API的权限。具体说明如下：
+
+操作：是指具体的权限点。
+
+访问级别：是指每个操作的访问级别，取值为写入（Write）、读取（Read）或列出（List）。
+
+资源类型：是指操作中支持授权的资源类型。具体说明如下：
+
+对于必选的资源类型，用前面加 * 表示。
+
+对于不支持资源级授权的操作，用全部资源表示。
+
+条件关键字：是指云产品自身定义的条件关键字。
+
+关联操作：是指成功执行操作所需要的其他权限。操作者必须同时具备关联操作的权限，操作才能成功。
+
+放大查看
+操作
+
+访问级别
+
+资源类型
+
+条件关键字
+
+关联操作
+
+dypns:CheckSmsVerifyCode
+
+none
+
+*全部资源
+
+*
+
+无	无
+请求参数
+放大查看
+名称
+
+类型
+
+必填
+
+描述
+
+示例值
+
+SchemeName	
+string
+
+否
+
+方案名称，如果不填则为“默认方案”。最多不超过 20 个字符。
+
+重要 如果发送接口的方案名称不为空，请确保该参数不为空且与发送接口的方案名称参数一致
+测试方案
+
+CountryCode	
+string
+
+否
+
+号码国家编码，默认为 86。
+
+86
+
+PhoneNumber	
+string
+
+是
+
+手机号。
+
+186****0000
+
+OutId	
+string
+
+否
+
+外部流水号。
+
+12123231
+
+VerifyCode	
+string
+
+是
+
+验证码。
+
+说明
+SendSmsVerifyCode 接口的字段 TemplateParam，配置方式有 2 种：
+
+{"code":"##code##","min":"5"}
+
+{"code":"123456","min":"5"}
+
+{"code":"##code##","min":"5"}验证码是 api 动态生成的，阿里云接口可以完成校验。
+
+{"code":"123456","min":"5"}验证码是用户配置的不是 api 动态生成，阿里云接口无法校验。
+
+请您按照实际情况传入对应的验证码。
+
+1231
+
+CaseAuthPolicy	
+integer
+
+否
+
+验证码大小写字母核验策略。取值：
+
+1：不区分大小写。
+
+2：区分大小写。
+
+1
+
+返回参数
+放大查看
+名称
+
+类型
+
+描述
+
+示例值
+
+object
+
+AccessDeniedDetail	
+string
+
+访问被拒绝详细信息。
+
+无
+
+Message	
+string
+
+状态码的描述。
+
+成功
+
+Model	
+object
+
+请求结果数据。
+
+OutId	
+string
+
+外部流水号。
+
+1212312
+
+VerifyResult	
+string
+
+短信验证码核验结果。取值：
+
+PASS：短信验证码核验成功。
+
+UNKNOWN：短信验证码核验失败。
+
+PASS
+
+Code	
+string
+
+接口请求状态码。
+
+返回 OK 代表请求成功。
+
+其他错误码，请参见返回码。
+
+重要 接口请求成功不代表短信验证码核验成功，短信验证码核验结果仅以Model.VerifyResult参数返回值为准。
+OK
+
+Success	
+boolean
+
+接口调用是否成功。取值：
+
+true：接口调用成功。
+
+false：接口调用失败。
+
+重要 接口调用成功不代表短信验证码核验成功，短信验证码核验结果仅以Model.VerifyResult参数返回值为准。
+true
+
+RequestId	
+string
+
+CF8854E5-DB21-3E5D-A9B1-DDC752FD7384
+
+示例
+正常返回示例
+
+JSON格式
+
+放大查看复制代码
+{
+  "AccessDeniedDetail": "无",
+  "Message": "成功",
+  "Model": {
+    "OutId": "1212312",
+    "VerifyResult": "PASS"
+  },
+  "Code": "OK",
+  "Success": true,
+  "RequestId": "CF8854E5-DB21-3E5D-A9B1-DDC752FD7384"
+}

docs/integrations/aliyun/SendSmsVerifyCode.md

@@ -0,0 +1,396 @@
+SendSmsVerifyCode - 发送短信验证码
+更新时间：2026年7月3日 09:54:53
+发送短信验证码。
+
+接口说明
+由于运营商近期加强对短信签名的管控。您自定义的签名面临下发失败问题，推荐您使用号码认证控制台赠送的短信签名和模板进行短信认证。系统赠送签名必须搭配系统赠送模板使用。
+
+请确保在使用该接口前，已充分了解号码认证服务产品的收费方式和价格，短信认证服务仅收取短信发送费用（按运营商回执状态计费，短信提交成功但运营商回执失败时不计费），核验服务免费。
+
+调试
+您可以在OpenAPI Explorer中直接运行该接口，免去您计算签名的困扰。运行成功后，OpenAPI Explorer可以自动生成SDK代码示例。
+
+ 调试 
+授权信息
+下表是API对应的授权信息，可以在RAM权限策略语句的Action元素中使用，用来给RAM用户或RAM角色授予调用此API的权限。具体说明如下：
+
+操作：是指具体的权限点。
+
+访问级别：是指每个操作的访问级别，取值为写入（Write）、读取（Read）或列出（List）。
+
+资源类型：是指操作中支持授权的资源类型。具体说明如下：
+
+对于必选的资源类型，用前面加 * 表示。
+
+对于不支持资源级授权的操作，用全部资源表示。
+
+条件关键字：是指云产品自身定义的条件关键字。
+
+关联操作：是指成功执行操作所需要的其他权限。操作者必须同时具备关联操作的权限，操作才能成功。
+
+放大查看
+操作
+
+访问级别
+
+资源类型
+
+条件关键字
+
+关联操作
+
+dypns:SendSmsVerifyCode
+
+create
+
+*全部资源
+
+*
+
+无	无
+请求参数
+放大查看
+名称
+
+类型
+
+必填
+
+描述
+
+示例值
+
+SchemeName	
+string
+
+否
+
+方案名称，如果不填则为“默认方案”。最多不超过 20 个字符。
+
+测试方案
+
+CountryCode	
+string
+
+否
+
+号码国家编码。默认为 86，目前也仅支持国内号码发送。
+
+86
+
+PhoneNumber	
+string
+
+是
+
+短信接收方手机号。
+
+130****0000
+
+SignName	
+string
+
+是
+
+签名名称。暂不支持使用自定义签名，请使用系统赠送的签名，您可在赠送签名配置页面选择需要下发的签名。
+
+恒创联众
+
+TemplateCode	
+string
+
+是
+
+短信模板 CODE。参数SignName选择赠送签名时，必须搭配赠送模板下发短信。您可在赠送模板配置页面选择适用您业务场景的模板。
+
+100001
+
+TemplateParam	
+string
+
+是
+
+短信模板参数。验证码位置有两种传值方式：
+
+可使用"##code##"替代，由参数 CodeType 指定验证码生成规则；
+
+也可直接传入具体的验证码值，直接下发至接收方。
+
+示例：如模板内容为：“您的验证码是${code}，有效期${min}分钟，请勿告诉他人。”。
+
+重要 上文中的 code 请替换成您实际申请的验证码模板中的参数名称
+该字段可传入{"code":"##code##","min":"5"}由系统根据规则生成验证码；
+
+或直接传入指定的验证码值{"code":"123456","min":"5"}。
+
+说明
+{"code":"##code##","min":"5"}验证码是 api 动态生成的，阿里云接口可以完成校验。
+
+{"code":"123456","min":"5"}验证码是用户配置的不是 api 动态生成，阿里云接口无法校验。
+
+说明
+如果 JSON 中需要带换行符，请参照标准的 JSON 协议处理。
+
+模板变量规范，请参见短信模板规范。
+
+{"code":"##code##","min":"5"}
+
+SmsUpExtendCode	
+string
+
+否
+
+上行短信扩展码。上行短信指发送给通信服务提供商的短信，用于定制某种服务、完成查询，或是办理某种业务等，需要收费，按运营商普通短信资费进行扣费。
+
+说明
+扩展码是生成签名时系统自动默认生成的，不支持自行传入。无特殊需要此字段的用户请忽略此字段。如需使用，请联系您的商务经理。
+
+1213123
+
+OutId	
+string
+
+否
+
+外部流水号。
+
+外部流水号（透传）
+
+CodeLength	
+integer
+
+否
+
+验证码长度支持 4～8 位长度，默认是 4 位。
+
+4
+
+ValidTime	
+integer
+
+否
+
+验证码有效时长，单位秒，默认为 300 秒。
+
+300
+
+DuplicatePolicy	
+integer
+
+否
+
+核验规则，当有效时间内对同场景内的同号码重复发送验证码时，旧验证码如何处理。
+
+1：覆盖处理（默认），即旧验证码会失效掉。
+
+2：保留，即多个验证码都是在有效期内都可以校验通过。
+
+枚举值：
+
+1 :
+覆盖
+
+2 :
+保留
+
+1
+
+Interval	
+integer
+
+否
+
+时间间隔，单位：秒。即多久间隔可以发送一次验证码，用于频控，默认 60 秒。
+
+60
+
+CodeType	
+integer
+
+否
+
+生成的验证码类型。当参数 TemplateParam 传入占位符时，此参数必填，将由系统根据指定的规则生成验证码。取值：
+
+1：纯数字（默认）。
+
+2：纯大写字母。
+
+3：纯小写字母。
+
+4：大小字母混合。
+
+5：数字+大写字母混合。
+
+6：数字+小写字母混合。
+
+7：数字+大小写字母混合。
+
+枚举值：
+
+1 :
+纯数字
+
+2 :
+纯大写字母
+
+3 :
+纯小写字母
+
+4 :
+大小字母混合
+
+5 :
+数字+大写字母混合
+
+6 :
+数字+小写字母混合
+
+7 :
+数字+大小写字母混合
+
+1
+
+ReturnVerifyCode	
+boolean
+
+否
+
+是否返回验证码。取值：
+
+true：返回。
+
+false：不返回。
+
+true
+
+AutoRetry	
+integer
+
+否
+
+是否自动替换签名重试（默认开启），可取值：
+
+1 开启自动重试功能，开启后，在验证码有效期内，当运营商返回明确的失败状态时，允许阿里云尽可能的尝试使用其他方式发送验证码，以提升发送成功率。其他方式包括且不限于：通过其他运营商重试、更换签名重试等
+
+0 不开启自动重试
+
+是否自动重试
+
+返回参数
+放大查看
+名称
+
+类型
+
+描述
+
+示例值
+
+object
+
+AccessDeniedDetail	
+string
+
+访问被拒绝详细信息。
+
+无
+
+Message	
+string
+
+状态码的描述。
+
+成功
+
+RequestId	
+string
+
+请求 ID。
+
+CC3BB6D2-2FDF-4321-9DCE-B38165CE4C47
+
+Model	
+object
+
+请求结果数据。
+
+VerifyCode	
+string
+
+验证码。
+
+4232
+
+RequestId	
+string
+
+请求 ID。
+
+a3671ccf-0102-4c8e-8797-a3678e091d09
+
+OutId	
+string
+
+外部流水号。
+
+1231231313
+
+BizId	
+string
+
+业务 ID。
+
+112231421412414124123^4
+
+Code	
+string
+
+请求状态码。返回 OK 代表请求成功。其他错误码，请参见返回码列表。
+
+OK
+
+Success	
+boolean
+
+请求是否成功。
+
+true：请求成功。
+
+false：请求失败。
+
+true
+
+示例
+正常返回示例
+
+JSON格式
+
+放大查看复制代码
+{
+  "AccessDeniedDetail": "无",
+  "Message": "成功 ",
+  "RequestId": "CC3BB6D2-2FDF-4321-9DCE-B38165CE4C47",
+  "Model": {
+    "VerifyCode": "4232",
+    "RequestId": "a3671ccf-0102-4c8e-8797-a3678e091d09",
+    "OutId": "1231231313",
+    "BizId": "112231421412414124123^4"
+  },
+  "Code": "OK",
+  "Success": true
+}
+错误码
+放大查看
+HTTP status code
+
+错误码
+
+错误信息
+
+描述
+
+400	MOBILE_NUMBER_ILLEGAL	The mobile number is illegal.	手机号码格式错误
+400	BUSINESS_LIMIT_CONTROL	The number has exceeded the limit for the day.	触发号码天级流控
+400	FREQUENCY_FAIL	Check frequency fail.	频控校验未通过
+400	INVALID_PARAMETERS	parameter is not valid.	非法参数
+400	FUNCTION_NOT_OPENED	You have not opened this function.	没有开通融合认证功能

docs/integrations/sms.md

@@ -1,9 +1,22 @@
 # 短信验证码（sms）
 
-> 文件:`app/integrations/sms.py` | 关联接口:[auth-sms-send](../api/auth-sms-send.md) · [auth-sms-login](../api/auth-sms-login.md) | [← 集成索引](./README.md)
+> 文件:`app/integrations/sms/`(分派器 `__init__` + `jiguang` / `aliyun` provider + `base`) | 关联接口:[auth-sms-send](../api/auth-sms-send.md) · [auth-sms-login](../api/auth-sms-login.md) | [← 集成索引](./README.md)
 
 ## 作用
-手机号 + 验证码登录的验证码发送 / 校验。**已接极光短信 REST**,由 `SMS_MOCK` 切 mock / real。
+手机号 + 验证码登录的验证码发送 / 校验。支持**可切换 provider**(`SMS_PROVIDER`):`jiguang`(默认,极光自管码)/ `aliyun`(阿里云号码认证托管码)。`SMS_MOCK` 另切 mock / real。
+
+## 短信提供商(`SMS_PROVIDER`,可切换 + 灰度回退)
+| | `jiguang`(默认) | `aliyun` |
+|---|---|---|
+| 验证码 | **本服务生成**、极光只下发、**本地内存校验** | **阿里云生成 + 下发 + 校验**(dypns 号码认证,Mode A,核验免费) |
+| 发码 | 极光 `/v1/messages` | `SendSmsVerifyCode`(`##code##` 占位) |
+| 校验 | 比对本地存码 | `CheckSmsVerifyCode` → `PASS` / `UNKNOWN` |
+| 多 worker | ⚠️ 内存存码不共享(见已知局限) | ✅ 阿里云托管,天然共享 |
+| 防爆破 | 单码失败 `SMS_MAX_VERIFY_ATTEMPTS` 次即作废 | **同语义**(本地 per-phone 失败计数,刻意与极光一致) |
+| 单号冷却 | 本地 `SMS_SEND_INTERVAL_SEC` | 交给阿里云 `Interval` |
+| 校验降级 | 本地无网络调用 | 阿里云接口异常 → `/sms/login` 返 **503**(非 400,便于排查) |
+
+`aliyun` 需在**号码认证控制台开通「融合认证」**,用系统赠送签名 + 赠送模板;配置见 `.env.example` 的 `ALIYUN_SMS_*`,SDK 为 `alibabacloud_dypnsapi20170525`。**以下章节描述 `jiguang` provider(自管码)细节**。
 
 | | mock(`SMS_MOCK=true`,默认 / 开发测试) | real(`SMS_MOCK=false`,生产) |
 |---|---|---|

docs/superpowers/specs/2026-07-25-aliyun-sms-verify-design.md

@@ -0,0 +1,182 @@
+# 阿里云短信验证服务 — 设计方案
+
+- 日期：2026-07-25
+- 状态：已定稿，待实现
+- 范围：新增阿里云 dypns（号码认证服务）短信验证码 provider，与现有极光短信可切换
+
+## 1. 背景与目标
+
+现有短信验证码服务 `app/integrations/sms.py`：本服务**本地生成**验证码、存**进程内存**、极光 REST 仅负责下发；`verify_code()` 比对本地内存（一次性 + 单码失败 `SMS_MAX_VERIFY_ATTEMPTS` 次即作废）。docstring 已标注"内存存码、多 worker 不共享"为技术债。
+
+阿里云文档（`docs/integrations/aliyun/`）为 **号码认证服务 dypns** 的 `SendSmsVerifyCode` + `CheckSmsVerifyCode`：该产品由**阿里云生成并校验**验证码（`{"code":"##code##"}` 模式），核验免费。
+
+目标：接入阿里云该套接口作为一个新的短信 provider，可与极光切换。
+
+## 2. 关键决策（已确认）
+
+1. **验证码模式 = Mode A（阿里云托管码）**：发码用 `SendSmsVerifyCode` + `##code##` 占位符，阿里云生成/存储/下发；校验用 `CheckSmsVerifyCode`，阿里云返回 `PASS/UNKNOWN`。本服务不再本地生成/存储验证码。
+2. **可切换 Provider**：新增 `SMS_PROVIDER=jiguang|aliyun` 开关，`send_code/verify_code` 按 provider 分派；保留极光作回退（短信=花钱+登录关键路径，灰度上线/融合认证未开通时可秒切回极光）。
+3. **官方 SDK**：调阿里云 dypns 用 `alibabacloud_dypnsapi20170525`，签名/加签由 SDK 处理。
+4. **防爆破与极光一致**（排查一致性）：阿里云路径**保留**与极光相同的"单码失败 N 次即作废"本地计数，而非改用 API 层频控，避免两 provider 行为不一致导致排查困惑。
+
+## 3. 模块结构（`sms.py` 单文件升级为 provider 包）
+
+```
+app/integrations/sms/
+  __init__.py     # 公开 API + 分派器:send_code / verify_code / SmsError
+                  #   - SMS_MOCK=true 短路(不碰任何 provider)
+                  #   - 按 settings.SMS_PROVIDER 选 jiguang / aliyun
+  base.py         # SmsError(沿用现定义)+ Provider 协议(send_code/verify_code 签名约定)
+  jiguang.py      # 现有自管码逻辑原样迁入(内存存码/冷却/一次性/防爆破 全保留,行为零改动)
+  aliyun.py       # 新增:SendSmsVerifyCode 发码 + CheckSmsVerifyCode 校验 + 本地失败计数
+```
+
+- `__init__.py` 继续 re-export `SmsError / send_code / verify_code`，故 `app/api/v1/auth.py:37` 的
+  `from app.integrations.sms import SmsError, send_code, verify_code` **导入不变**。
+- 纯增量重构：极光逻辑整体迁入 `jiguang.py`，对外行为零变化。
+
+## 4. 数据流 — 阿里云 provider（Mode A）
+
+### 4.1 发码 `aliyun.send_code(phone) -> int`
+1. 校验 `settings.aliyun_sms_configured`（缺 AK/SignName/TemplateCode → `SmsError(503)`）。
+2. 调 `SendSmsVerifyCode`：
+   - `PhoneNumber=phone`
+   - `SignName=ALIYUN_SMS_SIGN_NAME`、`TemplateCode=ALIYUN_SMS_TEMPLATE_CODE`
+   - `TemplateParam = json({"code":"##code##","min": str(ALIYUN_SMS_VALID_TIME_SEC//60)})`
+   - `CodeLength=ALIYUN_SMS_CODE_LENGTH`、`ValidTime=ALIYUN_SMS_VALID_TIME_SEC`、`Interval=ALIYUN_SMS_INTERVAL_SEC`
+   - `SchemeName=ALIYUN_SMS_SCHEME_NAME`(可空)
+3. 成功（`body.Success and body.Code=="OK"`）→ **清本地失败计数**（新码=新预算）→ 返回 `ALIYUN_SMS_INTERVAL_SEC` 作客户端冷却秒数。
+4. 失败 → 按 §6 错误码映射抛 `SmsError`。
+
+### 4.2 校验 `aliyun.verify_code(phone, code) -> bool`
+1. **本地失败计数**：`attempts >= SMS_MAX_VERIFY_ATTEMPTS` → 直接 `False`（码已作废，不调阿里云）。
+2. 调 `CheckSmsVerifyCode(PhoneNumber, VerifyCode=code, SchemeName)`。
+3. `body.Model.VerifyResult`：
+   - `"PASS"` → 清计数，返回 `True`（一次性）。
+   - `"UNKNOWN"` → `attempts += 1`，返回 `False`（码错/过期）。
+4. 网络错误 / 接口非 `OK` → 抛 `SmsError(503)`（**不静默返回 False**，区分"阿里云挂了"与"码错了"；网络错误不计入 attempts）。
+
+本服务**不存验证码**，仅存一个 per-phone 失败计数（见 §7）。
+
+## 5. 分派器 & mock（`__init__.py`）
+
+```
+send_code(phone):
+    if settings.SMS_MOCK:          # 短路:不碰 provider(测试/开发)
+        log placeholder code; return cooldown
+    return _provider().send_code(phone)
+
+verify_code(phone, code):
+    if settings.SMS_MOCK:          # 放行任意 N 位数字(沿用现 mock 语义)
+        return len(code)==SMS_CODE_LENGTH and code.isdigit()
+    return _provider().verify_code(phone, code)
+
+_provider():  jiguang if settings.SMS_PROVIDER=="jiguang" else aliyun
+```
+
+- mock 语义提到分派层、provider 无关 → 现有 28 个测试文件（conftest 设 `SMS_MOCK=true`）全部零改动通过。
+
+## 6. 错误映射
+
+### 发码（阿里云错误码 → SmsError.status_code）
+| 阿里云码 | HTTP | 说明 |
+|---|---|---|
+| `MOBILE_NUMBER_ILLEGAL` | 400 | 手机号格式错误 |
+| `BUSINESS_LIMIT_CONTROL` | 429 | 号码天级流控 |
+| `FREQUENCY_FAIL` | 429 | 频控（`Interval` 命中） |
+| `FUNCTION_NOT_OPENED` | 503 | 融合认证未开通（**critical 日志**，需运维开通） |
+| `INVALID_PARAMETERS` | 503 | 参数错误（配置/模板问题，**critical 日志**） |
+| 其他非 OK / `Success=false` / 网络错误 | 503 | 供应商不可用 |
+
+### 校验
+- `PASS` → True；`UNKNOWN` → False；接口异常/网络错误 → `SmsError(503)`。
+
+## 7. 防爆破 / 频控分工
+
+| 机制 | 极光（Mode B） | 阿里云（Mode A） |
+|---|---|---|
+| 验证码存储 | 本地内存 | **阿里云托管**（消除多 worker 存码债） |
+| 单号发送冷却 | 本地 `_last_sent` 60s | **交给阿里云 `Interval`**（无本地状态），命中→429 |
+| 单设备+IP 频控 | API 层 5/时、20/天 | 同左，**不变** |
+| **防爆破（单码失败 N 次即作废）** | 本地 `_CodeRecord.attempts` | **本地 per-phone 计数**，与极光同语义（§4.2） |
+
+- 阿里云路径的**唯一本地状态** = per-phone 失败计数 `dict[phone,int]` + `Lock` + GC（仿极光 `_gc`）。
+- 多 worker 降级：失败计数按 worker 各计，effective 上限 = N×workers；与极光现状**同级**（属刻意保留的一致性），且 API 层登录频控（`sms-login-device` 设备+IP 5/时）提供硬兜底。
+- 计数复位：`send_code` 成功清计数、`verify` PASS 清计数（新码/验过即新预算）。
+- API 层设备频控与测试账号短路（`app/core/test_account.py`）**完全不动**。
+
+## 8. 配置项（`app/core/config.py` 新增）
+
+```python
+SMS_PROVIDER: str = "jiguang"          # jiguang | aliyun;默认极光(保持现状,上线后切 aliyun)
+# --- 阿里云 dypns 号码认证 ---
+ALIYUN_SMS_ACCESS_KEY_ID: str = ""
+ALIYUN_SMS_ACCESS_KEY_SECRET: str = ""
+ALIYUN_SMS_SIGN_NAME: str = ""         # 系统赠送签名(自定义签名下发易失败)
+ALIYUN_SMS_TEMPLATE_CODE: str = ""     # 赠送模板 CODE(须与赠送签名搭配)
+ALIYUN_SMS_SCHEME_NAME: str = ""       # 方案名(可空=默认方案);send/check 必须一致 → 单一来源
+ALIYUN_SMS_ENDPOINT: str = "dypnsapi.aliyuncs.com"
+ALIYUN_SMS_CODE_LENGTH: int = 6        # CodeLength 4~8
+ALIYUN_SMS_VALID_TIME_SEC: int = 300   # ValidTime;短信内 min 文案 = //60
+ALIYUN_SMS_INTERVAL_SEC: int = 60      # Interval 单号发送频控
+```
+
+- 新增属性 `aliyun_sms_configured`（仿 `mt_cps_configured`）：AK_ID/AK_SECRET/SignName/TemplateCode 齐全才为真；`SMS_PROVIDER=aliyun` 但未配 → `send_code` 抛 `SmsError(503)`。
+- 复用现有 `SMS_MOCK`、`SMS_CODE_LENGTH`（mock 校验位数）、`SMS_MAX_VERIFY_ATTEMPTS`（防爆破上限，两 provider 共用）。
+
+### 配置敏感点
+- `TemplateParam` 变量名（`code`/`min`）须与控制台所选**赠送模板**一致。融合认证验证码模板通常即 `code`+`min`，按此硬编码并加注释；若模板变量名不同，改 `aliyun.py` 该处即可。
+- `SchemeName` 在 send 与 check 必须一致，故用**单一** `ALIYUN_SMS_SCHEME_NAME` 供两处，避免不匹配（CheckSmsVerifyCode 文档明确警告）。
+
+## 9. auth.py 改动（最小）
+
+`verify_code` 现在可能抛 `SmsError`（阿里云降级 503）。两处调用点各包一层 `try/except SmsError → HTTPException(e.status_code)`，与 `send_code` 现有写法一致：
+- `app/api/v1/auth.py` `sms_login`（约 L185）
+- `app/api/v1/auth.py` `wechat_bind_phone_sms`（约 L325）
+
+`send_code` 调用点已 try/except `SmsError`，无需改。
+
+## 10. 依赖 & SDK
+
+- `pyproject.toml` 增 `alibabacloud_dypnsapi20170525`（连带 `alibabacloud-tea-openapi` 等）。
+- SDK 同步阻塞调用 → 与现有 sync 端点 + sync httpx 风格一致（FastAPI 跑 threadpool，无碍）。
+- `aliyun.py` 内**惰性 import SDK + 惰性建 client**（仿 `wxpay` 惰性加载证书）：`SMS_PROVIDER=jiguang` 时不加载 alibabacloud，启动保持精简。
+- SDK 调用形态（实现时按实际包名/字段核对）：
+  ```python
+  from alibabacloud_dypnsapi20170525.client import Client
+  from alibabacloud_dypnsapi20170525 import models as dypns_models
+  from alibabacloud_tea_openapi import models as open_api_models
+  cfg = open_api_models.Config(access_key_id=..., access_key_secret=...)
+  cfg.endpoint = settings.ALIYUN_SMS_ENDPOINT
+  client = Client(cfg)
+  resp = client.send_sms_verify_code(dypns_models.SendSmsVerifyCodeRequest(...))
+  # resp.body.code / resp.body.success / resp.body.model.verify_code
+  resp = client.check_sms_verify_code(dypns_models.CheckSmsVerifyCodeRequest(...))
+  # resp.body.model.verify_result == "PASS"
+  ```
+
+## 11. 测试
+
+- 现有测试：`SMS_MOCK=true` → 分派器短路，全绿不变。
+- 新增 `tests/test_sms_aliyun.py`（monkeypatch SDK client，不发真网络）：
+  1. 发码成功 → 返回 cooldown、清计数。
+  2. 各错误码 → 对应 `SmsError.status_code`（400/429/503）。
+  3. 校验 `PASS`→True（清计数）/ `UNKNOWN`→False（计数 +1）/ 接口异常→`SmsError(503)`。
+  4. 失败计数达 `SMS_MAX_VERIFY_ATTEMPTS` → 直接 False，不再调阿里云。
+  5. `send_code` 成功复位计数。
+- 新增分派测试：`SMS_PROVIDER` 切换选中正确 provider；`SMS_MOCK` 优先于 provider。
+
+## 12. YAGNI（明确不做）
+
+- ❌ 不做 Redis/DB 存码（Mode A 无需；极光路径内存债维持现状，非本次范围）。
+- ❌ 不改极光任何行为、不动 API 层频控/测试账号逻辑。
+- ❌ 不做多签名/多模板轮换（单签名单模板足够）。
+- ❌ 不把失败计数持久化/跨进程（刻意保留与极光同级的本地态）。
+
+## 13. 验收标准
+
+- `SMS_PROVIDER=aliyun` 且配置齐全时：`/sms/send` 走 `SendSmsVerifyCode`、`/sms/login` 走 `CheckSmsVerifyCode`，真机可收码并登录。
+- `SMS_PROVIDER=jiguang`（默认）：行为与当前完全一致。
+- `SMS_MOCK=true`：任意 N 位数字通过，不发真短信。
+- 阿里云接口异常时：`/sms/login` 返回 503（非 400），日志可区分。
+- `ruff check .` 通过；新增/现有 `pytest` 全绿。

pyproject.toml

@@ -29,6 +29,9 @@ dependencies = [
     # HTTP 客户端 (调极光 REST)
     "httpx>=0.27.0",
 
+    # 阿里云号码认证(dypns)短信验证码 provider(SMS_PROVIDER=aliyun 时用;签名由 SDK 处理)
+    "alibabacloud_dypnsapi20170525>=2.0.0",
+
     # multipart form (FastAPI 表单上传依赖)
     "python-multipart>=0.0.9",
 

scripts/seed_admin_revenue_mock.py

@@ -1,211 +0,0 @@
-"""生成本地 admin「广告收益」与数据大盘用的可重复 mock 数据。
-
-只处理 ``local-admin-revenue-mock-`` 前缀的数据，重跑会替换自身数据，不会触碰真实本地记录。
-会覆盖 Draw（含一条历史 feed）、福利激励视频、提现视频，以及对应的金币流水。
-
-用法：
-    python -m scripts.seed_admin_revenue_mock
-"""
-from __future__ import annotations
-
-from datetime import datetime, time, timedelta
-
-from sqlalchemy import delete, select
-
-from app.core.config import settings
-from app.core.rewards import CN_TZ, cn_today
-from app.db.session import SessionLocal
-from app.models.ad_ecpm import AdEcpmRecord
-from app.models.ad_feed_reward import AdFeedRewardRecord
-from app.models.ad_reward import AdRewardRecord
-from app.models.user import User
-from app.models.wallet import CoinAccount, CoinTransaction
-
-PREFIX = "local-admin-revenue-mock-"
-PHONE = "19900009002"
-USERNAME = "80000009002"
-
-
-def _at(day_offset: int, hour: int, minute: int) -> datetime:
-    day = cn_today() - timedelta(days=day_offset)
-    return datetime.combine(day, time(hour, minute), tzinfo=CN_TZ)
-
-
-def _add_coin(
-    db,
-    *,
-    user_id: int,
-    amount: int,
-    biz_type: str,
-    ref_id: str,
-    created_at: datetime,
-    balance_after: int,
-) -> None:
-    db.add(CoinTransaction(
-        user_id=user_id,
-        amount=amount,
-        balance_after=balance_after,
-        biz_type=biz_type,
-        ref_id=ref_id,
-        remark="本地运营后台广告收益 Mock",
-        created_at=created_at,
-    ))
-
-
-def seed() -> dict[str, int]:
-    if settings.APP_ENV == "prod":
-        raise RuntimeError("Refusing to seed admin revenue mock data in production")
-
-    with SessionLocal() as db:
-        # 清理顺序按外键依赖从流水/奖励到展示；只碰本脚本自己的稳定前缀。
-        db.execute(delete(CoinTransaction).where(CoinTransaction.ref_id.like(f"{PREFIX}%")))
-        db.execute(delete(AdFeedRewardRecord).where(
-            AdFeedRewardRecord.client_event_id.like(f"{PREFIX}%")
-        ))
-        db.execute(delete(AdRewardRecord).where(AdRewardRecord.trans_id.like(f"{PREFIX}%")))
-        db.execute(delete(AdEcpmRecord).where(AdEcpmRecord.ad_session_id.like(f"{PREFIX}%")))
-
-        user = db.execute(select(User).where(User.phone == PHONE)).scalar_one_or_none()
-        if user is None:
-            user = User(
-                phone=PHONE,
-                username=USERNAME,
-                nickname="运营收益 Mock 用户",
-                register_channel="sms",
-                status="active",
-            )
-            db.add(user)
-            db.flush()
-        else:
-            user.nickname = "运营收益 Mock 用户"
-            user.status = "active"
-
-        balance = 0
-        event_count = 0
-        reward_count = 0
-        # 近四天的数据既能覆盖单日，也能覆盖近 7 天趋势与分类合计。
-        for day_offset in range(4):
-            suffix = f"d{day_offset}"
-            compare_trace = "local-invite-mock-compare-success"
-            coupon_trace = "mock-coupon-repeat-prod-second"
-
-            draw_events = [
-                ("draw", "comparison", compare_trace, 2800 + day_offset * 100, 10, 10),
-                ("draw", "coupon", coupon_trace, 1750 + day_offset * 100, 10, 28),
-            ]
-            # 历史 feed 必须被 Draw 分类一起计算，用于走查兼容逻辑。
-            if day_offset == 1:
-                draw_events.append(("feed", "coupon", coupon_trace, 1250, 11, 12))
-
-            for index, (ad_type, scene, trace_id, ecpm, hour, minute) in enumerate(draw_events, start=1):
-                session = f"{PREFIX}{suffix}-draw-{index}"
-                created_at = _at(day_offset, hour, minute)
-                db.add(AdEcpmRecord(
-                    user_id=user.id,
-                    ad_type=ad_type,
-                    feed_scene=scene,
-                    trace_id=trace_id,
-                    ad_session_id=session,
-                    adn="pangle" if index == 1 else "gdt",
-                    slot_id="mock-draw-rit",
-                    app_env="prod",
-                    our_code_id="104098712",
-                    ecpm_raw=str(ecpm),
-                    report_date=created_at.date().isoformat(),
-                    created_at=created_at,
-                ))
-                coin = 18 + day_offset * 2
-                db.add(AdFeedRewardRecord(
-                    client_event_id=f"{PREFIX}{suffix}-feed-reward-{index}",
-                    ad_session_id=session,
-                    user_id=user.id,
-                    reward_date=created_at.date().isoformat(),
-                    duration_seconds=20,
-                    unit_count=2,
-                    ecpm_raw=str(ecpm),
-                    adn="pangle" if index == 1 else "gdt",
-                    slot_id="mock-draw-rit",
-                    ad_type=ad_type,
-                    feed_scene=scene,
-                    trace_id=trace_id,
-                    app_env="prod",
-                    our_code_id="104098712",
-                    coin=coin,
-                    status="granted",
-                    created_at=created_at + timedelta(seconds=20),
-                ))
-                balance += coin
-                _add_coin(
-                    db,
-                    user_id=user.id,
-                    amount=coin,
-                    biz_type="feed_ad_reward",
-                    ref_id=f"{PREFIX}{suffix}-feed-coin-{index}",
-                    created_at=created_at + timedelta(seconds=20),
-                    balance_after=balance,
-                )
-                event_count += 1
-                reward_count += 1
-
-            for ad_type, ecpm, hour, coin in (
-                ("reward_video", 13200 + day_offset * 500, 14, 66),
-                ("withdrawal_video", 32000 + day_offset * 800, 18, 0),
-            ):
-                session = f"{PREFIX}{suffix}-{ad_type}"
-                created_at = _at(day_offset, hour, 6)
-                db.add(AdEcpmRecord(
-                    user_id=user.id,
-                    ad_type=ad_type,
-                    ad_session_id=session,
-                    adn="ks" if ad_type == "reward_video" else "baidu",
-                    slot_id="mock-video-rit",
-                    app_env="prod",
-                    our_code_id="104099389",
-                    ecpm_raw=str(ecpm),
-                    report_date=created_at.date().isoformat(),
-                    created_at=created_at,
-                ))
-                event_count += 1
-                if ad_type == "reward_video":
-                    db.add(AdRewardRecord(
-                        trans_id=f"{PREFIX}{suffix}-reward-video",
-                        user_id=user.id,
-                        coin=coin,
-                        status="granted",
-                        reward_scene="reward_video",
-                        ad_session_id=session,
-                        ecpm_raw=str(ecpm),
-                        app_env="prod",
-                        our_code_id="104099389",
-                        reward_date=created_at.date().isoformat(),
-                        reward_name="Mock 福利视频",
-                        created_at=created_at + timedelta(seconds=35),
-                    ))
-                    balance += coin
-                    _add_coin(
-                        db,
-                        user_id=user.id,
-                        amount=coin,
-                        biz_type="reward_video",
-                        ref_id=f"{PREFIX}{suffix}-reward-video-coin",
-                        created_at=created_at + timedelta(seconds=35),
-                        balance_after=balance,
-                    )
-                    reward_count += 1
-
-        account = db.get(CoinAccount, user.id)
-        if account is None:
-            account = CoinAccount(user_id=user.id)
-            db.add(account)
-        account.coin_balance = balance
-        account.total_coin_earned = balance
-        db.commit()
-        return {"events": event_count, "rewards": reward_count, "coin": balance}
-
-
-if __name__ == "__main__":
-    result = seed()
-    print(
-        "Seeded local admin revenue mock: "
-        f"{result['events']} impressions, {result['rewards']} rewards, {result['coin']} coins"
-    )

scripts/sync_pangle_revenue.py

@@ -1,7 +1,7 @@
-"""每日拉取 GroMore 排序价预估与 ADN Reporting 收益入库(供 admin 广告收益对账)。
+"""每日拉取穿山甲 GroMore 天级收益报表入库(供 admin 广告收益报表的「穿山甲后台收益」)。
 
-GroMore 数据 API 为 T+1:次日约 10:00 出初值，第三方 ADN Reporting 最晚约 13:50 更新。
-线上由 systemd timer 在 10:30、14:30 各跑一次;历史数据可能订正,故支持回补近 N 天。
+GroMore 数据 API 为 T+1:次日穿山甲约 10:00 出数。建议线上每天 ~10:30 由 systemd timer 跑一次
+(默认拉【昨天】);穿山甲对历史数据可能订正,故支持回补近 N 天(幂等 upsert,重跑无害)。
 
 用法:
     python -m scripts.sync_pangle_revenue                 # 拉昨天(北京时间)
@@ -117,7 +117,7 @@ def sync_range(start_date: str, end_date: str) -> None:
         stats = repo.upsert_daily_rows(db, rows)
     total_rev = round(sum(r["revenue_yuan"] for r in rows), 4)
     print(f"✅ 完成:接口 {len(raw)} 行 → 入库 {len(rows)} 行(跳过 {skipped}),"
-          f"新增 {stats['inserted']} / 更新 {stats['updated']};排序价预估合计 ¥{total_rev}")
+          f"新增 {stats['inserted']} / 更新 {stats['updated']};预估收益合计 ¥{total_rev}")
 
 
 def main() -> None:

tests/test_admin_ad_revenue_scope.py

@@ -8,15 +8,12 @@ from sqlalchemy import delete
 from app.admin.repositories import ad_revenue
 from app.db.session import SessionLocal
 from app.models.ad_ecpm import AdEcpmRecord
-from app.models.ad_feed_reward import AdFeedRewardRecord
 from app.models.ad_pangle_revenue import AdPangleDailyRevenue
 from app.models.ad_reward import AdRewardRecord
 from app.models.user import User
 
 REPORT_DATE = "2040-02-03"
 PLAYBACK_DATE = "2040-02-04"
-DETAIL_DATE = "2040-02-06"
-SOURCE_FALLBACK_DATE = "2040-02-07"
 
 
 def test_business_scope_filters_client_and_pangle_by_env_and_code(monkeypatch) -> None:
@@ -53,22 +50,18 @@ def test_business_scope_filters_client_and_pangle_by_env_and_code(monkeypatch) -
             AdPangleDailyRevenue(
                 report_date=REPORT_DATE, app_env="prod", our_code_id="prod-reward",
                 adn="", revenue_yuan=1.5, api_revenue_yuan=1.2, impressions=10,
-                synced_at=datetime(2040, 2, 4, 6, 30, tzinfo=UTC),
             ),
             AdPangleDailyRevenue(
                 report_date=REPORT_DATE, app_env="prod", our_code_id="prod-demo",
                 adn="", revenue_yuan=8.0, api_revenue_yuan=7.0, impressions=40,
-                synced_at=datetime(2040, 2, 4, 6, 30, tzinfo=UTC),
             ),
             AdPangleDailyRevenue(
                 report_date=REPORT_DATE, app_env="prod", our_code_id="104098712",
                 adn="", revenue_yuan=2.5, api_revenue_yuan=2.0, impressions=20,
-                synced_at=datetime(2040, 2, 4, 6, 30, tzinfo=UTC),
             ),
             AdPangleDailyRevenue(
                 report_date=REPORT_DATE, app_env="test", our_code_id="104127529",
                 adn="", revenue_yuan=9.0, api_revenue_yuan=8.0, impressions=50,
-                synced_at=datetime(2040, 2, 4, 6, 30, tzinfo=UTC),
             ),
         ])
         db.commit()
@@ -93,8 +86,6 @@ def test_business_scope_filters_client_and_pangle_by_env_and_code(monkeypatch) -
         assert business["total_revenue_yuan"] == 0.5
         assert business["total_pangle_revenue_yuan"] == 4.0
         assert business["total_pangle_api_revenue_yuan"] == 3.2
-        assert business["pangle_api_revenue_complete"] is True
-        assert business["pangle_latest_synced_at"] is not None
 
         all_codes = ad_revenue.ad_revenue_report(
             db,
@@ -140,7 +131,7 @@ def test_business_scope_filters_client_and_pangle_by_env_and_code(monkeypatch) -
         db.close()
 
 
-def test_reward_video_impression_revenue_is_independent_of_reward_status_and_cap() -> None:
+def test_reward_video_incomplete_playback_has_zero_revenue() -> None:
     db = SessionLocal()
     phone = "18800009992"
     sessions = {
@@ -156,17 +147,13 @@ def test_reward_video_impression_revenue_is_independent_of_reward_status_and_cap
 
         for index, (status, session_id) in enumerate(sessions.items(), start=1):
             created_at = datetime(2040, 2, 4, index, tzinfo=UTC)
-            # 发奖状态 capped 的广告故意使用 ¥1000 CPM，验证收入不套用金币侧 ¥500 CPM 封顶。
-            ecpm_raw = "100000" if status == "capped" else "10000"
             db.add(AdEcpmRecord(
                 user_id=user.id,
                 ad_type="reward_video",
                 ad_session_id=session_id,
-                adn=f"adn-{status}",
-                slot_id=f"rit-{status}",
                 app_env="prod",
                 our_code_id="prod-reward",
-                ecpm_raw=ecpm_raw,
+                ecpm_raw="10000",
                 report_date=PLAYBACK_DATE,
                 created_at=created_at,
             ))
@@ -179,7 +166,7 @@ def test_reward_video_impression_revenue_is_independent_of_reward_status_and_cap
                 ad_session_id=session_id,
                 app_env="prod",
                 our_code_id="prod-reward",
-                ecpm_raw=ecpm_raw,
+                ecpm_raw="10000",
                 reward_date=PLAYBACK_DATE,
                 created_at=created_at,
             ))
@@ -198,33 +185,22 @@ def test_reward_video_impression_revenue_is_independent_of_reward_status_and_cap
 
         revenue_by_status = {row["status"]: row["revenue_yuan"] for row in result["items"]}
         assert revenue_by_status == {
-            "closed_early": 0.1,
-            "too_short": 0.1,
-            "capped": 1.0,
+            "closed_early": 0.0,
+            "too_short": 0.0,
+            "capped": 0.1,
             "granted": 0.1,
         }
         assert result["total_impressions"] == 4
-        assert result["total_revenue_yuan"] == 1.3
+        assert result["total_revenue_yuan"] == 0.2
         assert len(result["daily"]) == 1
         assert result["daily"][0]["date"] == PLAYBACK_DATE
         assert result["daily"][0]["impressions"] == 4
-        assert result["daily"][0]["revenue_yuan"] == 1.3
-        assert sum(row["revenue_yuan"] for row in result["hourly"]) == 1.3
+        assert result["daily"][0]["revenue_yuan"] == 0.2
+        assert sum(row["revenue_yuan"] for row in result["hourly"]) == 0.2
         assert result["type_stats"]["reward_video"] == {
             "impressions": 4,
-            "revenue_yuan": 1.3,
-            "ecpm_yuan": 325.0,
+            "revenue_yuan": 0.2,
         }
-        detail_by_status = {
-            row["status"]: row["reward_detail"] for row in result["items"]
-        }
-        assert detail_by_status["granted"]["adn"] == "adn-granted"
-        assert detail_by_status["granted"]["slot_id"] == "rit-granted"
-        # 未进入发奖的记录可保留展示收入，但不能凭空生成奖励因子或占用 LT 累计。
-        for status in ("closed_early", "too_short", "capped"):
-            assert detail_by_status[status]["ecpm_factor"] is None
-            assert detail_by_status[status]["lt_factor_start"] is None
-            assert detail_by_status[status]["lt_index_start"] is None
     finally:
         db.rollback()
         db.execute(delete(AdRewardRecord).where(AdRewardRecord.reward_date == PLAYBACK_DATE))
@@ -232,214 +208,3 @@ def test_reward_video_impression_revenue_is_independent_of_reward_status_and_cap
         db.execute(delete(User).where(User.phone == phone))
         db.commit()
         db.close()
-
-
-def test_category_stats_merge_legacy_feed_and_withdrawal_video() -> None:
-    db = SessionLocal()
-    phone = "18800009993"
-    category_date = "2040-02-05"
-    try:
-        user = User(phone=phone, username="29999999993", register_channel="sms")
-        db.add(user)
-        db.flush()
-        db.add_all([
-            # Draw 经营分类必须包含新 draw 与历史 feed。
-            AdEcpmRecord(
-                user_id=user.id, ad_type="draw", ad_session_id="category-draw",
-                app_env="prod", our_code_id="prod-draw", ecpm_raw="10000",
-                report_date=category_date, created_at=datetime(2040, 2, 5, 1, tzinfo=UTC),
-            ),
-            AdEcpmRecord(
-                user_id=user.id, ad_type="feed", ad_session_id="category-feed",
-                app_env="prod", our_code_id="prod-draw", ecpm_raw="20000",
-                report_date=category_date, created_at=datetime(2040, 2, 5, 2, tzinfo=UTC),
-            ),
-            # 看视频经营分类必须包含福利与提现两个视频入口。
-            AdEcpmRecord(
-                user_id=user.id, ad_type="reward_video", ad_session_id="category-reward",
-                app_env="prod", our_code_id="prod-reward", ecpm_raw="30000",
-                report_date=category_date, created_at=datetime(2040, 2, 5, 3, tzinfo=UTC),
-            ),
-            AdEcpmRecord(
-                user_id=user.id, ad_type="withdrawal_video", ad_session_id="category-withdraw",
-                app_env="prod", our_code_id="prod-reward", ecpm_raw="50000",
-                report_date=category_date, created_at=datetime(2040, 2, 5, 4, tzinfo=UTC),
-            ),
-        ])
-        db.commit()
-
-        result = ad_revenue.ad_revenue_report(
-            db,
-            date_from=category_date,
-            date_to=category_date,
-            user_id=user.id,
-            app_env="prod",
-            revenue_scope="all",
-        )
-
-        assert result["category_stats"] == {
-            "draw": {"impressions": 2, "revenue_yuan": 0.3, "ecpm_yuan": 150.0},
-            "video": {"impressions": 2, "revenue_yuan": 0.8, "ecpm_yuan": 400.0},
-        }
-    finally:
-        db.rollback()
-        db.execute(delete(AdEcpmRecord).where(AdEcpmRecord.report_date == category_date))
-        db.execute(delete(User).where(User.phone == phone))
-        db.commit()
-        db.close()
-
-
-def test_feed_reward_detail_keeps_each_record_adn_instead_of_parent_adn() -> None:
-    db = SessionLocal()
-    phone = "18800009994"
-    try:
-        user = User(phone=phone, username="29999999994", register_channel="sms")
-        db.add(user)
-        db.flush()
-        db.add_all([
-            AdFeedRewardRecord(
-                client_event_id="detail-adn-pangle",
-                user_id=user.id,
-                reward_date=DETAIL_DATE,
-                duration_seconds=20,
-                unit_count=1,
-                ecpm_raw="12000",
-                adn="pangle",
-                slot_id="rit-pangle",
-                ad_type="draw",
-                feed_scene="coupon",
-                trace_id="detail-adn-trace",
-                app_env="prod",
-                our_code_id="104098712",
-                coin=12,
-                status="granted",
-                created_at=datetime(2040, 2, 6, 1, tzinfo=UTC),
-            ),
-            AdFeedRewardRecord(
-                client_event_id="detail-adn-gdt",
-                user_id=user.id,
-                reward_date=DETAIL_DATE,
-                duration_seconds=20,
-                unit_count=1,
-                ecpm_raw="25000",
-                adn="gdt",
-                slot_id="rit-gdt",
-                ad_type="draw",
-                feed_scene="coupon",
-                trace_id="detail-adn-trace",
-                app_env="prod",
-                our_code_id="104098712",
-                coin=25,
-                status="granted",
-                created_at=datetime(2040, 2, 6, 2, tzinfo=UTC),
-            ),
-        ])
-        db.commit()
-
-        result = ad_revenue.ad_revenue_report(
-            db,
-            date_from=DETAIL_DATE,
-            date_to=DETAIL_DATE,
-            user_id=user.id,
-            app_env="prod",
-            revenue_scope="all",
-        )
-
-        item = next(row for row in result["items"] if row["event_key"].startswith("feedgrp-"))
-        assert item["adn"] is None
-        assert [detail["adn"] for detail in item["sub_rewards"]] == ["pangle", "gdt"]
-        assert [detail["slot_id"] for detail in item["sub_rewards"]] == ["rit-pangle", "rit-gdt"]
-    finally:
-        db.rollback()
-        db.execute(delete(AdFeedRewardRecord).where(AdFeedRewardRecord.reward_date == DETAIL_DATE))
-        db.execute(delete(User).where(User.phone == phone))
-        db.commit()
-        db.close()
-
-
-def test_feed_reward_source_can_fallback_to_unique_trace_impression_only() -> None:
-    """发奖会话是整场 ID、展示会话是 impressionId 时，只在 trace+eCPM 唯一时回填 ADN。"""
-    db = SessionLocal()
-    phone = "18800009995"
-    try:
-        user = User(phone=phone, username="29999999995", register_channel="sms")
-        db.add(user)
-        db.flush()
-        db.add_all([
-            AdFeedRewardRecord(
-                client_event_id="source-fallback-unique", user_id=user.id,
-                reward_date=SOURCE_FALLBACK_DATE, duration_seconds=3, unit_count=0,
-                ecpm_raw="4700", ad_session_id="flow-session", trace_id="source-trace",
-                app_env="prod", our_code_id="104098712", coin=0, status="too_short",
-                ad_type="draw", feed_scene="comparison",
-                created_at=datetime(2040, 2, 7, 1, tzinfo=UTC),
-            ),
-            AdFeedRewardRecord(
-                client_event_id="source-fallback-ambiguous", user_id=user.id,
-                reward_date=SOURCE_FALLBACK_DATE, duration_seconds=3, unit_count=0,
-                ecpm_raw="4800", ad_session_id="flow-session", trace_id="source-trace",
-                app_env="prod", our_code_id="104098712", coin=0, status="too_short",
-                ad_type="draw", feed_scene="comparison",
-                created_at=datetime(2040, 2, 7, 2, tzinfo=UTC),
-            ),
-            AdEcpmRecord(
-                user_id=user.id, ad_type="draw", ad_session_id="impression-unique",
-                trace_id="source-trace", ecpm_raw="4700", adn="baidu", slot_id="rit-baidu",
-                app_env="prod", our_code_id="104098712", report_date=SOURCE_FALLBACK_DATE,
-                created_at=datetime(2040, 2, 7, 1, tzinfo=UTC),
-            ),
-            AdEcpmRecord(
-                user_id=user.id, ad_type="draw", ad_session_id="impression-ambiguous-a",
-                trace_id="source-trace", ecpm_raw="4800", adn="baidu", slot_id="rit-baidu",
-                app_env="prod", our_code_id="104098712", report_date=SOURCE_FALLBACK_DATE,
-                created_at=datetime(2040, 2, 7, 2, tzinfo=UTC),
-            ),
-            AdEcpmRecord(
-                user_id=user.id, ad_type="draw", ad_session_id="impression-ambiguous-b",
-                trace_id="source-trace", ecpm_raw="4800", adn="ks", slot_id="rit-ks",
-                app_env="prod", our_code_id="104098712", report_date=SOURCE_FALLBACK_DATE,
-                created_at=datetime(2040, 2, 7, 2, 1, tzinfo=UTC),
-            ),
-        ])
-        db.commit()
-
-        result = ad_revenue.ad_revenue_report(
-            db,
-            date_from=SOURCE_FALLBACK_DATE,
-            date_to=SOURCE_FALLBACK_DATE,
-            user_id=user.id,
-            app_env="prod",
-            revenue_scope="all",
-        )
-        item = next(row for row in result["items"] if row["event_key"].startswith("feedgrp-"))
-        details = {detail["ecpm"]: detail for detail in item["sub_rewards"]}
-        assert details["4700"]["adn"] == "baidu"
-        assert details["4700"]["slot_id"] == "rit-baidu"
-        assert details["4800"]["adn"] is None
-        assert details["4800"]["slot_id"] is None
-    finally:
-        db.rollback()
-        db.execute(delete(AdFeedRewardRecord).where(AdFeedRewardRecord.reward_date == SOURCE_FALLBACK_DATE))
-        db.execute(delete(AdEcpmRecord).where(AdEcpmRecord.report_date == SOURCE_FALLBACK_DATE))
-        db.execute(delete(User).where(User.phone == phone))
-        db.commit()
-        db.close()
-
-
-def test_pangle_api_day_is_provisional_before_14_beijing_time() -> None:
-    assert ad_revenue._pangle_api_day_complete(
-        REPORT_DATE,
-        {
-            "api_revenue_yuan": 3.2,
-            # D+1 10:30 北京时间。
-            "synced_at": datetime(2040, 2, 4, 2, 30, tzinfo=UTC),
-        },
-    ) is False
-    assert ad_revenue._pangle_api_day_complete(
-        REPORT_DATE,
-        {
-            "api_revenue_yuan": 3.2,
-            # D+1 14:00 北京时间，达到日终判定线。
-            "synced_at": datetime(2040, 2, 4, 6, 0, tzinfo=UTC),
-        },
-    ) is True

tests/test_auth.py

@@ -11,12 +11,13 @@ import time
 import pytest
 
 from app.integrations import sms
+from app.integrations.sms import jiguang
 
 
 def _reset(phone: str) -> None:
     """清该号的进程内存状态,隔离 real 模式用例。"""
-    sms._codes.pop(phone, None)
-    sms._last_sent.pop(phone, None)
+    jiguang._codes.pop(phone, None)
+    jiguang._last_sent.pop(phone, None)
 
 
 class _OkResp:
@@ -227,16 +228,16 @@ def test_sms_real_send_calls_jiguang(monkeypatch) -> None:
         captured.update(url=url, body=json, auth=headers.get("Authorization", ""))
         return _OkResp()
 
-    monkeypatch.setattr(sms.settings, "SMS_MOCK", False)
-    monkeypatch.setattr(sms.httpx, "post", _fake_post)
+    monkeypatch.setattr(jiguang.settings, "SMS_MOCK", False)
+    monkeypatch.setattr(jiguang.httpx, "post", _fake_post)
 
-    sms.send_code(phone)
+    jiguang.send_code(phone)
 
-    assert captured["url"] == sms.settings.SMS_SEND_ENDPOINT
+    assert captured["url"] == jiguang.settings.SMS_SEND_ENDPOINT
     assert captured["body"]["mobile"] == phone
-    assert captured["body"]["sign_id"] == sms.settings.SMS_SIGN_ID
-    assert captured["body"]["temp_id"] == sms.settings.SMS_TEMPLATE_ID
-    assert captured["body"]["temp_para"]["code"] == sms._codes[phone].code
+    assert captured["body"]["sign_id"] == jiguang.settings.SMS_SIGN_ID
+    assert captured["body"]["temp_id"] == jiguang.settings.SMS_TEMPLATE_ID
+    assert captured["body"]["temp_para"]["code"] == jiguang._codes[phone].code
     assert captured["auth"].startswith("Basic ")
 
 
@@ -244,33 +245,33 @@ def test_sms_real_verify_one_time_and_wrong(monkeypatch) -> None:
     """real 校验:错误码拒(不消费)→ 正确码成功 → 验过即作废。"""
     phone = "13455134000"
     _reset(phone)
-    monkeypatch.setattr(sms.settings, "SMS_MOCK", False)
-    monkeypatch.setattr(sms.httpx, "post", lambda *a, **k: _OkResp())
+    monkeypatch.setattr(jiguang.settings, "SMS_MOCK", False)
+    monkeypatch.setattr(jiguang.httpx, "post", lambda *a, **k: _OkResp())
 
-    sms.send_code(phone)
-    code = sms._codes[phone].code
+    jiguang.send_code(phone)
+    code = jiguang._codes[phone].code
     wrong = "000000" if code != "000000" else "111111"
 
-    assert sms.verify_code(phone, wrong) is False
-    assert sms.verify_code(phone, code) is True
-    assert sms.verify_code(phone, code) is False  # 已作废
+    assert jiguang.verify_code(phone, wrong) is False
+    assert jiguang.verify_code(phone, code) is True
+    assert jiguang.verify_code(phone, code) is False  # 已作废
 
 
 def test_sms_real_verify_attempts_exhausted(monkeypatch) -> None:
     """real 校验:错误次数到上限即作废,正确码也不再通过(防爆破)。"""
     phone = "13466134000"
     _reset(phone)
-    monkeypatch.setattr(sms.settings, "SMS_MOCK", False)
-    monkeypatch.setattr(sms.settings, "SMS_MAX_VERIFY_ATTEMPTS", 3)
-    monkeypatch.setattr(sms.httpx, "post", lambda *a, **k: _OkResp())
+    monkeypatch.setattr(jiguang.settings, "SMS_MOCK", False)
+    monkeypatch.setattr(jiguang.settings, "SMS_MAX_VERIFY_ATTEMPTS", 3)
+    monkeypatch.setattr(jiguang.httpx, "post", lambda *a, **k: _OkResp())
 
-    sms.send_code(phone)
-    code = sms._codes[phone].code
+    jiguang.send_code(phone)
+    code = jiguang._codes[phone].code
     wrong = "000000" if code != "000000" else "111111"
 
     for _ in range(3):
-        assert sms.verify_code(phone, wrong) is False
-    assert sms.verify_code(phone, code) is False  # 超限作废
+        assert jiguang.verify_code(phone, wrong) is False
+    assert jiguang.verify_code(phone, code) is False  # 超限作废
 
 
 def test_sms_real_balance_error_keeps_cooldown(monkeypatch) -> None:
@@ -284,36 +285,36 @@ def test_sms_real_balance_error_keeps_cooldown(monkeypatch) -> None:
         def json(self):
             return {"error": {"code": 50014, "message": "no money"}}
 
-    monkeypatch.setattr(sms.settings, "SMS_MOCK", False)
-    monkeypatch.setattr(sms.httpx, "post", lambda *a, **k: _ErrResp())
+    monkeypatch.setattr(jiguang.settings, "SMS_MOCK", False)
+    monkeypatch.setattr(jiguang.httpx, "post", lambda *a, **k: _ErrResp())
 
     with pytest.raises(sms.SmsError) as ei:
-        sms.send_code(phone)
+        jiguang.send_code(phone)
     assert ei.value.status_code == 503
-    assert phone not in sms._codes      # 没发出去的码已清
-    assert phone in sms._last_sent      # 冷却保留:失败也限速
+    assert phone not in jiguang._codes      # 没发出去的码已清
+    assert phone in jiguang._last_sent      # 冷却保留:失败也限速
 
     # 立即重试 → 被冷却挡下(429),不会再打极光
     with pytest.raises(sms.SmsError) as ei2:
-        sms.send_code(phone)
+        jiguang.send_code(phone)
     assert ei2.value.status_code == 429
 
 
 def test_sms_gc_purges_stale_only(monkeypatch) -> None:
     """GC 清过期码 / 旧冷却,但不动今天有效的(阈值设 0 强制每次扫)。"""
-    monkeypatch.setattr(sms, "_GC_THRESHOLD", 0)
-    sms._codes.clear()
-    sms._last_sent.clear()
+    monkeypatch.setattr(jiguang, "_GC_THRESHOLD", 0)
+    jiguang._codes.clear()
+    jiguang._last_sent.clear()
     now = time.time()
-    sms._codes["stale"] = sms._CodeRecord(code="111111", expires_at=now - 1)
-    sms._codes["fresh"] = sms._CodeRecord(code="222222", expires_at=now + 999)
-    sms._last_sent["old"] = now - 99999
-    sms._last_sent["recent"] = now
+    jiguang._codes["stale"] = jiguang._CodeRecord(code="111111", expires_at=now - 1)
+    jiguang._codes["fresh"] = jiguang._CodeRecord(code="222222", expires_at=now + 999)
+    jiguang._last_sent["old"] = now - 99999
+    jiguang._last_sent["recent"] = now
 
-    sms._gc(now)
+    jiguang._gc(now)
 
-    assert "stale" not in sms._codes and "fresh" in sms._codes
-    assert "old" not in sms._last_sent and "recent" in sms._last_sent
+    assert "stale" not in jiguang._codes and "fresh" in jiguang._codes
+    assert "old" not in jiguang._last_sent and "recent" in jiguang._last_sent
 
 
 # ============================ 用户名 / 默认昵称 ============================

tests/test_sms_aliyun.py

@@ -0,0 +1,185 @@
+"""阿里云短信 provider(Mode A)单元测试。
+
+SDK 交互隔离在 aliyun._call_send / aliyun._call_check 两个薄封装,本文件全程 monkeypatch
+它们(返回归一化结果 dict 或抛 SmsError)→ 不触真 SDK、不发网络。测的是 provider 的可映射逻辑:
+错误码→HTTP 码、PASS/UNKNOWN 解释、本地失败计数(与极光同语义)、mock 短路。
+"""
+from __future__ import annotations
+
+import pytest
+
+from app.core.config import settings
+from app.integrations.sms import aliyun
+from app.integrations.sms.base import SmsError
+
+PHONE = "13800138000"
+
+
+def _configure(monkeypatch, *, mock: bool = False) -> None:
+    """配齐阿里云凭证 + 设 SMS_MOCK;清本地失败计数隔离用例。"""
+    monkeypatch.setattr(settings, "SMS_MOCK", mock)
+    monkeypatch.setattr(settings, "ALIYUN_SMS_ACCESS_KEY_ID", "ak")
+    monkeypatch.setattr(settings, "ALIYUN_SMS_ACCESS_KEY_SECRET", "sk")
+    monkeypatch.setattr(settings, "ALIYUN_SMS_SIGN_NAME", "恒创联众")
+    monkeypatch.setattr(settings, "ALIYUN_SMS_TEMPLATE_CODE", "SMS_100001")
+    aliyun._verify_attempts.clear()
+
+
+def _send_ok(phone):
+    return {"success": True, "code": "OK", "message": "成功", "verify_code": "1234"}
+
+
+def _check(result):
+    def _f(phone, code):
+        return {"success": True, "code": "OK", "message": "成功", "verify_result": result}
+    return _f
+
+
+# ============================ 发码 ============================
+
+def test_send_success_returns_interval_and_resets_attempts(monkeypatch) -> None:
+    _configure(monkeypatch)
+    aliyun._verify_attempts[PHONE] = 3  # 旧失败计数
+    monkeypatch.setattr(aliyun, "_call_send", _send_ok)
+
+    assert aliyun.send_code(PHONE) == settings.ALIYUN_SMS_INTERVAL_SEC
+    assert PHONE not in aliyun._verify_attempts  # 新码 = 新预算
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ("MOBILE_NUMBER_ILLEGAL", 400),
+        ("BUSINESS_LIMIT_CONTROL", 429),
+        ("FREQUENCY_FAIL", 429),
+        ("FUNCTION_NOT_OPENED", 503),
+        ("INVALID_PARAMETERS", 503),
+        ("SOME_UNEXPECTED_CODE", 503),
+    ],
+)
+def test_send_maps_error_codes(monkeypatch, code, expected) -> None:
+    _configure(monkeypatch)
+    monkeypatch.setattr(
+        aliyun, "_call_send",
+        lambda phone: {"success": False, "code": code, "message": code, "verify_code": None},
+    )
+    with pytest.raises(SmsError) as ei:
+        aliyun.send_code(PHONE)
+    assert ei.value.status_code == expected
+
+
+def test_send_not_configured_raises_503_without_calling_aliyun(monkeypatch) -> None:
+    monkeypatch.setattr(settings, "SMS_MOCK", False)
+    monkeypatch.setattr(settings, "ALIYUN_SMS_ACCESS_KEY_ID", "")  # 凭证缺
+
+    def _boom(phone):
+        raise AssertionError("未配置时不应调用阿里云")
+
+    monkeypatch.setattr(aliyun, "_call_send", _boom)
+    with pytest.raises(SmsError) as ei:
+        aliyun.send_code(PHONE)
+    assert ei.value.status_code == 503
+
+
+def test_send_transport_error_propagates_503(monkeypatch) -> None:
+    _configure(monkeypatch)
+
+    def _boom(phone):
+        raise SmsError("network down", status_code=503)
+
+    monkeypatch.setattr(aliyun, "_call_send", _boom)
+    with pytest.raises(SmsError) as ei:
+        aliyun.send_code(PHONE)
+    assert ei.value.status_code == 503
+
+
+def test_send_mock_returns_interval_no_network(monkeypatch) -> None:
+    _configure(monkeypatch, mock=True)
+
+    def _boom(phone):
+        raise AssertionError("mock 不应调用阿里云")
+
+    monkeypatch.setattr(aliyun, "_call_send", _boom)
+    assert aliyun.send_code(PHONE) == settings.ALIYUN_SMS_INTERVAL_SEC
+
+
+# ============================ 校验 ============================
+
+def test_verify_pass_true_and_clears_attempts(monkeypatch) -> None:
+    _configure(monkeypatch)
+    aliyun._verify_attempts[PHONE] = 2
+    monkeypatch.setattr(aliyun, "_call_check", _check("PASS"))
+
+    assert aliyun.verify_code(PHONE, "1234") is True
+    assert PHONE not in aliyun._verify_attempts  # 验过即清
+
+
+def test_verify_unknown_false_and_increments(monkeypatch) -> None:
+    _configure(monkeypatch)
+    monkeypatch.setattr(aliyun, "_call_check", _check("UNKNOWN"))
+
+    assert aliyun.verify_code(PHONE, "0000") is False
+    assert aliyun._verify_attempts[PHONE] == 1
+    assert aliyun.verify_code(PHONE, "0000") is False
+    assert aliyun._verify_attempts[PHONE] == 2
+
+
+def test_verify_attempts_cap_short_circuits(monkeypatch) -> None:
+    _configure(monkeypatch)
+    aliyun._verify_attempts[PHONE] = settings.SMS_MAX_VERIFY_ATTEMPTS
+
+    def _boom(phone, code):
+        raise AssertionError("达失败上限后不应再调阿里云")
+
+    monkeypatch.setattr(aliyun, "_call_check", _boom)
+    assert aliyun.verify_code(PHONE, "1234") is False  # 本地作废
+
+
+def test_verify_api_error_raises_503(monkeypatch) -> None:
+    _configure(monkeypatch)
+    monkeypatch.setattr(
+        aliyun, "_call_check",
+        lambda phone, code: {"success": False, "code": "SYSTEM_ERROR",
+                             "message": "err", "verify_result": None},
+    )
+    with pytest.raises(SmsError) as ei:
+        aliyun.verify_code(PHONE, "1234")
+    assert ei.value.status_code == 503
+
+
+def test_verify_transport_error_raises_503(monkeypatch) -> None:
+    _configure(monkeypatch)
+
+    def _boom(phone, code):
+        raise SmsError("network down", status_code=503)
+
+    monkeypatch.setattr(aliyun, "_call_check", _boom)
+    with pytest.raises(SmsError) as ei:
+        aliyun.verify_code(PHONE, "1234")
+    assert ei.value.status_code == 503
+
+
+def test_verify_mock_passes_any_ndigit(monkeypatch) -> None:
+    _configure(monkeypatch, mock=True)
+
+    def _boom(phone, code):
+        raise AssertionError("mock 不应调用阿里云")
+
+    monkeypatch.setattr(aliyun, "_call_check", _boom)
+    assert aliyun.verify_code(PHONE, "123456") is True   # 6 位数字放行
+    assert aliyun.verify_code(PHONE, "12345") is False   # 位数不对
+
+
+# ============================ 端点:阿里云降级 → 503(auth.py 包 try/except)============================
+
+def test_sms_login_aliyun_outage_returns_503(client, monkeypatch) -> None:
+    """SMS_PROVIDER=aliyun 且校验时阿里云异常 → /sms/login 返 503(而非 400/500),便于区分排查。"""
+    _configure(monkeypatch)  # 配齐凭证 + SMS_MOCK=False + 清计数
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "aliyun")
+
+    def _boom(phone, code):
+        raise SmsError("aliyun down", status_code=503)
+
+    monkeypatch.setattr(aliyun, "_call_check", _boom)
+    r = client.post("/api/v1/auth/sms/login", json={"phone": "13812345678", "code": "1234"})
+    assert r.status_code == 503, r.text

tests/test_sms_dispatch.py

@@ -0,0 +1,47 @@
+"""SMS 分派器:按 settings.SMS_PROVIDER 路由到正确 provider。
+
+契约:send_code / verify_code **每次调用**读 settings.SMS_PROVIDER 选 provider(支持运行时切换 /
+灰度回退);默认 jiguang。此处 monkeypatch 两 provider 的实现为标记函数,断言路由命中 + 可秒切。
+"""
+from __future__ import annotations
+
+from app.core.config import settings
+from app.integrations import sms
+from app.integrations.sms import aliyun, jiguang
+
+
+def test_send_code_routes_by_provider_and_switches_per_call(monkeypatch) -> None:
+    calls: list[str] = []
+    monkeypatch.setattr(jiguang, "send_code", lambda phone: (calls.append("jiguang"), 60)[1])
+    monkeypatch.setattr(aliyun, "send_code", lambda phone: (calls.append("aliyun"), 60)[1])
+
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "jiguang")
+    assert sms.send_code("13800138000") == 60
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "aliyun")
+    assert sms.send_code("13800138000") == 60
+
+    assert calls == ["jiguang", "aliyun"]  # 每次按当前 provider 路由,运行时可切
+
+
+def test_verify_code_routes_by_provider(monkeypatch) -> None:
+    calls: list[str] = []
+    monkeypatch.setattr(jiguang, "verify_code", lambda phone, code: (calls.append("jiguang"), True)[1])
+    monkeypatch.setattr(aliyun, "verify_code", lambda phone, code: (calls.append("aliyun"), True)[1])
+
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "jiguang")
+    assert sms.verify_code("13800138000", "123456") is True
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "aliyun")
+    assert sms.verify_code("13800138000", "123456") is True
+
+    assert calls == ["jiguang", "aliyun"]
+
+
+def test_unknown_provider_falls_back_to_jiguang(monkeypatch) -> None:
+    """SMS_PROVIDER 非 aliyun 一律走 jiguang(默认兜底,防误配把登录打挂)。"""
+    calls: list[str] = []
+    monkeypatch.setattr(jiguang, "send_code", lambda phone: (calls.append("jiguang"), 60)[1])
+    monkeypatch.setattr(aliyun, "send_code", lambda phone: (calls.append("aliyun"), 60)[1])
+    monkeypatch.setattr(settings, "SMS_PROVIDER", "jiguang")
+
+    sms.send_code("13800138000")
+    assert calls == ["jiguang"]