Files
go-sms-V2/internal/service/report/pair.go
T
Tory bb60d60529
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
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 回填
2026-11-16 11:19:55 +08:00

396 lines
13 KiB
Go

// pair.go 阶段 5 收尾(Day58 挂账清偿/D28):回执重推与手动配对服务。
// - Pending:挂起明细分页(status=1 且挂起超 3h,实施计划 5.5 可配对口径)——
// 手动配对页数据源;msg_id 取该明细首段(message_report_seg MIN)。
// - Pair:四方式(msg_mobile/detail/task_time/time_mobile)圈中挂起明细→
// 人工指定终态(2 成功/3 失败退款/4 未知释放);终态链复用 finalizeDetail
// 单一实现(首锁回写+message_report 落库+计费确认+CMPP Deliver 推送),
// 与回执消费者行为零漂移——重复配对走锁定跳过分支,资金动作至多一次。
// - Repush:30 天窗口回执重推——命中行重投 DeliverEvent(与首推同口径)+
// push_status 回写;同步执行(dev 命中千级内;异步任务表挂账 D29 下载中心)。
package report
import (
"context"
"errors"
"fmt"
"time"
"go.uber.org/zap"
"gorm.io/gorm"
"go-sms/internal/pkg/logger"
"go-sms/internal/util"
)
// PairPendingWindow 手动配对可用窗口:挂起超 3h(实施计划 5.5 口径)。
const PairPendingWindow = 3 * time.Hour
// RepushWindowDays 回执重推数据源保留窗口(message_report 30 天)。
const RepushWindowDays = 30
// RepushBatchMax 单次重推执行上限(同步执行保护;超出记日志截断)。
const RepushBatchMax = 1000
// ErrPairParam 配对/重推参数错误(handler 映射 ISC:400)。
var ErrPairParam = errors.New("pair/repush param")
// PairQuery 挂起明细查询(配对页列表)。
type PairQuery struct {
Page, PageSize int64
Mobile string // 尾号模糊
TaskNo string // 精确
}
// PairPendingRow 挂起明细行(契约 web/src/api/record.ts PendingDetail)。
type PairPendingRow struct {
DetailID int64
TaskNo string
MsgID string // 通道 msg_id(该明细首段;msg_mobile 配对键)
Mobile string
Content string
SentAt time.Time
AgeHours int64
}
// PairRequest 手动配对请求(四方式,按 mode 取对应字段)。
type PairRequest struct {
Mode string // msg_mobile|detail|task_time|time_mobile
MsgID string // msg_mobile:通道 msg_id
Mobile string // msg_mobile/time_mobile
DetailID int64 // detail:明细雪花 ID 精确
TaskNo string // task_time
Start, End *time.Time
TargetStatus int8 // 2 成功(不退费)/3 失败(退款)/4 未知(冻结释放)
}
// PairResult 配对结果(matched=圈中挂起;updated=首锁回写;skipped=并发已终态)。
type PairResult struct {
Matched int64 `json:"matched"`
Updated int64 `json:"updated"`
Skipped int64 `json:"skipped"`
}
// RepushRequest 回执重推请求(时间窗必填;账号/手机号收窄)。
type RepushRequest struct {
AccountID int64
Mobiles []string
Start, End time.Time
}
// PairService 回执重推+手动配对(gateway 进程装配;db/bill/push 与 Consumer 同构)。
type PairService struct {
db *gorm.DB
bill *Billing
push PushSink
cb ReportEnqueuer // S4·C1:HTTP 回调入队(nil=跳过)
sf *util.Snowflake // 重推受理号(雪花;D29 异步任务表落地后即任务主键)
}
// NewPairService 构造(bill/push 可为 nil=跳过计费/推送;sf 可为 nil=受理号降级时间戳)。
func NewPairService(db *gorm.DB, bill *Billing, sf *util.Snowflake) *PairService {
return &PairService{db: db, bill: bill, sf: sf}
}
// WithPushSink 注入 CMPP Deliver 下发出口(链式,nil=跳过)。
func (p *PairService) WithPushSink(s PushSink) *PairService {
p.push = s
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 }
// pendingScope 挂起明细基础口径(status=1 且 COALESCE(send_at,created_at) 早于 now-3h)。
func (p *PairService) pendingScope(ctx context.Context) *gorm.DB {
return p.db.WithContext(ctx).
Table("message_detail AS d").
Where("d.status = 1 AND COALESCE(d.send_at, d.created_at) < ?",
time.Now().Add(-PairPendingWindow))
}
// Pending 挂起明细分页(挂起久在前;msg_id=该明细首段,长短信代表值)。
func (p *PairService) Pending(ctx context.Context, q PairQuery) ([]PairPendingRow, int64, error) {
page, size := q.Page, q.PageSize
if page < 1 {
page = 1
}
if size < 1 || size > 1000 {
size = 100
}
scope := p.pendingScope(ctx).
Joins("JOIN message_task t ON t.id = d.task_id")
if q.Mobile != "" {
scope = scope.Where("d.mobile LIKE ?", "%"+q.Mobile)
}
if q.TaskNo != "" {
scope = scope.Where("t.task_no = ?", q.TaskNo)
}
// Count 独立构造:列表查询带 ORDER BY 别名(sent_at),Count 继承会在
// sqlite 报 no such column(gorm 不剥离 ORDER BY)。
var total int64
cnt := p.pendingScope(ctx).
Joins("JOIN message_task t ON t.id = d.task_id")
if q.Mobile != "" {
cnt = cnt.Where("d.mobile LIKE ?", "%"+q.Mobile)
}
if q.TaskNo != "" {
cnt = cnt.Where("t.task_no = ?", q.TaskNo)
}
if err := cnt.Session(&gorm.Session{}).Count(&total).Error; err != nil {
return nil, 0, err
}
var rows []struct {
DetailID int64
TaskNo string
MsgID *string
Mobile string
Content string
SentAt string // sqlite 下 COALESCE 结果退化 string(MySQL 侧兼容),Go 侧解析
}
if err := scope.Session(&gorm.Session{}).
Select(`d.id AS detail_id, t.task_no AS task_no,
(SELECT MIN(s2.msg_id) FROM message_report_seg s2 WHERE s2.detail_id = d.id) AS msg_id,
d.mobile AS mobile, d.content AS content,
COALESCE(d.send_at, d.created_at) AS sent_at`).
Order("sent_at ASC").
Limit(int(size)).Offset(int((page - 1) * size)).
Scan(&rows).Error; err != nil {
return nil, 0, err
}
parseSentAt := func(s string) time.Time {
for _, layout := range []string{time.RFC3339Nano, time.RFC3339,
"2006-01-02 15:04:05.999999999-07:00", "2006-01-02 15:04:05.999999999", "2006-01-02 15:04:05"} {
if t, err := time.ParseInLocation(layout, s, time.Local); err == nil {
return t
}
}
return time.Time{}
}
now := time.Now()
out := make([]PairPendingRow, 0, len(rows))
for _, r := range rows {
msgID := ""
if r.MsgID != nil {
msgID = *r.MsgID
}
sentAt := parseSentAt(r.SentAt)
var age int64
if !sentAt.IsZero() {
age = int64(now.Sub(sentAt).Hours())
}
out = append(out, PairPendingRow{
DetailID: r.DetailID, TaskNo: r.TaskNo, MsgID: msgID,
Mobile: r.Mobile, Content: r.Content, SentAt: sentAt,
AgeHours: age,
})
}
return out, total, nil
}
// statusFor 终态 int8 → Day55 三态词。
func statusFor(status int8) Status {
switch status {
case 2:
return StatusSuccess
case 3:
return StatusFailure
default:
return StatusUnknown
}
}
// Pair 手动配对:四方式圈中挂起明细→逐条 finalizeDetail(首锁语义,
// 重复配对/并发终态走锁定跳过=skipped;资金动作至多一次)。
func (p *PairService) Pair(ctx context.Context, req PairRequest) (PairResult, error) {
// 受理即落账(与 Repush 同口径):断开不中止终态链;单条事务原子性
// 由 gorm 保证,重试幂等(首锁跳过)。
ctx = context.WithoutCancel(ctx)
var res PairResult
switch req.Mode {
case "msg_mobile", "detail", "task_time", "time_mobile":
default:
return res, fmt.Errorf("%w: 配对方式非法", ErrPairParam)
}
if req.TargetStatus < 2 || req.TargetStatus > 4 {
return res, fmt.Errorf("%w: 目标状态须为 2/3/4", ErrPairParam)
}
scope := p.pendingScope(ctx)
switch req.Mode {
case "msg_mobile":
if req.MsgID == "" || req.Mobile == "" {
return res, fmt.Errorf("%w: msg_id/mobile 必填", ErrPairParam)
}
scope = scope.Where(
"d.id IN (SELECT s.detail_id FROM message_report_seg s WHERE s.msg_id = ? AND s.mobile = ?)",
req.MsgID, req.Mobile)
case "detail":
if req.DetailID <= 0 {
return res, fmt.Errorf("%w: detail_id 非法", ErrPairParam)
}
scope = scope.Where("d.id = ?", req.DetailID)
case "task_time":
if req.TaskNo == "" {
return res, fmt.Errorf("%w: task_no 必填", ErrPairParam)
}
var taskID int64
if err := p.db.WithContext(ctx).
Table("message_task").Select("id").
Where("task_no = ?", req.TaskNo).Scan(&taskID).Error; err != nil || taskID == 0 {
return res, fmt.Errorf("%w: 任务号不存在", ErrPairParam)
}
scope = scope.Where("d.task_id = ?", taskID)
default: // time_mobile
if req.Mobile == "" {
return res, fmt.Errorf("%w: mobile 必填", ErrPairParam)
}
scope = scope.Where("d.mobile = ?", req.Mobile)
}
if req.Mode == "task_time" || req.Mode == "time_mobile" {
if req.Start != nil {
scope = scope.Where("COALESCE(d.send_at, d.created_at) >= ?", *req.Start)
}
if req.End != nil {
scope = scope.Where("COALESCE(d.send_at, d.created_at) <= ?", *req.End)
}
}
var ids []int64
if err := scope.Limit(1000).Pluck("d.id", &ids).Error; err != nil {
return res, err
}
res.Matched = int64(len(ids))
st := statusFor(req.TargetStatus)
now := time.Now()
for _, id := range ids {
var d struct {
ChannelID int64
Mobile string
}
if err := p.db.WithContext(ctx).Table("message_detail").
Select("channel_id, mobile").Where("id = ?", id).Scan(&d).Error; err != nil {
continue // 行消失(并发删除等):计入 skipped
}
locked, err := finalizeDetail(ctx, p.db, p.push,
id, d.ChannelID, req.TargetStatus, "MANUAL", now, st, d.Mobile)
if err != nil {
logger.L().Warn("pair_finalize_failed",
zap.Int64("detail_id", id), zap.Error(err))
res.Skipped++
continue
}
if locked {
res.Updated++
// 计费确认在终态锁定成功后触发(与 Consumer 回执链同语义)。
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++ // 圈中窗口与执行窗口间被回执/并发配对锁定
}
}
return res, nil
}
// statusInt8From 三态词 → 终态 int8(重推反向映射)。
func statusInt8From(s string) int8 {
switch s {
case string(StatusSuccess):
return 2
case string(StatusFailure):
return 3
default:
return 4
}
}
// Repush 30 天窗口回执重推:命中 report 行(detail JOIN 取 account/mobile)→
// 重投 DeliverEvent(与首推同 payload 口径)→ push_status/pushed_at 回写。
// 同步执行并返回 (受理号, 命中数);受理号雪花生成(D29 任务表落地后即任务主键)。
func (p *PairService) Repush(ctx context.Context, req RepushRequest) (int64, int64, error) {
// 受理即落账:执行段脱离请求取消链(客户端超时断开不中止投递/回写,
// Day66 实机验收发现逐条回写随 ctx canceled 全部丢失)。
ctx = context.WithoutCancel(ctx)
sess := p.db.WithContext(ctx).
Table("message_report AS r").
Select("r.id AS report_id, r.detail_id, r.status, r.raw_code, d.account_id, d.mobile").
Joins("JOIN message_detail d ON d.id = r.detail_id").
Where("r.report_at >= ? AND r.report_at <= ?", req.Start, req.End)
if req.AccountID > 0 {
sess = sess.Where("d.account_id = ?", req.AccountID)
}
if len(req.Mobiles) > 0 {
sess = sess.Where("d.mobile IN ?", req.Mobiles)
}
var rows []struct {
ReportID int64
DetailID int64
Status string
RawCode string
AccountID int64
Mobile string
}
if err := sess.Limit(RepushBatchMax + 1).Scan(&rows).Error; err != nil {
return 0, 0, err
}
if int64(len(rows)) > RepushBatchMax {
rows = rows[:RepushBatchMax]
logger.L().Warn("repush_batch_truncated",
zap.Int("cap", RepushBatchMax), zap.String("hint", "收窄时间窗/账号分批重推"))
}
now := time.Now()
// 批量回写:投递与回写按结果分组,2 次批量 UPDATE 替代逐条往返(千条窗
// 25s+ → 秒级);失败仅记日志不中断(重推幂等:重复圈中重投无害)。
pushed, failed := make([]int64, 0, len(rows)), make([]int64, 0, len(rows))
for _, r := range rows {
ev := &DeliverEvent{
AccountID: r.AccountID, DetailID: r.DetailID, Mobile: r.Mobile,
Stat: statForDeliver(statusInt8From(r.Status), r.RawCode),
SubmitAt: cmppTimeMMDDHHMMSS(now), DoneAt: cmppTimeMMDDHHMMSS(now),
}
// 注:重推不做 source=CMPP 短路——操作者圈中的即需重推的
//(非 CMPP 源投递后网关消费侧按账号反查无会话自然丢弃,尽力而为同首推口径)。
var pushErr error
if p.push != nil {
pushErr = p.push.PushDeliver(ctx, ev)
}
if pushErr != nil {
failed = append(failed, r.ReportID)
} else {
pushed = append(pushed, r.ReportID)
}
}
writeback := func(ids []int64, ps int8) {
if len(ids) == 0 {
return
}
if err := p.db.WithContext(ctx).
Table("message_report").Where("id IN ?", ids).
Updates(map[string]any{"push_status": ps, "pushed_at": now}).Error; err != nil {
logger.L().Warn("repush_status_writeback_failed",
zap.Int("count", len(ids)), zap.Int8("push_status", ps), zap.Error(err))
}
}
writeback(pushed, 1)
writeback(failed, 2)
var taskID int64
if p.sf != nil {
taskID = p.sf.NextID()
} else {
taskID = now.UnixMilli()
}
return taskID, int64(len(rows)), nil
}