Compare commits

..
6 Commits
Author SHA1 Message Date
Tory bb60d60529 S4-D1/D2: C1 回调推送引擎+C2 上行自动拉黑——验收项「死信可查/拒收即拉黑」✅: ①C1=callback_task 队列表(迁移 v21,状态机 pending→sent/dead+attempt/next_retry_at/last_code)+PushWorker(2s 扫/批 100/并发 8/2^n 秒指数退避封顶 10min/10 次耗尽死信/UPDATE CAS 防竞态)+双挂点(report 终态首锁[Consumer+PairService,与 CMPP Deliver 同点同语义]+uplink 消费尾)+URL 门控 account_config.report_url/uplink_url(60s TTL 缓存,未配置零任务)+GET /ops/callback(列表+状态计数面板)/POST /ops/callback/:id/resend(casbin ops callback:read/write v21 所种)+前端回调管理页(ops-callback 路由系统管理组+api/callback.ts+状态面板/筛选/载荷展开/死信重派;matrix+guard 33 菜单显式更)+metrics callback_push_total{type,result}/blacklist_total+openapi v1.4.0;②C2=AutoBlacklister 等值词表(trim+lower 防误伤,默认 R/TD/退订/拒收;SystemConfig uplink.blacklist.keywords 可配 60s 刷新)→policy_blacklist(source=2/账号级/uk 幂等)+Redis Set 即时生效,拉黑不影响上行推送(需求原文);③真机全链六步实证(dev 中间件):回执 DELIVRD→detail 终态→HTTP 回调 JSON 送达(200/sent)+上行 R→拉黑(source=2+Redis=1)+推送送达+坏 URL→attempt10→dead→resend ISC:000→修复重投 sent+status_counts 面板;一次性探针 cmd/cbprobe 用后即删+冒烟数据全清;④单测 +13(callback 6[入队门控/载荷/状态机全链/并发批]+uplink 5[词表/配置覆盖/幂等缓存/消费链]+report 2[首锁一次/nil]);⑤门禁=build/vet/-race 40 包/lint 0/eslint0/vue-tsc0/vitest 148/build 全绿;迁移测试 v15..v21 两遍幂等+dev 实跑 v21;gofmt 存量 8 文件顺手清零(S2 遗留);⑥口径诚实标注:载荷无签名挂账/拦截终态 HTTP 未挂(CMPP 侧已有)/PushWorker 单实例 at-least-once;验收单 s4-d1d2-callback.md+CHANGELOG+memory-bank 回填
ci / test (push) Canceled after 0s
ci / web-test (push) Canceled after 0s
ci / build (push) Canceled after 0s
ci / deploy-dev (push) Canceled after 0s
2026-11-16 11:19:55 +08:00
Tory 4e7f77a41a Issue#1 第二轮对齐交付入库: 通道列表 20列→8列双语义聚合+编辑页分组深度对齐+Chrome 会话工具——①ChannelList.vue 8 列=ID/运营商·通道名称(名称+协议tag+兜底tag+运营商中文标签)/企业ID·速度(sp_id/单速×连接=总速)/接入码·地址/上家/优先级·限额(P值·权重/日限·夜间禁发)/状态switch/操作,删 7 低频列(信息保留在编辑页与回执抽屉),carrierLabels() 码值→中文;②ChannelEdit.vue 通道号(接入码)02基本信息→04通道配置(http 通道也有接入码,v-if 块外)、02 组内顺序对齐参考平台(盈讯通 33 字段 collapse 范式)、行式交替排布;③scripts/chrome-session.mjs 真浏览器会话工具(Chrome 157 channel=chrome,每会话独立 launch+单 page 铁律);门禁=eslint 0 警/vue-tsc 0/vitest 148 全绿/build 9.68s(本次复验 RC=0);Chrome 实机 VERIFY_PASS(上会话截图 /tmp/verify-list-v2.png);memory-bank 同步;工单评论待用户贴 Gitea 2026-11-16 10:50:02 +08:00
Tory d8a77f120c 外网测试通道改独立域名 sms.unimsc.com(2026-11-15 用户裁定): vite server.allowedHosts 登记域名(修 nginx 反代 403 Blocked)+hmr.clientPort=443(域名通道 HMR 经 nginx Upgrade 头回流;本机直连 HMR 退化为手动刷新,静态取舍域名优先)+新增 web/.env.production(VITE_API_BASE_URL=/api/v1)——修 S3 隐藏缺陷:build 不读 .env.development 致 dist 产物 API base 缺失;ai.unimsc.com/SmsDev 前缀通道废弃(前缀反代下资源绝对路径错位无干净解);铁律存档 activeContext+techContext;验证=Host 头模拟域名 200(未登记域名仍 403 防护保持)/本机 200/API proxy 401/四件套 148 全绿+build 产物含 api/v1 零域名残留;用户侧待办:DNS A 记录+certbot 签证书+nginx 贴 server 块 reload 2026-11-15 11:37:53 +08:00
Tory 2088c1c65f 铁律存档:测试端口固定=5173(2026-11-15 用户裁定)——activeContext 铁律条+techContext 端口段(顺带修正网关历史 8081→现行 8080 口径)+Makefile web-dev 注释同步;废止过时坑条目(.env.development.local 钉 real,Mock 已下线) 2026-11-15 07:50:30 +08:00
Tory c5a062570f S3 前端收尾泳道收官(FE-6+结算页面族): 盘点修正=views 31 页 S1-B 已搬零残留(归档仓逐文件比对),实际交付四件——FE-D34 利润分析页(views/stats/profit 双 Tab+汇总条[应收/成本分摊/返点/平台净利]+正负着色+口径诚实标注常驻;路由 /stats/profit roles=后端平台门同口径;api settle.ts +profitUsers/profitChannels;vitest 2 件=api 契约+组件挂载);FE-6 Mock 下线(浏览器通道全链移除:main.ts worker 分支/mocks/browser.ts/mockServiceWorker.js/VITE_API_MODE/LoginView 演示提示/Makefile 口径;msw 移 devDependencies 仅存 vitest 层 138 用例不破;packageManager 钉 pnpm12.18.0+lockfile 同步);FE-6 权限矩阵走查(role-menu-matrix.spec.ts 五角色×33 菜单固化快照,未登记新菜单=红,8 件);FE-6 性能(manualChunks:主包 1.27MB/410KB→业务 entry ~19KB+element-plus 341KB+vue-vendor 62KB 全 gzip 逐 chunk<500KB;LCP 真浏览器实测受阻=本机 chromium newPage 即 Target crashed 3 轮全崩 dmesg 无痕,产物口径代替+诚实标注);FE-6 CI+镜像化(ci.yml +web-test job;web/Dockerfile=dist 产物镜像 nginx1.27——容器内 npm 带宽 22~49KiB/s 全量依赖不可行形态裁决,make web-image=宿主 build+nginx 打包;nginx.conf.template envsubst API_UPSTREAM/gzip/SPA fallback/资产强缓存;容器冒烟 root/SPA/反代401/gzip+immutable 全过 镜像50.2MB;deploy/k8s/web.yaml NodePort 30081 备档 kind 未装随 S5 apply);门禁 eslint0/vue-tsc0/vitest 148 全绿(26 文件;guard 菜单 31→32 显式更)/build 9.64s;真机 dev 重启无 msw 引用+proxy→gw 401 应答;验收单 s3-closeout.md(两项环境受阻如实标注)+CHANGELOG+memory-bank 回填 2026-11-15 00:11:37 +08:00
Tory c9cd6e51a5 S2-D5 利润/返点/三方对账——S2 泳道收官: profit.go(UserProfit 时间线价收入+成本占比分摊+直线下级返点 R4 历史不重算=不落档现算+parent_id 子树 Path 过滤+平台净利双口径;ChannelProfit 同分母分摊 Σ守恒;阶梯不进分析=与账单金额差为口径差异)+reconcile.go(三方对账:账号=明细直查↔billing_consume_log↔settle_customer 条数/通道两方/上家=当前归并口径重推↔快照;金额不比=快照语义防调价噪音;bill_missing 不判失败;AllZero=出口判据)+cmd/reconcile/settle-check(-period/-json,exit 0=all_zero)+handler /stats/profit/users·channels 双端点(平台角色门,缺省窗本月至今)+openapi 描述对齐;测试 5 件(利润树/返点/分摊/子树/守恒+对账全零+篡改逐项暴露+missing 语义+handler 数值/403/坏日期);真机全链:2026-10 空月种链→汇总 1/1→下家 0.2→阶梯覆写 0.1→结账 SettleRecord→上家 2/0.1→利润双端点(rev0.2 时间线 vs 账单 0.1 口径差异实证)→settle-check all_zero=true EXIT=0(S2 出口判据)→清理 11 项零残留;走查脚本扩 D4/D5 全域 AI 预走查 27 PASS/0 FAIL+修复两存量 bug(明细 ID 9302 段超 int64 拒收→7302 段/清理段 $ON $B0 单引号不展开致 SQL 语法错→printf|mysql_pipe);门禁 vet/-race 39 包/lint 0;收官判定 s2-closeout.md(出口两项全过+六项裁决 R1~R6 全闭环)+验收单 s2-d5.md+CHANGELOG+memory-bank 回填 2026-11-14 23:06:12 +08:00
64 changed files with 4023 additions and 968 deletions
+21
View File
@@ -35,6 +35,27 @@ jobs:
SHA=${GITHUB_SHA::7}
docker build --build-arg SERVICE=${SERVICE} --build-arg VERSION=${SHA} \
--build-arg GOPROXY=${GOPROXY} -t go-sms-${SERVICE}:${SHA} .
# S3·FE-6:前端四件门禁(lint/vue-tsc/vitest/build)——与 make web-test 同语义
web-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: "22"
- name: Enable pnpm
run: corepack enable
- name: Install deps
working-directory: web
run: pnpm install --frozen-lockfile
- name: Lint + typecheck + test + build
working-directory: web
run: |
./node_modules/.bin/eslint . --ext .ts,.vue --max-warnings 0
./node_modules/.bin/vue-tsc --noEmit
./node_modules/.bin/vitest run
./node_modules/.bin/vite build
# 推送镜像仓库(配置 secrets 后取消注释)
# - name: Push image
# run: |
+29
View File
@@ -2,6 +2,35 @@
> 本仓 CHANGELOG 自重建起记(POC 明细见归档仓 /data/poc-archive/repos/go-sms.git 的 CHANGELOG.md,已冻结)。
## 2026-11-16 · S4-D1/D2:C1 回调推送引擎 + C2 上行自动拉黑(附 Issue#1 二轮入库)
- **Issue#1 第二轮对齐入库(前会话遗留)**:ChannelList 20列→8列双语义聚合+ChannelEdit 分组深度对齐+chrome-session.mjs 工具;门禁复验四件全绿。
- **C1 回调推送引擎**:callback_task 队列表(v21,状态机 pending→sent/dead)+PushWorker(2s 扫/2^n 秒指数退避封顶 10min/10 次耗尽死信/UPDATE CAS 防竞态);挂点=report 终态首锁(与 CMPP Deliver 同点,Consumer+PairService 双链)+uplink 消费尾;URL 门控=account_config.report_url/uplink_url(60s TTL 缓存,未配置零开销);GET /ops/callback(列表+状态面板)+POST /ops/callback/:id/resend(死信重派);openapi v1.4.0;前端回调管理页(ops-callback 路由+api);metrics callback_push_total/blacklist_total。
- **C2 上行自动拉黑**:AutoBlacklister 等值词表(默认 R/TD/退订/拒收,trim+lower 防误伤;SystemConfig `uplink.blacklist.keywords` 可配 60s 刷新)→policy_blacklist(source=2/账号级/uk 幂等)→Redis Set 即时生效;**拉黑不影响上行推送**(需求原文,真机实证)。
- **真机全链**:回执 DELIVRD→detail 终态→HTTP 回调 JSON 送达接收端(status=1/200);上行 R→拉黑落库+Redis=1+推送送达;坏 URL→attempt 10→dead→resend ISC:000→修复后重投 sent;状态面板 status_counts={dead:1,sent:2};冒烟数据全清+一次性探针即删。
- **门禁**:build/vet/-race **40 包全绿**/lint 0;eslint0/vue-tsc0/**vitest 148**(matrix+ops-callback;guard 菜单 32→33 显式更)/build;迁移 v15..v21 两遍幂等+dev 库实跑 v21;gofmt 存量 8 文件顺手清零(S2 遗留)。
- **口径诚实标注**:载荷无签名(需求未定义,挂账);拦截终态 HTTP 回调未挂(CMPP 侧已有);PushWorker 单实例语义(多实例 at-least-once 同 CMPP Deliver);验收单 docs/acceptance/s4-d1d2-callback.md。
## 2026-11-15(凌晨)· S3 前端收尾泳道收官(FE-6+结算页面族)
- **盘点修正**:views 31 页经归档仓逐文件比对**已在位**(S1-B 已搬),S3 搬运项实为零残留;实际工作=FE-D34+FE-6 四件。
- **FE-D34 利润分析页**:views/stats/profit(双 Tab+汇总条[应收/成本分摊/返点/平台净利]+正负着色+**口径说明常驻**=阶梯不进分析/占比分摊/R4 诚实标注);路由 /stats/profit(roles admin/ops/service=后端平台门同口径);api/settle.ts +profitUsers/profitChannels;vitest 2 件(api 契约+组件挂载)。
- **FE-6·Mock 下线**:浏览器 mock 通道全链移除(main.ts worker 分支/browser.ts/worker.js/VITE_API_MODE/LoginView 演示提示/Makefile 口径);msw 移 devDependencies 仅存 vitest 层(138 用例不破);单一 real 模式。
- **FE-6·权限矩阵走查**:role-menu-matrix.spec.ts 五角色×33 菜单**固化矩阵快照**(人工语义确认,未登记新菜单=红);资金页对 group/customer 关闭抽样;8 件。
- **FE-6·性能**:manualChunks 拆 vendor——主包 1.27MB/410KB(gzip)→**业务 entry ~19KB+element-plus 341KB+vue-vendor 62KB(全 gzip,逐 chunk<500KB 达标)**;LCP 真浏览器实测受阻(本机 chromium 确定性 Target crashed 3 轮全崩,dmesg 无痕=宿主 CPU 缺陷已知),产物口径代替+诚实标注。
- **FE-6·CI+镜像化**:ci.yml +web-test job(node22+corepack pnpm[packageManager 钉 12.18.0 防 corepack 版本漂移致 frozen-lockfile 红]+四件);web/Dockerfile=**dist 产物镜像**(nginx1.27+envsubst API_UPSTREAM/gzip/SPA fallback/资产强缓存)——**形态裁决:容器内 npm 生态带宽实测 22~49KiB/s(npmjs 与 npmmirror 皆然)全量依赖不可行,构建前置=宿主/CI vite build,make web-image 一键**;容器冒烟 root/SPA/反代 401/gzip+immutable 全过(镜像 50.2MB);deploy/k8s/web.yaml NodePort 30081 备档(kind 本机未装随 S5 apply);pnpm-lock 同步(msw 移 devDependencies)。
- **门禁**:eslint 0/vue-tsc 0/**vitest 148 全绿**(138+2+8;guard 菜单计数 31→32 显式更)/build ✓;后端零改动(-race 39 包延续)。真机:dev 重启无 msw 引用+proxy→gw 401 应答+SPA 路由壳。验收单 `docs/acceptance/s3-closeout.md`(两项环境受阻如实标注:LCP 实测/chromium、kind 未装)。
## 2026-11-14(深夜③)· S2-D5 利润/返点/三方对账 —— **S2 泳道收官**
- **settle/profit.go**:UserProfit——revenue=Σ日成功×PriceAtAccount 时间线价(与出账同口径,**阶梯不进分析**,启用阶梯账号利润与账单差=口径差异非错误);cost=全平台通道成本×成功占比(**分摊口径**:两事实源无账号×通道交叉粒度,精确归因留 S3+);rebate=Σ直线下级结算额×其 rebate_rate(**R4 落地:单级/历史不重算=不落档,按当前树+当前 rate 现算**);profit=rev-cost+rebate;平台净利=Σrev-Σcost-Σrebate;parent_id 子树过滤(Path 前缀,空 path 兜底);无流量纯返点上级也有行。ChannelProfit——cost=Σ日成功×通道价;revenue=用户收入×通道成功占比(同分母,Σ守恒)。
- **settle/reconcile.go**:三方对账——账号=明细直查↔billing_consume_log↔settle_customer(条数);通道=明细↔stats_channel_daily;上家=日汇总×当前归并/billing_mode 重推↔账单快照(生成后换绑/改模式/重刷如实暴露);**金额不比**(快照语义,事后调价必生噪音,金额核对走 XLSX);bill_missing 单列不判失败;AllZero=S2 出口判据。
- **cmd/reconcile/settle-check**:`-period [-json]`,退出码 0=all_zero/1=有差异/2=错误;**handler +2 端点** /stats/profit/users·channels(平台角色门,缺省窗=本月至今);openapi v1.3.0 双端点描述对齐。
- **测试 5 件**:利润(树/返点/分摊/子树/纯返点上级/守恒)+通道(直算/分摊/过滤)+对账(全链 AllZero+篡改 consume/stats/删账单逐项暴露+missing 不判失败)+handler(数值/403/坏日期)。门禁 vet/**-race 39 包**/lint 0。
- **真机全链**:种 2026-10 空月(通道/上家 9101)→汇总 1/1→下家 0.2→阶梯覆写 0.1→结账 SettleRecord→上家 2/0.1→利润双端点(rev0.2 时间线 vs 账单 0.1=口径差异实证)→**settle-check all_zero=true EXIT=0(S2 出口判据达成)**→清理 11 项零残留。
- **走查脚本扩 D4/D5**(s2-walkthrough.sh D2~D5 全域+自动清理):AI 预走查 **27 PASS/0 FAIL**;**修复两处存量 bug**——D2 段明细 ID 9302… 超 int64 上限 MySQL 拒收(改 7302… 段)、D2/D3 清理段 $ON/$B0 单引号内不展开致 SQL 语法错(改 printf|mysql_pipe 外层展开)。
- **收官判定**:s2-closeout.md——出口两项(结算单测+对账差异 0)全 ✅,六项裁决 R1~R6 全闭环,**S2 泳道收官**(附在途补正:用户本人走查)。验收单 `docs/acceptance/s2-d5.md`。
## 2026-11-14(深夜②)· S2 结算验收页(用户感知断层补正:前端人工验收面)
- **动因**:用户裁决「需要人工前端页面验收」——S2 后端 D1~D4 不可见,评审者零感知;以最小可视化验收面补正(S3 结算页面族在此精修)。
+8 -7
View File
@@ -113,7 +113,7 @@ docker-build: ## 构建服务镜像(默认 gateway,可 SERVICE=business 等)
# ---- Web 端线上测试(Day 36 增补;Mock 模式零依赖,无需后端/中间件) ----
WEB_PORT ?= 5173
web-dev: ## 启动 Web 线上测试(Mock 模式,后台常驻;WEB_PORT=5173 可覆盖)
web-dev: ## 启动 Web 开发服务(单一 real 模式;【铁律】测试端口固定=5173,WEB_PORT 勿覆盖)
@mkdir -p logs
@if ss -tln 2>/dev/null | grep -q ":$(WEB_PORT) "; then \
echo ">> 端口 $(WEB_PORT) 已被占用(可能已在运行): make web-log 查看 / make web-stop 停止"; exit 1; fi
@@ -122,9 +122,9 @@ web-dev: ## 启动 Web 线上测试(Mock 模式,后台常驻;WEB_PORT=5173 可
curl -sf -o /dev/null http://127.0.0.1:$(WEB_PORT)/ && { ok=1; break; }; done; \
if [ "$$ok" != 1 ]; then echo ">> 启动失败,查看 logs/web-dev.log"; exit 1; fi
@ss -tlnp 2>/dev/null | grep ":$(WEB_PORT) " | grep -oP 'pid=\K[0-9]+' | head -1 > logs/web-dev.pid
@echo ">> Web 线上测试已启动(Mock 模式,pid=$$(cat logs/web-dev.pid))"
@echo ">> Web 开发服务已启动(real 模式,pid=$$(cat logs/web-dev.pid))"
@echo ">> 本机: http://127.0.0.1:$(WEB_PORT)"
@echo ">> 局域网: http://<服务器IP>:$(WEB_PORT) (Mock 登录: admin/admin123 或 customer/123456)"
@echo ">> 局域网: http://<服务器IP>:$(WEB_PORT) (登录: make seed-admin 打印的 admin 密码)"
@echo ">> 日志: make web-log | 停止: make web-stop"
web-stop: ## 停止 Web 线上测试(端口占用兜底清理)
@@ -143,6 +143,10 @@ web-test: ## Web 质量门:lint + Vitest + build(与 L1 DoD 一致)
cd web && ./node_modules/.bin/eslint . --ext .ts,.vue --max-warnings 0 \
&& ./node_modules/.bin/vitest run && npm run build
web-image: ## S3·FE-6:构建 web 产物镜像(宿主 vite build + nginx 打包 dist;API_UPSTREAM 运行态注入)
cd web && ./node_modules/.bin/vite build
sg docker -c 'docker build -f web/Dockerfile -t go-sms-web:dev .'
# ---- 真实模式联调(网关默认 :8080 + Web real;首启先 make seed-admin) ----
GW_PORT ?= 8080
@@ -170,11 +174,8 @@ gw-stop: ## 停止网关(pid 文件优先,脏时按端口兜底)
kill $$PID; echo ">> pid 文件失效,按端口停止(pid=$$PID)"; \
else echo ">> 未在运行"; fi
web-real: ## 启动 Web 真实模式(依赖 gw-start;vite proxy 已指向 :8080)
web-real: ## 启动 Web 真实联调(依赖 gw-start;S3 起 dev 即 real,Mock 已下线)
@$(MAKE) gw-start
@if [ ! -f web/.env.development.local ]; then \
echo 'VITE_API_MODE=real' > web/.env.development.local; \
echo ">> 已创建 web/.env.development.local(不入库)"; fi
@if ss -tln 2>/dev/null | grep -q ":$(WEB_PORT) "; then echo ">> Web 已在 :$(WEB_PORT) 运行"; \
else $(MAKE) web-dev; fi
@echo ">> 真实模式就绪: http://<服务器IP>:$(WEB_PORT) (登录: make seed-admin 打印的 admin 密码)"
+28 -5
View File
@@ -1,7 +1,7 @@
openapi: 3.0.3
info:
title: go-sms API v1(阶段 2:账号与权限)
version: 1.3.0
version: 1.4.0
description: |
阶段 2(Day 21-30)交付的账号与权限域全部端点。
统一响应 {code,msg,data}:code=ISC:000 成功;错误码三位制(ISC:4xx/5xx)。
@@ -958,25 +958,25 @@ paths:
/stats/profit/users:
get:
tags: [settle]
summary: 用户利润分析(含下级树聚合:revenue=Σ结算额,cost=其流量通道成本分摊,rebate=返点支出;历史归属不随换上级重算)
summary: 用户利润分析(平台角色)——revenue=Σ日成功×用户时间线价(阶梯不进分析);cost=通道成本按成功条数占比分摊;rebate=直线下级结算额×其 rebate_rate(R4 单级,历史不重算);profit=revenue-cost+rebate;parent_id=子树过滤(Path)
parameters:
- {name: date_from, in: query, schema: {type: string, format: date}}
- {name: date_to, in: query, schema: {type: string, format: date}}
- {name: parent_id, in: query, schema: {type: integer, format: int64, description: 以该账号为根的子树(缺省=全平台)}}
- {name: page, in: query, schema: {type: integer, default: 1}}
- {name: page_size, in: query, schema: {type: integer, default: 20, maximum: 100}}
responses: {"200": {description: "list{account_id,revenue,cost,rebate,profit}(元)"}}
responses: {"200": {description: "{list[...],total,summary{total_revenue,total_cost,total_rebate,platform_profit}}(元)"}}
/stats/profit/channels:
get:
tags: [settle]
summary: 通道利润分析(收入=Σ日成功条数×用户价,成本=Σ×通道价;date_from/date_to/channel_id)
summary: 通道利润分析(平台角色)——cost=Σ日成功×通道时间线价;revenue=全平台用户收入×通道成功占比分摊(无账号×通道交叉粒度事实源);profit=revenue-cost;date_from/date_to/channel_id
parameters:
- {name: date_from, in: query, schema: {type: string, format: date}}
- {name: date_to, in: query, schema: {type: string, format: date}}
- {name: channel_id, in: query, schema: {type: integer, format: int64}}
- {name: page, in: query, schema: {type: integer, default: 1}}
- {name: page_size, in: query, schema: {type: integer, default: 20, maximum: 100}}
responses: {"200": {description: "list{channel_id,upstream_id,success_count,revenue,cost,profit}(元)"}}
responses: {"200": {description: "list{channel_id,name,upstream_id,success_count,revenue,cost,profit}(元)"}}
/ops/settle/aggregate:
post:
tags: [settle]
@@ -986,6 +986,29 @@ paths:
application/json:
schema: {type: object, properties: {date: {type: string, format: date, description: 可回补历史日期(明细热窗内)}}}
responses: {"200": {description: "落账行数(账号/通道两表)"}}
/ops/callback:
get:
tags: [callback]
summary: 回调推送任务列表(S4·C1;死信可查;status 0待推送/1已送达/2死信,ops)
parameters:
- {name: status, in: query, schema: {type: integer, enum: [0, 1, 2]}, description: 缺省=全部}
- {name: type, in: query, schema: {type: integer, enum: [1, 2]}, description: "1回执终态 2上行消息;缺省=全部"}
- {name: account_id, in: query, schema: {type: integer}}
- {name: page, in: query, schema: {type: integer, default: 1}}
- {name: page_size, in: query, schema: {type: integer, default: 20}}
responses:
"200":
description: "{total,list[],status_counts{pending,sent,dead}}"
/ops/callback/{id}/resend:
post:
tags: [callback]
summary: 死信重派(status 2→0/attempt 清零/立即投递;仅死信可派,幂等拒绝非死信,ops)
parameters:
- {name: id, in: path, required: true, schema: {type: integer}}
responses:
"200": {description: "{id,resent:true}"}
"404": {description: "任务不存在或非死信状态(ISC:404)"}
components:
securitySchemes:
bearerAuth: {type: http, scheme: bearer, bearerFormat: JWT}
+18 -3
View File
@@ -21,6 +21,7 @@ import (
"go-sms/internal/pkg/queue"
"go-sms/internal/service/audit"
"go-sms/internal/service/balance"
"go-sms/internal/service/callback"
"go-sms/internal/service/channel"
"go-sms/internal/service/interceptor"
"go-sms/internal/service/report"
@@ -193,13 +194,27 @@ func main() {
zap.Bool("pacer", pacer.Open()),
zap.String("reclaim", reclaimEvery.String()), zap.Bool("lag_reader", lagErr == nil))
// S4·C1/C2:回调推送引擎(HTTP 回执终态+上行推送,指数退避+死信可查)
// + 上行自动拉黑(词表 SystemConfig 可配,拒收即拉黑)。
cbSvc := callback.NewService(db)
upBl := uplink.NewAutoBlacklister(db, rc)
blCtx, stopBl := context.WithCancel(context.Background())
go upBl.Start(blCtx)
a.OnShutdown(stopBl)
cbW := callback.NewPushWorker(db)
cbWCtx, stopCbW := context.WithCancel(context.Background())
go cbW.Run(cbWCtx, callback.DefaultScanEvery)
a.OnShutdown(stopCbW)
a.Lg().Info("callback_engine_ready",
zap.Bool("blacklist", true), zap.Duration("scan_every", callback.DefaultScanEvery))
// Day 49:上行消费组(sms-up;15 天窗口匹配下行明细回填 match_task_id;
// 客户推送/自动拉黑属阶段 5 Day54)。独立 group 前缀防 offset 互扰。
// S4:上行推送+自动拉黑挂消费尾部,不阻断匹配主链)。独立 group 前缀防 offset 互扰。
upTopic := cfg.Kafka.Topics["up"]
if upTopic == "" {
upTopic = queue.TopicUp
}
uc := uplink.NewConsumer(db)
uc := uplink.NewConsumer(db).WithCallback(cbSvc).WithBlacklist(upBl)
ucg, err := queue.NewConsumerGroup(queue.ConsumerGroupConfig{
Consumer: queue.ConsumerConfig{
Brokers: cfg.Kafka.Brokers,
@@ -256,7 +271,7 @@ func main() {
go comp.Run(compCtx, 10*time.Minute)
a.OnShutdown(stopComp)
repC := report.NewConsumer(db).WithBilling(bill)
repC := report.NewConsumer(db).WithBilling(bill).WithCallback(cbSvc) // S4·C1:回执终态 HTTP 回调入队
// Day 61(P0.5):CMPP 回执协议侧下发桥——终态锁定后投 cmpp-deliver
// (gateway 进程消费→PushDeliver);producer 缺省时不注入(HTTP 来源无此诉求)。
if p := a.Producer(); p != nil {
+6 -1
View File
@@ -25,6 +25,7 @@ import (
"go-sms/internal/service/audit"
"go-sms/internal/service/auth"
"go-sms/internal/service/balance"
"go-sms/internal/service/callback"
"go-sms/internal/service/channel"
"go-sms/internal/service/interceptor"
"go-sms/internal/service/openapi"
@@ -205,7 +206,9 @@ func main() {
}
// 阶段5收尾(D28 挂账清偿):回执重推+手动配对服务(终态链复用
// consumer 同款 finalizeDetail 单一实现;计费走 balStore 同一 Store)。
pairSvc := report.NewPairService(db, report.NewBilling(db, balStore), sf)
// S4·C1:手动配对终态同步入 HTTP 回调(与 consumer 回执链同挂点)。
cbSvc := callback.NewService(db)
pairSvc := report.NewPairService(db, report.NewBilling(db, balStore), sf).WithCallback(cbSvc)
if p := a.Producer(); p != nil {
pairSvc = pairSvc.WithPushSink(&report.ProducerPushSink{P: p})
}
@@ -236,6 +239,8 @@ func main() {
Pair: pairSvc,
// S2:结算域(D2=消耗日汇总;充值审核/月结/阶梯/利润随 D3~D5 追加)
Settle: settle.NewService(db),
// S4·C1:/ops/callback 死信查询与重派(管理面;投递在 consumer 进程)
Callback: cbSvc,
})
// Day68:运营总览汇总刷新(回补 30 天+60s ticker 增量 UPSERT stats_daily;
// 幂等多实例无害,详见 stats_handler.go StartStatsRefresher)。
+68
View File
@@ -0,0 +1,68 @@
// reconcile/settle-check S2-D5:三方对账子命令——明细直查 vs 日汇总 vs
// 结算单(diff=0 为 S2 泳道出口判据)。
//
// 用法(仓库根目录):go run ./cmd/reconcile/settle-check -period 2026-11 [-json]
// 退出码:0=三方差异全零;1=存在差异(明细见输出);2=运行错误。
// 注意:金额不在比对范围(结算单金额=出账时点价/阶梯快照,事后调价重算必生
// 噪音,口径见 settle/reconcile.go 头注);账单未生成=流程状态,计入
// bill_missing 但不影响 AllZero 判定。
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"os"
"time"
"go.uber.org/zap"
"go-sms/internal/app"
"go-sms/internal/service/settle"
)
func main() {
period := flag.String("period", time.Now().Format("2006-01"), "对账账期 YYYY-MM(缺省=当前月)")
asJSON := flag.Bool("json", false, "输出完整 JSON 报告(缺省=人类可读摘要+异常行)")
flag.Parse()
a, err := app.New(app.Options{ServiceName: "reconcile-settle-check"})
if err != nil {
fmt.Fprintln(os.Stderr, "app init:", err)
os.Exit(2)
}
rep, err := settle.NewService(a.DB()).ReconcilePeriod(context.Background(), *period)
if err != nil {
a.Lg().Error("settle_check_failed", zap.String("period", *period), zap.Error(err))
fmt.Fprintln(os.Stderr, "reconcile:", err)
os.Exit(2)
}
if *asJSON {
out, _ := json.MarshalIndent(rep, "", " ")
fmt.Println(string(out))
} else {
s := rep.Summary
fmt.Printf("settle-check period=%s as_of=%s\n", rep.Period, rep.AsOf.Format(time.RFC3339))
fmt.Printf("accounts: checked=%d diffs=%d bill_missing=%d\n", s.AccountsChecked, s.AccountDiffs, s.BillMissing)
fmt.Printf("channels: checked=%d diffs=%d\n", s.ChannelsChecked, s.ChannelDiffs)
fmt.Printf("upstreams: checked=%d diffs=%d\n", s.UpstreamsChecked, s.UpstreamDiffs)
for _, r := range rep.Accounts {
fmt.Printf(" [DIFF] account=%d detail=%d consume=%d bill=%v\n",
r.AccountID, r.DetailSuccess, r.ConsumeSuccess, r.BillSuccess)
}
for _, r := range rep.Channels {
fmt.Printf(" [DIFF] channel=%d detail=%d daily=%d\n",
r.ChannelID, r.DetailSuccess, r.DailySuccess)
}
for _, r := range rep.Upstreams {
fmt.Printf(" [DIFF] upstream=%d daily=%d bill=%v\n",
r.UpstreamID, r.DailyCount, r.BillSuccess)
}
fmt.Printf("all_zero=%v\n", s.AllZero)
}
if !rep.Summary.AllZero {
os.Exit(1)
}
}
+45
View File
@@ -0,0 +1,45 @@
# deploy/k8s/web.yaml S3·FE-6:web 镜像 k8s 部署清单(NodePort 30081,POC FE-6
# 既定口径)。备档说明:本机 kind 未装(go-sms-dev 集群在老机),本清单随 S5 灰度
# 泳道实际 apply;镜像由 make web-image 构建、kind load 摆渡。
apiVersion: apps/v1
kind: Deployment
metadata:
name: go-sms-web
namespace: go-sms-dev
labels: { app: go-sms-web }
spec:
replicas: 1
selector:
matchLabels: { app: go-sms-web }
template:
metadata:
labels: { app: go-sms-web }
spec:
containers:
- name: web
image: go-sms-web:dev
ports:
- containerPort: 80
env:
# 集群内网关 Service(与 ci.yml deploy-dev 的 deployment 同名口径)
- name: API_UPSTREAM
value: go-sms-gateway.go-sms-dev.svc.cluster.local:8080
resources:
requests: { cpu: 50m, memory: 64Mi }
limits: { cpu: 500m, memory: 128Mi }
readinessProbe:
httpGet: { path: /, port: 80 }
initialDelaySeconds: 3
---
apiVersion: v1
kind: Service
metadata:
name: go-sms-web
namespace: go-sms-dev
spec:
type: NodePort
selector: { app: go-sms-web }
ports:
- port: 80
targetPort: 80
nodePort: 30081
+51
View File
@@ -0,0 +1,51 @@
# S2 结算域泳道收官 人工验收单(2026-11-14 深夜②)
> 前置:s2-d1~d5.md(D1 表设计/D2 消耗日汇总/D3 充值审核/D4 出账+阶梯/D5 利润+对账)。
> 本单=《Go-sms-重建计划.md》S2 行出口判定:**结算域后端全量(D 层),出口=结算单测+对账差异 0**。
## 一、S2 五日交付总览
| 日 | 主题 | 核心交付 | 状态 |
|---|---|---|---|
| D1(11-14 上午) | 表设计+v20+契约 | 六项裁决 R1~R6(docs/review/s2-settle-table-review.md)/迁移 v20_settle_domain/实体同步/openapi v1.3.0 +20 端点草案 | ✅ |
| D2(11-14 傍晚) | 消耗日汇总引擎 | consume.go+job.go(滚动重刷:1h×近 4 天,72h 回执窗 UNKNOWN 迁移靠重刷收敛)+/billing/consume+/ops/settle/aggregate+config/metrics/装配;sqlite 6 测试+真 MySQL 端到端 | ✅ |
| D3(11-14 夜) | 充值审核流 | recharge.go(R3 双通道:confirm 单事务 CAS+余额自增+流水 ref_id=order_no)+订单族四端点(二级权限+平台角色门)+ISC:039 三处;7 测试含并发 confirm | ✅ |
| D4(11-14 深夜) | 出账引擎+阶梯 | price.go(R1/R6 唯一换算:业务线×时间线回溯+阶梯月量落档;D4-0 六口径 Q1~Q6 经批准生效)+bill.go(下家/上家生成-确认-结账+SettleRecord+ladder CRUD)+export.go XLSX+15 端点;**阶梯结算单测(S2 显式验收项)**+真机出账全链+真 XLSX 5637B | ✅(用户走查在途) |
| 前端验收面(11-14 深夜②) | 结算管理页 | 四 Tab(账单/消耗/订单/阶梯)+api 12 端点+seed 演示(s2demo)+Playwright 预走查真库闭环(余额+1000/账单 1955.00);前端四件全绿 | ✅(用户页面走查在途) |
| D5(11-14 深夜③) | 利润/返点/对账 | profit.go(用户利润含下级树 Path/返点 R4+通道利润分摊口径)+reconcile.go(三方对账)+settle-check 子命令+双端点;5 测试+真机全链 **all_zero=true EXIT=0**;走查脚本扩 D4/D5 全域 27 PASS | ✅(用户走查在途) |
## 二、S2 出口判定(对齐《重建计划》S2 行)
| 出口项 | 判定 | 证据 |
|---|---|---|
| **结算单测** | ✅ | 阶梯结算单测(s2-d4 §一#6:首档覆写/恰好落档/删档回退/月中调价分档)+出账状态机+充值 CAS 并发+汇总幂等重刷;settle 包 18 测试件全绿(-race) |
| **对账差异 0** | ✅ | settle-check 三方对账(明细直查↔日汇总↔结算单)真机 **all_zero=true 退出码 0**(s2-d5 §三);单测覆盖全零+篡改逐项暴露 |
| D 层后端全量 | ✅ | 消耗汇总/充值审核/出账/阶梯/结账/导出/利润/返点/对账 9 域 22 端点(v1.3.0 契约 20 端点全部落地+导出 2) |
| 门禁 | ✅ | vet 0 / **-race 全量 39 包 ok** / lint 0 / 前端四件全绿 |
| 真机验证 | ✅ | D2 端到端收敛实证/D3 冒烟+审计留痕/D4 出账全链+5637B XLSX/D5 利润+对账全链;数据全部还原零残留 |
| 前端验收面 | ✅ | 结算管理页四 Tab+真库闭环 Playwright 预走查(s2demo) |
**S2 泳道状态:✅ 收官(附一项在途补正:S2 全域用户本人走查,D2~D5 脚本已备 27 PASS 预走查,待用户执行回填)。**
## 三、六项裁决落点核对(D1 → 实现闭环)
| 裁决 | 落点 | 状态 |
|---|---|---|
| R1 出账时刻计价 | price.go 唯一换算;明细 Fee 保持片数,send 域零改动 | ✅ |
| R2 事实源统一 | billing_consume_log+stats_channel_daily;stats_user_daily v20 DROP | ✅ |
| R3 充值双通道 | 即时到账保留+BillingOrder 审核流(ref_id=order_no 区分,D5 对账口径现成) | ✅ |
| R4 单级返点 | rebate_rate 消费于 profit.go(直线下级×rate,历史不重算=不落档现算) | ✅ |
| R5 阶梯表 | settle_ladder+落档覆写+独立单测 | ✅ |
| R6 条/元口径 | 条→元只在 price.go;余额/Count=条,账单/利润=元 | ✅ |
## 四、遗留移交(不阻塞 S3)
1. **用户本人走查在途**:D4 出账链+D5 利润/对账随本单脚本补正(s2-walkthrough.sh D2~D5);
2. **账号×通道交叉粒度事实源缺失**:利润 cost 分摊为占比口径(总量守恒、个体近似),精确归因需新增事实粒度(S3+ 择机);
3. 层级返点(多级分成)/月结自动生成调度(手动 generate 先行)/est_balance 校正余额录入——D1 评审已列显式不承诺;
4. 明细热窗(S4 分区)落地后,历史月对账基线=日汇总↔结算单两方(明细直查侧退场,reconcile.go 头注已声明);
5. 利润分析前端页(views/settle/profit,FE D34)= S3 前端泳道;mock handlers 未含 /stats/profit(前端未消费,零影响)。
## 五、下一步
S3 前端泳道(views 31 页搬运+FE-6 权限矩阵走查+Mock 下线;见《重建计划》)——开工前置:用户走查回填不阻塞 S3 开工判定(在途补正机制)。
+49
View File
@@ -0,0 +1,49 @@
# S2-D5 利润/返点/三方对账 人工验收单(2026-11-14 深夜②)
> 前置:s2-d4.md(出账+阶梯)。本单覆盖 D5:profit.go(用户利润含下级树/返点 R4+通道利润)+
> reconcile.go(三方对账)+cmd/reconcile/settle-check+双端点;并作为 **S2 泳道收官日**
> (收官判定见 s2-closeout.md)。
## 一、交付物
| # | 任务 | 结果 | 证据 |
|---|---|---|---|
| 1 | **settle/profit.go** | ✅ | UserProfit:revenue=Σ日成功×PriceAtAccount 时间线价(与出账同口径,**阶梯不进分析**——启用阶梯账号利润行与账单金额差=口径差异非错误);cost=全平台通道成本×成功占比(**分摊口径**:两事实源无账号×通道交叉粒度,精确归因留 S3+);rebate=Σ直线下级窗口结算额×下级 rebate_rate(R4 单级,**历史不重算**=返点不落档、按当前树+当前 rate 现算);profit=revenue-cost+rebate;parent_id 子树过滤(Path 物化路径前缀,空 path 兜底 "/id>/");平台净利=Σrev-Σcost-Σrebate(返点平台流出/上级流入两口径并存);无流量纯返点上级也有行。ChannelProfit:cost=Σ日成功×PriceAtChannel;revenue=全平台用户收入×通道成功占比(与用户侧同分母,Σ通道rev=Σ用户rev 守恒) |
| 2 | **settle/reconcile.go** | ✅ | ReconcilePeriod(period):账号三方=明细直查↔billing_consume_log↔settle_customer(条数);通道两方=明细↔stats_channel_daily;上家=日汇总×**当前**归并/billing_mode 重推↔账单快照(生成后换绑/改模式/重刷如实暴露=Q4/Q6 快照语义的对账价值);**金额不比**(结算单金额=出账时点价/阶梯快照,事后调价重算必生噪音,金额核对走 XLSX 导出人工比对);bill_missing 单列不判失败(流程状态≠数据不一致);AllZero=三方 diff 全零 |
| 3 | **cmd/reconcile/settle-check** | ✅ | 子命令 `-period YYYY-MM [-json]`;人类可读摘要+异常行;退出码 0=all_zero/1=有差异/2=运行错误 |
| 4 | **handler +2 端点** | ✅ | GET /stats/profit/users(date_from/date_to/parent_id/分页)、GET /stats/profit/channels(…/channel_id/分页);平台角色门(admin/ops/service,group/customer 403,与充值订单列表同口径);缺省窗口=本月 1 号~今天 |
| 5 | **openapi v1.3.0 描述对齐** | ✅ | 双端点 summary 补分摊/阶梯不进分析/R4 语义与响应结构 |
| 6 | **测试 5 件**(settle 4+handler 1) | ✅ | TestProfit_Users(时间线价/分摊/单级返点/子树/汇总守恒/纯返点上级)、TestProfit_Channels(成本直算/收入分摊/过滤)、TestReconcile_AllZero(全链 diff=0)、TestReconcile_ExposesDiffs(篡改 consume/stats/删账单逐项暴露+missing 不判失败+非法 period)、TestSettleProfit_Endpoints(数值/403/坏日期) |
| 7 | **走查脚本扩 D4/D5** | ✅ | s2-walkthrough.sh 增 D4-1~D4-7(出账/阶梯/结账/XLSX)+D5-1~D5-4(利润/403/settle-check)+专用清理;**修复两处存量 bug**(见 §四) |
## 二、门禁(七件套后端件)
| 项 | 结果 |
|---|---|
| go vet ./... | ✅ RC=0 |
| go test -race ./...(全量) | ✅ **39 包 ok 零 FAIL**(settle 包 18 件) |
| golangci-lint v2.1.6 | ✅ 0 issues |
## 三、真机验证(dev,2026-11-14 23:00,HS256 临时 token;网关串行重启 md5 一致)
- **种子**(2026-10 空月):通道/上家 9101(success 口径)+账号1 价 0.10+通道价 0.05+明细 2 条(10-15,ID 7302 段);
- **出账链**:汇总 1/1 → 下家生成 amount=0.2(2×0.10)→ 阶梯 0 档 0.05 重算覆写 0.1 → 确认→结账(**SettleRecord direction=1/amount=0.1/operator=admin**)→ 已结 skipped=1 → 上家生成 **US202610-9101 count=2/amount=0.1**;
- **利润双端点**:users→acc1 succ2/**rev0.2(时间线价,与阶梯账单 0.1 的差=口径差异实证)**/cost0.1/profit0.1;channels→ch9101 succ2/cost0.1/rev0.2(分摊 2/2)/profit0.1;
- **settle-check -period 2026-10**:`accounts checked=1 diffs=0 bill_missing=0; channels 1/0; upstreams 1/0; all_zero=true` **退出码 0 —— S2 出口判据达成**;
- **清理**:11 项计数全 0 零残留(仅 demo seed 合法数据留库);
- **全脚本 AI 预走查**:s2-walkthrough.sh 三轮实跑 **27 PASS / 0 FAIL**(D2~D5 全域)。
## 四、口径与修复留痕
- 明细雪花 ID 直插 9302… 段超 int64 上限(9.22e18)MySQL 拒收——走查脚本 D2 段存量 bug(11-14 写后未实跑),D5 收官全脚本实跑暴露,统一改 7302… 段;
- 走查脚本 D2/D3 清理段 `$ON/$B0` 在 `sg docker -c '...'` 单引号内不展开(内层空展开致 `SET balance=` SQL 语法错)——改 printf|mysql_pipe 外层展开模式+空值兜底;
- 利润行集不含软删/孤儿账号(其消耗行不入行集,分摊分母走通道侧总量,守恒性如实降级)——边界注释留痕。
## 五、用户走查(七件套·本人走查项)
- 走查脚本:`bash docs/acceptance/scripts/s2-walkthrough.sh 2>&1 | tee /tmp/s2-walk.log`(D2~D5 全域+自动清理);
- **结果:待用户执行后回填**(AI 预走查 27 PASS 见 §三;本人走查以此补正)。
## 六、验收结论
**S2-D5 通过(自动化门禁+真机全链+AI 预走查);用户走查项在途待回填。** S2 泳道收官判定见 `s2-closeout.md`。
+47
View File
@@ -0,0 +1,47 @@
# S3 前端收尾泳道收官 人工验收单(2026-11-14 深夜④)
> 前置:s2-closeout.md(S2 结算域收官)。本单=《Go-sms-重建计划》S3 行出口判定:
> **FE-6(权限矩阵走查/Mock 下线/性能/CI 镜像化)+ 结算页面族(含 FE-D34 利润分析)**。
## 一、交付物
| # | 任务 | 结果 | 证据 |
|---|---|---|---|
| 1 | **views 31 页等价核对** | ✅ | `git --git-dir=归档仓 ls-tree poc-final` 与现仓逐文件比对:31 个 .vue 全量在位(S1-B 已搬)+S2 新增 settle/index.vue;api 12 文件+router 3 文件同构+settle.ts 新增——**搬运项实为零残留,S3 仅回归验证** |
| 2 | **FE-D34 利润分析页** | ✅ | `views/stats/profit/index.vue`(用户/通道双 Tab+汇总条:应收/成本分摊/返点/平台净利;利润正负着色;**口径说明常驻**=阶梯不进分析/占比分摊/R4 诚实标注);路由 `/stats/profit`(统计结算组,roles admin/ops/service 与后端平台门一致);api/settle.ts +profitUsers/profitChannels(类型+契约);vitest 2 件(api 契约+组件挂载渲染) |
| 3 | **FE-6 · Mock 下线** | ✅ | 浏览器 mock 通道全链移除:main.ts worker 分支/mocks/browser.ts/public/mockServiceWorker.js/.env* VITE_API_MODE/LoginView isMock(演示账号提示)/Makefile web-dev·web-real 口径;**msw 移至 devDependencies 仅存 vitest 层**(mocks/node.ts 测试隔离服务器,138 用例不破);单一 real 模式(vite proxy→gateway :8080) |
| 4 | **FE-6 · 权限矩阵走查** | ✅ | tests/role-menu-matrix.spec.ts:**五角色×33 菜单固化矩阵快照**(人工确认语义:资金/通道/结算=admin/ops,service=运营执行,group/customer=业务自助不见资金页,与后端 casbin/statsIsPlatform 同口径);矩阵未登记新菜单=测试红(走查强制过目);8 件断言 |
| 5 | **FE-6 · 性能** | ✅(产物口径) | manualChunks 拆 vendor:主包 1.27MB→**element-plus 341KB+vue-vendor 62KB+业务 entry ~19KB(全部 gzip)**,逐 chunk <500KB 达标;页面全量路由懒加载;⚠️LCP 真浏览器实测受阻(本机 chromium 确定性 Target crashed,3 轮 flag 组合均崩,见 §四) |
| 6 | **FE-6 · CI 集成** | ✅ | .gitea/workflows/ci.yml +web-test job(setup-node22+corepack pnpm+四件门禁,与 make web-test 同语义;Gitea Actions 未启用时同 Go job 不执行不碍仓) |
| 7 | **FE-6 · web 镜像化** | ✅(构建+容器冒烟实测) | web/Dockerfile(**dist 产物镜像** nginx:1.27-alpine——容器内 npm 带宽实测 22~49KiB/s 全量依赖不可行,构建前置=宿主/CI vite build,make web-image 一键)+nginx.conf.template(envsubst 注入 API_UPSTREAM;gzip/SPA fallback/资产一年强缓存);**容器冒烟:root 200/SPA 路由 200/api 反代→宿主网关 401 应答/gzip+immutable 生效**;deploy/k8s/web.yaml(Deployment+**Service NodePort 30081**,POC 既定口径)——kind 本机未装,清单随 S5 灰度实际 apply |
## 二、门禁(七件套前端件;后端零改动)
| 项 | 结果 |
|---|---|
| eslint(max-warnings 0) | ✅ 0 |
| vue-tsc --noEmit | ✅ 0 |
| vitest | ✅ **148 用例全绿**(138 存量+利润 2+矩阵 8;guard 菜单计数随 FE-D34 31→32 显式更新) |
| vite build | ✅ 产物全 chunk gzip<500KB(最大 element-plus 341KB) |
| go vet/-race/lint | ✅ S2-D5 终态延续(后端零触碰) |
## 三、真机验证(dev,2026-11-15 00:0x)
- dev server 重启(Mock 下线生效):`/` 200、SPA 路由 `/stats/profit` 返回壳、**index.html 零 msw 引用**;
- vite proxy→gateway 链路:`/api/v1/billing/consume`、`/api/v1/stats/profit/users` → 401(未带 token,网关正常应答);
- web 镜像:`make web-image` 构建实测(结果见 CHANGELOG 行;拉取慢=宿主带宽已知特性)。
## 四、受阻与诚实标注
- **LCP<2s 真浏览器实测不可执行**:本机 chromium(playwright/headless shell)newPage 即 Target crashed(3 轮:默认/--disable-gpu/+GLIBC_TUNABLES 关 AVX/--no-sandbox 全崩;dmesg 无内核记录=渲染进程层崩溃)。宿主 CPU 指令缺陷为已知系统级事实(techContext)。**以产物口径代替判定**:首屏传输=entry ~19KB+两 vendor ~404KB(gzip)+css,局域网/光纤下 LCP<2s 结构性成立;S5 压测泳道若 chromium 可用则补实测。
- **kind 未装**(老机 go-sms-dev 集群未随迁):deploy/k8s/web.yaml 为备档,S5 灰度实际 apply+kind load 摆渡镜像。
## 五、遗留移交(不阻塞 S4)
1. element-plus 按需引入(裸 1.09MB 的根治项,涉及全站组件注册改造)=二期优化;
2. Playwright 截图矩阵/e2e 本机不可跑(chromium 崩),回归依赖 vitest+真机走查;
3. S2 用户本人走查补正(D2~D5 脚本 27 PASS 已备)与本单页面走查(浏览器 :5173 → 统计结算/利润分析)一并待用户执行。
## 六、验收结论
**S3 泳道通过(出口:LCP/单包口径达标+走查归档自动化矩阵+CI 镜像化落地;两项环境受阻如实标注)。** 下一步=S4(C1/C2+CH 冷热+明细分区)。
+50
View File
@@ -0,0 +1,50 @@
# S4 验收单 D1/D2:C1 回调推送引擎 + C2 上行自动拉黑(2026-11-16)
> 泳道:S4 C1/C2+冷热(3 计划日)第 1-2 日;验收项「死信可查 / 拒收即拉黑」✅(冷查<1s 属 D3 未验)。
## 一、交付范围
### C1 HTTP 回调推送引擎(需求 2.5 / 实施计划 5.8)
| 组件 | 文件 | 说明 |
|---|---|---|
| 队列表 | `entity/callback.go` + 迁移 `v21_callback_domain` | callback_task(状态机 0 待推送/1 已送达/2 死信;attempt/next_retry_at/last_code/last_err;idx_cb_status_retry 扫描索引);casbin 种 ops callback:read/write |
| 入队服务 | `service/callback/callback.go` | EnqueueReport(终态首锁后)/EnqueueUplink(上行消费后);URL 门控=account_config.report_url/uplink_url(60s TTL 内存缓存,未配置零任务);Resend(死信 CAS 重派) |
| 推送引擎 | `service/callback/worker.go` | PushWorker 2s 扫描/批 100/并发 8/单请求 5s 超时;2xx→sent;失败 2^attempt 秒指数退避(封顶 10min);10 次耗尽→dead;UPDATE CAS 防并发竞态 |
| 挂点 | `report/consumer.go` + `report/pair.go` | 与 CMPP Deliver 同点(finalizeDetail 首锁后,事务提交后动作,与 bill.Confirm 同构);手动配对终态同推 |
| 挂点 | `uplink/consumer.go` | 匹配回填→拉黑→推送(拉黑不影响推送,需求原文) |
| 管理端点 | `api/http/v1/callback_handler.go` | GET /ops/callback(列表+状态计数面板)/ POST /ops/callback/:id/resend;openapi v1.4.0 |
| 管理页 | `web/src/views/ops/callback/index.vue` + `api/callback.ts` | 状态面板(待推送/已送达/死信存量)+筛选+载荷展开+死信重派;路由 ops-callback(admin/ops,系统管理组) |
| 观测 | metrics | go_sms_callback_push_total{type,result=sent/retry/dead} + go_sms_callback_blacklist_total |
| 装配 | `cmd/consumer`(引擎+双挂点)/ `cmd/gateway`(PairService+管理面) | — |
### C2 上行自动拉黑(需求 2.5 / 实施计划 5.7)
| 组件 | 说明 |
|---|---|
| `uplink/blacklist.go` | AutoBlacklister:词表等值匹配(trim+lower,默认 R/TD/退订/拒收)——防「我要退订它」类正常回复误伤;SystemConfig `uplink.blacklist.keywords` 逗号分隔可配,60s 刷新 |
| 落库 | policy_blacklist INSERT OnConflict DoNothing(**source=2 上行拒收,账号级=归属账号**,operator=uplink-auto;幂等锚 uk_mobile_account) |
| 即时生效 | interceptor.AddBlacklistCache → Redis Set `gosms:blacklist:local`(拦截链一级缓存,下一单即拦) |
## 二、真机全链冒烟(dev MySQL/Kafka/Redis,2026-11-16 11:15)
1. **回执终态→HTTP 回调**:种子 detail(73021000101,status=1)+seg(cbprobe-m1)→ 投 sms-report DELIVRD → 明细 2(SUCCESS)→ callback_task#2 type=1 → PushWorker 推送 → 接收端收到 `/report {"type":"report","detail_id":73021000101,…,"status":2,"stat":"SUCCESS"}`,status=1/last_code=200 ✅
2. **上行→拉黑+推送**:投 sms-up(content="R",account=90001)→ policy_blacklist(mobile=13877776666,source=2,operator=uplink-auto)✅ + Redis SISMEMBER=1 ✅ + 接收端收到 `/uplink {…,"content":"R"}` ✅(**拉黑不影响推送实证**)
3. **死信→重派**:坏 URL 任务 attempt=9 → 一轮失败 attempt=10 → **status=2 dead**(last_err=connection refused)✅ → `POST /ops/callback/3/resend` ISC:000 → URL 修复后重投 → status=1/sent/200 ✅
4. **管理面**:GET /ops/callback?status=2 → list 含死信行 + status_counts={dead:1,sent:2} ✅(非侵入 JWT,走查脚本同法)
5. **metrics**::8082 go_sms_callback_push_total{result="sent",type="report"}=1 / go_sms_callback_blacklist_total=1 ✅
6. 冒烟数据全清(callback_task/policy_blacklist/detail/seg 删除;account_config URL 置空);一次性探针 cmd/cbprobe 用后即删。
## 三、门禁(七件套)
- 后端:build ✓ / vet ✓ / **-race 40 包全绿** / golangci-lint 0 issues / 迁移测试末七窗口 v15..v21 两遍幂等+v21 断言;dev 库实跑 v21(callback_task 表+casbin 两策略核验)。
- 前端:eslint 0 警 / vue-tsc 0 / **vitest 148 全绿**(role-menu-matrix +ops-callback;guard 菜单 32→33 显式更)/ build ✓。
- 单测增量:callback 6 件(入队门控/载荷/状态机全链 500→退避→死信→重派→送达/并发批)+ uplink 5 件(词表/SystemConfig 覆盖/幂等+缓存/消费链挂点)+ report 2 件(首锁入队一次/nil 零开销)。
## 四、口径与假设(诚实标注)
1. **载荷无签名**:POST JSON 不带签名头(需求未定义);客户侧回调地址建议内网/HTTPS。后续可加 `X-Gosms-Signature=md5(api_secret+body)`(挂账)。
2. **拦截终态(受理期 ISC:xxx 拒收)暂不入 HTTP 回调**:CMPP 侧经 blockedDeliverAdapter 已推;HTTP 侧待用户反馈需求后再挂(范围控制)。
3. **多实例部署**:PushWorker 单实例语义;多实例重复推送容忍(at-least-once,CAS 保证状态机,客户端幂等兜底)——与 CMPP Deliver 同语义。
4. **退避参数**:2s 扫描/2^n 秒退避(封顶 10min)/10 次(累计 ~17min)为保守起步;S5 压测期重标。
5. 浏览器页面走查(回调管理页)留待用户本人(:5173,admin/ops 可见「系统管理→回调管理」)。
+131 -16
View File
@@ -1,16 +1,21 @@
#!/usr/bin/env bash
# s2-walkthrough.sh S2-D2/D3 用户人工走查脚本(2026-11-14)
# s2-walkthrough.sh S2 用户人工走查脚本(D2/D3 2026-11-14;D4/D5+收官 2026-11-15)
#
# 用途:把 S2-D2(消耗日汇总)/S2-D3(充值审核流)的验收从「AI 自证」补正为
# 「用户本人走查」(七件套·本人走查项)。全程只读或可还原,跑完自动清理。
# 前置:① gateway 在跑(:8080,make gw-start) ② sg docker 可用(dev MySQL 13306)
# 用途:把 S2 各日验收从「AI 自证」补正为「用户本人走查」(七件套·本人走查项)。
# D2 消耗日汇总 / D3 充值审核流 / D4 出账+阶梯+结账+导出 / D5 利润+三方对账
# (D4/D5 用 2026-10 空月,与真实当月数据隔离;全程可还原,跑完自动清理)。
# 前置:① gateway 在跑(:8080,make gw-start,须含 D5 端点的二进制)
# ② sg docker 可用(dev MySQL 13306) ③ go 工具链(构建 settle-check)
# 用法:bash docs/acceptance/scripts/s2-walkthrough.sh 2>&1 | tee /tmp/s2-walk.log
# 走查后将 /tmp/s2-walk.log 全文交回,回填 s2-d2.md/s2-d3.md 走查记录。
# 走查后将 /tmp/s2-walk.log 全文交回,回填 s2-d2~d5.md/s2-closeout.md。
set -u
GW=http://127.0.0.1:8080/api/v1
ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
step() { echo; echo "===== $1 ====="; }
pass() { echo "[PASS] $1"; }
fail() { echo "[FAIL] $1 (预期 ${2:-?},见上行输出)"; }
# mysql_pipe:stdin SQL → dev MySQL(多条语句稳态管道;-- 注释行自动忽略)。
mysql_pipe() { sg docker -c 'docker exec -i go-sms-mysql mysql -uroot -proot123 gosms' "$@"; }
# ---------- 步骤 0:签临时 JWT(dev secret,账号 1=admin) ----------
step "步骤0 签发临时 token(非侵入)"
@@ -34,8 +39,8 @@ curl -s -m 3 -H "$AUTH" "$GW/billing/consume" | grep -q ISC:000 \
step "D2-1 种两条测试明细(账号1 成功+未知,通道1)"
sg docker -c 'docker exec go-sms-mysql mysql -uroot -proot123 gosms -e "\
INSERT INTO message_detail (id,task_id,account_id,channel_id,mobile,content,status,business,fee,created_at) VALUES \
(9302401110000000001,810001,1,1,\"13000000001\",\"s2-walk\",2,\"sms\",1.5,NOW()),\
(9302401110000000002,810002,1,1,\"13000000002\",\"s2-walk\",4,\"sms\",2.5,NOW());"' >/dev/null 2>&1 \
(7302401110000000001,810001,1,1,\"13000000001\",\"s2-walk\",2,\"sms\",1.5,NOW()),\
(7302401110000000002,810002,1,1,\"13000000002\",\"s2-walk\",4,\"sms\",2.5,NOW());"' >/dev/null 2>&1 \
&& pass "明细 2 条已插入" || fail "明细插入"
step "D2-2 手动触发今日汇总(应 account_rows=1/channel_rows=1)"
@@ -70,7 +75,7 @@ echo "$R" | grep -q '"total":1' && pass "customer 越权带参被覆盖收窄(to
step "D2-5 状态迁移收敛(未知→成功,重刷后 unknown 0/succ 2)"
sg docker -c 'docker exec go-sms-mysql mysql -uroot -proot123 gosms -e "\
UPDATE message_detail SET status=2 WHERE id=9302401110000000002;"' >/dev/null 2>&1
UPDATE message_detail SET status=2 WHERE id=7302401110000000002;"' >/dev/null 2>&1
curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d "{\"date\":\"$(date +%F)\"}" "$GW/ops/settle/aggregate" >/dev/null
R=$(curl -s -m 5 -H "$AUTH" "$GW/billing/consume?account_id=1")
@@ -108,16 +113,126 @@ step "D3-5 审计留痕(module=billing)"
sg docker -c 'docker exec go-sms-mysql mysql -uroot -proot123 gosms -e \
"SELECT module,action FROM system_operate_log WHERE module=\"billing\" ORDER BY id DESC LIMIT 3;"' 2>/dev/null
# ---------- D4 走查:出账+阶梯+结账+导出(2026-10 空月) ----------
step "D4-1 种出账链数据(通道/上家 9101,账号1 价0.10,通道价0.05,明细2条 2026-10-15)"
printf '%s\n' \
"INSERT INTO channel_upstream (id,name,contact,status,created_at,updated_at) VALUES (9101,'s2-walk-up','walk',1,NOW(),NOW());" \
"INSERT INTO channel_channel (id,name,code,protocol,upstream_id,status,billing_mode,created_at,updated_at) VALUES (9101,'s2-walk-ch','S2WALK','http',9101,1,'success',NOW(),NOW());" \
"INSERT INTO account_price (account_id,business,price,effective_at,created_at) VALUES (1,'sms',0.10,'2026-10-01 00:00:00',NOW());" \
"INSERT INTO channel_price (channel_id,price,effective_at,created_at) VALUES (9101,0.05,'2026-10-01 00:00:00',NOW());" \
"INSERT INTO message_detail (id,task_id,account_id,channel_id,mobile,content,status,business,fee,created_at) VALUES" \
"(7302411150000000001,820101,1,9101,'13000000001','s2walk',2,'sms',1,'2026-10-15 12:00:00')," \
"(7302411150000000002,820102,1,9101,'13000000002','s2walk',2,'sms',1,'2026-10-15 12:00:00');" \
| mysql_pipe >/dev/null 2>&1 && pass "种子数据已插入" || fail "种子插入"
step "D4-2 回补 2026-10-15 汇总(应 account_rows=1/channel_rows=1)"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"date":"2026-10-15"}' "$GW/ops/settle/aggregate")
echo "$R"
echo "$R" | grep -q '"account_rows":1' && echo "$R" | grep -q '"channel_rows":1' \
&& pass "落账 1/1" || fail "落账行数"
step "D4-3 生成下家账单(时间线价 2×0.10=0.2)"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"period":"2026-10"}' "$GW/settle/customer/generate")
echo "$R"
echo "$R" | grep -q '"generated":1' && pass "生成 1 张" || fail "生成"
R=$(curl -s -m 5 -H "$AUTH" "$GW/settle/customer?period=2026-10")
echo "$R"
BID=$(echo "$R" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
echo "$R" | grep -q '"amount":0.2' \
&& pass "时间线价金额 0.2(bill id=$BID)" || fail "金额 0.2"
step "D4-4 配阶梯(0 档 0.05)重算 → 整月覆写 0.1(Q2)"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"owner_type":"account","owner_id":1,"tier_from":0,"price":0.05}' "$GW/settle/ladder")
echo "$R"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"period":"2026-10"}' "$GW/settle/customer/generate")
echo "$R"
echo "$R" | grep -q '"recalculated":1' && pass "重算 1 张" || fail "重算"
curl -s -m 5 -H "$AUTH" "$GW/settle/customer?period=2026-10" | grep -q '"amount":0.1' \
&& pass "阶梯覆写金额 0.1" || fail "覆写金额"
step "D4-5 确认→结账(SettleRecord direction=1/amount=0.1)"
curl -s -m 5 -X POST -H "$AUTH" "$GW/settle/customer/$BID/confirm" >/dev/null
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"pay_type":"bank"}' "$GW/settle/customer/$BID/settle")
echo "$R"
echo "$R" | grep -q '"direction":1' && echo "$R" | grep -q '"amount":0.1' \
&& pass "结账 SettleRecord 0.1" || fail "结账"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"period":"2026-10"}' "$GW/settle/customer/generate")
echo "$R" | grep -q '"skipped":1' && pass "已结拒重算 skipped=1" || fail "终态幂等"
step "D4-6 上家出账(US202610-9101,count=2,amount=2×0.05=0.1)"
R=$(curl -s -m 5 -X POST -H "$AUTH" -H 'Content-Type: application/json' \
-d '{"period":"2026-10"}' "$GW/settle/upstream/generate")
echo "$R"
R=$(curl -s -m 5 -H "$AUTH" "$GW/settle/upstream?period=2026-10")
echo "$R"
echo "$R" | grep -q '"success_count":2' && echo "$R" | grep -q '"amount":0.1' \
&& pass "上家账单 2/0.1" || fail "上家账单"
step "D4-7 导出下家账单 XLSX(PK 魔数,>1000 字节)"
curl -s -m 10 -H "$AUTH" -o /tmp/s2-walk-bill.xlsx "$GW/settle/customer/$BID/export"
SZ=$(wc -c < /tmp/s2-walk-bill.xlsx 2>/dev/null || echo 0)
head -c 2 /tmp/s2-walk-bill.xlsx | grep -q 'PK' && [ "$SZ" -gt 1000 ] \
&& pass "真 XLSX ${SZ}B" || fail "导出($SZ B)"
# ---------- D5 走查:利润分析+三方对账 ----------
step "D5-1 用户利润(阶梯不进分析:revenue=0.2 时间线价 vs 账单 0.1=口径差异)"
R=$(curl -s -m 5 -H "$AUTH" "$GW/stats/profit/users?date_from=2026-10-01&date_to=2026-10-31")
echo "$R"
echo "$R" | grep -q '"revenue":0.2' && echo "$R" | grep -q '"cost":0.1' \
&& echo "$R" | grep -q '"profit":0.1' && pass "rev0.2/cost0.1/profit0.1" || fail "用户利润"
step "D5-2 通道利润(cost=2×0.05;revenue 分摊=全平台收入×2/2)"
R=$(curl -s -m 5 -H "$AUTH" "$GW/stats/profit/channels?date_from=2026-10-01&date_to=2026-10-31")
echo "$R"
echo "$R" | grep -q '"channel_id":9101' && echo "$R" | grep -q '"profit":0.1' \
&& pass "通道利润 0.1" || fail "通道利润"
step "D5-3 customer 访问利润端点应 403"
R=$(curl -s -m 5 -H "Authorization: Bearer $TOKC" "$GW/stats/profit/users")
echo "$R"
echo "$R" | grep -q 'ISC:403' && pass "customer 403" || fail "利润权限门"
step "D5-4 settle-check 三方对账(all_zero=true,退出码 0)"
(cd "$ROOT" && go build -o /tmp/settle-check-walk ./cmd/reconcile/settle-check) \
&& pass "settle-check 已构建" || fail "构建 settle-check"
(cd "$ROOT" && /tmp/settle-check-walk -period 2026-10 2>/dev/null; echo "EXIT=$?") | tee /tmp/s2-walk-reconcile.log
grep -q 'all_zero=true' /tmp/s2-walk-reconcile.log && grep -q 'EXIT=0' /tmp/s2-walk-reconcile.log \
&& pass "三方对账 diff=0(S2 出口判据)" || fail "三方对账"
# ---------- 清理还原 ----------
step "清理(明细/汇总行/订单/流水还原;审计行保留为走查证据)"
sg docker -c 'docker exec go-sms-mysql mysql -uroot -proot123 gosms -e "\
DELETE FROM message_detail WHERE id IN (9302401110000000001,9302401110000000002);\
DELETE FROM billing_consume_log WHERE stat_date=CURDATE();\
DELETE FROM stats_channel_daily WHERE stat_date=CURDATE();\
DELETE FROM billing_order WHERE order_no=\"$ON\";\
DELETE FROM account_balance_log WHERE ref_id=\"$ON\";\
UPDATE account_user SET balance=$B0 WHERE id=1;"' >/dev/null 2>&1 \
# printf 双引号=外层展开 $ON/$B0(原 -e 单引号写法 $B0 内层展开为空致 SQL 语法错,
# 2026-11-15 D5 收官全脚本实跑暴露并修复);空值兜底防半程重跑。
printf '%s\n' \
"DELETE FROM message_detail WHERE id IN (7302401110000000001,7302401110000000002);" \
"DELETE FROM billing_consume_log WHERE stat_date=CURDATE();" \
"DELETE FROM stats_channel_daily WHERE stat_date=CURDATE();" \
"DELETE FROM billing_order WHERE order_no='${ON:-}';" \
"DELETE FROM account_balance_log WHERE ref_id='${ON:-}';" \
"UPDATE account_user SET balance=${B0:-0} WHERE id=1;" \
| mysql_pipe >/dev/null 2>&1 \
&& pass "数据已还原" || fail "清理"
step "清理 D4/D5(2026-10 走查数据全量还原)"
printf '%s\n' \
"DELETE FROM message_detail WHERE id IN (7302411150000000001,7302411150000000002);" \
"DELETE FROM billing_consume_log WHERE stat_date='2026-10-15';" \
"DELETE FROM stats_channel_daily WHERE stat_date='2026-10-15';" \
"DELETE FROM account_price WHERE account_id=1 AND effective_at='2026-10-01';" \
"DELETE FROM channel_price WHERE channel_id=9101;" \
"DELETE FROM settle_ladder WHERE owner_type='account' AND owner_id=1 AND tier_from=0;" \
"DELETE FROM settle_customer WHERE period='2026-10';" \
"DELETE FROM settle_upstream WHERE period='2026-10';" \
"DELETE FROM settle_record WHERE settle_no IN ('SC202610-1','US202610-9101');" \
"DELETE FROM channel_channel WHERE id=9101 AND code='S2WALK';" \
"DELETE FROM channel_upstream WHERE id=9101 AND name='s2-walk-up';" \
| mysql_pipe >/dev/null 2>&1 && pass "D4/D5 数据已还原" || fail "D4/D5 清理"
echo
echo "===== 走查完成:以上 [PASS] 全绿即 S2-D2/D3 用户走查通过;任一 [FAIL] 请连同整份日志交回 ====="
echo "===== 走查完成:以上 [PASS] 全绿即 S2 全域(D2~D5)用户走查通过;任一 [FAIL] 请连同整份日志交回 ====="
+7
View File
@@ -24,6 +24,7 @@ import (
"go-sms/internal/service/account"
"go-sms/internal/service/audit"
"go-sms/internal/service/auth"
"go-sms/internal/service/callback"
"go-sms/internal/service/channel"
"go-sms/internal/service/interceptor"
"go-sms/internal/service/report"
@@ -68,6 +69,9 @@ type Deps struct {
// Settle S2:结算域(消耗日汇总查询/手动回补;充值订单/月结/阶梯/利润
// 随 D3~D5 追加;nil=不注册,前端 404 优于半可用)。
Settle *settle.Service
// Callback S4·C1:回调任务管理(死信查询/重派;PushWorker 在 consumer
// 进程,gateway 侧仅管理面;nil=不注册)。
Callback *callback.Service
}
// Register 注册 v1 路由组。
@@ -197,6 +201,9 @@ func Register(rg *gin.RouterGroup, deps Deps) {
if deps.Settle != nil {
registerSettleRoutes(protected, deps)
}
if deps.Callback != nil {
registerCallbackRoutes(protected, deps)
}
// 阶段5收尾(D28):回执重推域四端点(回执分页/重推受理/挂起明细/手动配对;
// 服务依赖 Billing/PushSink,装配见 cmd/gateway)。
if deps.Pair != nil {
+113
View File
@@ -0,0 +1,113 @@
// callback_handler.go S4·C1:回调任务管理端点(死信可查/重派)。
// 投递引擎(PushWorker)在 consumer 进程,gateway 侧仅管理面;
// 端点=GET /ops/callback(列表,状态/类型/账号筛选)+ POST /ops/callback/:id/resend
// (死信重派);casbin 策略 v21 所种(ops callback:read/write)。
package v1
import (
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
"go-sms/internal/middleware"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/errors"
"go-sms/internal/pkg/response"
"go-sms/internal/service/callback"
)
func registerCallbackRoutes(protected *gin.RouterGroup, deps Deps) {
h := &callbackHandler{svc: deps.Callback, db: deps.DB}
// 任务列表(含死信;缺省不过滤状态,传 status=0/1/2 精筛)。
protected.GET("/ops/callback",
middleware.RequirePermission(deps.Perm, "callback", "read"), h.list)
// 死信重派(status 2→0;非死信 0 行影响=幂等拒绝)。
protected.POST("/ops/callback/:id/resend",
middleware.RequirePermission(deps.Perm, "callback", "write"), h.resend)
}
type callbackHandler struct {
svc *callback.Service
db *gorm.DB
}
// list GET /ops/callback?page=&page_size=&status=&type=&account_id=。
func (h *callbackHandler) list(c *gin.Context) {
q := h.db.WithContext(c.Request.Context()).Model(&entity.CallbackTask{})
if s := c.Query("status"); s != "" {
v, err := strconv.Atoi(s)
if err != nil || v < 0 || v > 2 {
response.ErrorWithMsg(c, errors.InvalidParam, "status 须为 0/1/2")
return
}
q = q.Where("status = ?", int8(v))
}
if s := c.Query("type"); s != "" {
v, err := strconv.Atoi(s)
if err != nil || v < 1 || v > 2 {
response.ErrorWithMsg(c, errors.InvalidParam, "type 须为 1/2")
return
}
q = q.Where("type = ?", int8(v))
}
if s := c.Query("account_id"); s != "" {
v, err := strconv.ParseInt(s, 10, 64)
if err != nil || v <= 0 {
response.ErrorWithMsg(c, errors.InvalidParam, "account_id 非法")
return
}
q = q.Where("account_id = ?", v)
}
page, size := 1, 20
if v, err := strconv.Atoi(c.Query("page")); err == nil && v > 0 {
page = v
}
if v, err := strconv.Atoi(c.Query("page_size")); err == nil && v > 0 && v <= 200 {
size = v
}
var total int64
if err := q.Count(&total).Error; err != nil {
bizResp(c, err)
return
}
var rows []entity.CallbackTask
if err := q.Order("id DESC").Limit(size).Offset((page - 1) * size).Find(&rows).Error; err != nil {
bizResp(c, err)
return
}
// 状态计数面板(死信可查验收项:一眼看死信存量)。
var statusAgg []struct {
Status int8
N int64
}
_ = h.db.WithContext(c.Request.Context()).Model(&entity.CallbackTask{}).
Select("status, COUNT(*) AS n").Group("status").Scan(&statusAgg).Error
agg := gin.H{}
for _, r := range statusAgg {
key := map[int8]string{0: "pending", 1: "sent", 2: "dead"}[r.Status]
if key != "" {
agg[key] = r.N
}
}
response.Success(c, gin.H{"total": total, "list": rows, "status_counts": agg})
}
// resend POST /ops/callback/:id/resend:死信重派(attempt 清零/立即到期)。
func (h *callbackHandler) resend(c *gin.Context) {
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil || id <= 0 {
response.ErrorWithMsg(c, errors.InvalidParam, "id 非法")
return
}
n, err := h.svc.Resend(c.Request.Context(), id)
if err != nil {
bizResp(c, err)
return
}
if n == 0 {
response.Error(c, errors.NotFound.WithMsg("任务不存在或非死信状态"))
return
}
response.Success(c, gin.H{"id": id, "resent": true})
}
+89
View File
@@ -65,6 +65,10 @@ func registerSettleRoutes(protected *gin.RouterGroup, deps Deps) {
middleware.RequirePermission(deps.Perm, "settle", "write"), h.ladderUpdate)
protected.DELETE("/settle/ladder/:id",
middleware.RequirePermission(deps.Perm, "settle", "write"), h.ladderDelete)
// S2-D5:利润分析双端点(平台角色门——利润含全平台资金信息,group/customer
// 403,与充值订单列表同口径;查询类不挂 settle:write)。
protected.GET("/stats/profit/users", h.profitUsers)
protected.GET("/stats/profit/channels", h.profitChannels)
}
// StartSettleAggregateJob v1 层装配入口(照 StartStatsRefresher 模式,仅
@@ -517,3 +521,88 @@ func (h *settleHandler) ladderDelete(c *gin.Context) {
}
response.Success(c, nil)
}
// ---- S2-D5:利润分析 ----
// parseProfitDates date_from/date_to 解析(YYYY-MM-DD;零值兜底=本月 1 号~今天,
// 月度利润视角)。返回 ok=false 时已写响应。
func parseProfitDates(c *gin.Context) (from, to time.Time, ok bool) {
now := time.Now()
from = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
to = now
if s := c.Query("date_from"); s != "" {
d, err := time.ParseInLocation("2006-01-02", s, time.Local)
if err != nil {
response.Error(c, errs.InvalidParam.WithMsg("date_from 须为 YYYY-MM-DD"))
return time.Time{}, time.Time{}, false
}
from = d
}
if s := c.Query("date_to"); s != "" {
d, err := time.ParseInLocation("2006-01-02", s, time.Local)
if err != nil {
response.Error(c, errs.InvalidParam.WithMsg("date_to 须为 YYYY-MM-DD"))
return time.Time{}, time.Time{}, false
}
to = d
}
return from, to, true
}
// profitUsers GET /stats/profit/users:用户利润(时间线价收入/成本分摊/直线下级
// 返点 R4/子树过滤;平台角色)。口径详见 settle/profit.go 头注。
func (h *settleHandler) profitUsers(c *gin.Context) {
if !statsIsPlatform(c) {
response.Error(c, errs.Forbidden.WithMsg("仅平台角色可查看利润分析"))
return
}
from, to, ok := parseProfitDates(c)
if !ok {
return
}
q := settle.UserProfitQuery{From: from, To: to, Page: 1, PageSize: 20}
if v, err := strconv.ParseInt(c.Query("parent_id"), 10, 64); err == nil && v > 0 {
q.ParentID = v
}
if v, err := strconv.Atoi(c.Query("page")); err == nil && v > 0 {
q.Page = v
}
if v, err := strconv.Atoi(c.Query("page_size")); err == nil && v > 0 {
q.PageSize = v
}
res, err := h.svc.UserProfit(c.Request.Context(), q)
if err != nil {
bizResp(c, err)
return
}
response.Success(c, res)
}
// profitChannels GET /stats/profit/channels:通道利润(通道价成本直算/收入占比
// 分摊;平台角色)。
func (h *settleHandler) profitChannels(c *gin.Context) {
if !statsIsPlatform(c) {
response.Error(c, errs.Forbidden.WithMsg("仅平台角色可查看利润分析"))
return
}
from, to, ok := parseProfitDates(c)
if !ok {
return
}
q := settle.ChannelProfitQuery{From: from, To: to, Page: 1, PageSize: 20}
if v, err := strconv.ParseInt(c.Query("channel_id"), 10, 64); err == nil && v > 0 {
q.ChannelID = v
}
if v, err := strconv.Atoi(c.Query("page")); err == nil && v > 0 {
q.Page = v
}
if v, err := strconv.Atoi(c.Query("page_size")); err == nil && v > 0 {
q.PageSize = v
}
res, err := h.svc.ChannelProfit(c.Request.Context(), q)
if err != nil {
bizResp(c, err)
return
}
response.Success(c, res)
}
+103 -1
View File
@@ -39,7 +39,8 @@ func newSettleRouterWithPerm(t *testing.T, perm middleware.PermissionChecker) (*
s.SetMaxOpenConns(1)
}
if err := db.AutoMigrate(&entity.MessageDetail{}, &entity.BillingConsumeLog{},
&entity.StatsChannelDaily{}, &entity.AccountUser{}, &entity.BillingOrder{}); err != nil {
&entity.StatsChannelDaily{}, &entity.AccountUser{}, &entity.BillingOrder{},
&entity.AccountPrice{}, &entity.ChannelPrice{}, &entity.ChannelChannel{}); err != nil {
t.Fatal(err)
}
// 流水表手动建:idx_account_time 与 BillingOrder 同名,glebarez 索引名
@@ -368,3 +369,104 @@ func TestSettleBill_FullFlow(t *testing.T) {
t.Fatalf("无 settle:write 应 403: %d %s", w.Code, w.Body.String())
}
}
// TestSettleProfit_Endpoints S2-D5:利润双端点——平台角色可查(数值口径),
// customer 403;坏日期 400。种子=helper 明细(账号1/100 今日各 1 成功,通道1)
// + 价(账号1=1.0,通道1=0.5):acc1 rev1.0/cost0.5(分摊 1.0×1/2)/profit0.5;
// ch1 succ2/cost1.0/rev1.0/profit0(账号100 无账号行,消耗行不入结果)。
func TestSettleProfit_Endpoints(t *testing.T) {
rg, db, setClaims := newSettleRouter(t)
today := time.Now().Format("2006-01-02")
yday := time.Now().AddDate(0, 0, -1)
if err := db.Create(&[]entity.AccountPrice{
{AccountID: 1, Business: "sms", Price: 1.0, EffectiveAt: yday},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.ChannelPrice{
{ChannelID: 1, Price: 0.5, EffectiveAt: yday},
}).Error; err != nil {
t.Fatal(err)
}
if _, _, err := settle.NewService(db).AggregateDay(t.Context(), time.Now()); err != nil {
t.Fatal(err)
}
setClaims(&middleware.Claims{AccountID: 1, Username: "admin", Roles: []string{"admin"}})
w := httptest.NewRecorder()
rg.ServeHTTP(w, httptest.NewRequest(http.MethodGet,
"/api/v1/stats/profit/users?date_from="+today+"&date_to="+today, nil))
if w.Code != 200 {
t.Fatalf("users status=%d body=%s", w.Code, w.Body.String())
}
var users struct {
Data struct {
Total int64 `json:"total"`
List []struct {
AccountID int64 `json:"account_id"`
Revenue float64 `json:"revenue"`
Cost float64 `json:"cost"`
Profit float64 `json:"profit"`
} `json:"list"`
Summary struct {
TotalRevenue float64 `json:"total_revenue"`
} `json:"summary"`
} `json:"data"`
}
if err := json.Unmarshal(w.Body.Bytes(), &users); err != nil {
t.Fatal(err)
}
if users.Data.Total != 1 || len(users.Data.List) != 1 {
t.Fatalf("users 应 1 行(账号100 无账号实体): %+v", users.Data)
}
r := users.Data.List[0]
if r.AccountID != 1 || r.Revenue != 1.0 || r.Cost != 0.5 || r.Profit != 0.5 {
t.Fatalf("acc1 利润行错: %+v", r)
}
w = httptest.NewRecorder()
rg.ServeHTTP(w, httptest.NewRequest(http.MethodGet,
"/api/v1/stats/profit/channels?date_from="+today+"&date_to="+today, nil))
if w.Code != 200 {
t.Fatalf("channels status=%d body=%s", w.Code, w.Body.String())
}
var channels struct {
Data struct {
Total int64 `json:"total"`
List []struct {
ChannelID int64 `json:"channel_id"`
SuccessCount int64 `json:"success_count"`
Revenue float64 `json:"revenue"`
Cost float64 `json:"cost"`
Profit float64 `json:"profit"`
} `json:"list"`
} `json:"data"`
}
if err := json.Unmarshal(w.Body.Bytes(), &channels); err != nil {
t.Fatal(err)
}
if channels.Data.Total != 1 || len(channels.Data.List) != 1 {
t.Fatalf("channels 应 1 行: %+v", channels.Data)
}
c := channels.Data.List[0]
if c.ChannelID != 1 || c.SuccessCount != 2 || c.Revenue != 1.0 || c.Cost != 1.0 || c.Profit != 0 {
t.Fatalf("ch1 利润行错: %+v", c)
}
// customer → 403;坏日期 → 400。
setClaims(&middleware.Claims{AccountID: 100, Username: "cust", Roles: []string{"customer"}})
for _, path := range []string{"/stats/profit/users", "/stats/profit/channels"} {
w = httptest.NewRecorder()
rg.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/api/v1"+path, nil))
if w.Code != http.StatusForbidden {
t.Fatalf("customer %s 应 403: %d %s", path, w.Code, w.Body.String())
}
}
setClaims(&middleware.Claims{AccountID: 1, Username: "admin", Roles: []string{"admin"}})
w = httptest.NewRecorder()
rg.ServeHTTP(w, httptest.NewRequest(http.MethodGet,
"/api/v1/stats/profit/users?date_from=2026/11/14", nil))
if w.Code == 200 {
t.Fatalf("坏日期应 4xx: %d %s", w.Code, w.Body.String())
}
}
+2
View File
@@ -49,5 +49,7 @@ func All() []any {
// 统计与运维(7)
&StatsChannelDaily{}, &SystemConfig{}, &SystemAlertRule{},
&SystemLoginLog{}, &SystemOperateLog{}, &SystemErrorCode{}, &FeErrorLog{},
// 回调与通知(S4·C1)
&CallbackTask{},
}
}
+38
View File
@@ -0,0 +1,38 @@
package entity
import "time"
// Callback 回调任务类型(S4·C1)。
const (
CallbackTypeReport int8 = 1 // 回执终态推送(账号 report_url)
CallbackTypeUplink int8 = 2 // 上行消息推送(账号 uplink_url)
)
// Callback 回调任务状态机(S4·C1)。
const (
CallbackPending int8 = 0 // 待推送(含退避等待)
CallbackSent int8 = 1 // 已送达(2xx)
CallbackDead int8 = 2 // 死信(重试耗尽,可重派)
)
// CallbackTask HTTP 回调推送任务(S4·C1:指数退避+死信可查)。
// 入队源=report 终态首锁/report 手动配对(EnqueueReport)与 uplink 消费
// (EnqueueUplink);PushWorker 扫描投递。幂等锚=无(每终态一条;report 侧
// 由 finalizeDetail 首锁语义天然至多一次,重放由 detail 终态锁定挡住)。
type CallbackTask struct {
ID int64 `gorm:"primaryKey;autoIncrement" json:"id"`
AccountID int64 `gorm:"index:idx_cb_account,priority:1" json:"account_id"`
Type int8 `gorm:"default:1" json:"type"` // 1 回执 2 上行(CallbackType*)
URL string `gorm:"size:512" json:"url"`
Payload string `gorm:"type:text" json:"payload"` // 客户回调 JSON 载荷
Status int8 `gorm:"index:idx_cb_status_retry,priority:1;default:0" json:"status"`
Attempt int `gorm:"default:0" json:"attempt"`
NextRetryAt time.Time `gorm:"index:idx_cb_status_retry,priority:2" json:"next_retry_at"`
LastCode int `json:"last_code"` // 最近一次 HTTP 状态码(0=连接层错误)
LastErr string `gorm:"size:255" json:"last_err"`
SentAt *time.Time `json:"sent_at"`
CreatedAt time.Time `gorm:"autoCreateTime;index:idx_cb_account,priority:2" json:"created_at"`
UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
}
func (CallbackTask) TableName() string { return "callback_task" }
+18
View File
@@ -83,6 +83,13 @@ var (
// SettleAggregateErrors 消耗日汇总执行失败次数(失败 Warn 不中断,
// 幂等下轮自愈;持续增长=真故障信号)。
SettleAggregateErrors prometheus.Counter
// ---- 回调推送域(S4·C1) ----
// CallbackPushTotal 推送结果计数({type}: report/uplink × {result}:
// sent=2xx 送达/retry=失败待重试/dead=死信)。
CallbackPushTotal *prometheus.CounterVec
// CallbackBlacklistTotal 上行自动拉黑新增数(S4·C2;幂等冲突不计)。
CallbackBlacklistTotal prometheus.Counter
)
var registry = prometheus.NewRegistry()
@@ -189,6 +196,16 @@ func init() {
Help: "消耗日汇总执行失败次数(幂等下轮自愈,持续增长=真故障,S2)",
})
CallbackPushTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "go_sms_callback_push_total",
Help: "回调推送结果(type: report/uplink × result: sent/retry/dead,S4·C1)",
}, []string{"type", "result"})
CallbackBlacklistTotal = prometheus.NewCounter(prometheus.CounterOpts{
Name: "go_sms_callback_blacklist_total",
Help: "上行自动拉黑新增数(幂等冲突不计,S4·C2)",
})
registry.MustRegister(
HTTPRequestsTotal, HTTPRequestDuration, HTTPRequestsInFlight,
SMSSubmitTotal, SMSReportTotal, KafkaProducerMessages,
@@ -198,6 +215,7 @@ func init() {
LongSmsExpireFailTotal,
ReportPendingTotal, ReportRecheckTotal, ReportRequeueTotal,
SettleAggregateRows, SettleAggregateErrors,
CallbackPushTotal, CallbackBlacklistTotal,
)
// Go 运行时与进程指标
registry.MustRegister(
+15 -11
View File
@@ -29,8 +29,8 @@ func TestMigrations_IdempotentAndVersioned(t *testing.T) {
seen[mig.ID] = true
last = mig
}
if last == nil || last.ID != "v20_settle_domain" {
t.Fatalf("终版迁移应为 v20_settle_domain,实际 %v", last)
if last == nil || last.ID != "v21_callback_domain" {
t.Fatalf("终版迁移应为 v21_callback_domain,实际 %v", last)
}
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
@@ -42,28 +42,28 @@ func TestMigrations_IdempotentAndVersioned(t *testing.T) {
}
opts := gormigrate.DefaultOptions
opts.TableName = "schema_migrations"
// 注册末七迁移(现 v14..v20;历史 v10/V11 含 MessageTask AutoMigrate,gleberez
// 注册末七迁移(现 v15..v21;历史 v10/V11 含 MessageTask AutoMigrate,gleberez
// sqlite 索引不查重,双块连跑撞 idx_account_time——同 v1+v6 已知方言缺口;
// v14 各建各表、v15 AutoMigrate 加列、v16/v17/v20 空库守卫补建表后加列/索引、
// v18/v19 新表 AutoMigrate,v20 另含 DROP IF EXISTS 与 casbin HasTable 守卫,
// v15 AutoMigrate 加列、v16/v17/v20 空库守卫补建表后加列/索引、
// v18/v19/v21 新表 AutoMigrate,v20 另含 DROP IF EXISTS 与 casbin HasTable 守卫,
// 单块两遍覆盖幂等)。
migs := Migrations()
gm := gormigrate.New(db.Session(&gorm.Session{Logger: logger.Discard}), opts, migs[len(migs)-7:])
if err := gm.Migrate(); err != nil {
t.Fatalf("v14..v20 首遍失败: %v", err)
t.Fatalf("v15..v21 首遍失败: %v", err)
}
if err := gm.Migrate(); err != nil {
t.Fatalf("v14..v20 二遍不幂等: %v", err)
t.Fatalf("v15..v21 二遍不幂等: %v", err)
}
v, err := CurrentMigrationVersion(db)
if err != nil {
t.Fatalf("查版本失败: %v", err)
}
if v == nil || *v != "v20_settle_domain" {
t.Fatalf("版本应为 v20_settle_domain,实际 %v", v)
if v == nil || *v != "v21_callback_domain" {
t.Fatalf("版本应为 v21_callback_domain,实际 %v", v)
}
// (v13 断言随窗口右移移除:message_report_seg/pk_total 由 v13 建,
// 现窗口 v14..v20 不含 v13;全量链路覆盖仍由 dev MySQL 实库验证。)
// (v13/v14 断言随窗口右移移除:各表由 v13/v14 建,
// 现窗口 v15..v21 不含;全量链路覆盖仍由 dev MySQL 实库验证。)
// Day 62:v15 后 account_config 应有账号级 CMPP 配额两列。
if !db.Migrator().HasColumn(&entity.AccountConfig{}, "CmppMaxConns") ||
!db.Migrator().HasColumn(&entity.AccountConfig{}, "CmppSpeed") {
@@ -97,6 +97,10 @@ func TestMigrations_IdempotentAndVersioned(t *testing.T) {
if db.Migrator().HasTable("stats_user_daily") {
t.Fatal("v20 后 stats_user_daily 应已 DROP(R2 单一事实源裁决)")
}
// S4·C1:v21 后 callback_task 建表(空库守卫 AutoMigrate 路径)。
if !db.Migrator().HasTable(&entity.CallbackTask{}) {
t.Fatal("v21 后应存在 callback_task 表")
}
}
// newTestDB 内存 SQLite + 自动建表。
+36
View File
@@ -467,6 +467,42 @@ func Migrations() []*gormigrate.Migration {
return nil // 列/表/策略可手工重建或清除,回滚为空操作(v16~v19 惯例)
},
},
// v21(S4·C1)回调推送域:callback_task 队列表(指数退避+死信可查)
// + ops 角色回调管理策略。表仅 AutoMigrate 空库守卫建(同 v18~v20 惯例;
// 存量库首跑由 migrate 链自动补建,无列变更)。
{
ID: "v21_callback_domain",
Migrate: func(tx *gorm.DB) error {
if !tx.Migrator().HasTable(&entity.CallbackTask{}) {
if err := tx.AutoMigrate(&entity.CallbackTask{}); err != nil {
return err
}
}
if tx.Migrator().HasTable(&casbinRule{}) { // v5 才建 casbin_rule
policies := []casbinRule{
{Ptype: "p", V0: "ops", V1: "callback", V2: "read"}, // 死信/任务查询
{Ptype: "p", V0: "ops", V1: "callback", V2: "write"}, // 死信重派
}
for _, p := range policies {
var n int64
if err := tx.Model(&casbinRule{}).
Where("ptype = ? AND v0 = ? AND v1 = ? AND v2 = ?", p.Ptype, p.V0, p.V1, p.V2).
Count(&n).Error; err != nil {
return err
}
if n == 0 {
if err := tx.Create(&p).Error; err != nil {
return err
}
}
}
}
return nil
},
Rollback: func(tx *gorm.DB) error {
return nil // 新表可手工清除,回滚为空操作(v16~v20 惯例)
},
},
}
}
+168
View File
@@ -0,0 +1,168 @@
// Package callback S4·C1:HTTP 回调推送引擎(指数退避+死信可查)。
// 入队源:report 终态首锁(EnqueueReport,与 CMPP Deliver 同挂点)/uplink
// 消费(EnqueueUplink);投递=PushWorker 周期扫描 callback_task(需求 2.5
// 回执/上行绑定地址;实施计划 5.8 重试队列+指数退避)。
// 客户通知双通道并存:CMPP 活跃会话走 cmpp-deliver(deliver_push.go),
// 配置 report_url/uplink_url 的账号走本引擎(验收=死信可查/重派可恢复)。
package callback
import (
"context"
"encoding/json"
"sync"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go.uber.org/zap"
"gorm.io/gorm"
)
// urlCacheTTL 账号回调地址缓存 TTL(策略变更最迟生效窗口)。
const urlCacheTTL = 60 * time.Second
// statForStatus 明细终态 int8 → 回调载荷状态词(与 statForDeliver 同口径;
// 成功=DELIVRD,失败/未知=errCode 透传截 16B,空兜底 UNKNOWN)。
func statForStatus(status int8, errCode string) string {
if status == 2 {
return "DELIVRD"
}
if errCode == "" {
return "UNKNOWN"
}
if r := []rune(errCode); len(r) > 16 {
return string(r[:16])
}
return errCode
}
// ReportPayload 回执终态回调载荷(标准 JSON;detail_id 与 Submit_Resp MsgID
// 同口径,客户据此对账)。
type ReportPayload struct {
Type string `json:"type"` // "report"
DetailID int64 `json:"detail_id"`
AccountID int64 `json:"account_id"`
Mobile string `json:"mobile"`
Status int8 `json:"status"` // 2 成功 3 失败 4 未知
Stat string `json:"stat"` // DELIVRD/UNDELIV/上游原始码
ErrorCode string `json:"error_code"`
ReportAt time.Time `json:"report_at"`
}
// UplinkPayload 上行消息回调载荷(需求 2.5:拉黑不影响上行推送)。
type UplinkPayload struct {
Type string `json:"type"` // "uplink"
UplinkID int64 `json:"uplink_id"`
AccountID int64 `json:"account_id"`
DestCode string `json:"dest_code"`
SrcMobile string `json:"src_mobile"`
Content string `json:"content"`
RecvAt string `json:"recv_at"` // RFC3339(透传事件原值)
}
type urlEntry struct {
report, uplink string
exp time.Time
}
// Service 回调入队器:URL 缓存(60s TTL)+ 载荷构造 + callback_task 写入。
// 实现 report.ReportEnqueuer / uplink.UplinkEnqueuer(装配层注入)。
type Service struct {
db *gorm.DB
mu sync.RWMutex
urls map[int64]urlEntry
}
// NewService 构造。
func NewService(db *gorm.DB) *Service {
return &Service{db: db, urls: map[int64]urlEntry{}}
}
// urlsFor 账号回调地址(缓存 miss 回源 account_config;DB 故障返回空串=
// 该账号本轮跳过,下轮回源自愈)。
func (s *Service) urlsFor(ctx context.Context, accountID int64) (report, uplink string) {
now := time.Now()
s.mu.RLock()
e, ok := s.urls[accountID]
s.mu.RUnlock()
if ok && now.Before(e.exp) {
return e.report, e.uplink
}
var cfg entity.AccountConfig
if err := s.db.WithContext(ctx).
Where("account_id = ? AND business = ?", accountID, "sms").
First(&cfg).Error; err != nil {
if err != gorm.ErrRecordNotFound {
logger.L().Warn("callback_url_lookup_failed",
zap.Int64("account_id", accountID), zap.Error(err))
}
return "", "" // 不缓存失败:下轮重查
}
s.mu.Lock()
s.urls[accountID] = urlEntry{report: cfg.ReportURL, uplink: cfg.UplinkURL, exp: now.Add(urlCacheTTL)}
s.mu.Unlock()
return cfg.ReportURL, cfg.UplinkURL
}
// EnqueueReport 回执终态入队(report 域调用;失败仅返回错误由调用方 Warn,
// 终态不回滚——与 CMPP Deliver 下发同口径)。
func (s *Service) EnqueueReport(ctx context.Context, detailID int64,
status int8, st, errCode, mobile string, now time.Time) error {
var accountID int64
if err := s.db.WithContext(ctx).Table("message_detail").
Select("account_id").Where("id = ?", detailID).Scan(&accountID).Error; err != nil {
return err
}
reportURL, _ := s.urlsFor(ctx, accountID)
if reportURL == "" {
return nil // 未配置回调地址:零任务(多数账号)
}
p := ReportPayload{
Type: "report", DetailID: detailID, AccountID: accountID, Mobile: mobile,
Status: status, Stat: statForStatus(status, errCode), ErrorCode: errCode,
ReportAt: now,
}
if st != "" { // report 域三态词优先(DELIVRD/FAILURE/UNKNOWN)
p.Stat = st
}
return s.insert(ctx, accountID, entity.CallbackTypeReport, reportURL, p)
}
// EnqueueUplink 上行消息入队(uplink 域调用;拉黑判定在前不影响推送)。
func (s *Service) EnqueueUplink(ctx context.Context, uplinkID, accountID int64,
destCode, srcMobile, content, recvAt string) error {
_, uplinkURL := s.urlsFor(ctx, accountID)
if uplinkURL == "" {
return nil
}
return s.insert(ctx, accountID, entity.CallbackTypeUplink, uplinkURL, UplinkPayload{
Type: "uplink", UplinkID: uplinkID, AccountID: accountID,
DestCode: destCode, SrcMobile: srcMobile, Content: content, RecvAt: recvAt,
})
}
func (s *Service) insert(ctx context.Context, accountID int64, typ int8, url string, payload any) error {
body, err := json.Marshal(payload)
if err != nil {
return err
}
return s.db.WithContext(ctx).Create(&entity.CallbackTask{
AccountID: accountID, Type: typ, URL: url,
Payload: string(body), Status: entity.CallbackPending,
NextRetryAt: time.Now(),
}).Error
}
// Resend 死信重派(status 2→0/attempt 清零/立即到期;CAS 仅死信可派)。
// 返回影响行数(0=非死信或不存在)。
func (s *Service) Resend(ctx context.Context, id int64) (int64, error) {
res := s.db.WithContext(ctx).Model(&entity.CallbackTask{}).
Where("id = ? AND status = ?", id, entity.CallbackDead).
Updates(map[string]any{
"status": entity.CallbackPending, "attempt": 0,
"next_retry_at": time.Now(), "last_err": "resend by ops",
})
return res.RowsAffected, res.Error
}
+203
View File
@@ -0,0 +1,203 @@
// callback_test.go S4·C1:入队(URL 配置门控/载荷)+ 推送状态机
// (sent/退避/死信/重派)——httptest 模拟客户回调地址。
package callback
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"time"
"go-sms/internal/model/entity"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
func newCallbackDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard})
if err != nil {
t.Fatalf("打开内存库失败: %v", err)
}
if err := db.AutoMigrate(&entity.CallbackTask{}, &entity.AccountConfig{}, &entity.MessageDetail{}); err != nil {
t.Fatalf("AutoMigrate 失败: %v", err)
}
return db
}
func mkDetailRow(t *testing.T, db *gorm.DB, accountID int64) int64 {
t.Helper()
d := entity.MessageDetail{TaskID: 1, AccountID: accountID, Mobile: "13800001111", Status: 2}
d.ID = time.Now().UnixNano()
if err := db.Create(&d).Error; err != nil {
t.Fatal(err)
}
return d.ID
}
// TestEnqueueReport_NoURL 未配置 report_url:零任务(多数账号零开销)。
func TestEnqueueReport_NoURL(t *testing.T) {
db := newCallbackDB(t)
s := NewService(db)
detailID := mkDetailRow(t, db, 5)
if err := s.EnqueueReport(context.Background(), detailID, 2, "SUCCESS", "", "13800001111", time.Now()); err != nil {
t.Fatal(err)
}
var n int64
db.Model(&entity.CallbackTask{}).Count(&n)
if n != 0 {
t.Fatalf("未配置 URL 应零任务, got %d", n)
}
}
// TestEnqueueReport_WithURL 配置 report_url:入队 type=report,载荷字段完整。
func TestEnqueueReport_WithURL(t *testing.T) {
db := newCallbackDB(t)
if err := db.Create(&entity.AccountConfig{
AccountID: 5, Business: "sms", ReportURL: "http://cb.example/hook",
}).Error; err != nil {
t.Fatal(err)
}
s := NewService(db)
detailID := mkDetailRow(t, db, 5)
if err := s.EnqueueReport(context.Background(), detailID, 3, "FAILURE", "UNDELIV", "13800001111", time.Now()); err != nil {
t.Fatal(err)
}
var task entity.CallbackTask
if err := db.First(&task).Error; err != nil {
t.Fatalf("任务未入队: %v", err)
}
if task.Type != entity.CallbackTypeReport || task.URL != "http://cb.example/hook" || task.Status != entity.CallbackPending {
t.Fatalf("type/url/status 异常: %+v", task)
}
var p ReportPayload
if err := json.Unmarshal([]byte(task.Payload), &p); err != nil {
t.Fatal(err)
}
if p.DetailID != detailID || p.AccountID != 5 || p.Stat != "FAILURE" || p.Mobile != "13800001111" {
t.Fatalf("载荷字段异常: %+v", p)
}
}
// TestEnqueueUplink 配置 uplink_url 才入队(type=uplink)。
func TestEnqueueUplink(t *testing.T) {
db := newCallbackDB(t)
s := NewService(db)
if err := s.EnqueueUplink(context.Background(), 9, 5, "10690", "13811112222", "R", "2026-11-16T10:00:00+08:00"); err != nil {
t.Fatal(err)
}
var n int64
db.Model(&entity.CallbackTask{}).Count(&n)
if n != 0 {
t.Fatalf("未配置 uplink_url 应零任务, got %d", n)
}
db.Create(&entity.AccountConfig{AccountID: 5, Business: "sms", UplinkURL: "http://cb.example/mo"})
if err := s.EnqueueUplink(context.Background(), 9, 5, "10690", "13811112222", "R", "2026-11-16T10:00:00+08:00"); err != nil {
t.Fatal(err)
}
var task entity.CallbackTask
if err := db.First(&task).Error; err != nil {
t.Fatalf("任务未入队: %v", err)
}
if task.Type != entity.CallbackTypeUplink {
t.Fatalf("type 期望 uplink(2), got %d", task.Type)
}
var p UplinkPayload
if err := json.Unmarshal([]byte(task.Payload), &p); err != nil {
t.Fatal(err)
}
if p.UplinkID != 9 || p.SrcMobile != "13811112222" || p.Content != "R" {
t.Fatalf("上行载荷异常: %+v", p)
}
}
// TestWorkerSentToDeadLifecycle 状态机全链:500→退避重排→耗尽死信→Resend→200 送达。
func TestWorkerSentToDeadLifecycle(t *testing.T) {
db := newCallbackDB(t)
code := 500
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(code)
}))
defer srv.Close()
task := entity.CallbackTask{
AccountID: 5, Type: entity.CallbackTypeReport, URL: srv.URL,
Payload: `{"type":"report"}`, Status: entity.CallbackPending,
NextRetryAt: time.Now(),
}
if err := db.Create(&task).Error; err != nil {
t.Fatal(err)
}
w := NewPushWorker(db)
w.maxAttempt = 2 // 测试压缩(生产 10)
// 第一轮:500 → attempt=1 重排(退避后到期)。
if n := w.Tick(context.Background()); n != 1 {
t.Fatalf("第一轮应处理 1 条, got %d", n)
}
var got entity.CallbackTask
db.First(&got, task.ID)
if got.Status != entity.CallbackPending || got.Attempt != 1 || !got.NextRetryAt.After(time.Now()) {
t.Fatalf("失败后应 pending+attempt=1+未来重试: %+v", got)
}
// 未到期不重扫。
if n := w.Tick(context.Background()); n != 0 {
t.Fatalf("退避窗口内不应重扫, got %d", n)
}
// 到期重扫 → 耗尽 → 死信。
db.Model(&entity.CallbackTask{}).Where("id = ?", task.ID).
Update("next_retry_at", time.Now().Add(-time.Second))
w.Tick(context.Background())
db.First(&got, task.ID)
if got.Status != entity.CallbackDead || got.Attempt != 2 {
t.Fatalf("重试耗尽应死信: %+v", got)
}
// 死信不参与扫描。
if n := w.Tick(context.Background()); n != 0 {
t.Fatalf("死信不应被扫描, got %d", n)
}
// 重派 → 服务恢复 → 送达。
if n, err := NewService(db).Resend(context.Background(), task.ID); err != nil || n != 1 {
t.Fatalf("Resend: n=%d err=%v", n, err)
}
code = http.StatusOK
w.Tick(context.Background())
db.First(&got, task.ID)
if got.Status != entity.CallbackSent || got.SentAt == nil || got.LastCode != 200 {
t.Fatalf("重派后应送达: %+v", got)
}
// 非死信重派=幂等拒绝(0 行)。
if n, _ := NewService(db).Resend(context.Background(), task.ID); n != 0 {
t.Fatalf("非死信 Resend 应 0 行, got %d", n)
}
}
// TestWorkerConcurrentBatch 并发批次全部推进(信号量不丢任务)。
func TestWorkerConcurrentBatch(t *testing.T) {
db := newCallbackDB(t)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
defer srv.Close()
for i := 0; i < 20; i++ {
db.Create(&entity.CallbackTask{
AccountID: 5, Type: entity.CallbackTypeUplink, URL: srv.URL,
Payload: "{}", Status: entity.CallbackPending, NextRetryAt: time.Now(),
})
}
w := NewPushWorker(db)
w.batch = 20
w.concurrency = 1 // sqlite 内存库并发写锁:单测串行(批次不丢任务语义不变)
if n := w.Tick(context.Background()); n != 20 {
t.Fatalf("应处理 20 条, got %d", n)
}
var sent int64
db.Model(&entity.CallbackTask{}).Where("status = ?", entity.CallbackSent).Count(&sent)
if sent != 20 {
t.Fatalf("应全部送达, got %d", sent)
}
}
+175
View File
@@ -0,0 +1,175 @@
// worker.go S4·C1:回调推送 Worker——周期扫描 callback_task(status=0 且到期)
// →HTTP POST→2xx 置 sent/失败指数退避/耗尽置 dead。单实例部署(与 consumer
// 同进程);多实例时批次 SELECT 无锁会重复推送(at-least-once,UPDATE CAS
// 保证状态机不乱,重复送达客户侧幂等兜底——与 CMPP Deliver 同语义)。
package callback
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go-sms/internal/pkg/metrics"
"go.uber.org/zap"
"gorm.io/gorm"
)
// 推送参数默认值(HDD→SSD 后保守起步;S5 基线期按压测重标)。
const (
DefaultScanEvery = 2 * time.Second // 扫描周期
DefaultBatch = 100 // 单轮上限
DefaultConcurrency = 8 // 并发推送信号量
DefaultTimeout = 5 * time.Second // 单次 HTTP 超时
DefaultMaxAttempt = 10 // 重试上限(超过=死信)
DefaultMaxBackoff = 10 * time.Minute // 退避封顶
)
// PushWorker 回调推送器。
type PushWorker struct {
db *gorm.DB
client *http.Client
batch int
concurrency int
maxAttempt int
maxBackoff time.Duration
}
// NewPushWorker 构造(零值参数取默认)。
func NewPushWorker(db *gorm.DB) *PushWorker {
return &PushWorker{
db: db,
client: &http.Client{
Timeout: DefaultTimeout,
},
batch: DefaultBatch,
concurrency: DefaultConcurrency,
maxAttempt: DefaultMaxAttempt,
maxBackoff: DefaultMaxBackoff,
}
}
// Run 常驻循环(caller 起 goroutine;ctx 取消即退出,每轮独立 tick)。
func (w *PushWorker) Run(ctx context.Context, every time.Duration) {
if every <= 0 {
every = DefaultScanEvery
}
t := time.NewTicker(every)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
w.Tick(ctx)
}
}
}
// Tick 单轮扫描推送(导出供测试/手动触发);返回本轮处理条数。
func (w *PushWorker) Tick(ctx context.Context) int {
var rows []entity.CallbackTask
if err := w.db.WithContext(ctx).
Where("status = ? AND next_retry_at <= ?", entity.CallbackPending, time.Now()).
Order("id ASC").Limit(w.batch).Find(&rows).Error; err != nil {
logger.L().Warn("callback_scan_failed", zap.Error(err))
return 0
}
sem := make(chan struct{}, w.concurrency)
done := make(chan struct{}, len(rows))
for i := range rows {
sem <- struct{}{}
go func(task entity.CallbackTask) {
defer func() { <-sem; done <- struct{}{} }()
w.pushOne(ctx, task)
}(rows[i])
}
for range rows {
<-done
}
return len(rows)
}
// pushOne 单条推送+状态机推进(CAS WHERE status=0:与 Resend/并发实例至多一次生效)。
func (w *PushWorker) pushOne(ctx context.Context, task entity.CallbackTask) {
typ := "report"
if task.Type == entity.CallbackTypeUplink {
typ = "uplink"
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, task.URL, bytes.NewReader([]byte(task.Payload)))
if err != nil {
w.markRetry(ctx, &task, 0, err.Error(), typ)
return
}
req.Header.Set("Content-Type", "application/json")
resp, err := w.client.Do(req)
if err != nil {
w.markRetry(ctx, &task, 0, truncate(err.Error(), 255), typ)
return
}
defer func() { _ = resp.Body.Close() }()
_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4<<10))
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
res := w.db.WithContext(ctx).Model(&entity.CallbackTask{}).
Where("id = ? AND status = ?", task.ID, entity.CallbackPending).
Updates(map[string]any{
"status": entity.CallbackSent, "last_code": resp.StatusCode,
"last_err": "", "sent_at": time.Now(),
})
if res.Error != nil {
logger.L().Warn("callback_mark_sent_failed", zap.Int64("id", task.ID), zap.Error(res.Error))
}
if res.RowsAffected > 0 {
metrics.CallbackPushTotal.WithLabelValues(typ, "sent").Inc()
}
return
}
w.markRetry(ctx, &task, resp.StatusCode, fmt.Sprintf("http %d", resp.StatusCode), typ)
}
// markRetry 失败推进:attempt+1 → 耗尽置 dead,否则退避重排。
func (w *PushWorker) markRetry(ctx context.Context, task *entity.CallbackTask, httpCode int, msg, typ string) {
attempt := task.Attempt + 1
updates := map[string]any{
"attempt": attempt, "last_code": httpCode, "last_err": truncate(msg, 255),
}
if attempt >= w.maxAttempt {
updates["status"] = entity.CallbackDead
updates["next_retry_at"] = time.Now() // MySQL 不收 zero time;死信不扫靠 status
} else {
backoff := time.Duration(1<<uint(attempt)) * time.Second // 2^attempt s
if backoff > w.maxBackoff {
backoff = w.maxBackoff
}
updates["next_retry_at"] = time.Now().Add(backoff)
}
res := w.db.WithContext(ctx).Model(&entity.CallbackTask{}).
Where("id = ? AND status = ?", task.ID, entity.CallbackPending).
Updates(updates)
if res.Error != nil {
logger.L().Warn("callback_mark_retry_failed", zap.Int64("id", task.ID), zap.Error(res.Error))
return
}
if res.RowsAffected > 0 {
if attempt >= w.maxAttempt {
metrics.CallbackPushTotal.WithLabelValues(typ, "dead").Inc()
logger.L().Warn("callback_task_dead",
zap.Int64("id", task.ID), zap.Int64("account_id", task.AccountID),
zap.Int("attempt", attempt), zap.String("url", task.URL))
} else {
metrics.CallbackPushTotal.WithLabelValues(typ, "retry").Inc()
}
}
}
func truncate(s string, n int) string {
if r := []rune(s); len(r) > n {
return string(r[:n])
}
return s
}
+34
View File
@@ -26,9 +26,18 @@ type Consumer struct {
db *gorm.DB
bill *Billing // Day 57:计费确认(nil=跳过,Day56 零破坏)
push PushSink // Day 61:CMPP Deliver 下发出口(nil=跳过)
cb ReportEnqueuer // S4·C1:HTTP 回调入队出口(nil=跳过)
requeue func(ev *Event) error // Day 69 三轮:unpaired 短重投出口(nil=直接按杂音丢弃)
}
// ReportEnqueuer 回执终态 HTTP 回调入队出口(S4·C1;装配层注入
// *callback.Service。终态首锁后调用,与 bill.Confirm 同为事务提交后动作;
// 内部失败由实现方/调用方 Warn 吞错——终态不回滚)。
type ReportEnqueuer interface {
EnqueueReport(ctx context.Context, detailID int64,
status int8, st, errCode, mobile string, now time.Time) error
}
// NewConsumer 构造。
func NewConsumer(db *gorm.DB) *Consumer { return &Consumer{db: db} }
@@ -45,6 +54,25 @@ func (c *Consumer) WithPushSink(p PushSink) *Consumer {
return c
}
// WithCallback 注入 HTTP 回调入队出口(S4·C1;链式,nil=跳过)。
func (c *Consumer) WithCallback(e ReportEnqueuer) *Consumer {
c.cb = e
return c
}
// enqueueReportLocked 终态首锁后的回调入队(吞错 Warn:推送失败不影响
// 已锁定的对账事实源——与 CMPP Deliver 下发同口径)。
func (c *Consumer) enqueueReportLocked(ctx context.Context, act *finAction, now time.Time) {
if c.cb == nil || act == nil {
return
}
if err := c.cb.EnqueueReport(ctx, act.detailID, act.status,
string(act.st), act.errCode, act.mobile, now); err != nil {
logger.L().Warn("callback_report_enqueue_failed",
zap.Int64("detail_id", act.detailID), zap.Error(err))
}
}
// WithRequeue 注入 unpaired 短重投出口(Day 69 三轮;链式,nil=不重投)。
// 场景:秒回模拟器回执(push→kafka→消费,~10ms)可跑赢发送侧 seg 落库
// (submit 往返+批量写,~20ms+)——合法回执 unpaired 若直接丢弃=detail
@@ -121,6 +149,9 @@ func (c *Consumer) Process(ctx context.Context, ev *Event) error {
if locked && c.bill != nil { // 首到终态锁定且事务已提交:计费确认(内部吞错,方向=少退不少扣)
c.bill.Confirm(ctx, act.detailID, act.status)
}
if locked { // S4·C1:HTTP 回调入队(账号配置 report_url 才产生任务)
c.enqueueReportLocked(ctx, act, now)
}
if !paired {
return c.handleUnpaired(ev) // Day 69 三轮:秒回竞态短重投,耗尽才按杂音丢弃
}
@@ -188,6 +219,9 @@ func (c *Consumer) recheckPending(ctx context.Context, ev *Event, st Status, now
if locked && c.bill != nil {
c.bill.Confirm(ctx, act.detailID, act.status)
}
if locked { // S4·C1:HTTP 回调入队(补刀终态同推)
c.enqueueReportLocked(ctx, act, now)
}
return nil
}
@@ -0,0 +1,62 @@
// consumer_callback_test.go S4·C1:回执终态首锁后的 HTTP 回调入队挂点
// (重复回执/已锁定不重复入队;挂点语义=与 bill.Confirm 同为事务后动作)。
package report
import (
"context"
"testing"
"time"
)
type capEnqueuer struct {
calls []capEnqCall
}
type capEnqCall struct {
detailID int64
status int8
}
func (e *capEnqueuer) EnqueueReport(_ context.Context, detailID int64,
status int8, st, errCode, mobile string, _ time.Time) error {
e.calls = append(e.calls, capEnqCall{detailID: detailID, status: status})
return nil
}
// TestConsumer_CallbackEnqueuedOnce 单段成功终态=入队一次;重复回执(终态
// 已锁定)=零重复——首锁幂等语义延伸到回调面。
func TestConsumer_CallbackEnqueuedOnce(t *testing.T) {
db := newConsumerDB(t)
enq := &capEnqueuer{}
c := NewConsumer(db).WithCallback(enq)
d := mkDetail(t, db, 1, "13800005555", 1)
mid := mkSeg(t, db, d.ID, 7, "13800005555", 1, 1)
if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13800005555")); err != nil {
t.Fatal(err)
}
if len(enq.calls) != 1 || enq.calls[0].detailID != d.ID || enq.calls[0].status != 2 {
t.Fatalf("首锁应入队一次: %+v", enq.calls)
}
// 同一回执重放:终态已锁定,跳过(零重复入队)。
if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13800005555")); err != nil {
t.Fatal(err)
}
if len(enq.calls) != 1 {
t.Fatalf("重复回执不应重复入队: %+v", enq.calls)
}
}
// TestConsumer_CallbackNilSink 注入 nil=零开销跳过(旧装配兼容)。
func TestConsumer_CallbackNilSink(t *testing.T) {
db := newConsumerDB(t)
c := NewConsumer(db) // 无 WithCallback
d := mkDetail(t, db, 1, "13800006666", 1)
mid := mkSeg(t, db, d.ID, 7, "13800006666", 1, 1)
if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13800006666")); err != nil {
t.Fatal(err)
}
if got := getDetail(t, db, d.ID); got.Status != 3 {
t.Fatalf("status=%d 期望 3", got.Status)
}
}
+15
View File
@@ -82,6 +82,7 @@ type PairService struct {
db *gorm.DB
bill *Billing
push PushSink
cb ReportEnqueuer // S4·C1:HTTP 回调入队(nil=跳过)
sf *util.Snowflake // 重推受理号(雪花;D29 异步任务表落地后即任务主键)
}
@@ -96,6 +97,12 @@ func (p *PairService) WithPushSink(s PushSink) *PairService {
return p
}
// WithCallback 注入 HTTP 回调入队出口(S4·C1;链式,nil=跳过)。
func (p *PairService) WithCallback(e ReportEnqueuer) *PairService {
p.cb = e
return p
}
// DB 裸查询出口(handler 回执分页 JOIN 查询复用同一连接)。
func (p *PairService) DB() *gorm.DB { return p.db }
@@ -282,6 +289,14 @@ func (p *PairService) Pair(ctx context.Context, req PairRequest) (PairResult, er
if p.bill != nil {
p.bill.Confirm(ctx, id, req.TargetStatus)
}
// S4·C1:HTTP 回调入队(与 Consumer 回执链同挂点;吞错 Warn)。
if p.cb != nil {
if err := p.cb.EnqueueReport(ctx, id, req.TargetStatus,
string(st), "MANUAL", d.Mobile, now); err != nil {
logger.L().Warn("callback_report_enqueue_failed",
zap.Int64("detail_id", id), zap.Error(err))
}
}
} else {
res.Skipped++ // 圈中窗口与执行窗口间被回执/并发配对锁定
}
+1
View File
@@ -1,6 +1,7 @@
// price.go S2-D4:生效价引擎——R1/R6 全链唯一「条→元」换算点。
//
// 口径(D4-0 用户批准方案默认):
//
// Q1 下家:金额=Σ(日成功条数×当日生效价);PriceAt=价格时间线 EffectiveAt≤当日
// 取最近;无价日按 0 元入账(账单明细如实体现,不阻断生成);
// Q2 阶梯:月成功总量落档后**整月单价按档位价覆写**(不做分档混合计价);
+343
View File
@@ -0,0 +1,343 @@
// profit.go S2-D5:利润分析引擎——用户(含下级树/返点)与通道双视角。
//
// 口径(与 D4 出账同源、分析性差异如实声明):
// - revenue(用户)=Σ(日成功条数×PriceAtAccount 时间线价)——与 GenerateCustomerBills
// 同口径;**阶梯不进分析**(阶梯是月结出账的整月覆写项,分析用时间线价,
// 启用阶梯的账号利润行与账单金额可能不同,属口径差异非数据错误);
// - cost(用户)=全平台通道成本×该账号成功条数/全平台通道成功条数——**占比分摊**
// (billing_consume_log 与 stats_channel_daily 无账号×通道交叉粒度,精确归因
// 需新增事实粒度,留 S3+;分摊在总量守恒下误差可控);
// - rebate(R4)=Σ 直线下级窗口结算额×下级 rebate_rate——该账号(作为上级)的
// 返点收入,等价于平台让利支出;**历史不重算**:返点不落档,每次查询按当前
// 树(直线下级)+当前 rate×窗口推导,不存在回溯修正动作(换上级只影响未来
// 窗口的归属);
// - profit(用户)=revenue-cost+rebate;平台净利(summary)=Σrevenue-Σcost-Σrebate
// (返点从平台口径流出、计入上级账号口径);
// - 通道侧:cost=Σ(日成功×PriceAtChannel);revenue=全平台用户收入×通道成功占比
// (同分摊口径,与用户侧共用同一分母,Σ通道revenue=Σ用户revenue 恒成立)。
//
// 单位:金额均=元(R6;条→元换算仍只在 price.go)。
package settle
import (
"context"
"sort"
"strconv"
"strings"
"time"
"go-sms/internal/model/entity"
errs "go-sms/internal/pkg/errors"
)
// dayWindow 分析窗口归一:零值兜底(From=本月 1 号/To=今天),闭区间转 [lo,hi) 半开。
func dayWindow(from, to time.Time) (time.Time, time.Time) {
now := time.Now()
if to.IsZero() {
to = now
}
hi := time.Date(to.Year(), to.Month(), to.Day(), 0, 0, 0, 0, to.Location()).
AddDate(0, 0, 1) // 含当日
if from.IsZero() {
from = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
}
lo := time.Date(from.Year(), from.Month(), from.Day(), 0, 0, 0, 0, from.Location())
return lo, hi
}
// UserProfitQuery 用户利润查询条件。
type UserProfitQuery struct {
From time.Time // 闭区间起(零值=本月 1 号)
To time.Time // 闭区间止(零值=今天)
ParentID int64 // >0:仅该账号为根的子树(Path 前缀)
Page int
PageSize int
}
// UserProfitRow 单账号利润行。
type UserProfitRow struct {
AccountID int64 `json:"account_id"`
Username string `json:"username"`
Role string `json:"role"`
SuccessCount int64 `json:"success_count"`
Revenue float64 `json:"revenue"` // 应收(元,时间线价)
Cost float64 `json:"cost"` // 通道成本分摊(元)
Rebate float64 `json:"rebate"` // 直线下级返点(R4)
Profit float64 `json:"profit"` // revenue-cost+rebate
}
// UserProfitSummary 汇总(与列表同 scope:parent_id 过滤后)。
type UserProfitSummary struct {
Count int `json:"count"`
TotalRevenue float64 `json:"total_revenue"`
TotalCost float64 `json:"total_cost"`
TotalRebate float64 `json:"total_rebate"`
PlatformProfit float64 `json:"platform_profit"` // Σrevenue-Σcost-Σrebate
}
// UserProfitResult 用户利润结果集。
type UserProfitResult struct {
List []UserProfitRow `json:"list"`
Total int64 `json:"total"`
Summary UserProfitSummary `json:"summary"`
}
// UserProfit 用户利润分析。行集=窗口内有消耗的账号 ∪ 收到返点的上级
// (无自身流量但下级活跃的代理也有行);按 revenue 降序分页(内存排序,
// 账号量级=运营开户数,非明细量级)。
func (s *Service) UserProfit(ctx context.Context, q UserProfitQuery) (*UserProfitResult, error) {
lo, hi := dayWindow(q.From, q.To)
// ① 消耗事实源(账号×业务×天)→ 逐行业务线时间线计价。
var consumes []entity.BillingConsumeLog
if err := s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).
Order("stat_date").Find(&consumes).Error; err != nil {
return nil, err
}
var accounts []entity.AccountUser
if err := s.db.WithContext(ctx).Find(&accounts).Error; err != nil {
return nil, err
}
accByID := make(map[int64]*entity.AccountUser, len(accounts))
for i := range accounts {
accByID[accounts[i].ID] = &accounts[i]
}
byID := make(map[int64]*UserProfitRow)
order := make([]int64, 0)
get := func(id int64) *UserProfitRow {
if r, ok := byID[id]; ok {
return r
}
acc := accByID[id]
if acc == nil { // 软删/孤儿消耗行:不入行集(分摊分母走通道侧)
return nil
}
r := &UserProfitRow{AccountID: id, Username: acc.Username, Role: acc.Role}
byID[id] = r
order = append(order, id)
return r
}
for _, c := range consumes {
r := get(c.AccountID)
if r == nil {
continue
}
r.SuccessCount += int64(c.SuccessCount)
price, _ := s.PriceAtAccount(ctx, c.AccountID, c.Business, c.StatDate)
r.Revenue += float64(c.SuccessCount) * price
}
// ② 通道成本总额 + 通道侧成功总数(分摊分母,与通道利润同源)。
channelCost, channelSuccess, err := s.channelCostTotal(ctx, lo, hi)
if err != nil {
return nil, err
}
for _, id := range order {
r := byID[id]
if channelSuccess > 0 {
r.Cost = channelCost * float64(r.SuccessCount) / float64(channelSuccess)
}
}
// ③ 返点(R4):直线下级窗口结算额×下级 rebate_rate → 计入上级行。
for _, id := range order {
child := byID[id]
if child.Revenue <= 0 {
continue
}
acc := accByID[id]
if acc == nil || acc.RebateRate <= 0 || acc.ParentID <= 0 {
continue
}
if parent := get(acc.ParentID); parent != nil {
parent.Rebate += child.Revenue * acc.RebateRate
}
}
// ④ 子树过滤(Path 物化路径前缀;path 空兜底 "/<id>/")。
if q.ParentID > 0 {
var root entity.AccountUser
if err := s.db.WithContext(ctx).First(&root, q.ParentID).Error; err != nil {
return nil, errs.NotFound.WithMsg("parent_id 账号不存在")
}
prefix := root.Path
if prefix == "" {
prefix = "/" + strconv.FormatInt(root.ID, 10) + "/"
}
filtered := make([]int64, 0, len(order))
for _, id := range order {
if id == root.ID || strings.HasPrefix(accByID[id].Path, prefix) {
filtered = append(filtered, id)
}
}
order = filtered
}
rows := make([]UserProfitRow, 0, len(order))
sum := UserProfitSummary{}
for _, id := range order {
r := byID[id]
r.Profit = r.Revenue - r.Cost + r.Rebate
sum.Count++
sum.TotalRevenue += r.Revenue
sum.TotalCost += r.Cost
sum.TotalRebate += r.Rebate
rows = append(rows, *r)
}
sum.PlatformProfit = sum.TotalRevenue - sum.TotalCost - sum.TotalRebate
sort.Slice(rows, func(i, j int) bool {
if rows[i].Revenue != rows[j].Revenue {
return rows[i].Revenue > rows[j].Revenue
}
return rows[i].AccountID < rows[j].AccountID
})
total := int64(len(rows))
if q.Page <= 0 {
q.Page = 1
}
if q.PageSize <= 0 || q.PageSize > 100 {
q.PageSize = 20
}
start := (q.Page - 1) * q.PageSize
if start >= len(rows) {
rows = []UserProfitRow{}
} else if start+q.PageSize < len(rows) {
rows = rows[start : start+q.PageSize]
} else {
rows = rows[start:]
}
return &UserProfitResult{List: rows, Total: total, Summary: sum}, nil
}
// channelCostTotal 窗口内全平台通道成本(Σ日成功×PriceAtChannel)与通道侧
// 成功总条数(分摊分母)。
func (s *Service) channelCostTotal(ctx context.Context, lo, hi time.Time) (cost float64, success int64, err error) {
var rows []entity.StatsChannelDaily
if err = s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).
Order("stat_date").Find(&rows).Error; err != nil {
return 0, 0, err
}
for _, r := range rows {
success += int64(r.SuccessCount)
price, _ := s.PriceAtChannel(ctx, r.ChannelID, r.StatDate)
cost += float64(r.SuccessCount) * price
}
return cost, success, nil
}
// ChannelProfitQuery 通道利润查询条件。
type ChannelProfitQuery struct {
From time.Time
To time.Time
ChannelID int64 // 0=全部
Page int
PageSize int
}
// ChannelProfitRow 单通道利润行。
type ChannelProfitRow struct {
ChannelID int64 `json:"channel_id"`
Name string `json:"name"`
UpstreamID int64 `json:"upstream_id"`
SuccessCount int64 `json:"success_count"`
Revenue float64 `json:"revenue"` // 全平台用户收入×成功占比(分摊)
Cost float64 `json:"cost"` // Σ日成功×通道时间线价
Profit float64 `json:"profit"`
}
// ChannelProfitResult 通道利润结果集。
type ChannelProfitResult struct {
List []ChannelProfitRow `json:"list"`
Total int64 `json:"total"`
}
// ChannelProfit 通道利润分析:成本=通道价直算;收入=占比分摊(无账号×通道
// 交叉粒度事实源,见文件头注);Σ通道 revenue=Σ用户 revenue 恒成立。
func (s *Service) ChannelProfit(ctx context.Context, q ChannelProfitQuery) (*ChannelProfitResult, error) {
lo, hi := dayWindow(q.From, q.To)
var stats []entity.StatsChannelDaily
db := s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).
Order("stat_date")
if q.ChannelID > 0 {
db = db.Where("channel_id = ?", q.ChannelID)
}
if err := db.Find(&stats).Error; err != nil {
return nil, err
}
var channels []entity.ChannelChannel
if err := s.db.WithContext(ctx).Find(&channels).Error; err != nil {
return nil, err
}
chByID := make(map[int64]*entity.ChannelChannel, len(channels))
for i := range channels {
chByID[channels[i].ID] = &channels[i]
}
// 全平台用户收入与通道侧成功总数(收入分摊分母;不随 channel_id 过滤,保证守恒)。
var totalRevenue float64
var consumes []entity.BillingConsumeLog
if err := s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).Find(&consumes).Error; err != nil {
return nil, err
}
for _, c := range consumes {
price, _ := s.PriceAtAccount(ctx, c.AccountID, c.Business, c.StatDate)
totalRevenue += float64(c.SuccessCount) * price
}
_, channelSuccess, err := s.channelCostTotal(ctx, lo, hi)
if err != nil {
return nil, err
}
byID := map[int64]*ChannelProfitRow{}
order := make([]int64, 0)
for _, r := range stats {
row := byID[r.ChannelID]
if row == nil {
row = &ChannelProfitRow{ChannelID: r.ChannelID}
if ch := chByID[r.ChannelID]; ch != nil {
row.Name, row.UpstreamID = ch.Name, ch.UpstreamID
}
byID[r.ChannelID] = row
order = append(order, r.ChannelID)
}
row.SuccessCount += int64(r.SuccessCount)
price, _ := s.PriceAtChannel(ctx, r.ChannelID, r.StatDate)
row.Cost += float64(r.SuccessCount) * price
}
rows := make([]ChannelProfitRow, 0, len(order))
for _, id := range order {
r := byID[id]
if channelSuccess > 0 {
r.Revenue = totalRevenue * float64(r.SuccessCount) / float64(channelSuccess)
}
r.Profit = r.Revenue - r.Cost
rows = append(rows, *r)
}
sort.Slice(rows, func(i, j int) bool {
if rows[i].SuccessCount != rows[j].SuccessCount {
return rows[i].SuccessCount > rows[j].SuccessCount
}
return rows[i].ChannelID < rows[j].ChannelID
})
total := int64(len(rows))
if q.Page <= 0 {
q.Page = 1
}
if q.PageSize <= 0 || q.PageSize > 100 {
q.PageSize = 20
}
start := (q.Page - 1) * q.PageSize
if start >= len(rows) {
rows = []ChannelProfitRow{}
} else if start+q.PageSize < len(rows) {
rows = rows[start : start+q.PageSize]
} else {
rows = rows[start:]
}
return &ChannelProfitResult{List: rows, Total: total}, nil
}
+241
View File
@@ -0,0 +1,241 @@
package settle
// profit_test.go S2-D5:利润分析单测——时间线价收入/成本占比分摊/直线下级
// 返点(R4,单级)/子树过滤(Path 前缀)/汇总守恒;通道侧成本直算+收入分摊。
// 口径差异声明:阶梯不进分析(与账单金额的差=口径差异,见 profit.go 头注)。
import (
"context"
"testing"
"time"
"gorm.io/gorm"
"go-sms/internal/model/entity"
)
// newProfitDB 出账全家桶 + 账号树。
func newProfitDB(t *testing.T) *gorm.DB {
t.Helper()
db := newBillDB(t)
if err := db.AutoMigrate(&entity.AccountUser{}); err != nil {
t.Fatal(err)
}
return db
}
// seedProfitTree 树:1(root)→{10(rate .10),12(rate 0)};10→11(rate .20)。
// 价:acc1=0.10 / acc10=0.20 / acc11=0.30 / acc12 无价(Q1:0 元入账)。
func seedProfitTree(t *testing.T, db *gorm.DB) {
t.Helper()
d := func(s string) time.Time {
v, _ := time.ParseInLocation("2006-01-02", s, time.Local)
return v
}
if err := db.Create(&[]entity.AccountUser{
{Model: entity.Model{ID: 1}, Username: "root", Role: "group", Path: "/1/"},
{Model: entity.Model{ID: 10}, Username: "a10", Role: "customer", ParentID: 1, Path: "/1/10/", RebateRate: 0.10},
{Model: entity.Model{ID: 11}, Username: "a11", Role: "customer", ParentID: 10, Path: "/1/10/11/", RebateRate: 0.20},
{Model: entity.Model{ID: 12}, Username: "a12", Role: "customer", ParentID: 1, Path: "/1/12/"},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.AccountPrice{
{AccountID: 1, Business: "sms", Price: 0.10, EffectiveAt: d("2026-11-01")},
{AccountID: 10, Business: "sms", Price: 0.20, EffectiveAt: d("2026-11-01")},
{AccountID: 11, Business: "sms", Price: 0.30, EffectiveAt: d("2026-11-01")},
}).Error; err != nil {
t.Fatal(err)
}
}
// seedProfitFlow 消耗(acc1:100/acc10:50/acc11:40/acc12:10 无价)+ 通道侧
// (ch1:150 + ch2:50=200,成本价均 0.04 → 总成本 8)。账号/通道成功总数一致=200。
func seedProfitFlow(t *testing.T, db *gorm.DB) {
t.Helper()
d := func(s string) time.Time {
v, _ := time.ParseInLocation("2006-01-02", s, time.Local)
return v
}
if err := db.Create(&[]entity.BillingConsumeLog{
{AccountID: 1, Business: "sms", StatDate: d("2026-11-10"), SuccessCount: 100},
{AccountID: 10, Business: "sms", StatDate: d("2026-11-10"), SuccessCount: 50},
{AccountID: 11, Business: "sms", StatDate: d("2026-11-20"), SuccessCount: 40},
{AccountID: 12, Business: "sms", StatDate: d("2026-11-10"), SuccessCount: 10},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.ChannelChannel{
{Model: entity.Model{ID: 1}, Name: "c1", Code: "pfc1", UpstreamID: 7},
{Model: entity.Model{ID: 2}, Name: "c2", Code: "pfc2"},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.ChannelPrice{
{ChannelID: 1, Price: 0.04, EffectiveAt: d("2026-11-01")},
{ChannelID: 2, Price: 0.04, EffectiveAt: d("2026-11-01")},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.StatsChannelDaily{
{ChannelID: 1, StatDate: d("2026-11-10"), SuccessCount: 150},
{ChannelID: 2, StatDate: d("2026-11-20"), SuccessCount: 50},
}).Error; err != nil {
t.Fatal(err)
}
}
// findRow 按账号取行。
func findRow(t *testing.T, res *UserProfitResult, id int64) UserProfitRow {
t.Helper()
for _, r := range res.List {
if r.AccountID == id {
return r
}
}
t.Fatalf("账号 %d 不在结果中: %+v", id, res.List)
return UserProfitRow{}
}
// TestProfit_Users 时间线价收入+占比分摊成本+单级返点+子树过滤+平台净利守恒。
//
// 期望:acc1 rev10/cost4/rebate1.0(=子10 rev10×0.10)/profit7;
// acc10 rev10/cost2/rebate2.4(=子11 rev12×0.20)/profit10.4;
// acc11 rev12/cost1.6/profit10.4;acc12 无价 rev0/cost0.4/profit-0.4;
// 汇总 rev32/cost8/rebate3.4/平台净利 32-8-3.4=20.6。
func TestProfit_Users(t *testing.T) {
db := newProfitDB(t)
seedProfitTree(t, db)
seedProfitFlow(t, db)
svc := NewService(db)
ctx := context.Background()
from, _ := time.ParseInLocation("2006-01-02", "2026-11-01", time.Local)
to, _ := time.ParseInLocation("2006-01-02", "2026-11-30", time.Local)
res, err := svc.UserProfit(ctx, UserProfitQuery{From: from, To: to})
if err != nil {
t.Fatal(err)
}
if res.Total != 4 || res.Summary.Count != 4 {
t.Fatalf("行数=%d/%d 期望 4", res.Total, res.Summary.Count)
}
r1 := findRow(t, res, 1)
if r1.SuccessCount != 100 || !feq(r1.Revenue, 10) || !feq(r1.Cost, 4) ||
!feq(r1.Rebate, 1.0) || !feq(r1.Profit, 7) {
t.Fatalf("acc1 错: %+v", r1)
}
r10 := findRow(t, res, 10)
if !feq(r10.Revenue, 10) || !feq(r10.Cost, 2) || !feq(r10.Rebate, 2.4) || !feq(r10.Profit, 10.4) {
t.Fatalf("acc10 错: %+v", r10)
}
r11 := findRow(t, res, 11)
if !feq(r11.Revenue, 12) || !feq(r11.Cost, 1.6) || r11.Rebate != 0 || !feq(r11.Profit, 10.4) {
t.Fatalf("acc11 错: %+v", r11)
}
r12 := findRow(t, res, 12)
if r12.Revenue != 0 || !feq(r12.Cost, 0.4) || !feq(r12.Profit, -0.4) {
t.Fatalf("acc12 错(无价 0 元入账): %+v", r12)
}
s := res.Summary
if !feq(s.TotalRevenue, 32) || !feq(s.TotalCost, 8) || !feq(s.TotalRebate, 3.4) ||
!feq(s.PlatformProfit, 20.6) {
t.Fatalf("汇总错: %+v", s)
}
// 子树过滤 parent_id=10:仅 10/11 两行,汇总随 scope 收窄。
res, err = svc.UserProfit(ctx, UserProfitQuery{From: from, To: to, ParentID: 10})
if err != nil {
t.Fatal(err)
}
if res.Total != 2 || res.Summary.Count != 2 {
t.Fatalf("子树行数=%d 期望 2", res.Total)
}
findRow(t, res, 10)
findRow(t, res, 11)
if !feq(res.Summary.TotalRevenue, 22) || !feq(res.Summary.TotalCost, 3.6) ||
!feq(res.Summary.TotalRebate, 2.4) {
t.Fatalf("子树汇总错: %+v", res.Summary)
}
// parent 不存在 → 404 业务错误。
if _, err := svc.UserProfit(ctx, UserProfitQuery{From: from, To: to, ParentID: 999}); err == nil {
t.Fatal("parent_id=999 应报错")
}
}
// TestProfit_Users_ParentWithoutTraffic 无自身流量的上级也有行(代理纯返点场景)。
func TestProfit_Users_ParentWithoutTraffic(t *testing.T) {
db := newProfitDB(t)
d := func(s string) time.Time {
v, _ := time.ParseInLocation("2006-01-02", s, time.Local)
return v
}
if err := db.Create(&[]entity.AccountUser{
{Model: entity.Model{ID: 20}, Username: "agent", Role: "group", Path: "/20/"},
{Model: entity.Model{ID: 21}, Username: "c21", Role: "customer", ParentID: 20, Path: "/20/21/", RebateRate: 0.5},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.AccountPrice{
{AccountID: 21, Business: "sms", Price: 0.10, EffectiveAt: d("2026-11-01")},
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.BillingConsumeLog{
{AccountID: 21, Business: "sms", StatDate: d("2026-11-10"), SuccessCount: 100},
}).Error; err != nil {
t.Fatal(err)
}
res, err := NewService(db).UserProfit(context.Background(), UserProfitQuery{
From: d("2026-11-01"), To: d("2026-11-30"),
})
if err != nil {
t.Fatal(err)
}
if res.Total != 2 {
t.Fatalf("行数=%d 期望 2(agent+c21)", res.Total)
}
agent := findRow(t, res, 20)
if agent.SuccessCount != 0 || agent.Revenue != 0 || !feq(agent.Rebate, 5.0) || !feq(agent.Profit, 5.0) {
t.Fatalf("agent 行错(纯返点): %+v", agent)
}
}
// TestProfit_Channels 通道成本直算+收入占比分摊+channel_id 过滤。
// ch1: succ150 cost6(150×0.04) rev24(32×150/200) profit18;
// ch2: succ50 cost2 rev8 profit6。
func TestProfit_Channels(t *testing.T) {
db := newProfitDB(t)
seedProfitTree(t, db)
seedProfitFlow(t, db)
svc := NewService(db)
ctx := context.Background()
from, _ := time.ParseInLocation("2006-01-02", "2026-11-01", time.Local)
to, _ := time.ParseInLocation("2006-01-02", "2026-11-30", time.Local)
res, err := svc.ChannelProfit(ctx, ChannelProfitQuery{From: from, To: to})
if err != nil {
t.Fatal(err)
}
if res.Total != 2 {
t.Fatalf("通道行数=%d 期望 2", res.Total)
}
if res.List[0].ChannelID != 1 { // succ 降序
t.Fatalf("排序错: %+v", res.List)
}
c1 := res.List[0]
if c1.Name != "c1" || c1.UpstreamID != 7 || c1.SuccessCount != 150 ||
!feq(c1.Cost, 6) || !feq(c1.Revenue, 24) || !feq(c1.Profit, 18) {
t.Fatalf("ch1 错: %+v", c1)
}
c2 := res.List[1]
if !feq(c2.Cost, 2) || !feq(c2.Revenue, 8) || !feq(c2.Profit, 6) {
t.Fatalf("ch2 错: %+v", c2)
}
// channel_id 过滤。
res, err = svc.ChannelProfit(ctx, ChannelProfitQuery{From: from, To: to, ChannelID: 2})
if err != nil || res.Total != 1 || res.List[0].ChannelID != 2 {
t.Fatalf("过滤错: %+v err=%v", res, err)
}
}
+236
View File
@@ -0,0 +1,236 @@
// reconcile.go S2-D5:三方对账——明细直查 vs 日汇总(R2 事实源)vs 结算单,
// diff=0 为 S2 泳道出口判据(《重建计划》S2 行)。
//
// 比对口径(全部为**条数**,status=2 成功侧):
// - 账号三方:message_detail 直查聚合 ↔ billing_consume_log 月和 ↔
// settle_customer.success_count(有单才比;未生成=流程状态,BillMissing
// 单列不判失败);
// - 通道两方:message_detail 直查聚合 ↔ stats_channel_daily 月和;
// - 上家:settle_upstream 快照 ↔ 日汇总×**当前**通道归并/billing_mode 重推
// (Q4/Q6 快照语义:生成后换绑/改模式/重刷会如实暴露差异——这正是对账目的);
// - 金额不比:结算单金额是出账时点价/阶梯快照(Q6),事后调价重算必生噪音;
// 金额核对走账单导出 XLSX 人工比对(D4 已验)。
//
// 注意:明细热窗仅 5 天(S4 分区规划)——历史月的"明细直查"侧在数据清退后
// 不再完整,届时对账基线=日汇总 vs 结算单两方;当前 dev 明细全量在库。
package settle
import (
"context"
"time"
"go-sms/internal/model/entity"
)
// ReconcileSummary 对账汇总计数。
type ReconcileSummary struct {
AccountsChecked int `json:"accounts_checked"` // 账号并集(明细∪汇总∪账单)
AccountDiffs int `json:"account_diffs"` // 账号侧差异行数
BillMissing int `json:"bill_missing"` // 有消耗无账单(流程状态,不判失败)
ChannelsChecked int `json:"channels_checked"` // 通道并集(明细∪汇总)
ChannelDiffs int `json:"channel_diffs"` // 通道侧差异行数
UpstreamsChecked int `json:"upstreams_checked"` // 上家并集(重推∪账单)
UpstreamDiffs int `json:"upstream_diffs"` // 上家侧差异行数(缺账单不计入)
AllZero bool `json:"all_zero"` // 三方差异全零(S2 出口判据)
}
// AccountDiffRow 账号对账行(仅差异/缺单账号入列)。
type AccountDiffRow struct {
AccountID int64 `json:"account_id"`
DetailSuccess int64 `json:"detail_success"` // 明细直查
ConsumeSuccess int64 `json:"consume_success"` // 日汇总
BillSuccess *int64 `json:"bill_success"` // 结算单(nil=未生成)
}
// ChannelDiffRow 通道对账行(仅差异通道入列)。
type ChannelDiffRow struct {
ChannelID int64 `json:"channel_id"`
DetailSuccess int64 `json:"detail_success"`
DailySuccess int64 `json:"daily_success"`
}
// UpstreamDiffRow 上家对账行(差异/缺单入列;重推=当前归并×当前口径)。
type UpstreamDiffRow struct {
UpstreamID int64 `json:"upstream_id"`
DailyCount int64 `json:"daily_count"` // 日汇总重推
BillSuccess *int64 `json:"bill_success"` // 账单快照(nil=未生成)
}
// ReconcileReport 对账报告(AsOf 时点;rows 仅异常行,全对=空)。
type ReconcileReport struct {
Period string `json:"period"`
AsOf time.Time `json:"as_of"`
Accounts []AccountDiffRow `json:"accounts"`
Channels []ChannelDiffRow `json:"channels"`
Upstreams []UpstreamDiffRow `json:"upstreams"`
Summary ReconcileSummary `json:"summary"`
}
// successAgg 明细直查聚合 DTO。
type successAgg struct {
ID int64
N int64
}
// detailSuccessBy 明细直查:窗口内按 key 维度聚合成功条数(ground truth)。
func (s *Service) detailSuccessBy(ctx context.Context, lo, hi time.Time, key string) (map[int64]int64, error) {
var rows []successAgg
if err := s.db.WithContext(ctx).Table("message_detail").
Select(key+" AS id, COALESCE(SUM(status = 2), 0) AS n").
Where("created_at >= ? AND created_at < ?", lo, hi).
Group(key).Scan(&rows).Error; err != nil {
return nil, err
}
out := make(map[int64]int64, len(rows))
for _, r := range rows {
out[r.ID] = r.N
}
return out, nil
}
// ReconcilePeriod 三方对账(period=YYYY-MM)。
func (s *Service) ReconcilePeriod(ctx context.Context, period string) (*ReconcileReport, error) {
lo, hi, err := PeriodBounds(period)
if err != nil {
return nil, err
}
rep := &ReconcileReport{Period: period, AsOf: time.Now(),
Accounts: []AccountDiffRow{}, Channels: []ChannelDiffRow{}, Upstreams: []UpstreamDiffRow{}}
// ① 账号三方:明细直查 ↔ 消耗日汇总 ↔ 下家结算单。
detailAcc, err := s.detailSuccessBy(ctx, lo, hi, "account_id")
if err != nil {
return nil, err
}
consumeAcc := map[int64]int64{}
var consumeRows []entity.BillingConsumeLog
if err := s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).Find(&consumeRows).Error; err != nil {
return nil, err
}
for _, r := range consumeRows {
consumeAcc[r.AccountID] += int64(r.SuccessCount)
}
var bills []entity.SettleCustomer
if err := s.db.WithContext(ctx).
Where("period = ?", period).Find(&bills).Error; err != nil {
return nil, err
}
billAcc := map[int64]entity.SettleCustomer{}
for _, b := range bills {
billAcc[b.AccountID] = b
}
accUnion := map[int64]struct{}{}
for id := range detailAcc {
accUnion[id] = struct{}{}
}
for id := range consumeAcc {
accUnion[id] = struct{}{}
}
for id := range billAcc {
accUnion[id] = struct{}{}
}
rep.Summary.AccountsChecked = len(accUnion)
for id := range accUnion {
d, c := detailAcc[id], consumeAcc[id]
bill, hasBill := billAcc[id]
billMismatch := hasBill && int64(bill.SuccessCount) != c
if d != c || billMismatch {
row := AccountDiffRow{AccountID: id, DetailSuccess: d, ConsumeSuccess: c}
if hasBill {
bs := int64(bill.SuccessCount)
row.BillSuccess = &bs
}
rep.Accounts = append(rep.Accounts, row)
rep.Summary.AccountDiffs++
} else if !hasBill {
rep.Accounts = append(rep.Accounts,
AccountDiffRow{AccountID: id, DetailSuccess: d, ConsumeSuccess: c})
rep.Summary.BillMissing++
}
}
// ② 通道两方:明细直查 ↔ 通道日汇总。
detailCh, err := s.detailSuccessBy(ctx, lo, hi, "channel_id")
if err != nil {
return nil, err
}
dailyCh := map[int64]int64{}
var statRows []entity.StatsChannelDaily
if err := s.db.WithContext(ctx).
Where("stat_date >= ? AND stat_date < ?", lo, hi).Find(&statRows).Error; err != nil {
return nil, err
}
for _, r := range statRows {
dailyCh[r.ChannelID] += int64(r.SuccessCount)
}
chUnion := map[int64]struct{}{}
for id := range detailCh {
chUnion[id] = struct{}{}
}
for id := range dailyCh {
chUnion[id] = struct{}{}
}
rep.Summary.ChannelsChecked = len(chUnion)
for id := range chUnion {
if detailCh[id] != dailyCh[id] {
rep.Channels = append(rep.Channels,
ChannelDiffRow{ChannelID: id, DetailSuccess: detailCh[id], DailySuccess: dailyCh[id]})
rep.Summary.ChannelDiffs++
}
}
// ③ 上家:日汇总×当前归并/口径重推 ↔ 账单快照。
dailyUp := map[int64]int64{}
var channels []entity.ChannelChannel
if err := s.db.WithContext(ctx).Find(&channels).Error; err != nil {
return nil, err
}
modeOf := map[int64]string{}
upstreamOf := map[int64]int64{}
for _, ch := range channels {
modeOf[ch.ID] = ch.BillingMode
upstreamOf[ch.ID] = ch.UpstreamID
}
for _, r := range statRows {
uid := upstreamOf[r.ChannelID]
if uid == 0 {
continue
}
dailyUp[uid] += int64(billableCount(modeOf[r.ChannelID], r))
}
var upBills []entity.SettleUpstream
if err := s.db.WithContext(ctx).
Where("period = ?", period).Find(&upBills).Error; err != nil {
return nil, err
}
billUp := map[int64]entity.SettleUpstream{}
for _, b := range upBills {
billUp[b.UpstreamID] = b
}
upUnion := map[int64]struct{}{}
for id := range dailyUp {
upUnion[id] = struct{}{}
}
for id := range billUp {
upUnion[id] = struct{}{}
}
rep.Summary.UpstreamsChecked = len(upUnion)
for id := range upUnion {
bill, hasBill := billUp[id]
if hasBill && int64(bill.SuccessCount) != dailyUp[id] {
bs := int64(bill.SuccessCount)
rep.Upstreams = append(rep.Upstreams,
UpstreamDiffRow{UpstreamID: id, DailyCount: dailyUp[id], BillSuccess: &bs})
rep.Summary.UpstreamDiffs++
} else if !hasBill {
// 有日汇总无账单:与账号侧 BillMissing 同语义,列行不计数。
rep.Upstreams = append(rep.Upstreams,
UpstreamDiffRow{UpstreamID: id, DailyCount: dailyUp[id]})
}
}
rep.Summary.AllZero = rep.Summary.AccountDiffs == 0 &&
rep.Summary.ChannelDiffs == 0 && rep.Summary.UpstreamDiffs == 0
return rep, nil
}
+175
View File
@@ -0,0 +1,175 @@
package settle
// reconcile_test.go S2-D5:三方对账单测——全链一致性(明细→日汇总→账单)
// diff=0;篡改各事实源逐项暴露差异;缺账单=流程状态不判失败。
import (
"context"
"testing"
"time"
"gorm.io/gorm"
"go-sms/internal/model/entity"
)
// seedReconcile 全链种子:明细(11-10:acc1 ch1 2成功+1未知;acc2 ch2 1成功)
// → AggregateDay → 双向出账。ch1 绑上家 7 且 success_unknown 口径,ch2 绑 7 默认 success。
func seedReconcile(t *testing.T, db *gorm.DB) {
t.Helper()
day, _ := time.ParseInLocation("2006-01-02 15:04", "2026-11-10 12:00", time.Local)
details := []entity.MessageDetail{
{SnowflakeModel: entity.SnowflakeModel{ID: 9200000001, CreatedAt: day},
TaskID: 900001, AccountID: 1, ChannelID: 1, Mobile: "13000000001",
Content: "t", Status: 2, Business: "sms", Fee: 1},
{SnowflakeModel: entity.SnowflakeModel{ID: 9200000002, CreatedAt: day},
TaskID: 900002, AccountID: 1, ChannelID: 1, Mobile: "13000000002",
Content: "t", Status: 2, Business: "sms", Fee: 1},
{SnowflakeModel: entity.SnowflakeModel{ID: 9200000003, CreatedAt: day},
TaskID: 900003, AccountID: 1, ChannelID: 1, Mobile: "13000000003",
Content: "t", Status: 4, Business: "sms", Fee: 1},
{SnowflakeModel: entity.SnowflakeModel{ID: 9200000004, CreatedAt: day},
TaskID: 900004, AccountID: 2, ChannelID: 2, Mobile: "13000000004",
Content: "t", Status: 2, Business: "sms", Fee: 1},
}
if err := db.Create(&details).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&[]entity.ChannelChannel{
{Model: entity.Model{ID: 1}, Name: "c1", Code: "rcc1", UpstreamID: 7, BillingMode: "success_unknown"},
{Model: entity.Model{ID: 2}, Name: "c2", Code: "rcc2", UpstreamID: 7},
}).Error; err != nil {
t.Fatal(err)
}
svc := NewService(db)
ctx := context.Background()
if _, _, err := svc.AggregateDay(ctx, day); err != nil {
t.Fatal(err)
}
if _, err := svc.GenerateCustomerBills(ctx, "2026-11"); err != nil {
t.Fatal(err)
}
if _, err := svc.GenerateUpstreamBills(ctx, "2026-11"); err != nil {
t.Fatal(err)
}
}
// TestReconcile_AllZero 全链一致:三方零差异(S2 出口判据)。
// 账号:acc1 明细2=汇总2=账单2;acc2 1=1=1。通道:ch1 2=2;ch2 1=1。
// 上家 7:重推(2+1未知)+(1)=4=账单 4。
func TestReconcile_AllZero(t *testing.T) {
db := newBillDB(t)
seedReconcile(t, db)
rep, err := NewService(db).ReconcilePeriod(context.Background(), "2026-11")
if err != nil {
t.Fatal(err)
}
s := rep.Summary
if !s.AllZero || s.AccountDiffs != 0 || s.ChannelDiffs != 0 || s.UpstreamDiffs != 0 {
t.Fatalf("应全零: %+v rows=%+v/%+v/%+v", s, rep.Accounts, rep.Channels, rep.Upstreams)
}
if s.AccountsChecked != 2 || s.BillMissing != 0 || s.ChannelsChecked != 2 || s.UpstreamsChecked != 1 {
t.Fatalf("checked 计数错: %+v", s)
}
var bill1, bill2 entity.SettleCustomer
var up7 entity.SettleUpstream
if err := db.Where("account_id = 1").First(&bill1).Error; err != nil {
t.Fatal(err)
}
if err := db.Where("account_id = 2").First(&bill2).Error; err != nil {
t.Fatal(err)
}
if err := db.Where("upstream_id = 7").First(&up7).Error; err != nil {
t.Fatal(err)
}
if bill1.SuccessCount != 2 || bill2.SuccessCount != 1 || up7.SuccessCount != 4 {
t.Fatalf("账单快照错: %+v/%+v/%+v", bill1, bill2, up7)
}
}
// TestReconcile_ExposesDiffs 篡改三处事实源逐项暴露:
// ①consume acc1 success 2→5 → AccountDiffs=1(明细2/汇总5/账单2 同行列出);
// ②stats ch1 success 2→9 → ChannelDiffs=1(明细2/日汇总9)+ 上家重推(9+1)+1=11
//
// vs 账单4 → UpstreamDiffs=1;③删 acc2 账单 → BillMissing=1 且 AllZero 仍真
// (在①②还原后单独验证:此处先验证 missing 计数,AllZero 断言只看 diffs)。
func TestReconcile_ExposesDiffs(t *testing.T) {
db := newBillDB(t)
seedReconcile(t, db)
svc := NewService(db)
ctx := context.Background()
// ① 篡改消耗日汇总。
if err := db.Model(&entity.BillingConsumeLog{}).
Where("account_id = 1").Update("success_count", 5).Error; err != nil {
t.Fatal(err)
}
// ② 篡改通道日汇总。
if err := db.Model(&entity.StatsChannelDaily{}).
Where("channel_id = 1").Update("success_count", 9).Error; err != nil {
t.Fatal(err)
}
rep, err := svc.ReconcilePeriod(ctx, "2026-11")
if err != nil {
t.Fatal(err)
}
if rep.Summary.AccountDiffs != 1 || len(rep.Accounts) != 1 {
t.Fatalf("账号差异应 1 行: %+v rows=%+v", rep.Summary, rep.Accounts)
}
a := rep.Accounts[0]
if a.AccountID != 1 || a.DetailSuccess != 2 || a.ConsumeSuccess != 5 ||
a.BillSuccess == nil || *a.BillSuccess != 2 {
t.Fatalf("账号差异行错: %+v", a)
}
if rep.Summary.ChannelDiffs != 1 || len(rep.Channels) != 1 ||
rep.Channels[0].ChannelID != 1 || rep.Channels[0].DetailSuccess != 2 || rep.Channels[0].DailySuccess != 9 {
t.Fatalf("通道差异行错: %+v", rep.Channels)
}
if rep.Summary.UpstreamDiffs != 1 || len(rep.Upstreams) != 1 {
t.Fatalf("上家差异应 1 行: %+v", rep.Upstreams)
}
u := rep.Upstreams[0]
if u.UpstreamID != 7 || u.DailyCount != 11 || u.BillSuccess == nil || *u.BillSuccess != 4 {
t.Fatalf("上家差异行错(重推 9+1未知+1=11 vs 账单 4): %+v", u)
}
if rep.Summary.AllZero {
t.Fatal("存在差异时 AllZero 应为 false")
}
// ③ 还原①②后删下家账单:BillMissing=1,但 diffs 全零 → AllZero 仍真。
if err := db.Model(&entity.BillingConsumeLog{}).
Where("account_id = 1").Update("success_count", 2).Error; err != nil {
t.Fatal(err)
}
if err := db.Model(&entity.StatsChannelDaily{}).
Where("channel_id = 1").Update("success_count", 2).Error; err != nil {
t.Fatal(err)
}
if err := db.Where("account_id = 2").Delete(&entity.SettleCustomer{}).Error; err != nil {
t.Fatal(err)
}
rep, err = svc.ReconcilePeriod(ctx, "2026-11")
if err != nil {
t.Fatal(err)
}
if rep.Summary.BillMissing != 1 || rep.Summary.AccountDiffs != 0 {
t.Fatalf("缺账单应 BillMissing=1 且 diffs=0: %+v", rep.Summary)
}
if !rep.Summary.AllZero {
t.Fatalf("缺账单=流程状态,不应判失败: %+v", rep.Summary)
}
var missing int
for _, r := range rep.Accounts {
if r.AccountID == 2 && r.BillSuccess == nil {
missing++
}
}
if missing != 1 {
t.Fatalf("acc2 应以 bill_success=nil 列出: %+v", rep.Accounts)
}
// ④ 非法 period → ISC:400。
if _, err := svc.ReconcilePeriod(ctx, "2026-1"); err == nil {
t.Fatal("非法 period 应报错")
}
}
+145
View File
@@ -0,0 +1,145 @@
// blacklist.go S4·C2:上行自动拉黑——回复「R/退订/拒收」等(词表 SystemConfig
// 可配,等值匹配)→ 写 policy_blacklist(source=2 上行拒收,账号级=归属账号)
// + Redis 黑名单缓存即时生效(拦截链检测 IN (0, account_id),下一单即拦)。
// 语义(需求 2.5/实施计划 5.7):拉黑不影响上行推送与 message_uplink 记录。
package uplink
import (
"context"
"strings"
"sync"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go-sms/internal/pkg/metrics"
"go-sms/internal/service/interceptor"
"go.uber.org/zap"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"github.com/redis/go-redis/v9"
)
// CfgKeyBlacklistWords 拉黑词表 SystemConfig 键(逗号分隔;等值匹配,
// 大小写不敏感;未配置=默认词表)。
const CfgKeyBlacklistWords = "uplink.blacklist.keywords"
// DefaultBlacklistWords 默认拉黑词表(需求原文「回复"拒收"等」+通用退订惯例)。
var DefaultBlacklistWords = []string{"R", "TD", "退订", "拒收"}
// defaultReloadEvery 词表刷新周期(运营改配置最迟生效窗口)。
const defaultReloadEvery = 60 * time.Second
// AutoBlacklister 上行自动拉黑器(词表内存缓存+定时刷新)。
type AutoBlacklister struct {
db *gorm.DB
rdb redis.UniversalClient
mu sync.RWMutex
words map[string]struct{} // lower(trim(word))
}
// NewAutoBlacklister 构造(首次 Reload 失败仅记日志,用默认词表)。
func NewAutoBlacklister(db *gorm.DB, rdb redis.UniversalClient) *AutoBlacklister {
b := &AutoBlacklister{db: db, rdb: rdb, words: lowerSet(DefaultBlacklistWords)}
if err := b.Reload(context.Background()); err != nil {
logger.L().Warn("uplink_blacklist_reload_failed_use_default", zap.Error(err))
}
return b
}
func lowerSet(words []string) map[string]struct{} {
m := make(map[string]struct{}, len(words))
for _, w := range words {
if w = strings.ToLower(strings.TrimSpace(w)); w != "" {
m[w] = struct{}{}
}
}
return m
}
// Reload 从 SystemConfig 重载词表(空/缺省行=默认词表)。
func (b *AutoBlacklister) Reload(ctx context.Context) error {
var row entity.SystemConfig
err := b.db.WithContext(ctx).
Where("cfg_key = ?", CfgKeyBlacklistWords).First(&row).Error
if err != nil {
if err == gorm.ErrRecordNotFound {
b.mu.Lock()
b.words = lowerSet(DefaultBlacklistWords)
b.mu.Unlock()
return nil
}
return err
}
parts := strings.Split(row.CfgValue, ",")
words := lowerSet(parts)
if len(words) == 0 {
words = lowerSet(DefaultBlacklistWords)
}
b.mu.Lock()
b.words = words
b.mu.Unlock()
return nil
}
// Start 定时刷新(caller 起 goroutine;ctx 取消即退出)。
func (b *AutoBlacklister) Start(ctx context.Context) {
t := time.NewTicker(defaultReloadEvery)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
if err := b.Reload(ctx); err != nil {
logger.L().Warn("uplink_blacklist_reload_failed", zap.Error(err))
}
}
}
}
// hit 内容等值命中(trim+lower;非前缀/包含,防正常回复误伤)。
func (b *AutoBlacklister) hit(content string) bool {
w := strings.ToLower(strings.TrimSpace(content))
if w == "" {
return false
}
b.mu.RLock()
defer b.mu.RUnlock()
_, ok := b.words[w]
return ok
}
// MaybeBlock 拉黑判定+落库:命中词表→INSERT policy_blacklist(uk 幂等,
// OnConflict DoNothing)→ Redis 缓存即时生效。返回是否新增(已存在=幂等跳过)。
func (b *AutoBlacklister) MaybeBlock(ctx context.Context, accountID int64, mobile, content string) bool {
if !b.hit(content) {
return false
}
row := entity.PolicyBlacklist{
Mobile: mobile, Source: 2, AccountID: accountID, Operator: "uplink-auto",
}
res := b.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}).
Create(&row)
if res.Error != nil {
logger.L().Warn("uplink_blacklist_insert_failed",
zap.Int64("account_id", accountID), zap.String("mobile", mobile), zap.Error(res.Error))
return false
}
if res.RowsAffected == 0 {
return false // 已在黑名单(手工/先前拉黑):幂等跳过
}
metrics.CallbackBlacklistTotal.Inc()
if b.rdb != nil {
if err := interceptor.AddBlacklistCache(ctx, b.rdb, mobile); err != nil {
logger.L().Warn("uplink_blacklist_cache_add_failed", zap.String("mobile", mobile), zap.Error(err))
}
}
logger.L().Info("uplink_blacklist_added",
zap.Int64("account_id", accountID), zap.String("mobile", mobile),
zap.String("content", content))
return true
}
+158
View File
@@ -0,0 +1,158 @@
// blacklist_test.go S4·C2:上行自动拉黑——词表匹配/SystemConfig 可配/
// 落库幂等/Redis 缓存即时生效。
package uplink
import (
"context"
"encoding/json"
"testing"
"go-sms/internal/model/entity"
"go-sms/internal/service/interceptor"
"github.com/alicebob/miniredis/v2"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
func newBlacklistDB(t *testing.T) *gorm.DB {
t.Helper()
db := newTestDB(t)
if err := db.AutoMigrate(&entity.PolicyBlacklist{}, &entity.SystemConfig{}); err != nil {
t.Fatalf("AutoMigrate 失败: %v", err)
}
return db
}
func mustJSON(t *testing.T, v any) []byte {
t.Helper()
b, err := json.Marshal(v)
if err != nil {
t.Fatal(err)
}
return b
}
// TestBlacklistHit 词表等值匹配:R/r/退订/拒收 命中;含字/空/正常回复不误伤。
func TestBlacklistHit(t *testing.T) {
db := newBlacklistDB(t)
b := NewAutoBlacklister(db, nil)
cases := []struct {
content string
want bool
}{
{"R", true}, {"r", true}, {" R ", true},
{"TD", true}, {"退订", true}, {"拒收", true},
{"我要退订", false}, {"请别再发了", false}, {"", false}, {"RR", false},
}
for _, c := range cases {
if got := b.hit(c.content); got != c.want {
t.Fatalf("hit(%q)=%v 期望 %v", c.content, got, c.want)
}
}
}
// TestBlacklistReload SystemConfig 词表覆盖默认(等值;去掉 R 只认「回T」)。
func TestBlacklistReload(t *testing.T) {
db := newBlacklistDB(t)
db.Create(&entity.SystemConfig{CfgKey: CfgKeyBlacklistWords, CfgValue: "回T, N"})
b := NewAutoBlacklister(db, nil)
if err := b.Reload(context.Background()); err != nil {
t.Fatal(err)
}
if !b.hit("回T") || !b.hit("n") {
t.Fatal("自定义词表未生效")
}
if b.hit("R") {
t.Fatal("自定义词表应替换默认(R 不应命中)")
}
// 空配置回落默认词表。
db.Model(&entity.SystemConfig{}).Where("cfg_key = ?", CfgKeyBlacklistWords).
Update("cfg_value", " , ")
if err := b.Reload(context.Background()); err != nil {
t.Fatal(err)
}
if !b.hit("R") {
t.Fatal("空配置应回落默认词表")
}
}
// TestMaybeBlockIdempotent 拉黑落库幂等+Redis 缓存即时生效(uk 冲突跳过)。
func TestMaybeBlockIdempotent(t *testing.T) {
db := newBlacklistDB(t)
mr := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
b := NewAutoBlacklister(db, rdb)
if !b.MaybeBlock(context.Background(), 5, "13800001111", "R") {
t.Fatal("首次拉黑应返回 true")
}
if b.MaybeBlock(context.Background(), 5, "13800001111", "R") {
t.Fatal("重复拉黑应幂等跳过(false)")
}
var rows []entity.PolicyBlacklist
db.Find(&rows)
if len(rows) != 1 || rows[0].Source != 2 || rows[0].AccountID != 5 || rows[0].Operator != "uplink-auto" {
t.Fatalf("拉黑行异常: %+v", rows)
}
n, err := rdb.SIsMember(context.Background(), interceptor.BlacklistCacheKey, "13800001111").Result()
if err != nil || !n {
t.Fatalf("Redis 黑名单缓存未生效: n=%v err=%v", n, err)
}
// 非拉黑词:零副作用。
if b.MaybeBlock(context.Background(), 5, "13800002222", "收到谢谢") {
t.Fatal("非拉黑词不应触发")
}
var cnt int64
db.Model(&entity.PolicyBlacklist{}).Count(&cnt)
if cnt != 1 {
t.Fatalf("不应新增行, got %d", cnt)
}
}
// TestConsumerBlacklistAndPush 消费链挂点:拒收词→拉黑(不影响推送)+ 推送入队。
func TestConsumerBlacklistAndPush(t *testing.T) {
db := newBlacklistDB(t)
if err := db.AutoMigrate(&entity.CallbackTask{}, &entity.AccountConfig{}); err != nil {
t.Fatalf("AutoMigrate 失败: %v", err)
}
db.Create(&entity.AccountConfig{AccountID: 5, Business: "sms", UplinkURL: "http://cb/mo"})
b := NewAutoBlacklister(db, nil)
// 推送出口打桩:捕获上行载荷。
got := make(chan string, 1)
c := NewConsumer(db).WithBlacklist(b).WithCallback(stubUplinkEnq{got})
payload := mustJSON(t, Event{
UplinkID: 9, DestCode: "10690", SrcMobile: "13900001111",
Content: "R", AccountID: 5, ChannelID: 7,
RecvAt: "2026-11-16T10:00:00+08:00",
})
if err := c.HandlePayload(context.Background(), payload); err != nil {
t.Fatal(err)
}
// 拉黑生效(source=2)。
var bl entity.PolicyBlacklist
if err := db.Where("mobile = ?", "13900001111").First(&bl).Error; err != nil {
t.Fatalf("拒收未拉黑: %v", err)
}
if bl.Source != 2 || bl.AccountID != 5 {
t.Fatalf("拉黑行异常: %+v", bl)
}
// 推送不因拉黑中断。
select {
case p := <-got:
if p == "" {
t.Fatal("推送载荷为空")
}
default:
t.Fatal("上行推送未触发")
}
}
type stubUplinkEnq struct{ ch chan string }
func (s stubUplinkEnq) EnqueueUplink(_ context.Context, uplinkID, accountID int64,
destCode, srcMobile, content, recvAt string) error {
s.ch <- srcMobile + ":" + content
return nil
}
+42 -2
View File
@@ -1,6 +1,8 @@
// consumer.go Day 49:sms-up 消费者——15 天窗口匹配下行明细,回填
// message_uplink.match_task_id(需求 2.5"只匹配 15 天内发送数据")。
// 客户推送(CMPP 优先/HTTP,uplink_url)与上行自动拉黑属阶段 5(Day 54)。
// S4 落地:C1 上行推送(WithCallback→callback.Service,账号 uplink_url)+
// C2 自动拉黑(WithBlacklist→AutoBlacklister,blacklist.go);两者均不
// 阻断匹配回填主链,失败 Warn 吞错。
package uplink
import (
@@ -9,28 +11,66 @@ import (
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go.uber.org/zap"
"gorm.io/gorm"
)
// MatchWindow 上行↔下行匹配窗口(15 天,需求 2.5)。
const MatchWindow = 15 * 24 * time.Hour
// UplinkEnqueuer 上行 HTTP 回调入队出口(S4·C1;装配层注入 *callback.Service)。
type UplinkEnqueuer interface {
EnqueueUplink(ctx context.Context, uplinkID, accountID int64,
destCode, srcMobile, content, recvAt string) error
}
// Consumer sms-up 消费者。
type Consumer struct {
db *gorm.DB
cb UplinkEnqueuer // S4·C1 上行推送(nil=跳过)
bl *AutoBlacklister // S4·C2 自动拉黑(nil=跳过)
}
// NewConsumer 构造。
func NewConsumer(db *gorm.DB) *Consumer { return &Consumer{db: db} }
// WithCallback 注入上行推送出口(链式,nil=跳过)。
func (c *Consumer) WithCallback(e UplinkEnqueuer) *Consumer {
c.cb = e
return c
}
// WithBlacklist 注入自动拉黑器(链式,nil=跳过)。
func (c *Consumer) WithBlacklist(b *AutoBlacklister) *Consumer {
c.bl = b
return c
}
// HandlePayload 消费入口(Kafka handler;载荷即 Event JSON)。
func (c *Consumer) HandlePayload(_ context.Context, value []byte) error {
var ev Event
if err := json.Unmarshal(value, &ev); err != nil {
return err // 非法载荷交由消费组重试→死信(与 submit 消费者同口径)
}
return c.MatchAndFill(context.Background(), &ev)
ctx := context.Background()
if err := c.MatchAndFill(ctx, &ev); err != nil {
return err
}
// S4·C2:拒收即拉黑(先于推送;拉黑不影响推送——需求原文语义)。
if c.bl != nil {
c.bl.MaybeBlock(ctx, ev.AccountID, ev.SrcMobile, ev.Content)
}
// S4·C1:上行推送(未配置 uplink_url 的账号零任务)。
if c.cb != nil {
if err := c.cb.EnqueueUplink(ctx, ev.UplinkID, ev.AccountID,
ev.DestCode, ev.SrcMobile, ev.Content, ev.RecvAt); err != nil {
logger.L().Warn("callback_uplink_enqueue_failed",
zap.Int64("uplink_id", ev.UplinkID), zap.Error(err))
}
}
return nil
}
// MatchAndFill 匹配并回填:同账号+同手机号、recv_at 前 15 天窗口内最近一条
+14 -9
View File
@@ -1,15 +1,20 @@
# 当前工作上下文(最近更新:2026-11-14)
# 当前工作上下文(最近更新:2026-11-16)
## 当前状态快照(2026-11-14 深夜,**S2-D4 收官,进度 4/5**)
## 当前状态快照(2026-11-16,**S4 D1/D2 完成,一期 17/27 计划日**)
- **仓库**:main 已推 Gitea;每日 bundle+push 双轨。
- **S2 进度 4/5**:D1 表设计+v20+契约 / D2 消耗日汇总(滚动重刷)/ D3 充值审核流 / **D4 ✅ 出账引擎+阶梯**——price.go(R1/R6 唯一换算:业务线×时间线回溯+阶梯月量落档)+bill.go(下家/上家生成-确认-结账+SettleRecord+ladder CRUD)+export.go XLSX 双导出+15 端点;**阶梯结算单测全绿(S2 显式验收项)**+上家 billing_mode 三口径+状态机终态幂等;真机出账全链(时间线 10→阶梯覆写 5→结账快照→真 XLSX 5637B)。D4-0 六口径(Q1~Q6)经方案批准生效。
- **⚠️ 流程补正在途**:七件套「本人走查」项——**结算验收页已上线**(浏览器 :5173 登录 s2demo/S2demo@2026 → 统计结算/结算管理,Playwright 预走查真库闭环已过:余额+1000/账单 1955.00 分毫不差),**待用户页面走查后回填**;curl 脚本 `docs/acceptance/scripts/s2-walkthrough.sh` 保留作回归。**casbin 留痕:SQL 直插 g 规则需重启 gateway 生效**。
- **24h 稳定性门槛 ✅ 终判通过**(S1 完全闭环,S5 压测前置确认)。
- **六项裁决速查**:R1/R6 换算只在 price.go(已落地)/R2 事实源 D2 落账/R3 双通道 D3 落地(ref_id 区分)/R4 rebate_rate(D5 消费)/R5 settle_ladder(D4 落地)。
- **下一步=S2-D5 利润/返点/三方对账(S2 收官)**:profit.go(用户利润含下级树 Path 聚合+通道利润+rebate 计算,R4 历史不重算)+reconcile.go(三方=明细直查 vs 日汇总 vs 结算单,diff=0=S2 出口)+cmd/reconcile settle-check 子命令+/stats/profit 双端点;收官=S2 全域用户走查(脚本+D4 出账链)+s2-closeout.md。
- **一期进度**:S0✅ S1✅ S2✅ / S3 ✅(11-15 凌晨)/ **S4-D1/D2 ✅(11-16)**——C1 回调推送引擎(callback_task v21+PushWorker 指数退避/死信可查可重派+双挂点 report 终态/uplink 消费+GET /ops/callback 管理面+前端回调管理页 ops-callback+metrics)+ C2 上行自动拉黑(等值词表 SystemConfig 可配→policy_blacklist source=2+Redis 即时生效;拉黑不影响推送);**真机全链六步实证**(回执→HTTP 回调 JSON 送达/上行 R→拉黑+推送/坏 URL→死信→resend→重投 sent/状态面板);门禁全绿(-race 40 包/vitest 148/lint 0);验收单 s4-d1d2-callback.md。**S4 剩余=D3 明细按天分区热 5 天+ClickHouse 冷热切换+冷查<1s**(动核心大表,方案先行)。
- **C1/C2 口径留痕**:载荷无签名(挂账);拦截终态 HTTP 回调未挂(CMPP 侧 blockedDeliverAdapter 已有);PushWorker 单实例语义(多实例 at-least-once);退避 2^n s 封顶 10min×10 次(S5 重标);casbin 策略=ops callback:read/write(v21 所种,SQL 直插 g 重启生效老规矩)。
- **⚠️ 流程补正在途(两项,不阻塞开工)**:①S2 用户本人走查(s2-walkthrough.sh D2~D5,AI 预走查 27 PASS);②S2 结算页+S3 利润页+**S4 回调管理页**浏览器走查(:5173,s2demo 登录[admin 角色];回调页在「系统管理→回调管理」)。
- **24h 稳定性门槛 ✅ 终判通过**(S5 压测前置;S4-D3 动大表后建议 S5 前复核 dmesg)。
- **真浏览器通道就位(2026-11-15)**:Google Chrome 157 官方 deb 直装 + Playwright `channel:'chrome'` 实测可用(`scripts/chrome-session.mjs` 通用会话工具,单 page 会话铁律见 techContext 工具链)——**参考短信平台登录参考 UI + AI 前端自验通道已打通**;注意本 AI 会话不支持读图,自验交付口径=截图供用户复核 + DOM/CSS/accessibility 结构化提取由 AI 分析;账号一律 env 临时传入不落盘。
- **Issue#1 两轮交付均已入库(2026-11-15/16)**:盈讯通调研+ChannelList 8 列双语义聚合+ChannelEdit 分组深度对齐+chrome-session 工具;工单评论仍待用户贴 Gitea(或给 token)。
- **六项裁决速查(S2 全闭环)**:R1/R6 换算只在 price.go / R2 事实源 D2 落账 / R3 双通道 D3 落地(ref_id 区分)/ R4 rebate_rate D5 落地(profit.go 现算不落档)/ R5 settle_ladder D4 落地。
- 归档仓(只读):/data/poc-archive/repos/go-sms.git。
- **本会话运维教训**:①`pkill/pgrep -f` 自匹配(铁律:`[x]` 括号技巧);②大镜像单窗>体积÷带宽;③du 无 sudo 静默失败误诊;④sed 换行/sed 误伤方法名(重构期优先编辑器工具);⑤Go 工具忽略 `_` 前缀文件;⑥集成测试需 `sg docker` 包裹(docker 组未重登);⑦**Makefile recipe 的 `exit 0` 只退出当前行 shell 不终止目标**(幂等短路须 if/else 递归 `$(MAKE)` 子目标);⑧**管道 `| tail -N` 截首行误导诊断**(gw-start"玄学 NOMATCH"两轮误诊实为 THEN 分支已生效,排查须看全量输出)。
- **【铁律】测试端口固定=5173**:Web 测试/联调/走查/对外验收口径**一律** `http://<服务器IP>:5173`(vite dev,`make web-dev`);**禁止**用 WEB_PORT 覆盖到其他端口、禁止 preview(4173 等)/临时容器端口(30099 等)作为验收与走查入口——一次性探测端口仅限本机调试且不入文档口径(2026-11-15 用户裁定)。
- **【铁律】外网测试统一域名入口=`https://sms.unimsc.com/`**(2026-11-15 用户裁定):nginx 根路径反代 443→192.168.5.18:5173(带 ws Upgrade 头);vite `allowedHosts:['sms.unimsc.com']`+`hmr.clientPort:443`(域名 HMR ✓,本机直连 HMR 退化为手动刷新);API 走 vite proxy→8080;**ai.unimsc.com/SmsDev 路径前缀通道废弃**(前缀反代下 vite 资源绝对路径错位无干净解);S5 上生产仅改 nginx proxy_pass→30081(web 镜像同构)。**S3 遗留缺陷顺手修**:build 不读 .env.development 致 dist 内 API base 缺失→新增 `web/.env.production`(VITE_API_BASE_URL=/api/v1)。
- **本会话教训**:①明细雪花 ID 直插 SQL 须 < int64 上限 9.22e18(9302… 段拒收,走查种子统一 7302… 段);②`sg docker -c '…$VAR…'` 单引号内变量不展开(内层空展开致 SQL 语法错)——多语句 SQL 用 `printf|docker exec -i` 外层展开;③网关重启须含最新端点二进制(串行 build→kill→md5);④**本机 chromium(含 headless shell)newPage 即 Target crashed**(disable-gpu/no-sandbox/GLIBC 关 AVX 均不救,dmesg 无痕)——Playwright 截图/e2e/LCP 实测本机不可用〔**11-15 已解:官方 Chrome 157 + `channel:'chrome'` 可用**,稳定口径=每会话独立 launch+单 page goto 导航(同 browser 第 2 个 newPage 必崩:renderer segfault error 25 固定偏移 0x90b1f9→zombie→挂起,chrome 崩溃 dmesg 有痕);工具=`scripts/chrome-session.mjs`,详见 techContext 工具链〕;⑤vite preview 只监听 IPv6 [::1](curl 127.0.0.1 不通,用 localhost);⑥组件测试 mount 须 `plugins:[ElementPlus]`(stubs 方式 el-table-column slot scope 会 undefined);⑦`web/.env.development.local` 已随 Mock 下线删除,再出现 VITE_API_MODE 文件即残留可径删。
- **历史运维教训**:①`pkill/pgrep -f` 自匹配(铁律:`[x]` 括号技巧);②大镜像单窗>体积÷带宽;③du 无 sudo 静默失败误诊;④sed 换行/sed 误伤方法名(重构期优先编辑器工具);⑤Go 工具忽略 `_` 前缀文件;⑥集成测试需 `sg docker` 包裹(docker 组未重登);⑦**Makefile recipe 的 `exit 0` 只退出当前行 shell 不终止目标**(幂等短路须 if/else 递归 `$(MAKE)` 子目标);⑧**管道 `| tail -N` 截首行误导诊断**(gw-start"玄学 NOMATCH"两轮误诊实为 THEN 分支已生效,排查须看全量输出)。
## 重建启动(2026-11-12 裁决 / 盘点 / 迁移方案)
@@ -46,7 +51,7 @@
## 常踩的坑(防复发)
1. `.env.development.local`(gitignore)会把 vite 钉在 real 模式——切 mock 前必查。
1. ~~`.env.development.local` 会把 vite 钉在 real——切 mock 前必查~~(S3 Mock 已下线,条目废止留痕;该文件已删,再出现 VITE_API_MODE 相关文件即残留径删)。
2. build 与 kill 并行=旧 inode 进程(Day 70);部署必须串行+md5 比对。
3. 持久化-还原键字段必须成对审计(Day 71 ref 字段漏存教训)。
4. 迁移版本号字典序坑(v10<v9,Day 46 修);gofmt 的 `//` 注释误闭合致 vite 编译错(W4)。
+6 -2
View File
@@ -16,9 +16,13 @@
| S2-D3 充值审核流 | recharge.go(创建/confirm 单事务 CAS+余额自增+流水 ref_id=order_no/驳回/列表)+ISC:039 三处同步+四端点(二级权限+平台角色门);测试 7 件含并发 confirm;真机全链冒烟+审计留痕实证 | ✅ 2026-11-14 夜(验收单 s2-d3.md) |
| S2-D4 出账+阶梯 | price.go(R1/R6 唯一换算)+bill.go(生成/确认/结账/SettleRecord/ladder)+export.go XLSX+15 端点;**阶梯结算单测(S2 显式验收项)**+上家三口径+状态机;真机出账全链(阶梯覆写/结账/真 XLSX) | ✅ 2026-11-14 深夜(验收单 s2-d4.md;用户走查在途补正) |
| S2 前端验收面 | 结算管理页四 Tab+api 12 端点+seed 演示(s2demo)+Playwright 预走查真库闭环(余额+1000/账单 1955.00);前端四件全绿 | ✅ 2026-11-14 深夜②(用户页面走查在途;s2-frontend-preview.md) |
| S2-D5 | 利润/返点+三方对账(diff=0=S2 出口)+S2 收官走查 | ⬜ 排期中 |
| S2-D5 利润/返点/对账 | profit.go(时间线价收入+成本分摊+R4 返点现算+子树过滤;通道利润守恒分摊)+reconcile.go(三方对账,金额不比,missing 不判失败)+settle-check 子命令+/stats/profit 双端点;**真机 all_zero=true EXIT=0=S2 出口判据**;走查脚本扩 D2~D5 全域 27 PASS | ✅ 2026-11-14 深夜③(用户走查在途;s2-d5.md) |
| S2 泳道收官 | 出口两项(结算单测+对账差异 0)全过;六项裁决 R1~R6 全闭环 | ✅ 2026-11-14 深夜③(判定单 s2-closeout.md;用户走查在途补正) |
| S3 前端收尾 | 盘点修正:views 31 页已在位零残留;FE-D34 利润页(/stats/profit)+FE-6 四件(Mock 浏览器通道下线/五角色×33 菜单矩阵快照/拆包全 chunk gzip<500KB/ci.yml web job+Dockerfile nginx+NodePort 30081 备档);vitest 148 全绿;LCP 实测与 kind 两项环境受阻如实标注 | ✅ 2026-11-15 凌晨(s3-closeout.md;页面走查在途) |
| S4-D1/D2 C1 回调推送+C2 拉黑 | callback_task(v21)+PushWorker(指数退避/死信/重派)+双挂点(report 终态 Consumer/PairService+uplink 消费)+GET /ops/callback 管理面+前端回调管理页;C2 等值词表可配拉黑+Redis 即时生效;真机全链六步实证;**死信可查/拒收即拉黑两项验收 ✅** | ✅ 2026-11-16(s4-d1d2-callback.md) |
| S4-D3 分区+冷热 | 明细按天分区热 5 天(v17 口径上 DDL 改造,方案先行)+CH 冷热切换(5 天前迁出)+record/history 冷查<1s+settle-check 对账基线自动切换验证 | ⬜ 下一步 |
| 观察项 | 24h 稳定性门槛(11-13 17:55 起计;期内 21:33 宿主主动重启=已知事件不判失败)期满核验 11-14 17:55 | ✅ 2026-11-14 18:02 终判通过(dmesg 0/零重启/驻留+md5 一致;S5 压测前置确认,S1 完全闭环) |
| S2~S5 | 结算域/前端收尾/C1C2+冷热/基线与灰度 | ⬜ 见《Go-sms-重建计划.md》 |
| S2~S5 | 结算域/前端收尾/C1C2+冷热/基线与灰度 | 🔄 S2✅S3✅S4 D1/D2✅(见《Go-sms-重建计划.md》) |
## 阶段总览(8 阶段 / 80 工作日)
+3 -1
View File
@@ -38,7 +38,7 @@
| MinIO | 19010/19011(API/Console) | |
| Prometheus+Alertmanager | — | 规则 `deploy/monitoring/alert_rules.yml` |
网关 dev 固定 **:8081**(`GW_PORT`,8080 被宿主旧进程占用);Web :5173;K8s NodePort 30080/30081。
网关 dev 固定 **:8080**(`GW_PORT` 可覆盖;历史 8081 为当时宿主 8080 被占用的临时覆盖,已废弃,vite proxy 按 8080);**Web 测试端口铁律=5173**(`make web-dev`,vite dev;WEB_PORT 不得覆盖、preview/临时容器端口不入口径);**外网测试统一入口=`https://sms.unimsc.com/`**(nginx 根路径反代 443→5173+ws Upgrade,vite allowedHosts 已登记;ai.unimsc.com/SmsDev 前缀通道废弃);K8s NodePort 30080/30081(S5 灰度 apply)。
## 常用命令
@@ -72,6 +72,8 @@ make ci-local SERVICE=gateway VERSION=dev
- Go 1.25.0;golangci-lint v2.1.6(`GOTOOLCHAIN=go1.25.0 go install ...@v2.1.6`)。
- Node/pnpm(web/node_modules 已就位);字典生成 `go run ./tools/gen-dict`(`npm run gen:dict`)。
- kind + kubectl(本地 K8s `go-sms-dev` 集群,scripts/kind-dev.yaml)。
- **Google Chrome stable 157**(2026-11-15 官方 deb 直装,`google-chrome --version` 验证):AI 登录参考 UI/前端自验的真浏览器通道。**约束(宿主 CPU 缺陷实测)**:Playwright 须 `channel:'chrome'`(自带 chromium newPage 即崩不可用);同一 browser 第 2 个 newPage 必崩(renderer segfault error 25 固定偏移 0x90b1f9 → zombie → newPage 永久挂起),**稳定口径=每会话独立 launch+单 page 内 goto 导航**(fresh 5/5、单页多导航 4/5[失败仅外网网络]实测);固定 args=`--no-sandbox --disable-gpu --disable-dev-shm-usage`。通用会话工具=`scripts/chrome-session.mjs`(带 per-step 超时+FAIL 重 launch,CLI 直跑或 import runSession 改造登录场景)。
- **OCR 工具链(2026-11-15)**:tesseract 5.5 + python3-pil(apt 直装);计算题图片验证码识别方案=`放大4x LANCZOS+Otsu 二值化+psm7/8/6 多数投票`+算式三态解析,脚本模板留档 /tmp/cap-solve.py(环境级工具不入仓,复用时按 activeContext Issue#1 条目重建)。
## 技术约束
- **重建期代码托管(2026-11-13 修订)**:**内网独立机 Gitea 已上线**——`ssh://git@192.168.5.27:24401/Tory/go-sms-V2.git`(账号 Tory,公钥=「5.18 SmsDev」;web 经用户侧域名/转发访问)。push 纪律=日终随 bundle 一并 push,本地仓+每日 bundle 备份双轨保留。2026-11-12 原裁决「不装 Gitea」的协作触发条款于 11-13 生效(运营探讨重建计划);网络事实修正:git.smpp.ltd 仅 IPv6 新机不可用、192.168.5.10=New API 网关且不可操作、开发机=192.168.5.18。
+51
View File
@@ -0,0 +1,51 @@
// chrome-session.mjs — 宿主 CPU 缺陷(8173M error 25)约束下的 Playwright+系统Chrome 会话工具
//
// 背景(2026-11-15 实测,详见 memory-bank/techContext):
// - Playwright 自带 chromium:newPage 即 Target crashed,不可用
// - 官方 Google Chrome 157(channel:'chrome'):可用,但**同一 browser 第 2 个 newPage 必崩**
// (renderer segfault error 25 @ 固定偏移 0x90b1f9,zombie 后 newPage 永久挂起)
// - 稳定口径 = 每会话独立 launch + 单 page 内 goto 导航(实测 5/5 与 4/5[失败仅外网网络])
//
// 用法:
// node scripts/chrome-session.mjs <url> [--shot 路径前缀] [--wait ms]
// 登录参考平台等复杂场景:复制本脚本 runSession() 回调改造(env 传账号,勿硬编码)
//
// 环境要求:web/node_modules(playwright)、google-chrome-stable(已装 157)
import { chromium } from '../web/node_modules/playwright/index.mjs';
const withTimeout = (p, ms, tag) =>
Promise.race([p, new Promise((_, rej) => setTimeout(() => rej(new Error(tag + ' TIMEOUT')), ms))]);
const ARGS = ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'];
const launch = () => withTimeout(chromium.launch({ channel: 'chrome', args: ARGS }), 20000, 'launch');
export async function runSession({ url, onReady, shotPrefix = '/tmp/chrome-session', waitMs = 2000, retries = 2 }) {
for (let attempt = 1; attempt <= retries + 1; attempt++) {
let browser;
try {
browser = await launch();
const page = await withTimeout(browser.newPage(), 15000, 'newPage'); // 铁律:本会话唯一 page,后续一律 page.goto
await withTimeout(page.goto(url, { timeout: 20000, waitUntil: 'domcontentloaded' }), 30000, 'goto');
await page.waitForTimeout(waitMs);
if (onReady) await onReady(page);
const title = await withTimeout(page.title(), 10000, 'title');
await withTimeout(page.screenshot({ path: `${shotPrefix}.png`, fullPage: true }), 20000, 'shot');
return { ok: true, title, url: page.url() };
} catch (e) {
console.error(`[chrome-session] attempt ${attempt} FAIL: ${e.message}`);
if (attempt > retries) return { ok: false, error: e.message };
await new Promise((r) => setTimeout(r, 1500));
} finally {
if (browser) await browser.close().catch(() => {});
}
}
}
// CLI 直跑:node scripts/chrome-session.mjs http://127.0.0.1:5173/
if (process.argv[1] && process.argv[1].endsWith('chrome-session.mjs')) {
const url = process.argv[2] || 'http://127.0.0.1:5173/';
const r = await runSession({ url });
console.log(JSON.stringify(r));
process.exit(r.ok ? 0 : 1);
}
-1
View File
@@ -1,2 +1 @@
VITE_API_MODE=real
VITE_API_BASE_URL=/api/v1
+4
View File
@@ -0,0 +1,4 @@
# build(mode=production)不读 .env.development——此前 dist 产物内 VITE_API_BASE_URL
# 为 undefined,axios 请求缺 /api/v1 前缀,S3 web 镜像内前端 API 实为断链(冒烟 curl
# 直打 /api 反代未暴露)。2026-11-15 补齐:产物走容器/网关 nginx 的 /api 反代。
VITE_API_BASE_URL=/api/v1
+11
View File
@@ -0,0 +1,11 @@
# web/Dockerfile S3·FE-6:前端镜像化(**dist 产物镜像**,nginx:alpine)。
# 形态裁决:不做容器内 node 构建——本机容器内 npm 生态带宽实测 22~49KiB/s
# (npmjs 与 npmmirror 皆然,全量依赖 ~250MB 不可行);构建前置=宿主/CI 的
# vite build(make web-image 自动执行,CI web-test job 同链)。镜像只关心产物。
# 运行态:静态资源 + SPA fallback + /api 反代(${API_UPSTREAM},默认
# go-sms-gateway:8080=k8s 集群内服务名;docker 独立跑时 -e API_UPSTREAM=host:port)。
FROM nginx:1.27-alpine
COPY web/nginx.conf.template /etc/nginx/templates/default.conf.template
COPY web/dist /usr/share/nginx/html
ENV API_UPSTREAM=go-sms-gateway:8080
EXPOSE 80
-6
View File
@@ -1,6 +0,0 @@
import { setupWorker } from 'msw/browser'
import { handlers } from './handlers'
import { fe2Handlers } from './fe2-handlers'
import { fe4DetailHandlers, fe4Handlers, fe4HistoryHandlers, fe4RepushHandlers, fe4UplinkHandlers, smsDownlinkHandlers } from './fe4-handlers'
export const worker = setupWorker(...handlers, ...fe2Handlers, ...fe4Handlers, ...fe4DetailHandlers, ...fe4HistoryHandlers, ...fe4UplinkHandlers, ...fe4RepushHandlers, ...smsDownlinkHandlers)
+35
View File
@@ -0,0 +1,35 @@
# nginx.conf.template S3·FE-6:envsubst 模板(官方 nginx 镜像 /etc/nginx/templates
# 机制,${API_UPSTREAM} 启动注入)。gzip 常开(vite 产物 gzip 后最大 chunk 341KB,
# FE-6 单包<500KB 以传输字节计)。
server {
listen 80;
server_name _;
gzip on;
gzip_types text/css application/javascript application/json image/svg+xml;
gzip_min_length 1024;
root /usr/share/nginx/html;
index index.html;
# hash 文件名资源:一年强缓存(vite contenthash,发版自动失效)
location /assets/ {
expires 1y;
add_header Cache-Control "public, immutable";
try_files $uri =404;
}
# SPA 路由 fallback
location / {
try_files $uri $uri/ /index.html;
}
# API 反代至网关(k8s 内=Service 名;独立容器=-e API_UPSTREAM 覆盖)
location /api/ {
proxy_pass http://${API_UPSTREAM};
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size 20m;
}
}
+2 -6
View File
@@ -3,6 +3,7 @@
"version": "0.1.0",
"private": true,
"type": "module",
"packageManager": "pnpm@12.18.0",
"scripts": {
"dev": "vite",
"build": "vite build",
@@ -21,7 +22,6 @@
"@element-plus/icons-vue": "^2.3.1",
"axios": "^1.7.2",
"element-plus": "^2.7.6",
"msw": "^2.3.1",
"pinia": "^2.1.7",
"vue": "^3.4.29",
"vue-router": "^4.3.3"
@@ -34,6 +34,7 @@
"eslint": "^8.57.0",
"eslint-plugin-vue": "^9.27.0",
"jsdom": "^24.1.0",
"msw": "^2.3.1",
"playwright": "^1.63.0",
"prettier": "^3.3.2",
"sass": "^1.77.6",
@@ -41,10 +42,5 @@
"vite": "^5.3.1",
"vitest": "^1.6.0",
"vue-tsc": "^2.0.22"
},
"msw": {
"workerDirectory": [
"public"
]
}
}
+177 -425
View File
File diff suppressed because it is too large Load Diff
-361
View File
@@ -1,361 +0,0 @@
/* eslint-disable */
/* tslint:disable */
/**
* Mock Service Worker.
* @see https://github.com/mswjs/msw
* - Please do NOT modify this file.
*/
const PACKAGE_VERSION = '2.15.0'
const INTEGRITY_CHECKSUM = '03cb67ac84128e63d7cd722a6e5b7f1e'
const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
const activeClientIds = new Set()
addEventListener('install', function () {
self.skipWaiting()
})
addEventListener('activate', function (event) {
event.waitUntil(self.clients.claim())
})
addEventListener('message', async function (event) {
const clientId = Reflect.get(event.source || {}, 'id')
if (!clientId || !self.clients) {
return
}
const client = await self.clients.get(clientId)
if (!client) {
return
}
const allClients = await self.clients.matchAll({
type: 'window',
})
switch (event.data) {
case 'KEEPALIVE_REQUEST': {
sendToClient(client, {
type: 'KEEPALIVE_RESPONSE',
})
break
}
case 'INTEGRITY_CHECK_REQUEST': {
sendToClient(client, {
type: 'INTEGRITY_CHECK_RESPONSE',
payload: {
packageVersion: PACKAGE_VERSION,
checksum: INTEGRITY_CHECKSUM,
},
})
break
}
case 'MOCK_ACTIVATE': {
activeClientIds.add(clientId)
sendToClient(client, {
type: 'MOCKING_ENABLED',
payload: {
client: {
id: client.id,
frameType: client.frameType,
},
},
})
break
}
case 'CLIENT_CLOSED': {
activeClientIds.delete(clientId)
const remainingClients = allClients.filter((client) => {
return client.id !== clientId
})
// Unregister itself when there are no more clients
if (remainingClients.length === 0) {
self.registration.unregister()
}
break
}
}
})
addEventListener('fetch', function (event) {
const requestInterceptedAt = Date.now()
// Bypass navigation requests.
if (event.request.mode === 'navigate') {
return
}
// Opening the DevTools triggers the "only-if-cached" request
// that cannot be handled by the worker. Bypass such requests.
if (
event.request.cache === 'only-if-cached' &&
event.request.mode !== 'same-origin'
) {
return
}
// Bypass all requests when there are no active clients.
// Prevents the self-unregistered worked from handling requests
// after it's been terminated (still remains active until the next reload).
if (activeClientIds.size === 0) {
return
}
const requestId = crypto.randomUUID()
event.respondWith(handleRequest(event, requestId, requestInterceptedAt))
})
/**
* @param {FetchEvent} event
* @param {string} requestId
* @param {number} requestInterceptedAt
*/
async function handleRequest(event, requestId, requestInterceptedAt) {
const client = await resolveMainClient(event)
const requestCloneForEvents = event.request.clone()
const response = await getResponse(
event,
client,
requestId,
requestInterceptedAt,
)
// Send back the response clone for the "response:*" life-cycle events.
// Ensure MSW is active and ready to handle the message, otherwise
// this message will pend indefinitely.
if (client && activeClientIds.has(client.id)) {
const serializedRequest = await serializeRequest(requestCloneForEvents)
// Omit the body of server-sent event stream responses.
// Cloning such responses would prevent client-side stream cancelations
// from reaching the original stream (a teed stream only cancels its
// source once both of its branches cancel) and would buffer the
// entire stream into the unconsumed clone indefinitely.
const isEventStreamResponse = response.headers
.get('content-type')
?.toLowerCase()
.startsWith('text/event-stream')
// Clone the response so both the client and the library could consume it.
const responseClone = isEventStreamResponse ? null : response.clone()
sendToClient(
client,
{
type: 'RESPONSE',
payload: {
isMockedResponse: IS_MOCKED_RESPONSE in response,
request: {
id: requestId,
...serializedRequest,
},
response: {
type: response.type,
status: response.status,
statusText: response.statusText,
headers: Object.fromEntries(response.headers.entries()),
body: responseClone ? responseClone.body : null,
},
},
},
responseClone && responseClone.body
? [serializedRequest.body, responseClone.body]
: [],
)
}
return response
}
/**
* Resolve the main client for the given event.
* Client that issues a request doesn't necessarily equal the client
* that registered the worker. It's with the latter the worker should
* communicate with during the response resolving phase.
* @param {FetchEvent} event
* @returns {Promise<Client | undefined>}
*/
async function resolveMainClient(event) {
const client = await self.clients.get(event.clientId)
if (activeClientIds.has(event.clientId)) {
return client
}
if (client?.frameType === 'top-level') {
return client
}
const allClients = await self.clients.matchAll({
type: 'window',
})
return allClients
.filter((client) => {
// Get only those clients that are currently visible.
return client.visibilityState === 'visible'
})
.find((client) => {
// Find the client ID that's recorded in the
// set of clients that have registered the worker.
return activeClientIds.has(client.id)
})
}
/**
* @param {FetchEvent} event
* @param {Client | undefined} client
* @param {string} requestId
* @param {number} requestInterceptedAt
* @returns {Promise<Response>}
*/
async function getResponse(event, client, requestId, requestInterceptedAt) {
// Clone the request because it might've been already used
// (i.e. its body has been read and sent to the client).
const requestClone = event.request.clone()
function passthrough() {
// Cast the request headers to a new Headers instance
// so the headers can be manipulated with.
const headers = new Headers(requestClone.headers)
// Remove the "accept" header value that marked this request as passthrough.
// This prevents request alteration and also keeps it compliant with the
// user-defined CORS policies.
const acceptHeader = headers.get('accept')
if (acceptHeader) {
const values = acceptHeader.split(',').map((value) => value.trim())
const filteredValues = values.filter(
(value) => value !== 'msw/passthrough',
)
if (filteredValues.length > 0) {
headers.set('accept', filteredValues.join(', '))
} else {
headers.delete('accept')
}
}
return fetch(requestClone, { headers })
}
// Bypass mocking when the client is not active.
if (!client) {
return passthrough()
}
// Bypass initial page load requests (i.e. static assets).
// The absence of the immediate/parent client in the map of the active clients
// means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
// and is not ready to handle requests.
if (!activeClientIds.has(client.id)) {
return passthrough()
}
// Notify the client that a request has been intercepted.
const serializedRequest = await serializeRequest(event.request)
const clientMessage = await sendToClient(
client,
{
type: 'REQUEST',
payload: {
id: requestId,
interceptedAt: requestInterceptedAt,
...serializedRequest,
},
},
[serializedRequest.body],
)
switch (clientMessage.type) {
case 'MOCK_RESPONSE': {
return respondWithMock(clientMessage.data)
}
case 'PASSTHROUGH': {
return passthrough()
}
}
return passthrough()
}
/**
* @param {Client} client
* @param {any} message
* @param {Array<Transferable>} transferrables
* @returns {Promise<any>}
*/
function sendToClient(client, message, transferrables = []) {
return new Promise((resolve, reject) => {
const channel = new MessageChannel()
channel.port1.onmessage = (event) => {
if (event.data && event.data.error) {
return reject(event.data.error)
}
resolve(event.data)
}
client.postMessage(message, [
channel.port2,
...transferrables.filter(Boolean),
])
})
}
/**
* @param {Response} response
* @returns {Response}
*/
function respondWithMock(response) {
// Setting response status code to 0 is a no-op.
// However, when responding with a "Response.error()", the produced Response
// instance will have status code set to 0. Since it's not possible to create
// a Response instance with status code 0, handle that use-case separately.
if (response.status === 0) {
return Response.error()
}
const mockedResponse = new Response(response.body, response)
Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
value: true,
enumerable: true,
})
return mockedResponse
}
/**
* @param {Request} request
*/
async function serializeRequest(request) {
return {
url: request.url,
mode: request.mode,
method: request.method,
headers: Object.fromEntries(request.headers.entries()),
cache: request.cache,
credentials: request.credentials,
destination: request.destination,
integrity: request.integrity,
redirect: request.redirect,
referrer: request.referrer,
referrerPolicy: request.referrerPolicy,
body: await request.arrayBuffer(),
keepalive: request.keepalive,
}
}
+34
View File
@@ -0,0 +1,34 @@
/** 回调任务管理 API(S4·C1;openapi v1.4.0 契约)。 */
import { get, post } from './request'
/** 回调任务(status: 0待推送 1已送达 2死信;type: 1回执终态 2上行)。 */
export interface CallbackTask {
id: number
account_id: number
type: number
url: string
payload: string
status: number
attempt: number
next_retry_at: string
last_code: number
last_err: string
sent_at: string | null
created_at: string
}
/** 列表结果(含状态计数面板)。 */
export interface CallbackListResult {
total: number
list: CallbackTask[]
status_counts: { pending?: number; sent?: number; dead?: number }
}
export const callbackApi = {
list: (params: Record<string, unknown>) => get<CallbackListResult>('/ops/callback', params),
resend: (id: number) => post<{ id: number; resent: boolean }>(`/ops/callback/${id}/resend`),
}
/** 状态码值 → 中文标签。 */
export const CALLBACK_STATUS: Record<number, string> = { 0: '待推送', 1: '已送达', 2: '死信' }
export const CALLBACK_TYPE: Record<number, string> = { 1: '回执终态', 2: '上行消息' }
+47
View File
@@ -66,6 +66,47 @@ export interface GenerateResult {
skipped: number
}
// ---- 利润分析(S2-D5;金额=元) ----
/** 用户利润行(revenue=时间线价收入;cost=通道成本占比分摊;rebate=直线下级返点 R4)。 */
export interface UserProfitRow {
account_id: number
username: string
role: string
success_count: number
revenue: number
cost: number
rebate: number
profit: number
}
/** 用户利润汇总(与列表同 scope)。 */
export interface UserProfitSummary {
count: number
total_revenue: number
total_cost: number
total_rebate: number
platform_profit: number
}
/** 用户利润结果集。 */
export interface UserProfitResult {
list: UserProfitRow[]
total: number
summary: UserProfitSummary
}
/** 通道利润行(revenue=全平台用户收入×通道成功占比分摊;cost=通道时间线价直算)。 */
export interface ChannelProfitRow {
channel_id: number
name: string
upstream_id: number
success_count: number
revenue: number
cost: number
profit: number
}
interface Paged<T> { total: number; list: T[] }
export const settleApi = {
@@ -95,6 +136,12 @@ export const settleApi = {
post<SettleLadder>('/settle/ladder', body),
deleteLadder: (id: number) => del<null>(`/settle/ladder/${id}`),
updateLadder: (id: number, body: { tier_from?: number; price?: number }) => put<null>(`/settle/ladder/${id}`, body),
// ---- 利润分析(D5;平台角色端点) ----
profitUsers: (params: { date_from: string; date_to: string; parent_id?: number; page?: number; page_size?: number }) =>
get<UserProfitResult>('/stats/profit/users', params),
profitChannels: (params: { date_from: string; date_to: string; channel_id?: number; page?: number; page_size?: number }) =>
get<{ list: ChannelProfitRow[]; total: number }>('/stats/profit/channels', params),
}
/** 导出下载(文件流需带 Authorization,axios JSON 拦截器不适配,走 fetch+blob)。 */
+2 -5
View File
@@ -45,11 +45,8 @@ async function bootstrap() {
setupDirectives(app)
setupRouterGuard(router)
// Mock 模式:仅开发态启用 msw(VITE_API_MODE=real 时直连后端)
if (import.meta.env.DEV && import.meta.env.VITE_API_MODE === 'mock') {
const { worker } = await import('../mocks/browser')
await worker.start({ onUnhandledRequest: 'bypass' })
}
// S3·FE-6:浏览器 Mock 通道已下线(单一 real 模式直连网关);msw 仅保留
// 于 vitest 层(mocks/node.ts,测试隔离服务器)。
await router.isReady()
app.mount('#app')
+3
View File
@@ -69,7 +69,10 @@ export const asyncRoutes: RouteRecordRaw[] = [
{ path: 'stats/user', name: 'stats-user', component: () => import('@/views/coming/ComingSoon.vue'), meta: { title: '用户统计', icon: 'DataLine', menu: true, group: '统计结算', roles: ['admin', 'ops', 'service'] } },
{ path: 'stats/channel', name: 'stats-channel', component: () => import('@/views/coming/ComingSoon.vue'), meta: { title: '通道统计', icon: 'TrendCharts', menu: true, group: '统计结算', roles: ['admin', 'ops'] } },
{ path: 'stats/profit', name: 'stats-profit', component: () => import('@/views/stats/profit/index.vue'), meta: { title: '利润分析', icon: 'Coin', menu: true, group: '统计结算', roles: ['admin', 'ops', 'service'], subtitle: '用户利润(含下级返点)· 通道利润 · 平台净利' } },
{ path: 'settle', name: 'settle', component: () => import('@/views/settle/index.vue'), meta: { title: '结算管理', icon: 'Wallet', menu: true, group: '统计结算', roles: ['admin', 'ops'] } },
{ path: 'ops/callback', name: 'ops-callback', component: () => import('@/views/ops/callback/index.vue'), meta: { title: '回调管理', icon: 'Promotion', menu: true, group: '系统管理', roles: ['admin', 'ops'], subtitle: '客户回调推送任务 · 指数退避 · 死信可查可重派' } },
{ path: 'logs', name: 'logs', component: () => import('@/views/coming/ComingSoon.vue'), meta: { title: '日志报表', icon: 'Document', menu: true, group: '系统管理', roles: ['admin', 'ops', 'service'] } },
{ path: 'system', name: 'system', component: () => import('@/views/coming/ComingSoon.vue'), meta: { title: '系统配置', icon: 'Setting', menu: true, group: '系统管理', roles: ['admin'] } },
+126 -30
View File
@@ -8,14 +8,24 @@
<section class="card ce-card">
<div class="ce-head">
<div class="ce-head-main">
<span class="card-head-title">{{ isEdit ? '短信通道编辑' : '短信通道添加' }}</span>
<small class="ce-head-sub">{{ isEdit ? '修改既有通道连接与运营参数' : '创建上游通道连接,协议参数按模板预填' }}</small>
</div>
<el-button size="small" @click="toggleAll">{{ allOpen ? '全部收缩' : '全部展开' }}</el-button>
</div>
<el-form ref="formRef" :model="form" :rules="rules" label-width="140px" class="ce-form">>
<el-form ref="formRef" :model="form" :rules="rules" label-width="140px" class="ce-form">
<el-collapse v-model="activePanels">
<!-- ① 通道模板 -->
<el-collapse-item title="通道模板" name="template">
<el-collapse-item name="template">
<template #title>
<div class="ce-sec">
<span class="ce-idx">01</span>
<span class="ce-sec-name">通道模板</span>
<span class="ce-sec-sub">选择协议模板,可复制已有通道参数</span>
</div>
</template>
<el-row :gutter="16">
<el-col :span="12">
<el-form-item label="运行模板" prop="protocol">
@@ -35,12 +45,19 @@
</el-row>
</el-collapse-item>
<!-- ② 基本信息 -->
<el-collapse-item title="基本信息" name="basic">
<el-collapse-item name="basic">
<template #title>
<div class="ce-sec">
<span class="ce-idx">02</span>
<span class="ce-sec-name">基本信息</span>
<span class="ce-sec-sub">名称 / 运营商 / 计费与运营属性</span>
</div>
</template>
<el-row :gutter="16">
<el-col :span="12">
<el-form-item label="通道名称" prop="name"><el-input v-model="form.name" maxlength="50" placeholder="通道名称" /></el-form-item>
<el-form-item label="通道号(接入码)" prop="code"><el-input v-model="form.code" placeholder="如 10690" /></el-form-item>
<el-form-item label="运营商" prop="carrier">
<el-checkbox-group v-model="carrierList">
<el-checkbox v-for="c in CARRIERS" :key="c.value" :value="c.value">{{ c.label }}</el-checkbox>
@@ -60,6 +77,9 @@
<el-option v-for="m in BILLING_MODES" :key="m.value" :label="m.label" :value="m.value" />
</el-select>
</el-form-item>
<el-form-item label="默认兜底通道">
<el-switch v-model="form.is_default" :active-value="1" :inactive-value="0" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="通道价格(元)" prop="price">
@@ -86,15 +106,19 @@
<el-option v-for="c in moOptions" :key="c.id" :label="c.name" :value="c.id" />
</el-select>
</el-form-item>
<el-form-item label="默认兜底通道">
<el-switch v-model="form.is_default" :active-value="1" :inactive-value="0" />
</el-form-item>
</el-col>
</el-row>
</el-collapse-item>
<!-- ③ 拦截机制 -->
<el-collapse-item title="拦截机制" name="intercept">
<el-collapse-item name="intercept">
<template #title>
<div class="ce-sec">
<span class="ce-idx">03</span>
<span class="ce-sec-name">拦截机制</span>
<span class="ce-sec-sub">发送限制 / 黑白名单 / 地区屏蔽</span>
</div>
</template>
<el-row :gutter="16">
<el-col :span="12">
<el-form-item label="发送限制">
@@ -121,13 +145,22 @@
<el-option label="限制" :value="1" />
</el-select>
</el-form-item>
<el-form-item label="通道号码规则">
<el-radio-group v-model="form.number_rule">
<el-radio v-for="r in NUMBER_RULES" :key="r.value" :value="r.value">{{ r.label }}</el-radio>
</el-radio-group>
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="频次">
<div class="ce-note">频次策略由 <router-link to="/policy" class="ce-link">规则策略中心</router-link> 统一配置(账号维度)</div>
</el-form-item>
<el-form-item label="模板ID模式">
<el-switch v-model="form.template_mode" :active-value="1" :inactive-value="0" />
<span class="hint ce-hint">上游模板ID模式({%变量%})</span>
</el-form-item>
</el-col>
<el-col :span="24">
<el-form-item label="通道号码规则">
<el-radio-group v-model="form.number_rule" class="ce-rule-group">
<el-radio v-for="r in NUMBER_RULES" :key="r.value" :value="r.value" border>{{ r.label }}</el-radio>
</el-radio-group>
</el-form-item>
<el-form-item label="黑关键字">
<div class="ce-tags">
<el-tag v-for="kw in kwList" :key="kw" closable type="danger" plain @close="removeKw(kw)">{{ kw }}</el-tag>
@@ -140,19 +173,20 @@
<el-button size="small" @click="openRegionDialog">选择地区</el-button>
</div>
</el-form-item>
<el-form-item label="频次">
<div class="ce-note">频次策略由 <router-link to="/policy" class="ce-link">规则策略中心</router-link> 统一配置(账号维度)</div>
</el-form-item>
<el-form-item label="模板ID模式">
<el-switch v-model="form.template_mode" :active-value="1" :inactive-value="0" />
<span class="hint ce-hint">上游模板ID模式({%变量%})</span>
</el-form-item>
</el-col>
</el-row>
</el-collapse-item>
<!-- ④ 通道配置(按协议动态) -->
<el-collapse-item :title="`通道配置(${form.protocol.toUpperCase()})`" name="conn">
<el-collapse-item name="conn">
<template #title>
<div class="ce-sec">
<span class="ce-idx">04</span>
<span class="ce-sec-name">通道配置</span>
<span class="ce-proto">{{ form.protocol.toUpperCase() }}</span>
<span class="ce-sec-sub">上游连接地址与协议参数</span>
</div>
</template>
<el-row :gutter="16">
<el-col :span="12">
<el-form-item :label="form.protocol === 'http' ? '接口地址' : '连接地址 IP/域名'" prop="host">
@@ -171,6 +205,10 @@
<el-input v-model="form.password" type="password" show-password :placeholder="isEdit ? '留空则不修改' : ''" />
</el-form-item>
</template>
<el-form-item label="通道号(接入码)" prop="code">
<el-input v-model="form.code" placeholder="如 10690" />
<span class="hint ce-hint">运营侧接入码,码号规则见拦截机制组</span>
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item v-if="form.protocol === 'cmpp'" label="CMPP版本">
@@ -205,7 +243,14 @@
</el-collapse-item>
<!-- ⑤ 优先发送(只读聚合:数据源为通道组四步路由 step2) -->
<el-collapse-item title="优先发送" name="priority">
<el-collapse-item name="priority">
<template #title>
<div class="ce-sec">
<span class="ce-idx">05</span>
<span class="ce-sec-name">优先发送</span>
<span class="ce-sec-sub">通道组路由聚合,只读</span>
</div>
</template>
<template v-if="isEdit">
<el-table v-if="priorityItems.length" :data="priorityItems" size="small">
<el-table-column prop="group" label="所属通道组" width="180" />
@@ -219,20 +264,36 @@
</el-collapse-item>
<!-- ⑥ 备注 -->
<el-collapse-item title="备注" name="remark">
<el-collapse-item name="remark">
<template #title>
<div class="ce-sec">
<span class="ce-idx">06</span>
<span class="ce-sec-name">备注</span>
<span class="ce-sec-sub">内部信息,客服备注仅客服可见</span>
</div>
</template>
<el-row :gutter="16">
<el-col :span="12">
<el-form-item label="备注">
<el-input v-model="form.remark" type="textarea" :rows="2" maxlength="255" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="客服备注">
<el-input v-model="form.service_remark" type="textarea" :rows="2" maxlength="255" placeholder="仅客服可见" />
</el-form-item>
</el-col>
</el-row>
</el-collapse-item>
</el-collapse>
<el-form-item class="ce-actions">
<el-button type="primary" :loading="saving" @click="save">确认保存</el-button>
<div class="ce-footer">
<span class="ce-footer-hint">带 <em class="ce-footer-star">*</em> 为必填项,未填写的选填项使用系统默认值</span>
<span class="ce-footer-btns">
<el-button @click="cancel">取消</el-button>
</el-form-item>
<el-button type="primary" :loading="saving" @click="save">确认保存</el-button>
</span>
</div>
</el-form>
</section>
@@ -411,12 +472,35 @@ function cancel() {
</script>
<style scoped>
/* W4:el-card 壳→shell .card+card-head;原子类(mb/flex/gap/text-star/!w-[])语义化 */
/* W4:el-card 壳→shell .card+card-head;原子类(mb/flex/gap/text-star/!w-[])语义化
S4(issue#1):表单 100% 内容区宽(去 860 上限)+编号式分区标题+粘性操作底栏 */
.ce-breadcrumb { margin-bottom: 12px; }
.ce-card { padding: 16px 18px 14px; }
.ce-card { padding: 16px 18px 0; }
.ce-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; margin-bottom: 10px; }
.ce-head-main { display: flex; align-items: baseline; gap: 10px; min-width: 0; }
.card-head-title { font-size: var(--gosms-fs-md); font-weight: 600; color: var(--gosms-text-bright); }
.ce-form { max-width: 860px; }
.ce-head-sub { font-size: var(--gosms-fs-sm); font-weight: 400; color: var(--gosms-text-muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
/* 表单铺满内容区(issue#1 主诉:原 max-width:860px 右侧大片空白) */
.ce-form { width: 100%; }
/* 编号式分区标题(参照盈讯通 1通道模板…5备注 信息架构) */
.ce-sec { display: flex; align-items: center; gap: 10px; min-width: 0; }
.ce-idx {
font-family: ui-monospace, 'JetBrains Mono', Consolas, monospace;
font-size: var(--gosms-fs-sm); font-weight: 600; line-height: 20px;
color: var(--gosms-primary); background: var(--gosms-primary-soft);
border: 1px solid var(--gosms-border-glow); border-radius: 5px;
padding: 0 6px; letter-spacing: 0.5px;
}
.ce-sec-name { font-size: var(--gosms-fs-body); font-weight: 600; color: var(--gosms-text-bright); }
.ce-proto {
font-family: ui-monospace, Consolas, monospace; font-size: var(--gosms-fs-xs);
line-height: 16px; color: var(--gosms-text-secondary);
border: 1px solid var(--gosms-border-strong); border-radius: 4px; padding: 0 5px;
}
.ce-sec-sub { font-size: var(--gosms-fs-sm); color: var(--gosms-text-muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.ce-hint { margin-left: 8px; }
.ce-hint-block { margin-top: 4px; }
.ce-w160 { width: 160px; }
@@ -427,7 +511,19 @@ function cancel() {
.ce-note { font-size: var(--gosms-fs-2xs); color: var(--gosms-text-muted); }
.ce-link { color: var(--gosms-primary); }
.ce-warn { width: 100%; font-size: var(--gosms-fs-2xs); color: var(--gosms-amber); }
.ce-actions { margin-top: 16px; }
.ce-rule-group { display: flex; flex-wrap: wrap; gap: 4px 0; }
.ce-region-grid { display: grid; grid-template-columns: repeat(4, 1fr); row-gap: 8px; }
/* 粘性操作底栏:贴卡底、玻璃底、滚动长表单时始终可达 */
.ce-footer {
position: sticky; bottom: 0; z-index: 5;
display: flex; align-items: center; justify-content: space-between; gap: 12px;
margin: 14px -18px 0; padding: 12px 18px;
background: var(--gosms-glass); backdrop-filter: blur(10px);
border-top: 1px solid var(--gosms-border); border-radius: 0 0 15px 15px;
}
.ce-footer-hint { font-size: var(--gosms-fs-sm); color: var(--gosms-text-muted); }
.ce-footer-star { font-style: normal; color: var(--gosms-red); }
.ce-footer-btns { display: flex; gap: 0; }
</style>
+44 -40
View File
@@ -12,53 +12,45 @@
<template #actions>
<el-button type="primary" @click="$router.push('/channel/edit')" v-permission="'channel:write'">新建通道</el-button>
</template>
<el-table-column prop="name" label="名称" min-width="120" />
<el-table-column prop="code" label="通道号" width="95" />
<el-table-column label="协议" width="75">
<el-table-column prop="id" label="ID" width="76" sortable />
<!-- 聚合列:双语义主行+次行(issue#1 参照盈讯通「运营商/通道名称」7 列聚合范式) -->
<el-table-column label="运营商/通道名称" min-width="190">
<template #default="{ row }">
<div class="cl-cell">
<div class="cl-main">
<span class="cl-name">{{ row.name }}</span>
<el-tag size="small">{{ String(row.protocol).toUpperCase() }}</el-tag>
<el-tag v-if="row.is_default" size="small" type="success">兜底</el-tag>
</div>
<span class="cl-sub">{{ carrierLabels(row.carrier) || '—' }}</span>
</div>
</template>
</el-table-column>
<el-table-column label="企业ID/速度" width="150">
<template #default="{ row }">
<div class="cl-cell">
<span class="cl-main cl-clip">{{ row.sp_id || row.username || '—' }}</span>
<span class="cl-sub">{{ row.speed }}×{{ row.conn_count }}={{ Number(row.speed) * Number(row.conn_count) }} 条/s</span>
</div>
</template>
</el-table-column>
<el-table-column label="接入码/地址" min-width="180">
<template #default="{ row }">
<div class="cl-cell">
<span class="cl-main cl-clip">{{ row.code }}</span>
<span class="cl-sub">{{ row.host }}{{ row.protocol === 'http' ? '' : `:${row.port}` }}</span>
</div>
</template>
</el-table-column>
<el-table-column prop="upstream_name" label="上家" min-width="110" show-overflow-tooltip />
<el-table-column label="地址" min-width="150" show-overflow-tooltip>
<template #default="{ row }">{{ row.host }}{{ row.protocol === 'http' ? '' : `:${row.port}` }}</template>
</el-table-column>
<el-table-column prop="username" label="账号" width="90" show-overflow-tooltip />
<el-table-column prop="speed" label="速度(条/s)" width="95" sortable />
<el-table-column prop="conn_count" label="连接数" width="70" />
<el-table-column label="总速度" width="85">
<template #default="{ row }">{{ Number(row.speed) * Number(row.conn_count) }}</template>
</el-table-column>
<el-table-column prop="priority" label="优先级" width="70" sortable />
<el-table-column prop="weight" label="权重" width="60" sortable />
<el-table-column label="默认" width="55">
<el-table-column label="优先级/限额" width="150">
<template #default="{ row }">
<el-tag v-if="row.is_default" size="small" type="success">兜底</el-tag>
<div class="cl-cell">
<span class="cl-main">P{{ row.priority }} · 权重 {{ row.weight }}</span>
<span class="cl-sub">日限 {{ row.day_limit > 0 ? row.day_limit : '不限' }} · 夜间 {{ row.night_limit > 0 ? '禁发' : '不限' }}</span>
</div>
</template>
</el-table-column>
<el-table-column prop="day_limit" label="日限额" width="90">
<template #default="{ row }">{{ row.day_limit > 0 ? row.day_limit : '不限' }}</template>
</el-table-column>
<el-table-column prop="night_limit" label="夜间限速" width="80">
<template #default="{ row }">{{ row.night_limit > 0 ? row.night_limit : '不限' }}</template>
</el-table-column>
<el-table-column prop="sign_mode" label="签名模式" width="80">
<template #default="{ row }">{{ ['后置', '前置', '智能'][row.sign_mode] ?? row.sign_mode }}</template>
</el-table-column>
<el-table-column prop="ext_length" label="扩展码长" width="75" />
<el-table-column label="模板ID" width="65">
<template #default="{ row }">{{ row.template_mode ? '是' : '否' }}</template>
</el-table-column>
<el-table-column prop="black_keywords" label="黑关键字" min-width="110" show-overflow-tooltip>
<template #default="{ row }">{{ row.black_keywords || '-' }}</template>
</el-table-column>
<el-table-column prop="block_regions" label="屏蔽地区" min-width="95" show-overflow-tooltip>
<template #default="{ row }">{{ row.block_regions || '-' }}</template>
</el-table-column>
<el-table-column prop="remark" label="备注" min-width="100" show-overflow-tooltip>
<template #default="{ row }">{{ row.remark || '-' }}</template>
</el-table-column>
<el-table-column prop="created_at" label="创建时间" width="160" />
<el-table-column label="状态" width="70">
<template #default="{ row }">
<el-switch :model-value="row.status === 1" @change="toggle(row as Channel)" />
@@ -117,6 +109,12 @@ import { onBeforeUnmount, onMounted, reactive, ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import ProTable from '@/components/ProTable.vue'
import { channelApi, PROTOCOLS, type Channel, type LinkStatus, type Receipt } from '@/api/channel'
import { CARRIERS } from './channel-form'
/** 运营商码值串 → 中文标签('cmcc,cucc' → '移动/联通')。 */
const carrierLabels = (carrier?: string): string =>
(carrier ?? '').split(',').map((s) => s.trim()).filter(Boolean)
.map((v) => CARRIERS.find((c) => c.value === v)?.label ?? v).join('/')
const rows = ref<Record<string, unknown>[]>([])
const total = ref(0)
@@ -212,7 +210,13 @@ onMounted(load)
</script>
<style scoped>
/* W4:drawer 内原子类语义化(mb-3→drawer-block/mt-2→间距类) */
/* W4:drawer 内原子类语义化(mb-3→drawer-block/mt-2→间距类)
S4(issue#1):列表 20 列→8 列聚合,双语义单元格(主行亮/次行 muted) */
.drawer-block { margin-bottom: 12px; }
.drawer-refresh-hint { margin-top: 8px; }
.cl-cell { display: flex; flex-direction: column; gap: 3px; padding: 3px 0; }
.cl-main { display: flex; align-items: center; gap: 6px; min-width: 0; }
.cl-name { font-weight: 600; color: var(--gosms-text-bright); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.cl-clip { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.cl-sub { font-size: var(--gosms-fs-sm); color: var(--gosms-text-muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
</style>
+2 -7
View File
@@ -23,10 +23,10 @@
<div class="glass-card login-card animate-slide-up">
<el-form ref="formRef" :model="form" :rules="rules" label-position="top" @keyup.enter="submit">
<el-form-item label="用户名" prop="username">
<el-input v-model="form.username" size="large" :placeholder="isMock ? '账号 · admin' : '请输入用户名'" data-testid="login-username" />
<el-input v-model="form.username" size="large" placeholder="请输入用户名" data-testid="login-username" />
</el-form-item>
<el-form-item label="密码" prop="password">
<el-input v-model="form.password" type="password" size="large" show-password :placeholder="isMock ? '密码 · ·······' : '请输入密码'" data-testid="login-password" />
<el-input v-model="form.password" type="password" size="large" show-password placeholder="请输入密码" data-testid="login-password" />
</el-form-item>
<el-button type="primary" size="large" class="login-btn btn-gradient" :loading="loading" data-testid="login-submit" @click="submit">
{{ loading ? '登录中…' : '登 录' }}
@@ -34,8 +34,6 @@
</el-form>
<!-- E5:安全提示(demo login-sec) -->
<p class="login-sec">连续 5 次失败将锁定 15 分钟</p>
<!-- C1:演示账号提示仅 mock 模式显示(与 main.ts worker 启用条件一致) -->
<p v-if="isMock" class="login-tip">Mock 账号:admin/admin123 · customer/123456</p>
</div>
</div>
</div>
@@ -54,8 +52,6 @@ const route = useRoute()
const userStore = useUserStore()
const formRef = ref<FormInstance>()
const loading = ref(false)
// C1:mock 演示提示只在开发态 mock 模式出现(生产 real 模式不泄露演示账号)
const isMock = import.meta.env.DEV && import.meta.env.VITE_API_MODE === 'mock'
const form = reactive({ username: '', password: '' })
const rules: FormRules = {
@@ -139,5 +135,4 @@ async function submit() {
.login-card { padding: 32px; }
.login-btn { width: 100%; margin-top: 8px; letter-spacing: 0.04em; }
.login-sec { color: var(--gosms-text-secondary); font-size: var(--gosms-fs-sm); text-align: center; margin: 14px 0 0; }
.login-tip { color: var(--gosms-text-secondary); font-size: var(--gosms-fs-base); text-align: center; margin: 6px 0 0; }
</style>
+130
View File
@@ -0,0 +1,130 @@
<template>
<div class="page-stack">
<section class="card cb-card">
<div class="cb-head">
<div>
<span class="card-head-title">回调管理</span>
<el-tag size="small" type="warning" class="cb-badge">S4·C1 验收版</el-tag>
</div>
<span class="cb-sub">客户回调推送任务(回执终态/上行)· 指数退避重试 · 死信可查可重派</span>
</div>
<!-- 数据脉象:状态计数面板(死信存量一眼可见) -->
<div class="cb-counts">
<div class="cb-count"><span class="cb-num">{{ counts.pending ?? 0 }}</span><span class="cb-label">待推送/重试中</span></div>
<div class="cb-count"><span class="cb-num cb-ok">{{ counts.sent ?? 0 }}</span><span class="cb-label">已送达</span></div>
<div class="cb-count"><span class="cb-num" :class="{ 'cb-dead': (counts.dead ?? 0) > 0 }">{{ counts.dead ?? 0 }}</span><span class="cb-label">死信(重试耗尽)</span></div>
</div>
<div class="cb-filters">
<el-select v-model="q.status" placeholder="状态(全部)" clearable style="width: 140px" @change="load">
<el-option label="待推送" :value="0" /><el-option label="已送达" :value="1" /><el-option label="死信" :value="2" />
</el-select>
<el-select v-model="q.type" placeholder="类型(全部)" clearable style="width: 130px" @change="load">
<el-option label="回执终态" :value="1" /><el-option label="上行消息" :value="2" />
</el-select>
<el-input-number v-model="q.account_id" :min="0" placeholder="账号ID" :controls="false" style="width: 110px" @change="load" />
<el-button type="primary" :loading="loading" @click="load">查询</el-button>
<el-button @click="showPayload = !showPayload">{{ showPayload ? '隐藏载荷' : '展开载荷' }}</el-button>
</div>
<el-table v-loading="loading" :data="rows" size="small">
<el-table-column prop="id" label="ID" width="80" sortable />
<el-table-column prop="account_id" label="账号" width="80" />
<el-table-column label="类型" width="90">
<template #default="{ row }">
<el-tag size="small" :type="row.type === 2 ? 'warning' : 'primary'">{{ CALLBACK_TYPE[row.type] ?? row.type }}</el-tag>
</template>
</el-table-column>
<el-table-column prop="url" label="回调地址" min-width="200" show-overflow-tooltip />
<el-table-column label="状态" width="100">
<template #default="{ row }">
<el-tag size="small" :type="row.status === 1 ? 'success' : row.status === 2 ? 'danger' : 'info'">
{{ CALLBACK_STATUS[row.status] ?? row.status }}
</el-tag>
</template>
</el-table-column>
<el-table-column prop="attempt" label="重试" width="70" />
<el-table-column label="最近结果" min-width="150" show-overflow-tooltip>
<template #default="{ row }">{{ row.last_code ? `HTTP ${row.last_code}` : '—' }}{{ row.last_err ? ` · ${row.last_err}` : '' }}</template>
</el-table-column>
<el-table-column prop="next_retry_at" label="下次重试" width="170" />
<el-table-column prop="created_at" label="入队时间" width="170" />
<el-table-column v-if="showPayload" label="载荷(JSON)" min-width="260">
<template #default="{ row }"><code class="cb-payload">{{ row.payload }}</code></template>
</el-table-column>
<el-table-column label="操作" width="110" fixed="right">
<template #default="{ row }">
<el-button v-if="row.status === 2" size="small" type="primary" @click="resend(row)">重派</el-button>
<span v-else class="cb-done">—</span>
</template>
</el-table-column>
<template #empty>
<el-empty description="暂无回调任务——账号配置 report_url/uplink_url 后,回执终态与上行消息自动入队推送" />
</template>
</el-table>
<el-pagination v-if="total > q.page_size" v-model:current-page="q.page" :page-size="q.page_size" :total="total"
layout="total, prev, pager, next" class="cb-pager" @current-change="load" />
</section>
</div>
</template>
<script setup lang="ts">
/** 回调管理页(S4·C1):callback_task 列表 + 状态面板 + 死信重派。
* 口径:PushWorker 在 consumer 进程投递(2s 扫描/2^n 秒退避/10 次耗尽死信);
* 本页仅管理面——列表查询 + 死信重派(POST /ops/callback/:id/resend)。 */
import { onMounted, reactive, ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import { callbackApi, CALLBACK_STATUS, CALLBACK_TYPE, type CallbackTask } from '@/api/callback'
const rows = ref<CallbackTask[]>([])
const counts = ref<Record<string, number>>({})
const total = ref(0)
const loading = ref(false)
const showPayload = ref(false)
const q = reactive<Record<string, number>>({ page: 1, page_size: 20, status: -1, type: 0, account_id: 0 })
async function load() {
loading.value = true
try {
const params: Record<string, unknown> = { page: q.page, page_size: q.page_size }
if (q.status >= 0) params.status = q.status
if (q.type > 0) params.type = q.type
if (q.account_id > 0) params.account_id = q.account_id
const res = await callbackApi.list(params)
rows.value = res.list ?? []
total.value = res.total ?? 0
counts.value = res.status_counts ?? {}
} finally {
loading.value = false
}
}
async function resend(row: CallbackTask) {
await ElMessageBox.confirm(`重派任务 #${row.id} 到 ${row.url}?重试计数将清零并立即投递。`, '死信重派', { type: 'warning' })
await callbackApi.resend(row.id)
ElMessage.success(`任务 #${row.id} 已重派`)
await load()
}
onMounted(load)
</script>
<style scoped>
.cb-card { display: grid; gap: 14px; }
.cb-head { display: flex; justify-content: space-between; align-items: baseline; gap: 12px; flex-wrap: wrap; }
.cb-badge { margin-left: 8px; }
.cb-sub { font-size: 12px; opacity: 0.65; }
.cb-counts { display: flex; gap: 12px; }
.cb-count { flex: 1; display: grid; gap: 2px; padding: 10px 14px; border-radius: 10px; background: var(--el-fill-color-light); }
.cb-num { font-size: 22px; font-weight: 600; font-variant-numeric: tabular-nums; }
.cb-ok { color: var(--el-color-success); }
.cb-dead { color: var(--el-color-danger); }
.cb-label { font-size: 12px; opacity: 0.65; }
.cb-filters { display: flex; gap: 10px; flex-wrap: wrap; align-items: center; }
.cb-payload { font-size: 11px; word-break: break-all; opacity: 0.85; }
.cb-done { opacity: 0.4; }
.cb-pager { justify-self: end; }
</style>
+166
View File
@@ -0,0 +1,166 @@
<template>
<div class="page-stack">
<section class="card pf-card">
<div class="pf-head">
<div>
<span class="card-head-title">利润分析</span>
<el-tag size="small" type="warning" class="pf-badge">FE-D34 · S3</el-tag>
</div>
<span class="pf-sub">用户利润(含下级返点 R4)· 通道利润 —— S2-D5 /stats/profit 双端点</span>
</div>
<div class="pf-filters">
<el-date-picker v-model="range" type="daterange" range-separator="至" start-placeholder="开始" end-placeholder="结束"
value-format="YYYY-MM-DD" style="width: 260px" @change="reload" />
<el-input-number v-if="tab === 'users'" v-model="parentId" :min="0" placeholder="上级账号(0=全平台)"
:controls="false" style="width: 150px" @change="loadUsers" />
<el-input-number v-else v-model="channelId" :min="0" placeholder="通道ID(0=全部)" :controls="false"
style="width: 140px" @change="loadChannels" />
<el-button type="primary" :loading="tab === 'users' ? loading.users : loading.channels" @click="reload">查询</el-button>
</div>
<el-tabs v-model="tab" class="pf-tabs" @tab-change="reload">
<!-- Tab1 用户利润 -->
<el-tab-pane label="用户利润" name="users">
<div v-if="summary" class="pf-summary">
<div class="pf-sum-item"><span class="pf-sum-label">应收(时间线价)</span><span class="pf-sum-val">{{ money(summary.total_revenue) }}</span></div>
<div class="pf-sum-item"><span class="pf-sum-label">通道成本(分摊)</span><span class="pf-sum-val">{{ money(summary.total_cost) }}</span></div>
<div class="pf-sum-item"><span class="pf-sum-label">代理返点(让利)</span><span class="pf-sum-val">{{ money(summary.total_rebate) }}</span></div>
<div class="pf-sum-item pf-sum-key"><span class="pf-sum-label">平台净利</span><span class="pf-sum-val">{{ money(summary.platform_profit) }}</span></div>
<div class="pf-sum-item"><span class="pf-sum-label">账号数</span><span class="pf-sum-val">{{ summary.count }}</span></div>
</div>
<el-table v-loading="loading.users" :data="userRows" size="small">
<el-table-column prop="account_id" label="账号ID" width="90" />
<el-table-column prop="username" label="用户名" min-width="110" show-overflow-tooltip />
<el-table-column prop="role" label="角色" width="90" />
<el-table-column prop="success_count" label="成功条数" width="100" sortable />
<el-table-column label="收入(元)" width="110" align="right">
<template #default="{ row }">{{ money(row.revenue) }}</template>
</el-table-column>
<el-table-column label="成本分摊(元)" width="120" align="right">
<template #default="{ row }">{{ money(row.cost) }}</template>
</el-table-column>
<el-table-column label="返点(元)" width="100" align="right">
<template #default="{ row }">{{ money(row.rebate) }}</template>
</el-table-column>
<el-table-column label="利润(元)" width="110" align="right" sortable prop="profit">
<template #default="{ row }">
<span :class="row.profit >= 0 ? 'pf-pos' : 'pf-neg'">{{ money(row.profit) }}</span>
</template>
</el-table-column>
<template #empty><el-empty description="窗口内无消耗账号" /></template>
</el-table>
</el-tab-pane>
<!-- Tab2 通道利润 -->
<el-tab-pane label="通道利润" name="channels">
<el-table v-loading="loading.channels" :data="channelRows" size="small">
<el-table-column prop="channel_id" label="通道ID" width="90" />
<el-table-column prop="name" label="通道名称" min-width="130" show-overflow-tooltip />
<el-table-column label="上家" width="90">
<template #default="{ row }">
<el-tag v-if="row.upstream_id > 0" size="small">#{{ row.upstream_id }}</el-tag>
<span v-else class="pf-dim">未绑</span>
</template>
</el-table-column>
<el-table-column prop="success_count" label="成功条数" width="110" sortable />
<el-table-column label="收入分摊(元)" width="120" align="right">
<template #default="{ row }">{{ money(row.revenue) }}</template>
</el-table-column>
<el-table-column label="成本(元)" width="110" align="right">
<template #default="{ row }">{{ money(row.cost) }}</template>
</el-table-column>
<el-table-column label="利润(元)" width="110" align="right" sortable prop="profit">
<template #default="{ row }">
<span :class="row.profit >= 0 ? 'pf-pos' : 'pf-neg'">{{ money(row.profit) }}</span>
</template>
</el-table-column>
<template #empty><el-empty description="窗口内无通道消耗" /></template>
</el-table>
</el-tab-pane>
</el-tabs>
<el-alert class="pf-note" type="info" :closable="false"
title="口径:收入=Σ日成功×价格时间线(阶梯为月结覆写项,不进分析,与账单金额差=口径差异);成本与通道收入=按成功条数占比分摊(无账号×通道交叉粒度事实源);返点=直线下级结算额×其返点率(R4,历史不重算)" />
</section>
</div>
</template>
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue'
import { ElMessage } from 'element-plus'
import { settleApi, type UserProfitRow, type UserProfitSummary, type ChannelProfitRow } from '@/api/settle'
defineOptions({ name: 'StatsProfitView' })
const tab = ref<'users' | 'channels'>('users')
const parentId = ref(0)
const channelId = ref(0)
const userRows = ref<UserProfitRow[]>([])
const channelRows = ref<ChannelProfitRow[]>([])
const summary = ref<UserProfitSummary | null>(null)
const loading = reactive({ users: false, channels: false })
// 缺省窗口=本月 1 号~今天(与后端缺省口径一致)。
const pad = (n: number) => String(n).padStart(2, '0')
const monthStart = () => {
const d = new Date()
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-01`
}
const today = () => {
const d = new Date()
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
}
const range = ref<[string, string] | null>([monthStart(), today()])
const money = (n: number) => Number(n ?? 0).toFixed(2)
function windowParams() {
const r = range.value ?? [monthStart(), today()]
return { date_from: r[0], date_to: r[1], page: 1, page_size: 50 }
}
async function loadUsers() {
loading.users = true
try {
const params = { ...windowParams(), ...(parentId.value > 0 ? { parent_id: parentId.value } : {}) }
const res = await settleApi.profitUsers(params)
userRows.value = res.list ?? []
summary.value = res.summary ?? null
} catch (e) { ElMessage.error((e as Error).message) } finally { loading.users = false }
}
async function loadChannels() {
loading.channels = true
try {
const params = { ...windowParams(), ...(channelId.value > 0 ? { channel_id: channelId.value } : {}) }
const res = await settleApi.profitChannels(params)
channelRows.value = res.list ?? []
} catch (e) { ElMessage.error((e as Error).message) } finally { loading.channels = false }
}
function reload() {
if (tab.value === 'users') loadUsers()
else loadChannels()
}
onMounted(() => { loadUsers(); loadChannels() })
</script>
<style scoped>
.pf-card { padding: 16px 20px; }
.pf-head { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; flex-wrap: wrap; margin-bottom: 4px; }
.pf-badge { margin-left: 8px; }
.pf-sub { color: var(--gosms-text-muted); font-size: var(--gosms-fs-base); }
.pf-filters { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin: 10px 0; }
.pf-tabs { margin-top: 4px; }
.pf-summary { display: flex; gap: 26px; flex-wrap: wrap; align-items: center; padding: 10px 14px; margin-bottom: 10px; border-radius: 8px; background: var(--gosms-bg-soft, rgba(127, 127, 127, 0.08)); }
.pf-sum-item { display: flex; flex-direction: column; gap: 2px; }
.pf-sum-label { color: var(--gosms-text-muted); font-size: 12px; }
.pf-sum-val { font-size: 16px; font-weight: 600; }
.pf-sum-key .pf-sum-val { color: var(--el-color-primary); }
.pf-pos { color: var(--el-color-success); }
.pf-neg { color: var(--el-color-danger); }
.pf-dim { color: var(--gosms-text-muted); }
.pf-note { margin-top: 12px; }
</style>
+4 -4
View File
@@ -2,13 +2,13 @@ import { describe, expect, it } from 'vitest'
import { accessibleRoutes } from '@/router/guard'
describe('路由权限过滤 accessibleRoutes', () => {
it('admin 直通全部业务路由(30 模块菜单,含 FE-2 通道与策略五入口+D19 定时任务+D20 模板管理+D22 结果反馈+D23 短信聚合页+D24 下行记录+D27 上行记录+D28 回执工具)', () => {
it('admin 直通全部业务路由(32 模块菜单,含 FE-2 通道与策略五入口+D19 定时任务+D20 模板管理+D22 结果反馈+D23 短信聚合页+D24 下行记录+D27 上行记录+D28 回执工具+S3·FE-D34 利润分析+S4·C1 回调管理)', () => {
const all = accessibleRoutes(['admin'])
const menus = all.flatMap((r) => (r.children ?? []).filter((c) => c.meta?.menu))
expect(menus.length).toBe(31)
// FE-2/D23 关键入口在菜单(D11 上家/D14 通道组/D16 导流+报备/D19 定时任务/D20 模板管理/D22 结果反馈/D23 聚合页)
expect(menus.length).toBe(33)
// FE-2/D23/S3 关键入口在菜单(D11 上家/D14 通道组/D16 导流+报备/D19 定时任务/D20 模板管理/D22 结果反馈/D23 聚合页/FE-D34 利润分析)
const names = menus.map((m) => m.name)
for (const want of ['channel-upstream', 'channel-group', 'policy-route', 'policy-report', 'sms-timer', 'sms-template', 'sms-result', 'sms-home', 'record-down']) {
for (const want of ['channel-upstream', 'channel-group', 'policy-route', 'policy-report', 'sms-timer', 'sms-template', 'sms-result', 'sms-home', 'record-down', 'stats-profit', 'ops-callback']) {
expect(names).toContain(want)
}
})
+74
View File
@@ -0,0 +1,74 @@
// profit-view.spec.ts S3·FE-D34:利润分析页(msw 局部 handler,不动全局种子——
// 与 settle 页同策略:结算域端点走真库联调,组件测试用 server.use 注入契约)。
// 锁定:双端点参数契约(date_from/date_to/parent_id/channel_id)、汇总条渲染、
// 利润正负着色、口径说明常驻(诚实标注)。
import { describe, expect, it, afterEach } from 'vitest'
import { http, HttpResponse } from 'msw'
import { mount, flushPromises } from '@vue/test-utils'
import ElementPlus from 'element-plus'
import { server } from '../mocks/node'
import StatsProfitView from '../src/views/stats/profit/index.vue'
import { settleApi } from '../src/api/settle'
const usersData = {
list: [
{ account_id: 1, username: 'root', role: 'group', success_count: 100, revenue: 10, cost: 4, rebate: 1.0, profit: 7 },
{ account_id: 12, username: 'a12', role: 'customer', success_count: 10, revenue: 0, cost: 0.4, rebate: 0, profit: -0.4 },
],
total: 2,
summary: { count: 2, total_revenue: 10, total_cost: 4.4, total_rebate: 1.0, platform_profit: 4.6 },
}
const channelsData = {
list: [{ channel_id: 9101, name: 'c1', upstream_id: 7, success_count: 150, revenue: 24, cost: 6, profit: 18 }],
total: 1,
}
let lastUsersQuery = ''
let lastChannelsQuery = ''
function stubProfit() {
server.use(
http.get('*/api/v1/stats/profit/users', ({ request }) => {
lastUsersQuery = request.url
return HttpResponse.json({ code: 'ISC:000', msg: '成功', data: usersData })
}),
http.get('*/api/v1/stats/profit/channels', ({ request }) => {
lastChannelsQuery = request.url
return HttpResponse.json({ code: 'ISC:000', msg: '成功', data: channelsData })
}),
)
}
afterEach(() => server.resetHandlers())
describe('FE-D34 利润分析', () => {
it('api 契约:用户/通道端点参数与响应结构', async () => {
stubProfit()
const users = await settleApi.profitUsers({ date_from: '2026-11-01', date_to: '2026-11-30', parent_id: 10 })
expect(users.summary.platform_profit).toBe(4.6)
expect(users.list[0].rebate).toBe(1.0)
expect(lastUsersQuery).toContain('date_from=2026-11-01')
expect(lastUsersQuery).toContain('parent_id=10')
const channels = await settleApi.profitChannels({ date_from: '2026-11-01', date_to: '2026-11-30', channel_id: 2 })
expect(channels.list[0].profit).toBe(18)
expect(lastChannelsQuery).toContain('channel_id=2')
})
it('组件:双 Tab 数据渲染+汇总条+利润正负着色+口径说明', async () => {
stubProfit()
const w = mount(StatsProfitView, { global: { plugins: [ElementPlus] } })
await flushPromises()
const text = w.text()
// 汇总条:平台净利 4.60 与账号数。
expect(text).toContain('平台净利')
expect(text).toContain('4.60')
// 用户行:正利润 7.00 / 负利润 -0.40(无价账号)。
expect(text).toContain('7.00')
expect(text).toContain('-0.40')
// 口径说明常驻(分摊/阶梯不进分析/返点 R4)。
expect(text).toContain('占比分摊')
expect(text).toContain('不进分析')
expect(w.find('.pf-neg').exists()).toBe(true)
// 通道 Tab 数据在挂载时一并加载。
expect(w.html()).toContain('18.00')
})
})
+73
View File
@@ -0,0 +1,73 @@
// role-menu-matrix.spec.ts S3·FE-6:五角色×全菜单权限矩阵走查(自动化快照)。
// 预期矩阵为**人工确认后的固化表**(非 routes.ts 同源推导)——任何人改动路由
// roles 都会在此暴露,走查语义=矩阵变更必须显式过目(与后端 casbin 五角色门对齐)。
// 语义基准:资金/通道/结算页=admin/ops;service=运营执行;group/customer=业务
// 与记录自助,不见平台资金信息(与后端 statsIsPlatform/ordersList/profit 平台门一致)。
import { describe, expect, it } from 'vitest'
import { accessibleRoutes } from '@/router/guard'
type Roles = 'admin' | 'ops' | 'service' | 'group' | 'customer'
const ALL: Roles[] = ['admin', 'ops', 'service', 'group', 'customer']
/** 预期矩阵:菜单 name → 允许角色(S3 固化,含 FE-D34 利润分析)。 */
const MATRIX: Record<string, Roles[]> = {
home: ALL,
notice: ['admin', 'ops', 'service', 'group'],
'account-list': ['admin', 'ops'],
audit: ['admin', 'ops', 'service'],
'sms-home': ALL, 'sms-batch': ALL, 'sms-personal': ALL, 'sms-timer': ALL,
'sms-result': ALL, 'sms-template': ALL, 'sms-downlink-detail': ALL,
video: ['admin', 'ops'], csp: ['admin', 'ops'], nullfilter: ['admin', 'ops'], shortlink: ['admin', 'ops'],
'record-down': ALL, 'record-up': ALL,
'record-repush': ['admin', 'ops', 'service'],
channel: ['admin', 'ops'], 'channel-upstream': ['admin', 'ops'], 'channel-group': ['admin', 'ops'],
policy: ['admin', 'ops'], 'policy-route': ['admin', 'ops'], 'policy-report': ['admin', 'ops'],
contacts: ALL,
'stats-user': ['admin', 'ops', 'service'], 'stats-channel': ['admin', 'ops'],
'stats-profit': ['admin', 'ops', 'service'], settle: ['admin', 'ops'],
'ops-callback': ['admin', 'ops'],
logs: ['admin', 'ops', 'service'], system: ['admin'], faq: ALL,
}
/** 实测:某角色经守卫过滤后的可见菜单集合。 */
function visibleMenus(role: Roles): Set<string> {
return new Set(
accessibleRoutes([role])
.flatMap((r) => r.children ?? [])
.filter((c) => c.meta?.menu)
.map((c) => String(c.name)),
)
}
describe('S3·FE-6 五角色×全菜单权限矩阵', () => {
const roles: Roles[] = ['admin', 'ops', 'service', 'group', 'customer']
it.each(roles)('角色 %s 可见菜单与矩阵一致', (role) => {
const visible = visibleMenus(role)
for (const [name, allow] of Object.entries(MATRIX)) {
const want = allow.includes(role)
expect(visible.has(name), `${role} × ${name}:期望${want ? '可见' : '不可见'}`).toBe(want)
}
})
it('矩阵覆盖全部菜单项(新增菜单未登记矩阵=本测试红,走查强制过目)', () => {
const adminVisible = visibleMenus('admin')
for (const name of adminVisible) expect(MATRIX[name], `菜单 ${name} 未登记矩阵`).toBeDefined()
expect(adminVisible.size).toBe(Object.keys(MATRIX).length)
})
it('资金与平台配置页对 group/customer 关闭(语义抽样:settle/stats-profit/channel/system)', () => {
for (const role of ['group', 'customer'] as Roles[]) {
const visible = visibleMenus(role)
for (const denied of ['settle', 'stats-profit', 'stats-channel', 'channel', 'channel-upstream', 'system', 'account-list', 'audit']) {
expect(visible.has(denied), `${role} 不应见 ${denied}`).toBe(false)
}
}
})
it('system 配置仅 admin', () => {
for (const role of ['ops', 'service', 'group', 'customer'] as Roles[]) {
expect(visibleMenus(role).has('system')).toBe(false)
}
})
})
+21 -1
View File
@@ -7,10 +7,30 @@ export default defineConfig({
resolve: {
alias: { '@': fileURLToPath(new URL('./src', import.meta.url)) },
},
build: {
rollupOptions: {
output: {
// S3·FE-6 单包<500KB(gzip):主包曾 1.27MB(裸)/410KB(gzip)——
// element-plus 全量与 vue 系拆 vendor chunk,业务主包独立小包;
// 页面级全部动态 import(路由懒加载已有),首屏只拉 entry+两 vendor。
manualChunks: {
'element-plus': ['element-plus', '@element-plus/icons-vue'],
'vue-vendor': ['vue', 'vue-router', 'pinia', 'axios'],
},
},
},
},
server: {
port: 5173,
// sms.unimsc.com 外网测试通道(2026-11-15 用户裁定,统一域名入口):
// 经 nginx 根路径反代(443→5173)访问,Host 头为域名,vite5.4+ DNS-rebinding
// 防护默认只放行 localhost/内网 IP,须显式登记;ai.unimsc.com/SmsDev 前缀通道已废弃。
allowedHosts: ['sms.unimsc.com'],
// HMR 经域名通道回流:wss://sms.unimsc.com/(443,nginx 已配 Upgrade 头)。
// 静态配置取舍=域名优先;本机直连 :5173 时 HMR 退化为断连警告+手动刷新(功能无损)。
hmr: { clientPort: 443 },
proxy: {
// real 模式时代理到本地网关;mock 模式由 msw 在浏览器网络层拦截。
// real 模式时代理到本地网关(S3 起 Mock 已下线,单一 real 通道)。
// 网关自 Day42 起按 configs/config.dev.yaml 稳定监听 :8080
// (历史 8081 为当时 8080 被宿主机旧进程占用时的临时 env 覆盖,已废弃)。
'/api': { target: 'http://127.0.0.1:8080', changeOrigin: true },