496 lines
12 KiB
Go
496 lines
12 KiB
Go
package withdrawal
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"hfb_sys/backend/internal/model"
|
|
"hfb_sys/backend/internal/modules/wallet"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type Repository struct {
|
|
db *gorm.DB
|
|
walletRepo *wallet.Repository
|
|
}
|
|
|
|
func NewRepository(db *gorm.DB, walletRepo *wallet.Repository) *Repository {
|
|
return &Repository{
|
|
db: db,
|
|
walletRepo: walletRepo,
|
|
}
|
|
}
|
|
|
|
// 用户创建提现申请
|
|
func (r *Repository) Create(userID uint64, req CreateWithdrawalRequest) (*WithdrawalDTO, error) {
|
|
// 验证收款账号
|
|
var paymentAccount model.UserPaymentAccount
|
|
if err := r.db.Where("id = ? AND user_id = ? AND status = ?", req.PaymentAccountID, userID, "active").
|
|
First(&paymentAccount).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, errors.New("payment account not found")
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// 计算手续费和实际到账金额
|
|
fee := req.Amount * WithdrawalFeeRate
|
|
actualAmount := req.Amount - fee
|
|
|
|
// 生成提现单号
|
|
withdrawNo, err := generateWithdrawNo()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 解密账号（用于存储快照）
|
|
decryptedNo, err := r.decryptAccountNo(paymentAccount.AccountNo)
|
|
if err != nil {
|
|
decryptedNo = paymentAccount.AccountNo
|
|
}
|
|
|
|
withdrawal := model.WithdrawalRequest{
|
|
WithdrawNo: withdrawNo,
|
|
UserID: userID,
|
|
Amount: req.Amount,
|
|
Fee: fee,
|
|
ActualAmount: actualAmount,
|
|
PaymentAccountID: &req.PaymentAccountID,
|
|
AccountType: paymentAccount.AccountType,
|
|
AccountName: paymentAccount.AccountName,
|
|
AccountNo: maskAccountNo(decryptedNo, paymentAccount.AccountType),
|
|
BankName: paymentAccount.BankName,
|
|
BankBranch: paymentAccount.BankBranch,
|
|
Status: "pending",
|
|
}
|
|
|
|
// 事务处理
|
|
err = r.db.Transaction(func(tx *gorm.DB) error {
|
|
// 创建提现申请
|
|
if err := tx.Create(&withdrawal).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 冻结用户余额
|
|
if err := wallet.AppendEntries(tx, wallet.Entry{
|
|
UserID: userID,
|
|
Direction: "out",
|
|
Amount: req.Amount,
|
|
BalanceType: "available",
|
|
BizType: "withdraw_freeze",
|
|
BizNo: withdrawNo,
|
|
Remark: "提现冻结",
|
|
}, wallet.Entry{
|
|
UserID: userID,
|
|
Direction: "in",
|
|
Amount: req.Amount,
|
|
BalanceType: "frozen",
|
|
BizType: "withdraw_freeze",
|
|
BizNo: withdrawNo,
|
|
Remark: "提现冻结",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return r.FindByID(userID, withdrawal.ID)
|
|
}
|
|
|
|
// 用户查询提现列表
|
|
func (r *Repository) List(userID uint64, page, pageSize int) (*PaginatedResult, error) {
|
|
var total int64
|
|
if err := r.db.Model(&model.WithdrawalRequest{}).
|
|
Where("user_id = ?", userID).
|
|
Count(&total).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset := (page - 1) * pageSize
|
|
var withdrawals []model.WithdrawalRequest
|
|
if err := r.db.Where("user_id = ?", userID).
|
|
Order("created_at DESC").
|
|
Offset(offset).Limit(pageSize).
|
|
Find(&withdrawals).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
items := make([]WithdrawalDTO, 0, len(withdrawals))
|
|
for _, w := range withdrawals {
|
|
items = append(items, toDTO(w))
|
|
}
|
|
|
|
return &PaginatedResult{
|
|
Items: items,
|
|
Total: total,
|
|
Page: page,
|
|
PageSize: pageSize,
|
|
}, nil
|
|
}
|
|
|
|
// 用户查询提现详情
|
|
func (r *Repository) FindByID(userID, id uint64) (*WithdrawalDTO, error) {
|
|
var withdrawal model.WithdrawalRequest
|
|
if err := r.db.Where("id = ? AND user_id = ?", id, userID).
|
|
First(&withdrawal).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrWithdrawalNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
dto := toDTO(withdrawal)
|
|
return &dto, nil
|
|
}
|
|
|
|
// 用户取消提现
|
|
func (r *Repository) Cancel(userID, id uint64) error {
|
|
var withdrawal model.WithdrawalRequest
|
|
if err := r.db.Where("id = ? AND user_id = ?", id, userID).
|
|
First(&withdrawal).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return ErrWithdrawalNotFound
|
|
}
|
|
return err
|
|
}
|
|
|
|
// 只有待审核状态可以取消
|
|
if withdrawal.Status != "pending" {
|
|
return ErrWithdrawalLocked
|
|
}
|
|
|
|
return r.db.Transaction(func(tx *gorm.DB) error {
|
|
// 更新状态
|
|
if err := tx.Model(&withdrawal).Update("status", "cancelled").Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 解冻余额
|
|
if err := wallet.AppendEntries(tx, wallet.Entry{
|
|
UserID: userID,
|
|
Direction: "out",
|
|
Amount: withdrawal.Amount,
|
|
BalanceType: "frozen",
|
|
BizType: "withdraw_cancel",
|
|
BizNo: withdrawal.WithdrawNo,
|
|
Remark: "用户取消提现",
|
|
}, wallet.Entry{
|
|
UserID: userID,
|
|
Direction: "in",
|
|
Amount: withdrawal.Amount,
|
|
BalanceType: "available",
|
|
BizType: "withdraw_cancel",
|
|
BizNo: withdrawal.WithdrawNo,
|
|
Remark: "用户取消提现",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// 管理员查询提现列表
|
|
func (r *Repository) AdminList(query AdminListQuery) (*AdminPaginatedResult, error) {
|
|
db := r.db.Model(&model.WithdrawalRequest{})
|
|
|
|
if query.Status != "" {
|
|
db = db.Where("status = ?", query.Status)
|
|
}
|
|
if query.UserID > 0 {
|
|
db = db.Where("user_id = ?", query.UserID)
|
|
}
|
|
|
|
var total int64
|
|
if err := db.Count(&total).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset := (query.Page - 1) * query.Size
|
|
var withdrawals []model.WithdrawalRequest
|
|
if err := db.Order("created_at DESC").
|
|
Offset(offset).Limit(query.Size).
|
|
Find(&withdrawals).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
items := make([]WithdrawalDetailDTO, 0, len(withdrawals))
|
|
for _, w := range withdrawals {
|
|
dto, err := r.toDetailDTO(w)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
items = append(items, *dto)
|
|
}
|
|
|
|
return &AdminPaginatedResult{
|
|
Items: items,
|
|
Total: total,
|
|
Page: query.Page,
|
|
PageSize: query.Size,
|
|
}, nil
|
|
}
|
|
|
|
// 管理员查询提现详情
|
|
func (r *Repository) AdminFindByID(id uint64) (*WithdrawalDetailDTO, error) {
|
|
var withdrawal model.WithdrawalRequest
|
|
if err := r.db.First(&withdrawal, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrWithdrawalNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return r.toDetailDTO(withdrawal)
|
|
}
|
|
|
|
// 管理员审核提现
|
|
func (r *Repository) Review(adminID, id uint64, req ReviewWithdrawalRequest) (*WithdrawalDetailDTO, error) {
|
|
var withdrawal model.WithdrawalRequest
|
|
if err := r.db.First(&withdrawal, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrWithdrawalNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// 只有待审核状态可以审核
|
|
if withdrawal.Status != "pending" {
|
|
return nil, ErrWithdrawalLocked
|
|
}
|
|
|
|
now := time.Now()
|
|
|
|
if req.Approved {
|
|
// 审核通过，进入处理中状态
|
|
withdrawal.Status = "processing"
|
|
} else {
|
|
// 审核拒绝，解冻余额
|
|
withdrawal.Status = "rejected"
|
|
}
|
|
|
|
withdrawal.ReviewedBy = &adminID
|
|
withdrawal.ReviewedAt = &now
|
|
withdrawal.ReviewRemark = req.Remark
|
|
|
|
err := r.db.Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Save(&withdrawal).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 如果拒绝，解冻余额
|
|
if !req.Approved {
|
|
if err := wallet.AppendEntries(tx, wallet.Entry{
|
|
UserID: withdrawal.UserID,
|
|
Direction: "out",
|
|
Amount: withdrawal.Amount,
|
|
BalanceType: "frozen",
|
|
BizType: "withdraw_reject",
|
|
BizNo: withdrawal.WithdrawNo,
|
|
Remark: fmt.Sprintf("提现被拒绝: %s", req.Remark),
|
|
}, wallet.Entry{
|
|
UserID: withdrawal.UserID,
|
|
Direction: "in",
|
|
Amount: withdrawal.Amount,
|
|
BalanceType: "available",
|
|
BizType: "withdraw_reject",
|
|
BizNo: withdrawal.WithdrawNo,
|
|
Remark: fmt.Sprintf("提现被拒绝: %s", req.Remark),
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return r.AdminFindByID(id)
|
|
}
|
|
|
|
// 管理员确认打款
|
|
func (r *Repository) ConfirmPayment(adminID, id uint64, req ConfirmPaymentRequest) (*WithdrawalDetailDTO, error) {
|
|
var withdrawal model.WithdrawalRequest
|
|
if err := r.db.First(&withdrawal, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrWithdrawalNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// 只有处理中状态可以确认打款
|
|
if withdrawal.Status != "processing" {
|
|
return nil, ErrWithdrawalLocked
|
|
}
|
|
|
|
now := time.Now()
|
|
withdrawal.Status = "completed"
|
|
withdrawal.PaidBy = &adminID
|
|
withdrawal.PaidAt = &now
|
|
withdrawal.PaymentProofURL = req.PaymentProofURL
|
|
withdrawal.PaymentRemark = req.Remark
|
|
|
|
err := r.db.Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Save(&withdrawal).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 扣除冻结余额
|
|
if err := wallet.AppendEntries(tx, wallet.Entry{
|
|
UserID: withdrawal.UserID,
|
|
Direction: "out",
|
|
Amount: withdrawal.Amount,
|
|
BalanceType: "frozen",
|
|
BizType: "withdraw_complete",
|
|
BizNo: withdrawal.WithdrawNo,
|
|
Remark: "提现完成",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return r.AdminFindByID(id)
|
|
}
|
|
|
|
// 转换为用户DTO
|
|
func toDTO(w model.WithdrawalRequest) WithdrawalDTO {
|
|
return WithdrawalDTO{
|
|
ID: w.ID,
|
|
WithdrawNo: w.WithdrawNo,
|
|
UserID: w.UserID,
|
|
Amount: w.Amount,
|
|
Fee: w.Fee,
|
|
ActualAmount: w.ActualAmount,
|
|
AccountType: w.AccountType,
|
|
AccountName: w.AccountName,
|
|
AccountNo: w.AccountNo,
|
|
BankName: w.BankName,
|
|
Status: w.Status,
|
|
ReviewRemark: w.ReviewRemark,
|
|
CreatedAt: w.CreatedAt,
|
|
UpdatedAt: w.UpdatedAt,
|
|
ReviewedAt: w.ReviewedAt,
|
|
PaidAt: w.PaidAt,
|
|
}
|
|
}
|
|
|
|
// 转换为管理员详细DTO
|
|
func (r *Repository) toDetailDTO(w model.WithdrawalRequest) (*WithdrawalDetailDTO, error) {
|
|
// 查询用户信息
|
|
var user model.User
|
|
r.db.Select("nickname, phone").First(&user, w.UserID)
|
|
|
|
// 查询审核人信息
|
|
var reviewedByName string
|
|
if w.ReviewedBy != nil {
|
|
var admin model.AdminUser
|
|
if err := r.db.Select("nickname").First(&admin, *w.ReviewedBy).Error; err == nil {
|
|
reviewedByName = admin.Nickname
|
|
}
|
|
}
|
|
|
|
// 查询打款人信息
|
|
var paidByName string
|
|
if w.PaidBy != nil {
|
|
var admin model.AdminUser
|
|
if err := r.db.Select("nickname").First(&admin, *w.PaidBy).Error; err == nil {
|
|
paidByName = admin.Nickname
|
|
}
|
|
}
|
|
|
|
// 获取完整账号（管理员可见）
|
|
fullAccountNo := w.AccountNo
|
|
if w.PaymentAccountID != nil {
|
|
var paymentAccount model.UserPaymentAccount
|
|
if err := r.db.First(&paymentAccount, *w.PaymentAccountID).Error; err == nil {
|
|
decrypted, err := r.decryptAccountNo(paymentAccount.AccountNo)
|
|
if err == nil {
|
|
fullAccountNo = decrypted
|
|
}
|
|
}
|
|
}
|
|
|
|
return &WithdrawalDetailDTO{
|
|
ID: w.ID,
|
|
WithdrawNo: w.WithdrawNo,
|
|
UserID: w.UserID,
|
|
UserNickname: user.Nickname,
|
|
UserPhone: user.Phone,
|
|
Amount: w.Amount,
|
|
Fee: w.Fee,
|
|
ActualAmount: w.ActualAmount,
|
|
PaymentAccountID: w.PaymentAccountID,
|
|
AccountType: w.AccountType,
|
|
AccountName: w.AccountName,
|
|
AccountNo: fullAccountNo,
|
|
BankName: w.BankName,
|
|
BankBranch: w.BankBranch,
|
|
Status: w.Status,
|
|
ReviewedBy: w.ReviewedBy,
|
|
ReviewedByName: reviewedByName,
|
|
ReviewedAt: w.ReviewedAt,
|
|
ReviewRemark: w.ReviewRemark,
|
|
PaidBy: w.PaidBy,
|
|
PaidByName: paidByName,
|
|
PaidAt: w.PaidAt,
|
|
PaymentProofURL: w.PaymentProofURL,
|
|
PaymentRemark: w.PaymentRemark,
|
|
CreatedAt: w.CreatedAt,
|
|
UpdatedAt: w.UpdatedAt,
|
|
}, nil
|
|
}
|
|
|
|
// 生成提现单号
|
|
func generateWithdrawNo() (string, error) {
|
|
buf := make([]byte, 8)
|
|
if _, err := rand.Read(buf); err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("WD%d%s", time.Now().Unix(), hex.EncodeToString(buf)[:8]), nil
|
|
}
|
|
|
|
// 账号脱敏
|
|
func maskAccountNo(accountNo, accountType string) string {
|
|
length := len(accountNo)
|
|
if length <= 4 {
|
|
return accountNo
|
|
}
|
|
|
|
switch accountType {
|
|
case "alipay", "wechat":
|
|
if length == 11 {
|
|
return accountNo[:3] + "****" + accountNo[7:]
|
|
}
|
|
return accountNo[:2] + "****" + accountNo[length-2:]
|
|
case "bank":
|
|
if length > 8 {
|
|
return accountNo[:4] + "****" + accountNo[length-4:]
|
|
}
|
|
return accountNo[:2] + "****" + accountNo[length-2:]
|
|
}
|
|
return accountNo
|
|
}
|
|
|
|
// 简化的解密函数（实际应该调用 paymentaccount 模块的解密）
|
|
func (r *Repository) decryptAccountNo(encrypted string) (string, error) {
|
|
// 这里应该调用 paymentaccount 包的解密函数
|
|
// 为了简化，直接返回（实际使用时需要正确实现）
|
|
return encrypted, nil
|
|
}
|