Files
affiliate_dash/backend/internal/service/rock_redeem_confirm.go
T
zhaoxing a9473990be refactor: 移除 Rock 发货处理中状态,新增异常派生筛选标记
- 新增迁移 028:历史 redeeming 回退为 bound,重建 pending 部分索引
- pending 语义改为 bound + redeem_requested_at 标记,不再写状态与状态日志
- 新增 anomaly 虚拟筛选项:基于状态日志派生异常标记,不改状态、不落库
- 状态列追加「⚠️ 异常」标签,统计新增 anomaly_stock
- 清理前后端 redeeming 相关分支与文案
2026-11-14 15:40:19 +08:00

368 lines
12 KiB
Go

package service
import (
"context"
"errors"
"fmt"
"log"
"strings"
"sync/atomic"
"time"
"affiliate_dash/internal/model"
)
const (
rockRedeemPollInterval = 20 * time.Second
rockRedeemBatchSize = 20
rockRedeemCallGap = 2 * time.Second
rockRedeemTimeout = 15 * time.Minute
rockRedeemFirstRetry = 30 * time.Second
rockRedeemMaxRetry = 5 * time.Minute
)
var rockRedeemWorkerRunning atomic.Bool
// RockRedeemConfirmSummary 是一次 pending 确认批次的汇总。
type RockRedeemConfirmSummary struct {
Scanned int `json:"scanned"`
Confirmed int `json:"confirmed"`
Pending int `json:"pending"`
Failed int `json:"failed"`
TimedOut int `json:"timed_out"`
}
// SetRedeemConfirmHook 注册「上游确认发货后同步订单」的回调,由 main 装配 DeliveryService。
func (s *RockService) SetRedeemConfirmHook(hook func(ctx context.Context, order *model.FulfillmentOrder, token *model.RockToken) error) {
s.redeemConfirmHook = hook
}
// RunRedeemConfirmWorker 启动发货结果确认任务:每 20 秒扫描一次「发货确认中」标记。
//
// 频控保护:上游 110001 时全局冷却 60 秒,且每个 Token 使用指数退避,
// 避免把 0666.pro 的公开刷新接口打成持续频控。
func (s *RockService) RunRedeemConfirmWorker(ctx context.Context) {
lastCleanup := time.Now()
ticker := time.NewTicker(rockRedeemPollInterval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
if rockUpstreamRateLimitActive() {
continue
}
if _, err := s.ProcessRedeemingTokens(ctx); err != nil && !errors.Is(err, errRockRedeemBusy) {
log.Printf("[Rock] 发货结果确认任务失败: %v", err)
}
if time.Since(lastCleanup) >= 24*time.Hour {
s.CleanupRockDeliveryLogs(ctx)
lastCleanup = time.Now()
}
}
}
}
var errRockRedeemBusy = errors.New("发货结果确认任务正在执行")
// ProcessRedeemingTokens 扫描并确认一批「发货确认中」的 Token。
//
// 判定口径是标记而非状态:status=bound + 已提交兑换 + 尚未拿到履约结果。
// 可被后台任务或测试直接调用。
func (s *RockService) ProcessRedeemingTokens(ctx context.Context) (*RockRedeemConfirmSummary, error) {
if !rockRedeemWorkerRunning.CompareAndSwap(false, true) {
return nil, errRockRedeemBusy
}
defer rockRedeemWorkerRunning.Store(false)
now := time.Now()
var tokens []model.RockToken
if err := s.db.WithContext(ctx).
Where("status = ?", model.RockStatusBound).
Where("redeem_requested_at IS NOT NULL").
Where("redeemed_at IS NULL").
Where("(redeem_next_retry_at IS NULL OR redeem_next_retry_at <= ?)", now).
Order("redeem_next_retry_at ASC").
Limit(rockRedeemBatchSize).
Find(&tokens).Error; err != nil {
return nil, err
}
summary := &RockRedeemConfirmSummary{Scanned: len(tokens)}
for i := range tokens {
if i > 0 {
if rockUpstreamRateLimitActive() {
break
}
select {
case <-ctx.Done():
return summary, ctx.Err()
case <-time.After(rockRedeemCallGap):
}
}
confirmed, timedOut, err := s.confirmRedeemingToken(ctx, &tokens[i])
if err != nil {
summary.Failed++
log.Printf("[Rock] 确认 Token %d 发货结果失败: %v", tokens[i].ID, err)
continue
}
if confirmed {
summary.Confirmed++
continue
}
summary.Pending++
if timedOut {
summary.TimedOut++
}
}
return summary, nil
}
// confirmRedeemingToken 查询一次上游结果并更新本地状态。
func (s *RockService) confirmRedeemingToken(ctx context.Context, token *model.RockToken) (confirmed bool, timedOut bool, err error) {
if token == nil {
return false, false, errors.New("Token 不存在")
}
cfg, err := s.GetConfig(ctx)
if err != nil {
return false, false, err
}
recorder := s.NewDeliveryRecorder(token.AssignedOrderNo, nil, "", "")
recorder.AttachToken(token)
ctx = withRockDeliveryRecorder(ctx, recorder)
ref, err := s.refreshRedeemStatus(ctx, token, cfg.BearerToken)
if err != nil {
if isRockRateLimitError(err) {
markRockUpstreamRateLimited()
}
s.bumpRedeemRetry(ctx, token, err.Error(), false)
if recorder != nil {
recorder.Internal(ctx, "redeem_confirm", "failed", err.Error(), nil)
}
return false, false, err
}
if ref == nil {
s.bumpRedeemRetry(ctx, token, "上游未返回刷新结果", false)
return false, false, errors.New("上游未返回刷新结果")
}
now := time.Now()
upstreamStatus := strings.ToLower(strings.TrimSpace(ref.Token.Status))
// 上游明确失效:终止处理并标记异常。
if upstreamStatus == model.RockStatusAbnormal {
s.markRedeemingAbnormal(ctx, token, "上游状态异常(发货确认)", recorder)
return false, false, nil
}
if rockUpstreamRedeemed(ref) {
fulfillID := extractRockFulfillID(ref, rockClaimBaseline(token))
redeemedAt := now
if parsed, ok := parseRockTime(ref.Token.RedeemedAt); ok {
redeemedAt = parsed
}
fromStatus := token.Status
_ = s.db.WithContext(ctx).Unscoped().Model(token).Updates(map[string]interface{}{
"status": model.RockStatusRedeemed,
"upstream_fulfill_id": fulfillID,
"redeemed_at": redeemedAt,
"redeem_checked_at": now,
"redeem_next_retry_at": nil,
"redeem_last_message": "",
"redeem_last_error": "",
"redeem_timeout_warned_at": nil,
"updated_at": now,
}).Error
writeRockTokenStatusChange(s.db.WithContext(ctx), token, fromStatus, model.RockStatusRedeemed,
rockTokenSourceRedeem, "上游确认发货", false, nil)
token.Status = model.RockStatusRedeemed
token.UpstreamFulfillID = fulfillID
token.RedeemedAt = &redeemedAt
if recorder != nil {
recorder.Internal(ctx, "state_change", "success", "上游确认发货", map[string]interface{}{
"upstream_status": ref.Token.Status,
"upstream_redeemed_at": ref.Token.RedeemedAt,
"upstream_fulfill_id": fulfillID,
})
}
s.syncDeliveredOrder(ctx, token, recorder)
return true, false, nil
}
// 仍在官方处理中:保持 bound + 标记,指数退避。
waitingMessage := strings.TrimSpace(ref.Message)
if waitingMessage == "" {
waitingMessage = "官方处理中,请稍后刷新查看结果"
}
_ = s.db.WithContext(ctx).Unscoped().Model(token).Updates(map[string]interface{}{
"redeem_checked_at": now,
"redeem_last_message": waitingMessage,
"redeem_last_error": "",
"updated_at": now,
}).Error
token.RedeemCheckedAt = &now
token.RedeemLastMessage = waitingMessage
attempts := token.RedeemAttempts
s.bumpRedeemRetry(ctx, token, "", true)
if recorder != nil {
recorder.Internal(ctx, "redeem_confirm", "pending", waitingMessage, map[string]interface{}{
"upstream_status": ref.Token.Status,
"attempts": attempts,
})
}
// 超过等待上限仍未确认:保持处理中,仅告警一次(不做状态流转)。
if token.RedeemRequestedAt != nil && now.Sub(*token.RedeemRequestedAt) >= rockRedeemTimeout && token.RedeemTimeoutWarnedAt == nil {
warnAt := now
_ = s.db.WithContext(ctx).Unscoped().Model(token).Updates(map[string]interface{}{
"redeem_timeout_warned_at": warnAt,
"redeem_last_message": waitingMessage + "(已超过 15 分钟未确认,已告警)",
}).Error
if recorder != nil {
recorder.Internal(ctx, "redeem_timeout", "pending", "上游超过 15 分钟未确认发货", nil)
}
return false, true, nil
}
return false, false, nil
}
func (s *RockService) refreshRedeemStatus(ctx context.Context, token *model.RockToken, bearerToken string) (*RockRefreshResponse, error) {
var firstErr error
if strings.TrimSpace(token.RedeemCode) != "" {
ref, err := s.client.RefreshRedeemBinding(ctx, token.RedeemCode)
if err == nil {
return ref, nil
}
firstErr = err
// 频控时不要再打管理端接口,直接交给退避。
if isRockRateLimitError(err) {
return nil, err
}
}
if strings.TrimSpace(token.UpstreamTokenID) != "" {
ref, err := s.client.RefreshToken(ctx, bearerToken, token.UpstreamTokenID)
if err == nil {
return ref, nil
}
if firstErr == nil {
firstErr = err
}
return nil, err
}
if firstErr != nil {
return nil, firstErr
}
return nil, errors.New("缺少兑换码与上游 Token ID,无法确认发货结果")
}
func (s *RockService) bumpRedeemRetry(ctx context.Context, token *model.RockToken, lastError string, countAttempt bool) {
if token == nil {
return
}
attempts := token.RedeemAttempts
if countAttempt {
attempts++
}
delay := rockRedeemFirstRetry
switch {
case attempts <= 1:
delay = rockRedeemFirstRetry
case attempts == 2:
delay = time.Minute
case attempts == 3:
delay = 2 * time.Minute
default:
delay = rockRedeemMaxRetry
}
if token.RedeemRequestedAt != nil && time.Since(*token.RedeemRequestedAt) >= rockRedeemTimeout {
delay = rockRedeemMaxRetry
}
next := time.Now().Add(delay)
updates := map[string]interface{}{
"redeem_attempts": attempts,
"redeem_next_retry_at": next,
"updated_at": time.Now(),
}
if strings.TrimSpace(lastError) != "" {
updates["redeem_last_error"] = lastError
}
_ = s.db.WithContext(ctx).Unscoped().Model(token).Updates(updates).Error
token.RedeemAttempts = attempts
token.RedeemNextRetryAt = &next
}
func (s *RockService) markRedeemingAbnormal(ctx context.Context, token *model.RockToken, reason string, recorder *RockDeliveryRecorder) {
fromStatus := token.Status
_ = s.db.WithContext(ctx).Unscoped().Model(token).Updates(map[string]interface{}{
"status": model.RockStatusAbnormal,
"redeem_last_error": reason,
"redeem_next_retry_at": nil,
"redeem_timeout_warned_at": nil,
"remark": appendRockRemark(token.Remark, reason),
"updated_at": time.Now(),
}).Error
writeRockTokenStatusChange(s.db.WithContext(ctx), token, fromStatus, model.RockStatusAbnormal,
rockTokenSourceRedeem, reason, false, nil)
token.Status = model.RockStatusAbnormal
if recorder != nil {
recorder.Internal(ctx, "state_change", "failed", reason, map[string]interface{}{
"from_status": fromStatus,
"to_status": model.RockStatusAbnormal,
})
}
}
func (s *RockService) syncDeliveredOrder(ctx context.Context, token *model.RockToken, recorder *RockDeliveryRecorder) {
if s.redeemConfirmHook == nil || token == nil || strings.TrimSpace(token.AssignedOrderNo) == "" {
return
}
var order model.FulfillmentOrder
if err := s.db.WithContext(ctx).Where("order_no = ?", token.AssignedOrderNo).First(&order).Error; err != nil {
if recorder != nil {
recorder.Internal(ctx, "order_update", "failed", "读取订单失败: "+err.Error(), map[string]interface{}{
"order_no": token.AssignedOrderNo,
})
}
return
}
var lastErr error
for attempt := 0; attempt < 3; attempt++ {
if err := s.redeemConfirmHook(ctx, &order, token); err == nil {
if recorder != nil {
recorder.Internal(ctx, "order_update", "success", "订单已同步为已交付", map[string]interface{}{
"order_no": order.OrderNo,
})
}
return
} else {
lastErr = err
time.Sleep(time.Second)
}
}
if recorder != nil {
recorder.Internal(ctx, "order_update", "failed", fmt.Sprintf("同步订单失败: %v", lastErr), map[string]interface{}{
"order_no": order.OrderNo,
})
}
log.Printf("[Rock] Token %d 已确认发货,但订单 %s 同步失败: %v", token.ID, token.AssignedOrderNo, lastErr)
}
func appendRockRemark(existing, reason string) string {
existing = strings.TrimSpace(existing)
reason = strings.TrimSpace(reason)
if reason == "" {
return existing
}
if existing == "" {
return reason
}
if strings.Contains(existing, reason) {
return existing
}
return existing + "\n" + reason
}