386 lines
16 KiB
Go
386 lines
16 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gogf/gf/v2/database/gdb"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
|
||
v1 "tool-api/api/admin/v1"
|
||
"tool-api/internal/consts"
|
||
"tool-api/internal/model/entity"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 管理端「订单管理 + 退款」逻辑
|
||
//
|
||
// 数据源：member_orders（order_type 1=会员套餐 2=次数包，同一张表）。
|
||
//
|
||
// 退款语义（本次核心）：
|
||
// - 仅允许 status=1(已发货) → 2(已退款)；其它状态给可读业务错误（4015）。
|
||
// - 幂等：status=2 再调 → 成功返回，但**不重复回收权益**（幂等由行锁 + status 判定保证）。
|
||
// - revokeService=true → 回收所购服务：
|
||
// 会员套餐：回退 users.level_expire_at（减去本单购买的天数），回收后若已到期则同时回落默认等级；
|
||
// level_expire_at IS NULL（永久）**同样真取消**：置为当前时刻（已过期，用户裁定 2026-09-23），
|
||
// level_key 保留不清空，失效判定交给 EffectiveLevelKey。
|
||
// 次数包： 扣回 user_tool_quota 的付费次数（扣到 0 为止，不出负数）。
|
||
// revokeService=false → 仅改状态，权益保留。
|
||
// - 释放券：退款时释放该订单占用的免单券 / 优惠码（仅当状态确实 1→2 时执行）。
|
||
// - 审计：记录操作人（审计上下文）、订单号、是否回收服务。
|
||
//
|
||
// 幂等/一致性设计说明：
|
||
// 回收权益与状态变更在**同一事务**内完成（按 out_trade_no 行锁），任一失败整体回滚 →
|
||
// 「已退款必然已按 revokeService 处理完毕」。新增列 service_revoked 记录**实际回收结果**
|
||
// （勾选「取消服务」且确有生效中的授权被解除才为 1；勾了但无可回收授权为 0，避免「列表显示已回收
|
||
// 但实际什么都没回收」的不诚实记录），用于列表展示与审计留痕（即便将来放开「退款后再回收」也据此判重）。
|
||
// ============================================================================
|
||
|
||
// AdminOrderList 订单列表（分页 + 关键字 + 状态筛选，默认创建时间倒序）。
|
||
func AdminOrderList(ctx context.Context, req *v1.OrderListReq) (*v1.OrderListRes, error) {
|
||
page, pageSize := normalizePage(req.Page, req.PageSize, 20)
|
||
m := g.Model(consts.TableMemberOrders)
|
||
if req.Status != nil {
|
||
m = m.Where("status", *req.Status)
|
||
}
|
||
if kw := strings.TrimSpace(req.Keyword); kw != "" {
|
||
like := "%" + kw + "%"
|
||
// 关键字：订单号 直接匹配；用户名/昵称 通过 users 子查询匹配归属用户
|
||
m = m.Where(
|
||
"out_trade_no LIKE ? OR user_id IN (SELECT id FROM "+consts.TableUsers+" WHERE nickname LIKE ? OR username LIKE ?)",
|
||
like, like, like,
|
||
)
|
||
}
|
||
total, err := m.Count()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
records, err := m.Page(page, pageSize).OrderDesc("created_at").OrderDesc("id").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
userInfo := orderUsersMap(ctx, records)
|
||
planNames, _ := planNameMap(ctx)
|
||
packNames, _ := quotaPackNameMap(ctx)
|
||
toolNames, _ := toolNameMap(ctx)
|
||
|
||
list := make([]v1.OrderItem, 0, len(records))
|
||
for _, r := range records {
|
||
uid := r["user_id"].Int64()
|
||
orderType := r["order_type"].Int()
|
||
if orderType == 0 {
|
||
orderType = consts.OrderTypeMember // 兼容加列之前的历史订单
|
||
}
|
||
item := v1.OrderItem{
|
||
Id: r["id"].Int64(),
|
||
OutTradeNo: r["out_trade_no"].String(),
|
||
UserId: uid,
|
||
OrderType: orderType,
|
||
PlanKey: r["plan_key"].String(),
|
||
PackKey: r["pack_key"].String(),
|
||
ToolKey: r["tool_key"].String(),
|
||
Times: r["times"].Int(),
|
||
OriginPriceCents: r["origin_price_cents"].Int64(),
|
||
DiscountCents: r["discount_cents"].Int64(),
|
||
PaidPriceCents: r["paid_price_cents"].Int64(),
|
||
PromoKind: r["promo_kind"].Int(),
|
||
Status: r["status"].Int(),
|
||
StatusText: orderStatusText(r["status"].Int()),
|
||
ServiceRevoked: r["service_revoked"].Int(),
|
||
PayChannel: r["pay_channel"].String(),
|
||
RefundStatus: r["refund_status"].Int(),
|
||
RefundNo: r["refund_no"].String(),
|
||
RefundAmount: r["refund_amount"].Int64(),
|
||
RefundReason: r["refund_reason"].String(),
|
||
CreatedAt: timeStr(r["created_at"].GTime()),
|
||
PaidAt: timeStr(r["paid_at"].GTime()),
|
||
RefundedAt: timeStr(r["refunded_at"].GTime()),
|
||
}
|
||
if u, ok := userInfo[uid]; ok {
|
||
item.Nickname = u["nickname"].String()
|
||
item.Username = u["username"].String()
|
||
item.AvatarUrl = u["avatar_url"].String()
|
||
}
|
||
item.Title = orderTitle(orderType, r["plan_key"].String(), r["pack_key"].String(), r["tool_key"].String(),
|
||
planNames, packNames, toolNames)
|
||
list = append(list, item)
|
||
}
|
||
return &v1.OrderListRes{List: list, Total: total}, nil
|
||
}
|
||
|
||
// orderUsersMap 批量取订单归属用户信息（一次查询，避免 N+1）。
|
||
func orderUsersMap(ctx context.Context, records gdb.Result) map[int64]gdb.Record {
|
||
out := map[int64]gdb.Record{}
|
||
idSet := map[int64]struct{}{}
|
||
for _, r := range records {
|
||
if uid := r["user_id"].Int64(); uid > 0 {
|
||
idSet[uid] = struct{}{}
|
||
}
|
||
}
|
||
if len(idSet) == 0 {
|
||
return out
|
||
}
|
||
ids := make([]int64, 0, len(idSet))
|
||
for id := range idSet {
|
||
ids = append(ids, id)
|
||
}
|
||
rows, err := g.Model(consts.TableUsers).WhereIn("id", ids).All()
|
||
if err != nil {
|
||
return out
|
||
}
|
||
for _, u := range rows {
|
||
out[u["id"].Int64()] = u
|
||
}
|
||
return out
|
||
}
|
||
|
||
// orderTitle 计算订单商品展示名。
|
||
//
|
||
// 会员套餐 → 套餐名；次数包 → 工具名 · 档位名（工具名缺失时仅档位名）。
|
||
func orderTitle(
|
||
orderType int, planKey, packKey, toolKey string,
|
||
planNames, packNames, toolNames map[string]string,
|
||
) string {
|
||
if orderType == consts.OrderTypeQuota {
|
||
title := packNames[packKey]
|
||
if tn := toolNames[toolKey]; tn != "" && title != "" {
|
||
title = tn + " · " + title
|
||
}
|
||
return title
|
||
}
|
||
return planNames[planKey]
|
||
}
|
||
|
||
// AdminOrderRefund 已迁移至 order_refund.go（真退款状态机：
|
||
// 调微信 /xpay/refund_order + 回调分流 + 查单轮询，权益回收移到确认成功时）。
|
||
|
||
// revokeOrderServiceTx 回收订单所购服务（仅已知订单行快照，事务内、行锁已持有）。
|
||
//
|
||
// 返回 revoked = 是否确有「生效中的授权」被解除，供 service_revoked 按**实际结果**落库。
|
||
func revokeOrderServiceTx(ctx context.Context, tx gdb.TX, o *orderSnapshot) (bool, error) {
|
||
if o.OrderType == consts.OrderTypeQuota {
|
||
return revokeQuotaServiceTx(ctx, tx, o)
|
||
}
|
||
return revokeMemberServiceTx(ctx, tx, o)
|
||
}
|
||
|
||
// revokeQuotaServiceTx 次数包回收：扣回对应工具付费次数（扣到 0 为止，不出负数）。
|
||
//
|
||
// 不变量：total_bought >= times_left（扣减 total_bought 时不低于扣减后的 times_left），
|
||
// 使看板「付费额度累计消耗 = Σ(total_bought - times_left)」保持自洽。
|
||
//
|
||
// 返回 revoked = 实际扣回了「生效中的付费额度」（原 times_left > 0）：
|
||
// 无额度记录 / 额度已耗尽(=0) 时不产生实际回收，返回 false。
|
||
func revokeQuotaServiceTx(ctx context.Context, tx gdb.TX, o *orderSnapshot) (bool, error) {
|
||
if o.ToolKey == "" || o.Times <= 0 {
|
||
// 数据异常（正常发货要求 toolKey 非空且 times>0）：无可回收项，跳过并告警
|
||
g.Log().Warningf(ctx, "[refund] 次数包订单缺少工具/次数，跳过回收 outTradeNo=%s toolKey=%q times=%d",
|
||
o.OutTradeNo, o.ToolKey, o.Times)
|
||
return false, nil
|
||
}
|
||
row, err := tx.Model(consts.TableUserToolQuota).
|
||
Where("user_id", o.UserId).Where("tool_key", o.ToolKey).LockUpdate().One()
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if row.IsEmpty() {
|
||
// 该用户在该工具上已无付费额度记录（可能已过期清理）：无可回收项
|
||
return false, nil
|
||
}
|
||
id := row["id"].Int64()
|
||
left := row["times_left"].Int()
|
||
bought := row["total_bought"].Int()
|
||
newLeft := left - o.Times
|
||
if newLeft < 0 {
|
||
newLeft = 0 // 扣到 0 为止，绝不为负
|
||
}
|
||
newBought := bought - o.Times
|
||
if newBought < newLeft {
|
||
newBought = newLeft
|
||
}
|
||
if _, err = tx.Model(consts.TableUserToolQuota).Where("id", id).Data(g.Map{
|
||
"times_left": newLeft,
|
||
"total_bought": newBought,
|
||
// ⚠️ 库内 NOW()：避免 Go 侧传参 datetime 的 TZ-01 8h 偏差（新代码不得引入）。
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return false, err
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 次数包回收 userId=%d tool=%s -%d 次（剩余 %d→%d）outTradeNo=%s",
|
||
o.UserId, o.ToolKey, o.Times, left, newLeft, o.OutTradeNo)
|
||
// 原本就有可用额度才构成「生效中的授权被解除」；额度已为 0 时扣减不产生实际回收。
|
||
return left > 0, nil
|
||
}
|
||
|
||
// revokeMemberServiceTx 会员套餐回收：回退 users.level_expire_at。
|
||
//
|
||
// 回收模型（重放算账，修复「退 A 误扣 B」）：
|
||
// - 旧行为 `GREATEST(level_expire_at - INTERVAL days DAY, now)` 是对「当前到期时间」盲目减
|
||
// 本单天数：若本单到期后用户又买了 B，退 A 会把 **B 的天数一起减掉**。
|
||
// - 新行为：按发货同款顺延规则（extendMembership），重放该用户所有「已发货未退款」的会员单
|
||
// （本单在进入本函数前已被置为 status=2 → 自然排除），得到理论到期时间，再把当前到期时间
|
||
// 收敛过去。审计例：T 买 A(30d)→到期→T+60 买 B(30d)→退 A：重放只剩 B → 到期仍为 T+90，
|
||
// 一分不减。
|
||
// - level_expire_at 为 NULL（永久）→ 维持用户裁定（2026-09-23）**真取消、置为已过期**：
|
||
// 写入 level_expire_at = NOW()；level_key 保留不清空，失效判定交给 EffectiveLevelKey。
|
||
// - 等级回落**只经 EffectiveLevelKey 收敛**（与「自然到期」口径一致），本函数不改 level_key。
|
||
//
|
||
// ⚠️ TZ-01 铁律：本库 DSN 未指定 loc，Go 侧传参 datetime 落库会早一个时区偏移。
|
||
// 重放用的 paid_at 全部**读自 DB**（同一时区口径），差值 deltaMinutes 由两个 DB 值相减
|
||
// （偏移相消），最终用 `level_expire_at - INTERVAL ? MINUTE` 在**库内**完成算术，
|
||
// GREATEST(..., NOW()) 兜底「已过期哨兵」（与旧实现同款豁免）；updated_at 用库内 NOW()。
|
||
//
|
||
// 返回 revoked = 回收**前**是否为「生效中的会员」（唯一判定走 EffectiveLevelKey），
|
||
// 供 service_revoked 按实际结果落库（已过期 / 免费用户退款时不记「已回收」）。
|
||
func revokeMemberServiceTx(ctx context.Context, tx gdb.TX, o *orderSnapshot) (bool, error) {
|
||
row, err := tx.Model(consts.TableUsers).Where("id", o.UserId).LockUpdate().One()
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if row.IsEmpty() {
|
||
return false, nil
|
||
}
|
||
expire := row["level_expire_at"].GTime()
|
||
// 回收前是否为「生效中的会员」：唯一判定走 EffectiveLevelKey（永久 NULL 与未过期同为有效，已过期回落默认）。
|
||
wasEffective := EffectiveLevelKey(&entity.Users{
|
||
LevelKey: row["level_key"].String(),
|
||
LevelExpireAt: expire,
|
||
}) != consts.DefaultLevelKey
|
||
|
||
// 永久会员：真取消，置为已过期（用户裁定 2026-09-23）。
|
||
// NOW() 在库内取，规避 Go 侧传参的时区偏差（TZ-01）；WHERE 限定 IS NULL，绝不误动有限期。
|
||
if expire == nil || expire.IsZero() {
|
||
if _, err = tx.Exec(
|
||
"UPDATE "+consts.TableUsers+" SET level_expire_at = NOW(), updated_at = NOW() "+
|
||
"WHERE id = ? AND level_expire_at IS NULL",
|
||
o.UserId); err != nil {
|
||
return false, err
|
||
}
|
||
if err = rollbackQuotaPeriodTx(ctx, tx, o.UserId); err != nil {
|
||
return false, err
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 永久会员回收置为已过期 userId=%d outTradeNo=%s", o.UserId, o.OutTradeNo)
|
||
return wasEffective, nil
|
||
}
|
||
|
||
// ===== 重放算账：理论到期时间 =====
|
||
// ⚠️ 必须排除本单：手工路径在本函数执行时订单尚未翻转 status（仍为 1），
|
||
// 仅按 status 过滤会把本单算进重放；API 确认路径同样适用（本单即将置为已退款）。
|
||
orders, err := tx.Model(consts.TableMemberOrders).
|
||
Where("user_id", o.UserId).
|
||
Where("order_type", consts.OrderTypeMember).
|
||
Where("status", consts.OrderStatusDelivered).
|
||
Where("id <> ?", o.Id).
|
||
OrderAsc("paid_at").OrderAsc("id").
|
||
All()
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
var runExpire time.Time // 零值 = 尚无任何会员时长
|
||
runLevel := ""
|
||
for _, r := range orders {
|
||
days := r["duration_days"].Int()
|
||
if days <= 0 {
|
||
continue
|
||
}
|
||
paid := r["paid_at"].GTime()
|
||
if paid == nil || paid.IsZero() {
|
||
paid = r["created_at"].GTime() // 老订单兜底
|
||
}
|
||
if paid == nil || paid.IsZero() {
|
||
continue
|
||
}
|
||
level := r["level_key"].String()
|
||
// 与 extendMembership 同款：同档且未到期 → 顺延；跨档/更高档 → 从购买时刻起算。
|
||
// （简化：不重放「高等级不降权」的 level_key 归属，到期时间口径一致；level_key 本就不由本函数改写。）
|
||
base := paid.Time
|
||
if !runExpire.IsZero() && runExpire.After(paid.Time) && runLevel == level {
|
||
base = runExpire
|
||
}
|
||
runExpire = base.AddDate(0, 0, days)
|
||
runLevel = level
|
||
}
|
||
|
||
if runExpire.IsZero() {
|
||
// 退款后已无任何剩余会员单：沿用旧口径——从当前到期时间减去本单天数、夹到当前时刻。
|
||
// （用户可能在本单之前还有「无订单可考」的剩余时长，减法比直接置 NOW() 更不误伤。）
|
||
days := o.DurationDays
|
||
if days <= 0 {
|
||
days = 0
|
||
}
|
||
// 「已过期哨兵」下限沿用旧实现的 Go 侧传参豁免（与库内 NOW() 在 EffectiveLevelKey
|
||
// 下用户可见行为一致；且规避 DB 与进程秒级时钟差导致的判定抖动）。
|
||
if _, err = tx.Exec(
|
||
"UPDATE "+consts.TableUsers+" SET level_expire_at = GREATEST(level_expire_at - INTERVAL ? MINUTE, ?), "+
|
||
"updated_at = NOW() WHERE id = ? AND level_expire_at IS NOT NULL",
|
||
int64(days)*24*60, gtime.Now(), o.UserId); err != nil {
|
||
return false, err
|
||
}
|
||
if err = rollbackQuotaPeriodTx(ctx, tx, o.UserId); err != nil {
|
||
return false, err
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 会员回收（重放后无剩余会员单，减本单 %d 天夹到当前）userId=%d outTradeNo=%s",
|
||
days, o.UserId, o.OutTradeNo)
|
||
return wasEffective, nil
|
||
}
|
||
|
||
// 差值收敛：delta = 当前到期 − 理论到期（分钟）。delta<=0 说明重放不短于现状
|
||
// （退款绝不该「延长」权益）→ 不动库。算术全部发生在库内（INTERVAL ? MINUTE）。
|
||
deltaMinutes := int64(expire.Time.Sub(runExpire).Minutes() + 0.5)
|
||
if deltaMinutes <= 0 {
|
||
g.Log().Warningf(ctx, "[refund] 会员回收重放结果不短于当前到期，跳过减法 userId=%d delta=%dmin outTradeNo=%s",
|
||
o.UserId, deltaMinutes, o.OutTradeNo)
|
||
return wasEffective, nil
|
||
}
|
||
result, err := tx.Exec(
|
||
"UPDATE "+consts.TableUsers+" SET level_expire_at = GREATEST(level_expire_at - INTERVAL ? MINUTE, ?), "+
|
||
"updated_at = NOW() WHERE id = ? AND level_expire_at IS NOT NULL",
|
||
deltaMinutes, gtime.Now(), o.UserId)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if n, _ := result.RowsAffected(); n == 0 {
|
||
g.Log().Warningf(ctx, "[refund] 会员回收未命中（用户已无有限期）userId=%d outTradeNo=%s", o.UserId, o.OutTradeNo)
|
||
return false, nil
|
||
}
|
||
if err = rollbackQuotaPeriodTx(ctx, tx, o.UserId); err != nil {
|
||
return false, err
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 会员回收（重放算账）userId=%d 收敛 -%d 分钟 outTradeNo=%s", o.UserId, deltaMinutes, o.OutTradeNo)
|
||
return wasEffective, nil
|
||
}
|
||
|
||
// rollbackQuotaPeriodTx 回滚发货时写的 users.quota_period_days：
|
||
// 取该用户**剩余**最新一笔已发货会员单的套餐周期；没有 → 0（跟随全局）。
|
||
// 幂等：重复调用结果一致；绝不回写本单所属套餐的周期（本单已置为退款态，不在查询集内）。
|
||
func rollbackQuotaPeriodTx(ctx context.Context, tx gdb.TX, userId int64) error {
|
||
value, err := tx.Model(consts.TableMemberOrders+" o").
|
||
LeftJoin(consts.TableMemberPlans+" p", "p.plan_key = o.plan_key").
|
||
Where("o.user_id", userId).
|
||
Where("o.order_type", consts.OrderTypeMember).
|
||
Where("o.status", consts.OrderStatusDelivered).
|
||
OrderDesc("o.id").
|
||
Limit(1).
|
||
Value("p.quota_period_days")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
days := 0 // 0 = 跟随全局（users.quota_period_days 的语义）
|
||
if value != nil {
|
||
days = value.Int()
|
||
}
|
||
if days < 0 {
|
||
days = 0
|
||
}
|
||
if _, err = tx.Exec(
|
||
"UPDATE "+consts.TableUsers+" SET quota_period_days = ?, updated_at = NOW() WHERE id = ?",
|
||
days, userId); err != nil {
|
||
return err
|
||
}
|
||
g.Log().Infof(ctx, "[refund] 回滚额度周期 userId=%d → %d 天", userId, days)
|
||
return nil
|
||
}
|