team/hm-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

f ‘部分退款’

Browse Source
This commit is contained in:
liangzai
2026-01-20 20:18:46 +08:00
parent ed8d311e02
commit 3dcef00566
10 changed files with 166 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
app/main/api/desc/front/agent.api
View File

@@ -326,12 +326,14 @@ type (
SubWithdrawReward float64 `json:"sub_withdraw_reward"` SubWithdrawReward float64 `json:"sub_withdraw_reward"`
} }
Commission { Commission {
OrderId string `json:"order_id"` // 订单号 OrderId string `json:"order_id"` // 订单号
ProductName string `json:"product_name"` ProductName string `json:"product_name"`
Amount float64 `json:"amount"` Amount float64 `json:"amount"` // 原始佣金金额
Status int64 `json:"status"` // 状态：0-已结算，1-冻结中，2-已退款 RefundedAmount float64 `json:"refunded_amount"` // 已退款佣金金额
CreateTime string `json:"create_time"` NetAmount float64 `json:"net_amount"` // 剩余净佣金金额 = amount - refunded_amount
QueryParams map[string]interface{} `json:"query_params,omitempty"` Status int64 `json:"status"` // 状态：0-已结算，1-冻结中，2-已退款
CreateTime string `json:"create_time"`
QueryParams map[string]interface{} `json:"query_params,omitempty"`
} }
GetCommissionReq { GetCommissionReq {
Page int64 `form:"page"` // 页码 Page int64 `form:"page"` // 页码

9
app/main/api/internal/logic/admin_order/adminrefundorderlogic.go
View File

@@ -92,8 +92,9 @@ func (l *AdminRefundOrderLogic) handleAlipayRefund(order *model.Order, req *type
return nil, err return nil, err
} }
// 退款成功后，更新代理佣金状态并扣除钱包金额 // 退款成功后，按本次退款金额更新代理佣金状态并扣除钱包金额
paylogic.HandleCommissionAndWalletDeduction(l.ctx, l.svcCtx, nil, order) // 注意：refundAmount 为本次实际退款金额，可以是部分退款
_ = paylogic.HandleCommissionAndWalletDeduction(l.ctx, l.svcCtx, nil, order, req.RefundAmount)
return &types.AdminRefundOrderResp{ return &types.AdminRefundOrderResp{
Status: model.OrderStatusRefunded, Status: model.OrderStatusRefunded,
@@ -119,15 +120,13 @@ func (l *AdminRefundOrderLogic) handleWechatRefund(order *model.Order, req *type
} }
// 微信退款是异步的，创建pending状态的退款记录 // 微信退款是异步的，创建pending状态的退款记录
// 注意：代理佣金扣除将在微信退款回调成功后再执行，不在此处提前扣除
refundNo := l.generateRefundNo(order.OrderNo) refundNo := l.generateRefundNo(order.OrderNo)
err = l.createRefundRecordAndUpdateOrder(order, req, refundNo, "", model.OrderStatusRefunding, model.OrderRefundStatusPending) err = l.createRefundRecordAndUpdateOrder(order, req, refundNo, "", model.OrderStatusRefunding, model.OrderRefundStatusPending)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 退款成功后，更新代理佣金状态并扣除钱包金额
paylogic.HandleCommissionAndWalletDeduction(l.ctx, l.svcCtx, nil, order)
return &types.AdminRefundOrderResp{ return &types.AdminRefundOrderResp{
Status: model.OrderRefundStatusPending, Status: model.OrderRefundStatusPending,
RefundNo: refundNo, RefundNo: refundNo,

9
app/main/api/internal/logic/agent/getagentcommissionlogic.go
View File

@@ -58,8 +58,15 @@ func (l *GetAgentCommissionLogic) GetAgentCommission(req *types.GetCommissionReq
if copyErr != nil { if copyErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取代理佣金列表, %v", err) return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取代理佣金列表, %v", err)
} }
// 显式设置 status 字段 // 显式设置 status 字段和已退款金额
commission.Status = agentCommissionModel.Status commission.Status = agentCommissionModel.Status
commission.RefundedAmount = agentCommissionModel.RefundedAmount
// 计算净佣金金额（防御性处理，避免出现负数）
netAmount := agentCommissionModel.Amount - agentCommissionModel.RefundedAmount
if netAmount < 0 {
netAmount = 0
}
commission.NetAmount = netAmount
product, findProductErr := l.svcCtx.ProductModel.FindOne(l.ctx, agentCommissionModel.ProductId) product, findProductErr := l.svcCtx.ProductModel.FindOne(l.ctx, agentCommissionModel.ProductId)
if findProductErr != nil { if findProductErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "获取代理佣金列表, %v", err) return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "获取代理佣金列表, %v", err)

16
app/main/api/internal/logic/agent/getagentrevenueinfologic.go
View File

@@ -126,30 +126,36 @@ func calculateDirectPushReport(commissions []*model.AgentCommission, loc *time.L
// 转换时区 // 转换时区
createTime := c.CreateTime createTime := c.CreateTime
// 只统计非退款的佣金（status != 2） // 只统计未被全部退款的佣金
if c.Status == 2 { if c.Status == 2 {
continue continue
} }
// 统计净佣金：原始金额减去已退款金额
netAmount := c.Amount - c.RefundedAmount
if netAmount <= 0 {
continue
}
// 统计总量 // 统计总量
report.TotalCommission += c.Amount report.TotalCommission += netAmount
report.TotalReport++ report.TotalReport++
// 近24小时（滚动周期） // 近24小时（滚动周期）
if createTime.After(todayStart) { if createTime.After(todayStart) {
report.Today.Commission += c.Amount report.Today.Commission += netAmount
report.Today.Report++ report.Today.Report++
} }
// 近7天（滚动周期） // 近7天（滚动周期）
if createTime.After(last7dStart) { if createTime.After(last7dStart) {
report.Last7D.Commission += c.Amount report.Last7D.Commission += netAmount
report.Last7D.Report++ report.Last7D.Report++
} }
// 近30天（滚动周期） // 近30天（滚动周期）
if createTime.After(last30dStart) { if createTime.After(last30dStart) {
report.Last30D.Commission += c.Amount report.Last30D.Commission += netAmount
report.Last30D.Report++ report.Last30D.Report++
} }
} }

128
app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go
View File

@@ -18,24 +18,61 @@ import (
) )
// HandleCommissionAndWalletDeduction 处理退款后的佣金状态更新和钱包金额扣除 // HandleCommissionAndWalletDeduction 处理退款后的佣金状态更新和钱包金额扣除
// 这是一个公共函数，可以被支付宝和微信退款逻辑共享使用 // refundAmount 为本次实际退款金额（单位：元），从代理侧总共需要承担的金额
// 只有当订单状态不为已退款时，才会处理佣金状态更新和钱包金额扣除 // 该函数会优先冲减当前订单相关的佣金（基于 RefundedAmount），不足部分再从钱包余额/冻结余额中扣除
func HandleCommissionAndWalletDeduction(ctx context.Context, svcCtx *svc.ServiceContext, session sqlx.Session, order *model.Order) error { func HandleCommissionAndWalletDeduction(ctx context.Context, svcCtx *svc.ServiceContext, session sqlx.Session, order *model.Order, refundAmount float64) error {
// 查询非已退款的佣金 if refundAmount <= 0 {
return nil
}
// 查询当前订单关联的所有佣金记录（包括已结算和冻结），剔除已经完全退款的
commissionBuilder := svcCtx.AgentCommissionModel.SelectBuilder() commissionBuilder := svcCtx.AgentCommissionModel.SelectBuilder()
commissions, commissionsErr := svcCtx.AgentCommissionModel.FindAll(ctx, commissionBuilder.Where(squirrel.And{ commissions, commissionsErr := svcCtx.AgentCommissionModel.FindAll(ctx, commissionBuilder.Where(squirrel.And{
squirrel.Eq{"order_id": order.Id}, squirrel.Eq{"order_id": order.Id},
squirrel.NotEq{"status": 2}, // 只查询非已退款的佣金 squirrel.NotEq{"status": 2}, // 排除已全部退款的佣金
}), "") }), "")
if commissionsErr != nil { if commissionsErr != nil {
logx.Errorf("查询代理佣金失败，订单ID: %d, 错误: %v", order.Id, commissionsErr) logx.Errorf("查询代理佣金失败，订单ID: %d, 错误: %v", order.Id, commissionsErr)
return nil // 返回 nil，因为佣金更新失败不应影响退款流程 return nil // 返回 nil，因为佣金更新失败不应影响退款流程
} }
if len(commissions) == 0 {
return nil
}
// 剩余需要由佣金 + 钱包共同承担的退款金额
remainRefundAmount := refundAmount
// 记录每个代理本次需要从钱包扣除的金额，避免同一代理多条佣金时重复查钱包并产生多条流水
type walletAdjust struct {
agentId int64
amount float64 // 需要从该代理钱包扣除的金额（正数）
}
walletAdjustMap := make(map[int64]*walletAdjust)
// 1. 先在佣金记录上做冲减：增加 RefundedAmount，必要时将状态置为已退款
for _, commission := range commissions { for _, commission := range commissions {
// 记录更新佣金状态前的状态值，用于后续判断 available := commission.Amount - commission.RefundedAmount
oldCommissionStatus := commission.Status if available <= 0 {
commission.Status = 2 // 设置为已退款 continue
}
if remainRefundAmount <= 0 {
break
}
// 当前这条佣金最多可冲减 available，本次实际冲减 currentRefund
currentRefund := available
if currentRefund > remainRefundAmount {
currentRefund = remainRefundAmount
}
// 更新佣金的已退款金额
commission.RefundedAmount += currentRefund
// 如果这条佣金已经被完全冲减，则标记为已退款
if commission.RefundedAmount >= commission.Amount {
commission.Status = 2
}
// 更新佣金状态到数据库 // 更新佣金状态到数据库
var updateCommissionErr error var updateCommissionErr error
@@ -46,13 +83,30 @@ func HandleCommissionAndWalletDeduction(ctx context.Context, svcCtx *svc.Service
} }
if updateCommissionErr != nil { if updateCommissionErr != nil {
logx.Errorf("更新代理佣金状态失败，佣金ID: %d, 订单ID: %d, 错误: %v", commission.Id, order.Id, updateCommissionErr) logx.Errorf("更新代理佣金状态失败，佣金ID: %d, 订单ID: %d, 错误: %v", commission.Id, order.Id, updateCommissionErr)
continue // 如果佣金状态更新失败，就不继续处理钱包 continue // 如果佣金状态更新失败，就不继续计入本次冲减
}
// 记录该代理需要从钱包扣除的金额（可能后续还有其他佣金叠加）
wa, ok := walletAdjustMap[commission.AgentId]
if !ok {
wa = &walletAdjust{agentId: commission.AgentId}
walletAdjustMap[commission.AgentId] = wa
}
wa.amount += currentRefund
remainRefundAmount -= currentRefund
}
// 2. 再按代理维度，从钱包（冻结余额/可用余额）中扣除对应金额
for _, wa := range walletAdjustMap {
if wa.amount <= 0 {
continue
} }
// 处理用户钱包的金额扣除 // 处理用户钱包的金额扣除
wallet, err := svcCtx.AgentWalletModel.FindOneByAgentId(ctx, commission.AgentId) wallet, err := svcCtx.AgentWalletModel.FindOneByAgentId(ctx, wa.agentId)
if err != nil { if err != nil {
logx.Errorf("查询代理钱包失败，代理ID: %d, 错误: %v", commission.AgentId, err) logx.Errorf("查询代理钱包失败，代理ID: %d, 错误: %v", wa.agentId, err)
continue continue
} }
@@ -60,22 +114,17 @@ func HandleCommissionAndWalletDeduction(ctx context.Context, svcCtx *svc.Service
balanceBefore := wallet.Balance balanceBefore := wallet.Balance
frozenBalanceBefore := wallet.FrozenBalance frozenBalanceBefore := wallet.FrozenBalance
// 如果是冻结状态的佣金，直接扣减冻结余额 // 优先从冻结余额中扣除（与原先“冻结佣金优先使用冻结余额”的设计一致）
if oldCommissionStatus == 1 { deduct := wa.amount
// 冻结状态的佣金，根据订单金额优先减少冻结金额，如果冻结金额不足则减少钱包余额 if wallet.FrozenBalance >= deduct {
if wallet.FrozenBalance >= order.Amount { wallet.FrozenBalance -= deduct
// 冻结余额足够，优先减少冻结金额
wallet.FrozenBalance -= order.Amount
} else {
// 冻结余额不足，先扣减所有冻结金额，再扣减余额
remaining := order.Amount - wallet.FrozenBalance
wallet.FrozenBalance = 0
wallet.Balance -= remaining
}
// 其他状态的佣金，比如已结算状态（status = 0），直接扣减钱包余额
} else { } else {
wallet.Balance -= order.Amount remaining := deduct - wallet.FrozenBalance
wallet.FrozenBalance = 0
// 可用余额可以为负数，由业务承担风险
wallet.Balance -= remaining
} }
// 变动后余额和冻结余额 // 变动后余额和冻结余额
balanceAfter := wallet.Balance balanceAfter := wallet.Balance
frozenBalanceAfter := wallet.FrozenBalance frozenBalanceAfter := wallet.FrozenBalance
@@ -87,29 +136,28 @@ func HandleCommissionAndWalletDeduction(ctx context.Context, svcCtx *svc.Service
updateWalletErr = svcCtx.AgentWalletModel.UpdateWithVersion(ctx, nil, wallet) updateWalletErr = svcCtx.AgentWalletModel.UpdateWithVersion(ctx, nil, wallet)
} }
if updateWalletErr != nil { if updateWalletErr != nil {
logx.Errorf("更新代理钱包失败，代理ID: %d, 错误: %v", commission.AgentId, updateWalletErr) logx.Errorf("更新代理钱包失败，代理ID: %d, 错误: %v", wa.agentId, updateWalletErr)
continue continue
} }
// 创建钱包交易流水记录（退款） // 创建钱包交易流水记录（退款）
transErr := svcCtx.AgentService.CreateWalletTransaction( transErr := svcCtx.AgentService.CreateWalletTransaction(
ctx, ctx,
session, session,
commission.AgentId, wa.agentId,
model.WalletTransactionTypeRefund, model.WalletTransactionTypeRefund,
-order.Amount, -wa.amount*-1, // 钱包流水金额为负数
balanceBefore, balanceBefore,
balanceAfter, balanceAfter,
frozenBalanceBefore, frozenBalanceBefore,
frozenBalanceAfter, frozenBalanceAfter,
order.OrderNo, order.OrderNo,
commission.Id, 0, // 这里不强绑到某一条具体佣金记录，按订单维度记录
"订单退款，佣金已扣除", "订单退款，佣金已扣除",
) )
if transErr != nil { if transErr != nil {
logx.Errorf("创建代理钱包流水记录失败，代理ID: %d, 错误: %v", commission.AgentId, transErr) logx.Errorf("创建代理钱包流水记录失败，代理ID: %d, 错误: %v", wa.agentId, transErr)
continue continue
} }
} }
return nil return nil
} }
@@ -129,7 +177,8 @@ func NewWechatPayRefundCallbackLogic(ctx context.Context, svcCtx *svc.ServiceCon
} }
// handleQueryOrderRefund 处理查询订单退款 // handleQueryOrderRefund 处理查询订单退款
func (l *WechatPayRefundCallbackLogic) handleQueryOrderRefund(orderNo string, status refunddomestic.Status) error { // refundAmountYuan 表示微信本次实际退款金额（单位：元）
func (l *WechatPayRefundCallbackLogic) handleQueryOrderRefund(orderNo string, status refunddomestic.Status, refundAmountYuan float64) error {
order, err := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, orderNo) order, err := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, orderNo)
if err != nil { if err != nil {
return errors.Wrapf(err, "查找查询订单信息失败: %s", orderNo) return errors.Wrapf(err, "查找查询订单信息失败: %s", orderNo)
@@ -171,8 +220,8 @@ func (l *WechatPayRefundCallbackLogic) handleQueryOrderRefund(orderNo string, st
return errors.Wrapf(err, "更新查询订单状态失败: %s", orderNo) return errors.Wrapf(err, "更新查询订单状态失败: %s", orderNo)
} }
// 退款成功时，更新代理佣金状态并扣除钱包金额 // 退款成功时，按本次实际退款金额更新代理佣金状态并扣除钱包金额
HandleCommissionAndWalletDeduction(ctx, l.svcCtx, session, order) _ = HandleCommissionAndWalletDeduction(ctx, l.svcCtx, session, order, refundAmountYuan)
} }
// 查找最新的pending状态的退款记录 // 查找最新的pending状态的退款记录
@@ -295,15 +344,22 @@ func (l *WechatPayRefundCallbackLogic) WechatPayRefundCallback(w http.ResponseWr
var processErr error var processErr error
// 计算本次实际退款金额（单位：元），用于后续佣金和钱包扣减
var refundAmountYuan float64
if notification.Amount != nil && notification.Amount.Refund != nil {
// 微信退款金额单位为分，这里转换为元
refundAmountYuan = float64(*notification.Amount.Refund) / 100.0
}
// 4. 根据订单号前缀处理不同类型的订单 // 4. 根据订单号前缀处理不同类型的订单
switch { switch {
case strings.HasPrefix(orderNo, "Q_"): case strings.HasPrefix(orderNo, "Q_"):
processErr = l.handleQueryOrderRefund(orderNo, status) processErr = l.handleQueryOrderRefund(orderNo, status, refundAmountYuan)
case strings.HasPrefix(orderNo, "A_"): case strings.HasPrefix(orderNo, "A_"):
processErr = l.handleAgentOrderRefund(orderNo, status) processErr = l.handleAgentOrderRefund(orderNo, status)
default: default:
// 兼容旧订单，假设没有前缀的是查询订单 // 兼容旧订单，假设没有前缀的是查询订单
processErr = l.handleQueryOrderRefund(orderNo, status) processErr = l.handleQueryOrderRefund(orderNo, status, refundAmountYuan)
} }
// 5. 处理错误并响应 // 5. 处理错误并响应

22
app/main/api/internal/queue/paySuccessNotify.go
View File

@@ -247,33 +247,23 @@ func (l *PaySuccessNotifyUserHandler) handleError(ctx context.Context, err error
// 退款 // 退款
if order.PaymentPlatform == "wechat" { if order.PaymentPlatform == "wechat" {
// 微信退款为异步结果，这里只发起退款申请，订单状态与佣金/钱包扣减交由退款回调统一处理
refundErr := l.svcCtx.WechatPayService.WeChatRefund(ctx, order.OrderNo, order.Amount, order.Amount) refundErr := l.svcCtx.WechatPayService.WeChatRefund(ctx, order.OrderNo, order.Amount, order.Amount)
if refundErr != nil { if refundErr != nil {
logx.Error(refundErr) logx.Error(refundErr)
return asynq.SkipRetry return asynq.SkipRetry
} }
// 微信退款成功，更新订单、佣金、钱包状态 logx.Infof("已发起微信退款申请, orderID: %d, amount: %f", order.Id, order.Amount)
logx.Infof("微信退款成功, orderID: %d", order.Id)
// 更新订单状态为退款
order.Status = "refunded"
updateOrderErr := l.svcCtx.OrderModel.UpdateWithVersion(ctx, nil, order)
if updateOrderErr != nil {
logx.Errorf("更新订单状态失败，订单ID: %d, 错误: %v", order.Id, updateOrderErr)
return fmt.Errorf("更新订单状态失败: %v", updateOrderErr)
}
// 使用公共函数处理佣金和钱包扣除
paylogic.HandleCommissionAndWalletDeduction(ctx, l.svcCtx, nil, order)
return asynq.SkipRetry return asynq.SkipRetry
} else { } else {
// 支付宝退款为同步结果，这里直接根据返回结果更新订单和佣金/钱包
refund, refundErr := l.svcCtx.AlipayService.AliRefund(ctx, order.OrderNo, order.Amount) refund, refundErr := l.svcCtx.AlipayService.AliRefund(ctx, order.OrderNo, order.Amount)
if refundErr != nil { if refundErr != nil {
logx.Error(refundErr) logx.Error(refundErr)
return asynq.SkipRetry return asynq.SkipRetry
} }
if refund.IsSuccess() { if refund.IsSuccess() {
logx.Errorf("支付宝退款成功, orderID: %d", order.Id) logx.Infof("支付宝退款成功, orderID: %d", order.Id)
// 更新订单状态为退款 // 更新订单状态为退款
order.Status = "refunded" order.Status = "refunded"
updateOrderErr := l.svcCtx.OrderModel.UpdateWithVersion(ctx, nil, order) updateOrderErr := l.svcCtx.OrderModel.UpdateWithVersion(ctx, nil, order)
@@ -282,8 +272,8 @@ func (l *PaySuccessNotifyUserHandler) handleError(ctx context.Context, err error
return fmt.Errorf("更新订单状态失败: %v", updateOrderErr) return fmt.Errorf("更新订单状态失败: %v", updateOrderErr)
} }
// 使用公共函数处理佣金和钱包扣除 // 使用公共函数按本次退款金额处理佣金和钱包扣除
paylogic.HandleCommissionAndWalletDeduction(ctx, l.svcCtx, nil, order) _ = paylogic.HandleCommissionAndWalletDeduction(ctx, l.svcCtx, nil, order, order.Amount)
return asynq.SkipRetry return asynq.SkipRetry
} else { } else {

11
app/main/api/internal/queue/unfreezeCommission.go
View File

@@ -70,9 +70,14 @@ func (l *UnfreezeCommissionHandler) ProcessTask(ctx context.Context, t *asynq.Ta
return err return err
} }
// 更新钱包余额：增加佣金金额到balance，减少相应的frozen_balance // 计算当前佣金在发生退款后的“净佣金金额”
// 注意：这里应该转移的是当前佣金记录的金额，而不是全部冻结余额 commissionAmount := commission.Amount - commission.RefundedAmount
commissionAmount := commission.Amount if commissionAmount <= 0 {
logx.Infof("佣金记录ID %d 已被全部退款或无可解冻金额，跳过解冻", commissionID)
return nil
}
// 更新钱包余额：增加净佣金金额到 balance，减少相应的 frozen_balance
agentWallet.Balance += commissionAmount agentWallet.Balance += commissionAmount
agentWallet.FrozenBalance -= commissionAmount agentWallet.FrozenBalance -= commissionAmount
agentWallet.UpdateTime = now agentWallet.UpdateTime = now

14
app/main/api/internal/types/types.go
View File

@@ -1338,12 +1338,14 @@ type BindMobileResp struct {
} }
type Commission struct { type Commission struct {
OrderId string `json:"order_id"` // 订单号 OrderId string `json:"order_id"` // 订单号
ProductName string `json:"product_name"` ProductName string `json:"product_name"`
Amount float64 `json:"amount"` Amount float64 `json:"amount"` // 原始佣金金额
Status int64 `json:"status"` // 状态：0-已结算，1-冻结中，2-已退款 RefundedAmount float64 `json:"refunded_amount"` // 已退款佣金金额
CreateTime string `json:"create_time"` NetAmount float64 `json:"net_amount"` // 剩余净佣金金额 = amount - refunded_amount
QueryParams map[string]interface{} `json:"query_params,omitempty"` Status int64 `json:"status"` // 状态：0-已结算，1-冻结中，2-已退款
CreateTime string `json:"create_time"`
QueryParams map[string]interface{} `json:"query_params,omitempty"`
} }
type CreateMenuReq struct { type CreateMenuReq struct {

37
app/main/model/agentCommissionModel_gen.go
View File

@@ -54,17 +54,18 @@ type (
} }
AgentCommission struct { AgentCommission struct {
Id int64 `db:"id"` Id int64 `db:"id"`
AgentId int64 `db:"agent_id"` AgentId int64 `db:"agent_id"`
OrderId int64 `db:"order_id"` OrderId int64 `db:"order_id"`
Amount float64 `db:"amount"` Amount float64 `db:"amount"`
ProductId int64 `db:"product_id"` // 产品ID RefundedAmount float64 `db:"refunded_amount"` // 已退款佣金金额
Status int64 `db:"status"` // 状态：0-已结算，1-冻结中，2-已退款 ProductId int64 `db:"product_id"` // 产品ID
CreateTime time.Time `db:"create_time"` Status int64 `db:"status"`
UpdateTime time.Time `db:"update_time"` // 更新时间 CreateTime time.Time `db:"create_time"`
DeleteTime sql.NullTime `db:"delete_time"` // 删除时间 UpdateTime time.Time `db:"update_time"` // 更新时间
DelState int64 `db:"del_state"` // 删除状态 DeleteTime sql.NullTime `db:"delete_time"` // 删除时间
Version int64 `db:"version"` // 版本号 DelState int64 `db:"del_state"` // 删除状态
Version int64 `db:"version"` // 版本号
} }
) )
@@ -79,11 +80,11 @@ func (m *defaultAgentCommissionModel) Insert(ctx context.Context, session sqlx.S
data.DelState = globalkey.DelStateNo data.DelState = globalkey.DelStateNo
tydataAgentCommissionIdKey := fmt.Sprintf("%s%v", cacheTydataAgentCommissionIdPrefix, data.Id) tydataAgentCommissionIdKey := fmt.Sprintf("%s%v", cacheTydataAgentCommissionIdPrefix, data.Id)
return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?)", m.table, agentCommissionRowsExpectAutoSet) query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, agentCommissionRowsExpectAutoSet)
if session != nil { if session != nil {
return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version) return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version)
} }
return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version) return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version)
}, tydataAgentCommissionIdKey) }, tydataAgentCommissionIdKey)
} }
@@ -109,9 +110,9 @@ func (m *defaultAgentCommissionModel) Update(ctx context.Context, session sqlx.S
return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, agentCommissionRowsWithPlaceHolder) query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, agentCommissionRowsWithPlaceHolder)
if session != nil { if session != nil {
return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id) return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id)
} }
return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id) return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id)
}, tydataAgentCommissionIdKey) }, tydataAgentCommissionIdKey)
} }
@@ -127,9 +128,9 @@ func (m *defaultAgentCommissionModel) UpdateWithVersion(ctx context.Context, ses
sqlResult, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { sqlResult, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, agentCommissionRowsWithPlaceHolder) query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, agentCommissionRowsWithPlaceHolder)
if session != nil { if session != nil {
return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id, oldVersion) return session.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id, oldVersion)
} }
return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id, oldVersion) return conn.ExecCtx(ctx, query, data.AgentId, data.OrderId, data.Amount, data.RefundedAmount, data.ProductId, data.Status, data.DeleteTime, data.DelState, data.Version, data.Id, oldVersion)
}, tydataAgentCommissionIdKey) }, tydataAgentCommissionIdKey)
if err != nil { if err != nil {
return err return err

4
deploy/script/gen_models.ps1
View File

@@ -11,8 +11,8 @@ $tables = @(
# "agent_active_stat", # "agent_active_stat",
# "agent_audit", # "agent_audit",
# "agent_closure", # "agent_closure",
# "agent_commission" "agent_commission"
"agent_wallet_transaction" # "agent_wallet_transaction"
# "agent_commission_deduction" # "agent_commission_deduction"
# "agent_link", # "agent_link",
# "agent_membership_config", # "agent_membership_config",