f

app/main/api/desc/front/agent.api

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

app/main/api/internal/logic/admin_order/adminrefundorderlogic.go

@@ -92,8 +92,10 @@ func (l *AdminRefundOrderLogic) handleAlipayRefund(order *model.Order, req *type
 			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{
 			Status:   model.OrderStatusRefunded,
@@ -125,9 +127,6 @@ func (l *AdminRefundOrderLogic) handleWechatRefund(order *model.Order, req *type
 		return nil, err
 	}
 
-	// 退款成功后，更新代理佣金状态并扣除钱包金额
-	paylogic.HandleCommissionAndWalletDeduction(l.ctx, l.svcCtx, nil, order)
-
 	return &types.AdminRefundOrderResp{
 		Status:   model.OrderRefundStatusPending,
 		RefundNo: refundNo,

app/main/api/internal/logic/agent/getagentcommissionlogic.go

@@ -58,8 +58,15 @@ func (l *GetAgentCommissionLogic) GetAgentCommission(req *types.GetCommissionReq
 			if copyErr != nil {
 				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取代理佣金列表, %v", err)
 			}
-			// 显式设置 status 字段
+			// 显式设置 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)
 			if findProductErr != nil {
 				return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "获取代理佣金列表, %v", err)

app/main/api/internal/logic/agent/getagentrevenueinfologic.go

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

app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go

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

app/main/api/internal/queue/paySuccessNotify.go

@@ -247,33 +247,23 @@ func (l *PaySuccessNotifyUserHandler) handleError(ctx context.Context, err error
 
 		// 退款
 		if order.PaymentPlatform == "wechat" {
+			// 微信退款为异步结果，这里只发起退款申请，订单状态与佣金/钱包扣减交由退款回调统一处理
 			refundErr := l.svcCtx.WechatPayService.WeChatRefund(ctx, order.OrderNo, order.Amount, order.Amount)
 			if refundErr != nil {
 				logx.Error(refundErr)
 				return asynq.SkipRetry
 			}
-			// 微信退款成功，更新订单、佣金、钱包状态
-			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)
-
+			logx.Infof("已发起微信退款申请, orderID: %d, amount: %f", order.Id, order.Amount)
 			return asynq.SkipRetry
 		} else {
+			// 支付宝退款为同步结果，这里直接根据返回结果更新订单和佣金/钱包
 			refund, refundErr := l.svcCtx.AlipayService.AliRefund(ctx, order.OrderNo, order.Amount)
 			if refundErr != nil {
 				logx.Error(refundErr)
 				return asynq.SkipRetry
 			}
 			if refund.IsSuccess() {
-				logx.Errorf("支付宝退款成功, orderID: %d", order.Id)
+				logx.Infof("支付宝退款成功, orderID: %d", order.Id)
 				// 更新订单状态为退款
 				order.Status = "refunded"
 				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)
 				}
 
-				// 使用公共函数处理佣金和钱包扣除
-				paylogic.HandleCommissionAndWalletDeduction(ctx, l.svcCtx, nil, order)
+				// 使用公共函数按本次退款金额处理佣金和钱包扣除
+				_ = paylogic.HandleCommissionAndWalletDeduction(ctx, l.svcCtx, nil, order, order.Amount)
 
 				return asynq.SkipRetry
 			} else {
@@ -297,7 +287,6 @@ func (l *PaySuccessNotifyUserHandler) handleError(ctx context.Context, err error
 
 	return asynq.SkipRetry
 }
-
 // desensitizeParams 对敏感数据进行脱敏处理
 func (l *PaySuccessNotifyUserHandler) desensitizeParams(data []byte) ([]byte, error) {
 	// 解析JSON数据到map

app/main/api/internal/queue/unfreezeCommission.go

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

app/main/api/internal/types/types.go

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

app/main/model/agentCommissionModel_gen.go

@@ -54,17 +54,18 @@ type (
 	}
 
 	AgentCommission struct {
-		Id         int64        `db:"id"`
-		AgentId    int64        `db:"agent_id"`
-		OrderId    int64        `db:"order_id"`
-		Amount     float64      `db:"amount"`
-		ProductId  int64        `db:"product_id"` // 产品ID
-		Status     int64        `db:"status"`     // 状态：0-已结算，1-冻结中，2-已退款
-		CreateTime time.Time    `db:"create_time"`
-		UpdateTime time.Time    `db:"update_time"` // 更新时间
-		DeleteTime sql.NullTime `db:"delete_time"` // 删除时间
-		DelState   int64        `db:"del_state"`   // 删除状态
-		Version    int64        `db:"version"`     // 版本号
+		Id             int64        `db:"id"`
+		AgentId        int64        `db:"agent_id"`
+		OrderId        int64        `db:"order_id"`
+		Amount         float64      `db:"amount"`
+		RefundedAmount float64      `db:"refunded_amount"` // 已退款佣金金额
+		ProductId      int64        `db:"product_id"`      // 产品ID
+		Status         int64        `db:"status"`
+		CreateTime     time.Time    `db:"create_time"`
+		UpdateTime     time.Time    `db:"update_time"` // 更新时间
+		DeleteTime     sql.NullTime `db:"delete_time"` // 删除时间
+		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
 	tydataAgentCommissionIdKey := fmt.Sprintf("%s%v", cacheTydataAgentCommissionIdPrefix, data.Id)
 	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 {
-			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)
 }
 
@@ -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) {
 		query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, agentCommissionRowsWithPlaceHolder)
 		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)
 }
 
@@ -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) {
 		query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, agentCommissionRowsWithPlaceHolder)
 		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)
 	if err != nil {
 		return err