fix: move withdrawal commission deduction from application to approval

- commissionWithdrawLogic: remove upfront commission deduction;
  balance check now includes sum of all pending withdrawals to prevent
  double-spending; transaction only creates the withdrawal record (status=0)
- approveWithdrawal: add FOR UPDATE lock on user row, balance check before
  deducting, atomic commission decrement and commission log inside one
  transaction; clear user cache after commit
- rejectWithdrawal: remove commission refund and log — commission was never
  deducted on application under the new flow
- add migration 02150: refund commission for existing status=0 withdrawals
  that were deducted under the old logic; includes rollback script

Co-authored-by: multica-agent <github@multica.ai>

internal/logic/public/user/commissionWithdrawLogic.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"time"
 
-	logicCommon "github.com/perfect-panel/server/internal/logic/common"
-	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -38,48 +36,39 @@ func (l *CommissionWithdrawLogic) CommissionWithdraw(req *types.CommissionWithdr
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
 
-	if u.Commission < req.Amount {
-		logger.Errorf("User %d has insufficient commission balance: %.2f, requested: %.2f", u.Id, float64(u.Commission)/100, float64(req.Amount)/100)
+	// Sum all pending (status=0) withdrawals to compute available balance.
+	// Available = commission - pendingTotal; commission is only deducted on approval.
+	var pendingTotal int64
+	if err = l.svcCtx.DB.WithContext(l.ctx).
+		Model(&user.Withdrawal{}).
+		Where("user_id = ? AND status = 0", u.Id).
+		Select("COALESCE(SUM(amount), 0)").
+		Scan(&pendingTotal).Error; err != nil {
+		l.Errorf("Failed to query pending withdrawals for user %d: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Failed to query pending withdrawals for user %d", u.Id)
+	}
+
+	if u.Commission < req.Amount+pendingTotal {
+		logger.Errorf("User %d insufficient available commission: total=%d pending=%d requested=%d",
+			u.Id, u.Commission, pendingTotal, req.Amount)
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserCommissionNotEnough), "User %d has insufficient commission balance", u.Id)
 	}
 
-	tx := l.svcCtx.DB.WithContext(l.ctx).Begin()
 	now := time.Now()
-
-	// Atomically deduct the requested amount so concurrent commission growth is preserved.
-	if err = l.svcCtx.DB.WithContext(l.ctx).
-		Model(&user.User{}).
-		Where("id = ? AND commission >= ?", u.Id, req.Amount).
-		UpdateColumn("commission", gorm.Expr("commission - ?", req.Amount)).Error; err != nil {
-		tx.Rollback()
-		l.Errorf("Failed to update user %d commission balance: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to update user %d commission balance: %v", u.Id, err)
-	}
-	_ = l.svcCtx.UserModel.ClearUserCache(l.ctx, u)
-
-	// create withdrawal log
-	if err = logicCommon.WriteCommissionLog(tx, u.Id, log.CommissionTypeConvertBalance, req.Amount, ""); err != nil {
-		tx.Rollback()
-		l.Errorf("Failed to create commission log for user %d: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create commission log for user %d: %v", u.Id, err)
-	}
-
-	err = tx.Model(&user.Withdrawal{}).Create(&user.Withdrawal{
-		UserId:  u.Id,
-		Amount:  req.Amount,
-		Content: req.Content,
-		Status:  0,
-		Reason:  "",
-	}).Error
-
+	var w user.Withdrawal
+	err = l.svcCtx.DB.WithContext(l.ctx).Transaction(func(tx *gorm.DB) error {
+		w = user.Withdrawal{
+			UserId:  u.Id,
+			Amount:  req.Amount,
+			Content: req.Content,
+			Status:  0,
+			Reason:  "",
+		}
+		return tx.Create(&w).Error
+	})
 	if err != nil {
-		tx.Rollback()
-		l.Errorf("Failed to create withdrawal log for user %d: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create withdrawal log for user %d: %v", u.Id, err)
-	}
-	if err = tx.Commit().Error; err != nil {
-		l.Errorf("Transaction commit failed for user %d withdrawal: %v", u.Id, err)
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Transaction commit failed for user %d withdrawal: %v", u.Id, err)
+		l.Errorf("Failed to create withdrawal for user %d: %v", u.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create withdrawal for user %d: %v", u.Id, err)
 	}
 
 	return &types.WithdrawalLog{