379 lines
14 KiB
Go
379 lines
14 KiB
Go
package wallet
|
|
|
|
import (
|
|
"errors"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.apinb.com/bsm-sdk/core/errcode"
|
|
"git.apinb.com/bsm-sdk/core/infra"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/config"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/impl"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/common"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
var walletOwnerModels = map[string]any{
|
|
"user": &models.UserAccount{},
|
|
"staff": &models.StaffAccount{},
|
|
"delivery": &models.DeliveryBasic{},
|
|
"gas": &models.GasBasic{},
|
|
}
|
|
|
|
func ListWalletBasic(ctx *gin.Context) {
|
|
ownerType := strings.TrimSpace(ctx.Query("owner_type"))
|
|
if ownerType != "" && ownerType != "user" && ownerType != "staff" && ownerType != "delivery" && ownerType != "gas" && ownerType != "platform" {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
ownerIdentities := strings.Split(strings.TrimSpace(ctx.Query("owner_identities")), ",")
|
|
if len(ownerIdentities) == 1 && ownerIdentities[0] == "" {
|
|
ownerIdentities = nil
|
|
}
|
|
if len(ownerIdentities) > 100 {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
listWalletPage[models.WalletBasic](ctx, ownerType, ownerIdentities)
|
|
}
|
|
func GetWalletBasic(ctx *gin.Context) { getWalletByIdentity[models.WalletBasic](ctx) }
|
|
func ListWalletBank(ctx *gin.Context) { listWalletPage[models.WalletBank](ctx, "", nil) }
|
|
func GetWalletBank(ctx *gin.Context) { getWalletByIdentity[models.WalletBank](ctx) }
|
|
func ListWalletPayment(ctx *gin.Context) { listWalletPage[models.WalletPayment](ctx, "", nil) }
|
|
func GetWalletPayment(ctx *gin.Context) { getWalletByIdentity[models.WalletPayment](ctx) }
|
|
func ListWalletRecord(ctx *gin.Context) { listWalletPage[models.WalletRecord](ctx, "", nil) }
|
|
func GetWalletRecord(ctx *gin.Context) { getWalletByIdentity[models.WalletRecord](ctx) }
|
|
func ListWalletRefund(ctx *gin.Context) { listWalletPage[models.WalletRefund](ctx, "", nil) }
|
|
func GetWalletRefund(ctx *gin.Context) { getWalletByIdentity[models.WalletRefund](ctx) }
|
|
func ListWalletApplyCash(ctx *gin.Context) { listWalletPage[models.WalletApplyCash](ctx, "", nil) }
|
|
func GetWalletApplyCash(ctx *gin.Context) { getWalletByIdentity[models.WalletApplyCash](ctx) }
|
|
|
|
func listWalletPage[T any](ctx *gin.Context, ownerType string, ownerIdentities []string) {
|
|
page, size := common.PageSize(ctx)
|
|
var list []T
|
|
var total int64
|
|
model := new(T)
|
|
query := common.ApplyKeywordFilter(ctx, common.ActiveRecords(impl.DBService.Model(model)), model)
|
|
if ownerType != "" {
|
|
query = query.Where("owner_type = ?", ownerType)
|
|
}
|
|
if len(ownerIdentities) > 0 {
|
|
query = query.Where("owner_identity IN ?", ownerIdentities)
|
|
}
|
|
if err := query.Count(&total).Error; err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
if err := query.Order("created_at desc").Offset((page - 1) * size).Limit(size).Find(&list).Error; err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
response, err := common.PublicResourceResponse(list)
|
|
if err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
protectWalletResponse(response, false)
|
|
infra.Response.Success(ctx, gin.H{"total": total, "list": common.ProtectPreciseLocation(ctx, model, response)})
|
|
}
|
|
|
|
func getWalletByIdentity[T any](ctx *gin.Context) {
|
|
var data T
|
|
if err := common.ActiveRecords(impl.DBService).Where("identity = ?", ctx.Param("identity")).First(&data).Error; err != nil {
|
|
common.RespondRecordError(ctx, err)
|
|
return
|
|
}
|
|
response, err := common.PublicResourceResponse(data)
|
|
if err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
protectWalletResponse(response, true)
|
|
infra.Response.Success(ctx, common.ProtectPreciseLocation(ctx, new(T), response))
|
|
}
|
|
|
|
func protectWalletResponse(value any, includeDetails bool) {
|
|
switch data := value.(type) {
|
|
case map[string]any:
|
|
for _, key := range []string{"alipay_id", "alipay_name", "wxpay_id", "wxpay_name"} {
|
|
if text, ok := data[key].(string); ok && text != "" {
|
|
data[key] = maskWalletAccount(text)
|
|
}
|
|
}
|
|
if last4, ok := data["card_no_last4"].(string); ok && last4 != "" {
|
|
data["card_no_masked"] = "****" + last4
|
|
delete(data, "card_no_last4")
|
|
}
|
|
if owner, ok := data["card_owner"].(string); ok && owner != "" {
|
|
data["card_owner"] = common.MaskPersonalNameValue(owner)
|
|
}
|
|
if !includeDetails {
|
|
delete(data, "args")
|
|
delete(data, "callback_msg")
|
|
delete(data, "order_info")
|
|
delete(data, "result")
|
|
}
|
|
for _, item := range data {
|
|
protectWalletResponse(item, includeDetails)
|
|
}
|
|
case []any:
|
|
for _, item := range data {
|
|
protectWalletResponse(item, includeDetails)
|
|
}
|
|
}
|
|
}
|
|
|
|
func maskWalletAccount(value string) string {
|
|
runes := []rune(value)
|
|
if len(runes) <= 2 {
|
|
return strings.Repeat("*", len(runes))
|
|
}
|
|
return string(runes[0]) + strings.Repeat("*", len(runes)-2) + string(runes[len(runes)-1])
|
|
}
|
|
|
|
func GetOrCreateOwnerWallet(ctx *gin.Context) {
|
|
ownerType := strings.ToLower(strings.TrimSpace(ctx.Param("owner_type")))
|
|
ownerIdentity := strings.TrimSpace(ctx.Param("owner_identity"))
|
|
ownerID, err := resolveWalletOwner(ownerType, ownerIdentity)
|
|
if err != nil {
|
|
common.RespondRecordError(ctx, err)
|
|
return
|
|
}
|
|
var wallet models.WalletBasic
|
|
err = impl.DBService.Transaction(func(tx *gorm.DB) error {
|
|
err := tx.Where("owner_type = ? AND owner_identity = ?", ownerType, ownerIdentity).First(&wallet).Error
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
candidate := models.WalletBasic{
|
|
Entity: models.Entity{Identity: models.NewIdentity(), Status: common.StatusEnable},
|
|
OwnerType: ownerType, OwnerID: ownerID, OwnerIdentity: ownerIdentity,
|
|
}
|
|
if err := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&candidate).Error; err != nil {
|
|
return err
|
|
}
|
|
return tx.Where("owner_type = ? AND owner_identity = ?", ownerType, ownerIdentity).First(&wallet).Error
|
|
})
|
|
if err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
response, err := common.PublicResourceResponse(wallet)
|
|
if err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
infra.Response.Success(ctx, common.ProtectPreciseLocation(ctx, &models.WalletBasic{}, response))
|
|
}
|
|
|
|
func resolveWalletOwner(ownerType, ownerIdentity string) (uint64, error) {
|
|
if ownerType == "platform" {
|
|
if ownerIdentity != "heqi" {
|
|
return 0, errors.New("invalid platform owner")
|
|
}
|
|
return 0, nil
|
|
}
|
|
model := walletOwnerModels[ownerType]
|
|
if model == nil || ownerIdentity == "" {
|
|
return 0, errors.New("invalid wallet owner")
|
|
}
|
|
return common.ResolveIdentityID(model, ownerIdentity, true)
|
|
}
|
|
|
|
func UpdateWalletBasicStatus(ctx *gin.Context) {
|
|
var request struct {
|
|
Status int `json:"status" binding:"required"`
|
|
}
|
|
if err := ctx.ShouldBindJSON(&request); err != nil ||
|
|
(request.Status != common.StatusEnable && request.Status != common.StatusDisable && request.Status != common.StatusFrozen) {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
common.UpdateAllowedByIdentity(ctx, &models.WalletBasic{}, gin.H{"status": request.Status}, []string{"status"})
|
|
}
|
|
|
|
func RechargeWalletBasic(ctx *gin.Context) {
|
|
if !common.RequirePlatformRoot(ctx) {
|
|
return
|
|
}
|
|
var request struct {
|
|
RequestNo string `json:"request_no" binding:"required,max=128"`
|
|
Amount int64 `json:"amount" binding:"required"`
|
|
Withdrawable bool `json:"withdrawable"`
|
|
Reason string `json:"reason" binding:"required,max=1000"`
|
|
Remark string `json:"remark" binding:"max=2000"`
|
|
}
|
|
if err := ctx.ShouldBindJSON(&request); err != nil ||
|
|
request.Amount <= 0 || request.Amount > config.Spec.Wallet.ManualRechargeMaxAmount ||
|
|
strings.TrimSpace(request.RequestNo) == "" || strings.TrimSpace(request.Reason) == "" {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
operatorIdentity, operatorName := common.PlatformOperator(ctx)
|
|
var record models.WalletRecord
|
|
err := impl.DBService.Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Where("request_no = ?", request.RequestNo).First(&record).Error; err == nil {
|
|
return nil
|
|
} else if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
var wallet models.WalletBasic
|
|
if err := tx.Where("identity = ?", ctx.Param("identity")).First(&wallet).Error; err != nil {
|
|
return err
|
|
}
|
|
updates := map[string]any{"balance": gorm.Expr("balance + ?", request.Amount)}
|
|
query := tx.Model(&models.WalletBasic{}).
|
|
Where("id = ? AND status = ? AND balance <= ?", wallet.ID, common.StatusEnable, math.MaxInt64-request.Amount)
|
|
if request.Withdrawable {
|
|
updates["withdrawal_balance"] = gorm.Expr("withdrawal_balance + ?", request.Amount)
|
|
query = query.Where("withdrawal_balance <= ?", math.MaxInt64-request.Amount)
|
|
}
|
|
result := query.Updates(updates)
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected != 1 {
|
|
return errors.New("wallet is disabled or balance overflow")
|
|
}
|
|
if err := tx.Where("id = ?", wallet.ID).First(&wallet).Error; err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
record = models.WalletRecord{
|
|
Entity: models.Entity{Identity: models.NewIdentity(), Status: common.StatusEnable},
|
|
WalletBasicID: wallet.ID, RecordNo: models.NewIdentity(), RequestNo: request.RequestNo,
|
|
Direction: "income", TradeType: "recharge", Amount: request.Amount,
|
|
BalanceAfter: wallet.Balance, WithdrawalBalanceAfter: wallet.WithdrawalBalance,
|
|
InTradeNo: request.RequestNo, PayChannel: "manual",
|
|
OperatorIdentity: operatorIdentity, OperatorName: operatorName,
|
|
Ymd: dateNumber(now, "20060102"), Ym: dateNumber(now, "200601"),
|
|
Remark: strings.TrimSpace(request.Reason + " " + request.Remark),
|
|
}
|
|
return tx.Create(&record).Error
|
|
})
|
|
if err != nil {
|
|
if lookupErr := impl.DBService.Where("request_no = ?", request.RequestNo).First(&record).Error; lookupErr == nil {
|
|
response, responseErr := common.PublicResourceResponse(record)
|
|
if responseErr != nil {
|
|
infra.Response.Error(ctx, responseErr)
|
|
return
|
|
}
|
|
infra.Response.Success(ctx, response)
|
|
return
|
|
}
|
|
common.RespondRecordError(ctx, err)
|
|
return
|
|
}
|
|
response, err := common.PublicResourceResponse(record)
|
|
if err != nil {
|
|
infra.Response.Error(ctx, err)
|
|
return
|
|
}
|
|
infra.Response.Success(ctx, response)
|
|
}
|
|
|
|
func ApproveWalletApplyCash(ctx *gin.Context) {
|
|
reviewWalletApplyCash(ctx, common.StatusApproved)
|
|
}
|
|
|
|
func RejectWalletApplyCash(ctx *gin.Context) {
|
|
reviewWalletApplyCash(ctx, common.StatusRejected)
|
|
}
|
|
|
|
func reviewWalletApplyCash(ctx *gin.Context, targetStatus int) {
|
|
var request struct {
|
|
Reason string `json:"reason" binding:"required,max=2000"`
|
|
}
|
|
if err := ctx.ShouldBindJSON(&request); err != nil || strings.TrimSpace(request.Reason) == "" {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
operatorIdentity, operatorName := common.PlatformOperator(ctx)
|
|
err := impl.DBService.Transaction(func(tx *gorm.DB) error {
|
|
var application models.WalletApplyCash
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("identity = ? AND status = ?", ctx.Param("identity"), common.StatusEnable).First(&application).Error; err != nil {
|
|
return err
|
|
}
|
|
if application.ApplyStatus == targetStatus {
|
|
return nil
|
|
}
|
|
if application.ApplyStatus != common.StatusPending {
|
|
return errors.New("cash application is not pending")
|
|
}
|
|
now := time.Now()
|
|
if targetStatus == common.StatusRejected {
|
|
result := tx.Model(&models.WalletBasic{}).
|
|
Where("id = ? AND withdrawal_balance <= ?", application.WalletBasicID, math.MaxInt64-application.Amount).
|
|
Update("withdrawal_balance", gorm.Expr("withdrawal_balance + ?", application.Amount))
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected != 1 {
|
|
return errors.New("withdrawal balance overflow")
|
|
}
|
|
}
|
|
return tx.Model(&application).Updates(map[string]any{
|
|
"apply_status": targetStatus, "reviewer_identity": operatorIdentity, "reviewer_name": operatorName,
|
|
"reviewed_at": &now, "review_reason": request.Reason,
|
|
}).Error
|
|
})
|
|
if err != nil {
|
|
common.RespondRecordError(ctx, err)
|
|
return
|
|
}
|
|
infra.Response.Success(ctx, gin.H{"updated": true, "apply_status": targetStatus})
|
|
}
|
|
|
|
// CompleteWalletApplyCash records the external payout result after approval.
|
|
func CompleteWalletApplyCash(ctx *gin.Context) {
|
|
var request struct {
|
|
TradeNo string `json:"trade_no" binding:"required,max=128"`
|
|
CallbackMsg string `json:"callback_msg" binding:"max=4000"`
|
|
}
|
|
if err := ctx.ShouldBindJSON(&request); err != nil || strings.TrimSpace(request.TradeNo) == "" {
|
|
infra.Response.Error(ctx, errcode.ErrInvalidArgument)
|
|
return
|
|
}
|
|
err := impl.DBService.Transaction(func(tx *gorm.DB) error {
|
|
var application models.WalletApplyCash
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("identity = ? AND status = ?", ctx.Param("identity"), common.StatusEnable).
|
|
First(&application).Error; err != nil {
|
|
return err
|
|
}
|
|
if application.ApplyStatus == common.StatusCompleted {
|
|
if application.TradeNo == request.TradeNo {
|
|
return nil
|
|
}
|
|
return errors.New("cash application already completed")
|
|
}
|
|
if application.ApplyStatus != common.StatusApproved {
|
|
return errors.New("cash application is not approved")
|
|
}
|
|
now := time.Now()
|
|
return tx.Model(&application).Updates(map[string]any{
|
|
"apply_status": common.StatusCompleted, "trade_no": strings.TrimSpace(request.TradeNo),
|
|
"callback_msg": request.CallbackMsg, "completed_at": &now,
|
|
}).Error
|
|
})
|
|
if err != nil {
|
|
common.RespondRecordError(ctx, err)
|
|
return
|
|
}
|
|
infra.Response.Success(ctx, gin.H{"updated": true, "apply_status": common.StatusCompleted})
|
|
}
|
|
|
|
func dateNumber(value time.Time, layout string) int32 {
|
|
number, _ := strconv.ParseInt(value.Format(layout), 10, 32)
|
|
return int32(number)
|
|
}
|