302 lines
8.5 KiB
Go
302 lines
8.5 KiB
Go
package wallet
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"fmt"
|
|
"math"
|
|
"time"
|
|
|
|
"hfb_sys/backend/internal/model"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
type Repository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
type Entry struct {
|
|
UserID uint64
|
|
OrderID *uint64
|
|
Direction string
|
|
Amount float64
|
|
BalanceType string
|
|
BizType string
|
|
BizNo string
|
|
Remark string
|
|
}
|
|
|
|
func NewRepository(db *gorm.DB) *Repository {
|
|
return &Repository{db: db}
|
|
}
|
|
|
|
func (r *Repository) Account(userID uint64) (*AccountDTO, error) {
|
|
var account model.WalletAccount
|
|
err := r.db.Transaction(func(tx *gorm.DB) error {
|
|
if err := ensureAccount(tx, userID); err != nil {
|
|
return err
|
|
}
|
|
return tx.Where("user_id = ?", userID).First(&account).Error
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return toAccountDTO(account), nil
|
|
}
|
|
|
|
func (r *Repository) Ledger(userID uint64, page, pageSize int) (*PaginatedResult, error) {
|
|
var total int64
|
|
if err := r.db.Model(&model.WalletLedger{}).Where("user_id = ?", userID).Count(&total).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
offset := (page - 1) * pageSize
|
|
var rows []model.WalletLedger
|
|
if err := r.db.Where("user_id = ?", userID).Order("id DESC").Offset(offset).Limit(pageSize).Find(&rows).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]LedgerDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
items = append(items, toLedgerDTO(row))
|
|
}
|
|
return &PaginatedResult{Items: items, Total: total, Page: page, PageSize: pageSize}, nil
|
|
}
|
|
|
|
func (r *Repository) Recharge(userID uint64, amount float64) (*AccountDTO, error) {
|
|
err := r.db.Transaction(func(tx *gorm.DB) error {
|
|
return AppendEntries(tx, Entry{
|
|
UserID: userID,
|
|
Direction: "in",
|
|
Amount: amount,
|
|
BalanceType: "available",
|
|
BizType: "dev_recharge",
|
|
BizNo: "DEV",
|
|
Remark: "开发环境充值",
|
|
})
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Account(userID)
|
|
}
|
|
|
|
func (r *Repository) ConfirmRechargeFromChannel(userID uint64, bizNo string, amountCent int64) error {
|
|
if userID == 0 || amountCent <= 0 || bizNo == "" {
|
|
return ErrInvalidAmount
|
|
}
|
|
amount := roundWalletMoney(float64(amountCent) / 100)
|
|
return r.db.Transaction(func(tx *gorm.DB) error {
|
|
if err := ensureAccount(tx, userID); err != nil {
|
|
return err
|
|
}
|
|
var account model.WalletAccount
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("user_id = ?", userID).
|
|
First(&account).Error; err != nil {
|
|
return err
|
|
}
|
|
var existing int64
|
|
if err := tx.Model(&model.WalletLedger{}).
|
|
Where("user_id = ? AND biz_type = ? AND biz_no = ?", userID, "channel_recharge", bizNo).
|
|
Count(&existing).Error; err != nil {
|
|
return err
|
|
}
|
|
if existing > 0 {
|
|
return nil
|
|
}
|
|
return AppendEntries(tx, Entry{
|
|
UserID: userID,
|
|
Direction: "in",
|
|
Amount: amount,
|
|
BalanceType: "available",
|
|
BizType: "channel_recharge",
|
|
BizNo: bizNo,
|
|
Remark: "渠道充值入账",
|
|
})
|
|
})
|
|
}
|
|
|
|
// Withdraw 保留仓库能力；当前公开提现入口在 service 层标记为待开发，不会调用到这里。
|
|
func (r *Repository) Withdraw(userID uint64, amount float64) (*AccountDTO, error) {
|
|
amount = roundWalletMoney(amount)
|
|
if userID == 0 || amount <= 0 {
|
|
return nil, ErrInvalidAmount
|
|
}
|
|
err := r.db.Transaction(func(tx *gorm.DB) error {
|
|
return AppendEntries(tx, Entry{
|
|
UserID: userID,
|
|
Direction: "out",
|
|
Amount: amount,
|
|
BalanceType: "available",
|
|
BizType: "withdraw_apply",
|
|
BizNo: fmt.Sprintf("WD%d", time.Now().UnixNano()),
|
|
Remark: "卖家申请提现",
|
|
})
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return r.Account(userID)
|
|
}
|
|
|
|
func (r *Repository) AdminLedger(query AdminLedgerQuery) (*PaginatedResult, error) {
|
|
db := r.db.Table("wallet_ledger AS wl").
|
|
Select(`wl.id, wl.ledger_no, wl.user_id, COALESCE(u.phone, '') AS user_phone,
|
|
COALESCE(u.nickname, '') AS user_nickname, wl.order_id, COALESCE(ro.order_no, '') AS order_no,
|
|
wl.direction, wl.amount, wl.balance_after, wl.balance_type, wl.biz_type, wl.biz_no,
|
|
wl.remark, wl.created_at`).
|
|
Joins("LEFT JOIN users AS u ON u.id = wl.user_id").
|
|
Joins("LEFT JOIN rental_orders AS ro ON ro.id = wl.order_id")
|
|
|
|
countDB := r.db.Model(&model.WalletLedger{})
|
|
if query.UserID > 0 {
|
|
db = db.Where("wl.user_id = ?", query.UserID)
|
|
countDB = countDB.Where("user_id = ?", query.UserID)
|
|
}
|
|
if query.OrderID > 0 {
|
|
db = db.Where("wl.order_id = ?", query.OrderID)
|
|
countDB = countDB.Where("order_id = ?", query.OrderID)
|
|
}
|
|
if query.BizType != "" {
|
|
db = db.Where("wl.biz_type = ?", query.BizType)
|
|
countDB = countDB.Where("biz_type = ?", query.BizType)
|
|
}
|
|
|
|
var total int64
|
|
if err := countDB.Count(&total).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
offset := (query.Page - 1) * query.PageSize
|
|
var items []AdminLedgerDTO
|
|
if err := db.Order("wl.id DESC").Offset(offset).Limit(query.PageSize).Scan(&items).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &PaginatedResult{Items: items, Total: total, Page: query.Page, PageSize: query.PageSize}, nil
|
|
}
|
|
|
|
func AppendEntries(tx *gorm.DB, entries ...Entry) error {
|
|
for _, entry := range entries {
|
|
entry.Amount = roundWalletMoney(entry.Amount)
|
|
if entry.Amount <= 0 {
|
|
continue
|
|
}
|
|
if err := ensureAccount(tx, entry.UserID); err != nil {
|
|
return err
|
|
}
|
|
var account model.WalletAccount
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("user_id = ?", entry.UserID).First(&account).Error; err != nil {
|
|
return err
|
|
}
|
|
balanceAfter, err := applyEntry(&account, entry)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Save(&account).Error; err != nil {
|
|
return err
|
|
}
|
|
ledgerNo, err := newLedgerNo()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ledger := model.WalletLedger{
|
|
LedgerNo: ledgerNo,
|
|
UserID: entry.UserID,
|
|
OrderID: entry.OrderID,
|
|
Direction: entry.Direction,
|
|
Amount: entry.Amount,
|
|
BalanceAfter: balanceAfter,
|
|
BalanceType: entry.BalanceType,
|
|
BizType: entry.BizType,
|
|
BizNo: entry.BizNo,
|
|
Remark: entry.Remark,
|
|
}
|
|
if err := tx.Create(&ledger).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ensureAccount(tx *gorm.DB, userID uint64) error {
|
|
account := model.WalletAccount{
|
|
UserID: userID,
|
|
AvailableBalance: 0,
|
|
FrozenBalance: 0,
|
|
Status: "active",
|
|
}
|
|
return tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&account).Error
|
|
}
|
|
|
|
func applyEntry(account *model.WalletAccount, entry Entry) (float64, error) {
|
|
entry.Amount = roundWalletMoney(entry.Amount)
|
|
account.AvailableBalance = roundWalletMoney(account.AvailableBalance)
|
|
account.FrozenBalance = roundWalletMoney(account.FrozenBalance)
|
|
switch entry.BalanceType {
|
|
case "available":
|
|
if entry.Direction == "in" {
|
|
account.AvailableBalance = roundWalletMoney(account.AvailableBalance + entry.Amount)
|
|
} else {
|
|
if account.AvailableBalance < entry.Amount {
|
|
return 0, ErrInsufficientBalance
|
|
}
|
|
account.AvailableBalance = roundWalletMoney(account.AvailableBalance - entry.Amount)
|
|
}
|
|
return account.AvailableBalance, nil
|
|
case "frozen":
|
|
if entry.Direction == "in" {
|
|
account.FrozenBalance = roundWalletMoney(account.FrozenBalance + entry.Amount)
|
|
} else {
|
|
if account.FrozenBalance < entry.Amount {
|
|
return 0, ErrInsufficientBalance
|
|
}
|
|
account.FrozenBalance = roundWalletMoney(account.FrozenBalance - entry.Amount)
|
|
}
|
|
return account.FrozenBalance, nil
|
|
default:
|
|
return 0, fmt.Errorf("unsupported balance type: %s", entry.BalanceType)
|
|
}
|
|
}
|
|
|
|
func roundWalletMoney(value float64) float64 {
|
|
return math.Round(value)
|
|
}
|
|
|
|
func toAccountDTO(account model.WalletAccount) *AccountDTO {
|
|
return &AccountDTO{
|
|
UserID: account.UserID,
|
|
AvailableBalance: account.AvailableBalance,
|
|
FrozenBalance: account.FrozenBalance,
|
|
Status: account.Status,
|
|
}
|
|
}
|
|
|
|
func toLedgerDTO(row model.WalletLedger) LedgerDTO {
|
|
return LedgerDTO{
|
|
ID: row.ID,
|
|
LedgerNo: row.LedgerNo,
|
|
UserID: row.UserID,
|
|
OrderID: row.OrderID,
|
|
Direction: row.Direction,
|
|
Amount: row.Amount,
|
|
BalanceAfter: row.BalanceAfter,
|
|
BalanceType: row.BalanceType,
|
|
BizType: row.BizType,
|
|
BizNo: row.BizNo,
|
|
Remark: row.Remark,
|
|
CreatedAt: row.CreatedAt,
|
|
}
|
|
}
|
|
|
|
func newLedgerNo() (string, error) {
|
|
// 生成格式：WL + YYYYMMDDHHMMSS + 毫秒 + 4位随机数
|
|
// 例如：WL202606051234561230456，便于用户和客服识别。
|
|
now := time.Now()
|
|
buf := make([]byte, 2)
|
|
if _, err := rand.Read(buf); err != nil {
|
|
return "", err
|
|
}
|
|
randomNum := (int(buf[0])<<8 | int(buf[1])) % 10000
|
|
return fmt.Sprintf("WL%s%03d%04d", now.Format("20060102150405"), now.Nanosecond()/1_000_000, randomNum), nil
|
|
}
|