410 lines
16 KiB
Go
410 lines
16 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gogf/gf/v2/database/gdb"
|
||
"github.com/gogf/gf/v2/errors/gerror"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
"github.com/gogf/gf/v2/util/grand"
|
||
|
||
v1 "tool-api/api/admin/v1"
|
||
"tool-api/internal/consts"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 真退款链路：调微信 /xpay/refund_order + 退款回调分流 + 查单轮询兜底
|
||
//
|
||
// 状态机（member_orders.status × refund_status）：
|
||
// status=1(已发货) + refund_status=0 → 可发起退款
|
||
// 发起（API 路径） → refund_status=1(退款中)，refund_no/refund_amount/reason 落库
|
||
// → 平台 xpay_refund_notify 推送 / RefundStatusPoll 查单轮询确认
|
||
// → 确认成功：status=2 + refund_status=2 + 回收权益（在此刻才回收）
|
||
// → 确认失败/超时：refund_status=3（status 保持 1，可重新发起）
|
||
// 发起（手工路径） → 手工登记（Manual / iOS apple 渠道 / 平台未配置）当场 status=2 +
|
||
// refund_status=2 + 回收权益（无异步确认环节，与旧版语义一致）
|
||
// refund_status=2 → 幂等返回；refund_status=3 → 允许重新发起（换新 refund_no）
|
||
//
|
||
// 权益回收时机：API 路径下从「发起时」移到「确认成功时」（finalize 统一执行），
|
||
// 杜绝「退款失败但权益已回收」。回收意图在发起时落 refund_revoke 列，回调/轮询据此执行。
|
||
//
|
||
// 时区铁律（TZ-01）：所有 datetime 写入一律 gdb.Raw("NOW()")（库内取值），
|
||
// 严禁本文件引入 Go 侧 datetime 传参写库。
|
||
// ============================================================================
|
||
|
||
// refundWindowDays 平台退款窗口：支付 365 天内可退（180 天内退手续费，见 doc/会员购买接入说明.md）。
|
||
const refundWindowDays = 365
|
||
|
||
// OrderRefundOptions 后台「确认退款」的选项。
|
||
type OrderRefundOptions struct {
|
||
RevokeService bool // 同时回收所购服务（意图落 refund_revoke，确认成功后执行）
|
||
Reason string // 退款原因（手工登记必填；API 退款选填随单报平台）
|
||
Manual bool // 手工退款登记：不调平台接口，仅落库（iOS / 平台后台已手工退的场景）
|
||
}
|
||
|
||
// AdminOrderRefund 订单退款（真退款状态机，替换旧「点了就置已退款」实现）。
|
||
func AdminOrderRefund(ctx context.Context, outTradeNo string, opt OrderRefundOptions) (*v1.OrderRefundRes, error) {
|
||
outTradeNo = strings.TrimSpace(outTradeNo)
|
||
if outTradeNo == "" {
|
||
return nil, errOrderInvalid("订单号不能为空")
|
||
}
|
||
opt.Reason = strings.TrimSpace(opt.Reason)
|
||
|
||
res := &v1.OrderRefundRes{OutTradeNo: outTradeNo}
|
||
var beforeStatus int
|
||
// 出网参数（事务内组装、事务提交后才发起资金动作，不占行锁）
|
||
var apiOpenid, apiOutTradeNo, apiRefundNo string
|
||
var apiAmount int64
|
||
apiStarted := false
|
||
|
||
err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
|
||
// 行锁：并发的两次退款串行化
|
||
row, err := tx.Model(consts.TableMemberOrders).
|
||
Where("out_trade_no", outTradeNo).LockUpdate().One()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if row.IsEmpty() {
|
||
return errOrderInvalid("订单不存在")
|
||
}
|
||
o := orderSnapshotFromRecord(row)
|
||
beforeStatus = o.Status
|
||
refundStatus := row["refund_status"].Int()
|
||
res.RefundStatus = refundStatus
|
||
|
||
// ===== 幂等分支 =====
|
||
if o.Status == consts.OrderStatusRefunded || refundStatus == consts.RefundStatusSuccess {
|
||
res.AlreadyRefunded = true
|
||
res.ServiceRevoked = row["service_revoked"].Int() == 1
|
||
res.Status = consts.OrderStatusRefunded
|
||
res.StatusText = orderStatusText(consts.OrderStatusRefunded)
|
||
return nil
|
||
}
|
||
if refundStatus == consts.RefundStatusProcessing {
|
||
res.Refunding = true
|
||
res.Status = o.Status
|
||
res.StatusText = "退款中"
|
||
return nil
|
||
}
|
||
switch o.Status {
|
||
case consts.OrderStatusPending:
|
||
return errOrderInvalid("订单尚未支付，无法退款")
|
||
case consts.OrderStatusClosed:
|
||
return errOrderInvalid("订单已关闭，无法退款")
|
||
case consts.OrderStatusDelivered:
|
||
// 唯一允许发起退款的起点状态
|
||
default:
|
||
return errOrderInvalid("订单状态异常，无法退款")
|
||
}
|
||
|
||
// 平台退款窗口：支付超 365 天不可退（超窗只能走手工登记，如 App Store 退款）
|
||
if paidAt := row["paid_at"].GTime(); paidAt != nil && !paidAt.IsZero() &&
|
||
time.Since(paidAt.Time) > refundWindowDays*24*time.Hour {
|
||
return errOrderInvalid("订单支付已超过 365 天，平台不再支持退款；如已线下退款请勾选「手工退款登记」")
|
||
}
|
||
|
||
amount := o.PaidPriceCents
|
||
if amount <= 0 {
|
||
amount = o.PriceCents // 老订单 paid_price_cents 为 0 时回退原价（S14 口径）
|
||
}
|
||
|
||
// 手工退款判定：显式 Manual / iOS 渠道（开发者无法主动退款，用户向 App Store 申请）/
|
||
// 平台未配置（无法出网）。显式手工与 iOS 渠道必须留原因（审计要求）；
|
||
// 「平台未配置」的降级路径不强制（兼容既有联调/测试流程）。
|
||
platformUnconfigured := !xpayConfig(ctx).Configured()
|
||
manual := opt.Manual || o.PayChannel == consts.PayChannelIOS || platformUnconfigured
|
||
if manual && (opt.Manual || o.PayChannel == consts.PayChannelIOS) && opt.Reason == "" {
|
||
return errOrderInvalid("手工退款登记必须填写退款原因")
|
||
}
|
||
|
||
if manual {
|
||
// ===== 手工路径：当场回收 + 落「已退款」（旧版语义 + 退款列补记）=====
|
||
serviceRevoked := 0
|
||
if opt.RevokeService {
|
||
revoked, rerr := revokeOrderServiceTx(ctx, tx, o)
|
||
if rerr != nil {
|
||
return rerr
|
||
}
|
||
if revoked {
|
||
serviceRevoked = 1
|
||
}
|
||
}
|
||
if err = releaseVoucherForOrderTx(ctx, tx, o); err != nil {
|
||
return err
|
||
}
|
||
// refunded_at / refund_finished_at / updated_at 用库内 NOW()（TZ-01）
|
||
if _, err = tx.Model(consts.TableMemberOrders).Where("out_trade_no", outTradeNo).Data(g.Map{
|
||
"status": consts.OrderStatusRefunded,
|
||
"service_revoked": serviceRevoked,
|
||
"refunded_at": gdb.Raw("NOW()"),
|
||
"refund_status": consts.RefundStatusSuccess,
|
||
"refund_amount": amount,
|
||
"refund_reason": opt.Reason,
|
||
"refund_finished_at": gdb.Raw("NOW()"),
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return err
|
||
}
|
||
res.Revoked = true
|
||
res.ServiceRevoked = serviceRevoked == 1
|
||
res.Status = consts.OrderStatusRefunded
|
||
res.RefundStatus = consts.RefundStatusSuccess
|
||
res.StatusText = orderStatusText(consts.OrderStatusRefunded)
|
||
return nil
|
||
}
|
||
|
||
// ===== API 路径：事务内落「退款中」，提交后出网调 /xpay/refund_order =====
|
||
refundNo := newRefundNo(o.Id)
|
||
if _, err = tx.Model(consts.TableMemberOrders).Where("out_trade_no", outTradeNo).Data(g.Map{
|
||
"refund_no": refundNo,
|
||
"refund_status": consts.RefundStatusProcessing,
|
||
"refund_amount": amount,
|
||
"refund_reason": opt.Reason,
|
||
"refund_revoke": boolToInt(opt.RevokeService),
|
||
"refunded_at": nil, // 确认成功时才写（避免「退款中」却显示退款时间）
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return err
|
||
}
|
||
apiOpenid, apiOutTradeNo, apiRefundNo, apiAmount = o.Openid, o.OutTradeNo, refundNo, amount
|
||
apiStarted = true
|
||
res.Refunding = true
|
||
res.RefundNo = refundNo
|
||
res.Status = o.Status
|
||
res.RefundStatus = consts.RefundStatusProcessing
|
||
res.StatusText = "退款中"
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
switch {
|
||
case res.AlreadyRefunded:
|
||
res.Message = "订单已是退款状态，未重复执行"
|
||
case res.Refunding && !apiStarted:
|
||
res.Message = "退款已在处理中，等待平台确认"
|
||
case res.Refunding && apiStarted:
|
||
// 出网在事务提交后（资金动作不占行锁）；同步失败 → 置「失败」并报错给管理员
|
||
if rerr := XPayRefundOrder(ctx, apiOpenid, apiOutTradeNo, apiRefundNo, apiAmount, opt.Reason); rerr != nil {
|
||
markRefundFailed(ctx, outTradeNo, apiRefundNo)
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "order.refund", TargetType: "order", TargetId: outTradeNo,
|
||
Before: g.Map{"status": beforeStatus, "refund_status": consts.RefundStatusProcessing},
|
||
After: g.Map{"refund_status": consts.RefundStatusFailed},
|
||
Result: consts.AuditResultFail, Remark: rerr.Error(),
|
||
})
|
||
return nil, gerror.Newf("发起平台退款失败：%v（订单已标记退款失败，可修正后重试）", rerr)
|
||
}
|
||
res.Message = "已发起平台退款，确认后自动回收权益"
|
||
if opt.RevokeService {
|
||
res.Message += "（refund_revoke=1，收到平台成功推送即回收）"
|
||
}
|
||
}
|
||
|
||
if res.Message == "" {
|
||
res.Message = "退款已受理"
|
||
}
|
||
// 审计（旁路）：发起动作本身
|
||
if !res.AlreadyRefunded {
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "order.refund",
|
||
TargetType: "order",
|
||
TargetId: outTradeNo,
|
||
Before: g.Map{"status": beforeStatus, "refund_status": consts.RefundStatusNone},
|
||
After: g.Map{
|
||
"status": res.Status,
|
||
"refund_status": res.RefundStatus,
|
||
"revoke_intent": opt.RevokeService,
|
||
"manual": opt.Manual,
|
||
"reason": opt.Reason,
|
||
},
|
||
Result: consts.AuditResultSuccess,
|
||
Remark: res.Message,
|
||
})
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
// newRefundNo 生成商户退款单号：R + 订单id + 'x' + 8 位随机字母数字。
|
||
// 微信 out_refund_no 要求 6-32 位、仅字母数字（含 -_|*），此处最长 1+19+1+8=29 位。
|
||
// 每次发起（含失败重试）都生成新号，避免与历史退款单号冲突。
|
||
func newRefundNo(orderId int64) string {
|
||
return fmt.Sprintf("R%dx%s", orderId, grand.S(8))
|
||
}
|
||
|
||
func boolToInt(b bool) int {
|
||
if b {
|
||
return 1
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// markRefundFailed 平台退款同步失败 / 轮询确认超时：置 refund_status=3（status 不动，可重试）。
|
||
func markRefundFailed(ctx context.Context, outTradeNo, refundNo string) {
|
||
if _, err := g.Model(consts.TableMemberOrders).
|
||
Where("out_trade_no", outTradeNo).
|
||
Where("refund_no", refundNo).
|
||
Where("refund_status", consts.RefundStatusProcessing).
|
||
Data(g.Map{
|
||
"refund_status": consts.RefundStatusFailed,
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
g.Log().Errorf(ctx, "[refund] 标记退款失败落库异常 outTradeNo=%s err=%v", outTradeNo, err)
|
||
}
|
||
}
|
||
|
||
// refundNotifyHandle 处理平台退款结果推送（/pay/notify 按 Event 分流进入）。
|
||
func refundNotifyHandle(ctx context.Context, raw []byte) (string, error) {
|
||
notify, err := ParseRefundNotify(raw)
|
||
if err != nil {
|
||
g.Log().Warningf(ctx, "[xpay] 退款推送解析失败: %v raw=%s", err, string(raw))
|
||
return XPayNotifyAckFail("bad payload"), nil
|
||
}
|
||
order, err := entityOrderByOutTradeNo(ctx, notify.OutTradeNo)
|
||
if err != nil {
|
||
// 订单不存在多为脏数据，回成功避免平台无意义重试
|
||
g.Log().Warningf(ctx, "[xpay] 退款推送对应订单不存在: %s", notify.OutTradeNo)
|
||
return XPayNotifyAck(), nil
|
||
}
|
||
if order.RefundStatus != consts.RefundStatusProcessing {
|
||
return XPayNotifyAck(), nil // 幂等：非「退款中」一律忽略重复推送
|
||
}
|
||
// 退款单号交叉校验：推送单号与本地不一致（如旧号的迟到推送）→ 忽略并告警
|
||
pushNo := notify.OutRefundNo
|
||
if pushNo == "" {
|
||
pushNo = notify.RefundInfo.OutRefundNo
|
||
}
|
||
if pushNo != "" && order.RefundNo != "" && pushNo != order.RefundNo {
|
||
g.Log().Warningf(ctx, "[xpay] 退款推送单号不匹配，忽略: outTradeNo=%s local=%s push=%s",
|
||
notify.OutTradeNo, order.RefundNo, pushNo)
|
||
return XPayNotifyAck(), nil
|
||
}
|
||
|
||
switch {
|
||
case notify.RefundNotifySuccess():
|
||
confirmed, ferr := confirmRefund(ctx, notify.OutTradeNo)
|
||
if ferr != nil {
|
||
g.Log().Errorf(ctx, "[xpay] 退款确认落库失败 outTradeNo=%s err=%v", notify.OutTradeNo, ferr)
|
||
return XPayNotifyAckFail("finalize failed"), nil // 让平台重试
|
||
}
|
||
g.Log().Infof(ctx, "[xpay] 退款确认成功（推送） outTradeNo=%s confirmed=%v", notify.OutTradeNo, confirmed)
|
||
return XPayNotifyAck(), nil
|
||
case pushNo != "" || notify.RefundInfo.RefundFee > 0:
|
||
// 携带了退款信息但判定为非成功 → 显式失败，置 refund_status=3 供管理员重试
|
||
markRefundFailed(ctx, notify.OutTradeNo, order.RefundNo)
|
||
g.Log().Warningf(ctx, "[xpay] 退款推送判定为失败 outTradeNo=%s raw=%s", notify.OutTradeNo, string(raw))
|
||
return XPayNotifyAck(), nil
|
||
default:
|
||
// 字段判不动（文档外枚举/字段缺失）：保持「退款中」交查单轮询收敛；回成功停止重试
|
||
g.Log().Warningf(ctx, "[xpay] 退款推送结果不可判定，留待轮询 outTradeNo=%s raw=%s", notify.OutTradeNo, string(raw))
|
||
return XPayNotifyAck(), nil
|
||
}
|
||
}
|
||
|
||
// confirmRefund 退款确认成功（推送 / 轮询共用）：状态 1→2 + 按发起时的意图回收权益 + 释放券。
|
||
// 返回 confirmed = 本次调用是否真正完成了状态翻转（幂等：重复确认返回 false）。
|
||
func confirmRefund(ctx context.Context, outTradeNo string) (bool, error) {
|
||
confirmed := false
|
||
err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
|
||
row, err := tx.Model(consts.TableMemberOrders).
|
||
Where("out_trade_no", outTradeNo).LockUpdate().One()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if row.IsEmpty() || row["status"].Int() != consts.OrderStatusDelivered {
|
||
return nil // 并发已确认 / 状态异常 → 幂等无操作
|
||
}
|
||
o := orderSnapshotFromRecord(row)
|
||
revokeService := row["refund_revoke"].Int() == 1
|
||
|
||
serviceRevoked := 0
|
||
if revokeService {
|
||
revoked, rerr := revokeOrderServiceTx(ctx, tx, o)
|
||
if rerr != nil {
|
||
return rerr
|
||
}
|
||
if revoked {
|
||
serviceRevoked = 1
|
||
}
|
||
}
|
||
if err = releaseVoucherForOrderTx(ctx, tx, o); err != nil {
|
||
return err
|
||
}
|
||
if _, err = tx.Model(consts.TableMemberOrders).Where("out_trade_no", outTradeNo).Data(g.Map{
|
||
"status": consts.OrderStatusRefunded,
|
||
"service_revoked": serviceRevoked,
|
||
"refunded_at": gdb.Raw("NOW()"),
|
||
"refund_status": consts.RefundStatusSuccess,
|
||
"refund_finished_at": gdb.Raw("NOW()"),
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return err
|
||
}
|
||
confirmed = true
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if confirmed {
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "order.refund.confirm",
|
||
TargetType: "order",
|
||
TargetId: outTradeNo,
|
||
After: g.Map{"status": consts.OrderStatusRefunded, "refund_status": consts.RefundStatusSuccess},
|
||
Result: consts.AuditResultSuccess,
|
||
Remark: "退款确认成功（平台推送/查单轮询）",
|
||
})
|
||
}
|
||
return confirmed, nil
|
||
}
|
||
|
||
// RefundStatusPoll 退款轮询兜底：扫「退款中」的订单主动查单确认。
|
||
// 推送丢失时的兜底路径；结果不可判定的单超过 24h 置「失败」告警，交管理员重试。
|
||
// 注册于 cmd.go（cronPatternRefundPoll，每 2 分钟）。
|
||
func RefundStatusPoll(ctx context.Context) {
|
||
if !xpayConfig(ctx).Configured() {
|
||
return
|
||
}
|
||
records, err := g.Model(consts.TableMemberOrders).
|
||
Where("refund_status", consts.RefundStatusProcessing).
|
||
Where("status", consts.OrderStatusDelivered).
|
||
WhereLT("updated_at", gtime.Now().Add(-2*time.Minute)).
|
||
OrderAsc("id").
|
||
Limit(50).
|
||
All()
|
||
if err != nil {
|
||
g.Log().Warningf(ctx, "[refund] 轮询扫单失败: %v", err)
|
||
return
|
||
}
|
||
for _, r := range records {
|
||
outTradeNo := r["out_trade_no"].String()
|
||
state, qerr := XPayQueryOrder(ctx, r["openid"].String(), outTradeNo)
|
||
if qerr != nil {
|
||
g.Log().Debugf(ctx, "[refund] 轮询查单跳过 outTradeNo=%s err=%v", outTradeNo, qerr)
|
||
continue
|
||
}
|
||
if state.Refund.Known && state.Refund.Success {
|
||
confirmed, ferr := confirmRefund(ctx, outTradeNo)
|
||
if ferr != nil {
|
||
g.Log().Errorf(ctx, "[refund] 轮询确认落库失败 outTradeNo=%s err=%v", outTradeNo, ferr)
|
||
continue
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 轮询确认成功 outTradeNo=%s confirmed=%v", outTradeNo, confirmed)
|
||
continue
|
||
}
|
||
// 发起超 24h 仍无法确认 → 置失败并告警（管理员核对后重试 / 手工登记）
|
||
updated := r["updated_at"].GTime()
|
||
if updated != nil && !updated.IsZero() && time.Since(updated.Time) > 24*time.Hour {
|
||
markRefundFailed(ctx, outTradeNo, r["refund_no"].String())
|
||
g.Log().Errorf(ctx, "[refund] 退款超 24h 未确认，置为失败待人工核对 outTradeNo=%s raw=%s",
|
||
outTradeNo, state.RawJson)
|
||
}
|
||
}
|
||
}
|