lanhu/platform
2
0
Fork 0
Code Issues Actions Packages Releases 13 Activity

重构交易处理逻辑，合并充值与购买流程，优化交易状态管理；更新相关数据结构和接口

Browse Source
This commit is contained in:
luorijun
2025-06-26 09:28:42 +08:00
parent 065a7c77c3
commit 7d0bd84649
18 changed files with 843 additions and 919 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
web/services/bill.go Normal file
View File

@@ -0,0 +1,9 @@
package services
var Bill = &billService{}
type billService struct{}
func (s *billService) GenNo() string {
return ID.GenReadable("bil")
}

4
web/services/id.go
View File

@@ -43,7 +43,9 @@ var (
ErrSequenceOverflow = errors.New("sequence overflow")
)
func (s *IdService) GenSerial(ctx context.Context) (string, error) {
func (s *IdService) GenSerial() (string, error) {
var ctx = context.Background()
// 构造Redis键
now := time.Now().Unix()
key := idSerialKey(now)

487
web/services/resource.go
View File

@@ -1,8 +1,6 @@
package services
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"platform/pkg/u"
@@ -23,221 +21,68 @@ var Resource = &resourceService{}
type resourceService struct{}
func (s *resourceService) CreateResource(uid int32, now time.Time, ser *CreateResourceData) error {
func (s *resourceService) CreateResourceByBalance(uid int32, now time.Time, data *CreateResourceData) error {
return g.Redsync.WithLock(userBalanceKey(uid), func() error {
return q.Q.Transaction(func(q *q.Query) error {
// 检查用户
user, err := q.User.
Where(q.User.ID.Eq(uid)).
Take()
if err != nil {
return err
}
data, err := ser.ToData()
if err != nil {
return err
}
// 检查余额
var amount = user.Balance.Sub(data.GetAmount())
if amount.IsNegative() {
return ErrBalanceNotEnough
}
var name = data.GetName()
var amount = data.GetPrice()
// 保存套餐
resource, err := createResource(q, uid, now, data)
if err != nil {
return core.NewServErr("创建套餐失败", err)
}
// 保存交易信息
err = q.Q.Transaction(func(q *q.Query) error {
// 更新用户余额
_, err = q.User.
Where(q.User.ID.Eq(uid)).
UpdateSimple(q.User.Balance.Value(amount))
if err != nil {
return core.NewServErr("更新用户余额失败", err)
}
// 检查用户
user, err := q.User.
Where(q.User.ID.Eq(uid)).
Take()
if err != nil {
return err
}
// 生成账单
err = q.Bill.Create(bill2.NewForConsume(uid, Bill.GenNo(), data.GetSubject(), data.GetAmount(), resource))
if err != nil {
return core.NewServErr("生成账单失败", err)
}
// 检查余额
if user.Balance.Cmp(amount) < 0 {
return ErrBalanceNotEnough
}
return nil
})
})
}
func (s *resourceService) CreateResourceByTrade(uid int32, now time.Time, data *CreateResourceData, trade *m.Trade) error {
return q.Q.Transaction(func(q *q.Query) error {
// 保存套餐
resource, err := createResource(q, uid, now, data)
if err != nil {
return err
return core.NewServErr("创建套餐失败", err)
}
// 生成账单
bill := m.Bill{
UserID: uid,
ResourceID: &resource.ID,
BillNo: ID.GenReadable("bil"),
Info: u.P("购买套餐 - " + name),
Type: int32(bill2.TypeConsume),
Amount: amount,
}
err = q.Bill.
Omit(q.Bill.TradeID, q.Bill.RefundID).
Create(&bill)
err = q.Bill.Create(bill2.NewForConsume(uid, Bill.GenNo(), data.GetSubject(), data.GetAmount(), resource, trade))
if err != nil {
return err
}
// 更新用户余额
_, err = q.User.
Where(q.User.ID.Eq(uid)).
UpdateSimple(q.User.Balance.Value(user.Balance.Sub(amount)))
if err != nil {
return err
}
return nil
}, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
if err != nil {
return err
}
return nil
}
func (s *resourceService) PrepareResource(uid int32, now time.Time, ser *PrepareResourceData) (*TradeCreateResult, error) {
name := ser.GetName()
amount := ser.GetPrice()
method := ser.PaymentMethod
platform := ser.PaymentPlatform
// 保存到数据库
var result *TradeCreateResult
err := q.Q.Transaction(func(q *q.Query) error {
var err error
// 生成交易订单
result, err = Trade.CreateTrade(q, uid, now, &TradeCreateData{
Subject: "购买套餐 - " + name,
Amount: amount,
ExpireAt: time.Now().Add(30 * time.Minute),
Type: trade2.TypeRecharge,
Method: method,
Platform: platform,
})
if err != nil {
return err
}
// 保存请求缓存
err = g.Redis.Set(context.Background(), resPrepareKey(result.TradeNo), &PrepareResourceCache{
Uid: uid,
TradeId: result.Trade.ID,
BillId: result.Bill.ID,
PrepareResourceData: ser,
}, 30*time.Minute).Err()
if err != nil {
return err
return core.NewServErr("生成账单失败", err)
}
return nil
})
if err != nil {
return nil, err
}
return result, nil
}
func (s *resourceService) CompleteResource(tradeNo string, now time.Time, opResult ...*TradeSuccessResult) error {
// 获取请求缓存
reqStr, err := g.Redis.Get(context.Background(), resPrepareKey(tradeNo)).Result()
if err != nil {
return core.NewBizErr("交易不存在或已过期")
}
cache := new(PrepareResourceCache)
if err := json.Unmarshal([]byte(reqStr), cache); err != nil {
return err
}
// 检查交易结果
var rs *TradeSuccessResult
if len(opResult) > 0 && opResult[0] != nil {
rs = opResult[0]
} else {
var err error
rs, err = Trade.CheckTradeIfCreated(&CheckTradeData{
TradeNo: tradeNo,
Method: cache.PaymentMethod,
})
if err != nil {
return err
}
}
data, err := cache.ToData()
if err != nil {
return err
}
// 保存交易信息
err = q.Q.Transaction(func(q *q.Query) error {
// 完成交易
_, err = Trade.OnTradeCreated(q, &OnTradeCreateData{
TradeNo: tradeNo,
TradeSuccessResult: *rs,
})
if err != nil {
return fmt.Errorf("完成交易失败: %w", err)
}
// 保存套餐
resource, err := createResource(q, cache.Uid, now, data)
if err != nil {
return fmt.Errorf("创建套餐失败: %w", err)
}
// 更新账单
_, err = q.Bill.Debug().
Where(q.Bill.ID.Eq(cache.BillId)).
Updates(&m.Bill{
ResourceID: &resource.ID,
})
if err != nil {
return fmt.Errorf("更新账单失败: %w", err)
}
// 删除缓存
err = g.Redis.Del(context.Background(), tradeNo).Err()
if err != nil {
return fmt.Errorf("删除缓存失败: %w", err)
}
return nil
})
if err != nil {
return err
}
return nil
}
func (s *resourceService) CancelResource(tradeNo string, now time.Time, opRevoked ...bool) error {
// 删除请求缓存
cacheStr, err := g.Redis.GetDel(context.Background(), tradeNo).Result()
if err != nil {
return err
}
cache := new(PrepareResourceCache)
if err := json.Unmarshal([]byte(cacheStr), cache); err != nil {
return err
}
// 取消交易
if len(opRevoked) <= 0 {
err = Trade.CancelTrade(tradeNo, cache.PaymentMethod)
if err != nil {
return err
}
}
// 更新订单状态
err = Trade.OnTradeCanceled(q.Q, tradeNo, now)
if err != nil {
return err
}
return nil
}
func createResource(q *q.Query, uid int32, now time.Time, data CreateTypeResourceDataInter) (*m.Resource, error) {
func createResource(q *q.Query, uid int32, now time.Time, data *CreateResourceData) (*m.Resource, error) {
// 套餐基本信息
var resource = m.Resource{
@@ -245,51 +90,55 @@ func createResource(q *q.Query, uid int32, now time.Time, data CreateTypeResourc
ResourceNo: u.P(ID.GenReadable("res")),
Active: true,
}
switch data := data.(type) {
switch data.Type {
// 短效套餐
case *CreateShortResourceData:
var duration = time.Duration(data.Expire) * 24 * time.Hour
case resource2.TypeShort:
var short = data.Short
if short == nil {
return nil, core.NewBizErr("短效套餐数据不能为空")
}
var duration = time.Duration(short.Expire) * 24 * time.Hour
resource.Type = int32(resource2.TypeShort)
resource.Short = &m.ResourceShort{
Type: data.Mode,
Live: data.Live,
Quota: &data.Quota,
Type: short.Mode,
Live: short.Live,
Quota: &short.Quota,
Expire: u.P(orm.LocalDateTime(now.Add(duration))),
DailyLimit: data.DailyLimit,
DailyLimit: short.DailyLimit,
}
// 长效套餐
case *CreateLongResourceData:
var duration = time.Duration(data.Expire) * 24 * time.Hour
case resource2.TypeLong:
var long = data.Long
if long == nil {
return nil, core.NewBizErr("长效套餐数据不能为空")
}
var duration = time.Duration(long.Expire) * 24 * time.Hour
resource.Type = int32(resource2.TypeLong)
resource.Long = &m.ResourceLong{
Type: data.Mode,
Live: data.Live,
Quota: &data.Quota,
Type: long.Mode,
Live: long.Live,
Quota: &long.Quota,
Expire: u.P(orm.LocalDateTime(now.Add(duration))),
DailyLimit: data.DailyLimit,
DailyLimit: long.DailyLimit,
}
default:
return nil, fmt.Errorf("不支持的套餐类型")
return nil, core.NewBizErr("不支持的套餐类型")
}
err := q.Resource.Create(&resource)
if err != nil {
return nil, err
return nil, core.NewServErr("创建套餐失败", err)
}
return &resource, nil
}
func resPrepareKey(tradeNo string) string {
return fmt.Sprintf("resource:prepare:%s", tradeNo)
}
type CreateTypeResourceDataInter interface {
GetName() string
GetPrice() decimal.Decimal
type CreateResourceData struct {
Type resource2.Type `json:"type" validate:"required"`
Short *CreateShortResourceData `json:"short,omitempty"`
Long *CreateLongResourceData `json:"long,omitempty"`
}
type CreateShortResourceData struct {
@@ -303,7 +152,51 @@ type CreateShortResourceData struct {
price *decimal.Decimal
}
func (data *CreateShortResourceData) GetName() string {
type CreateLongResourceData struct {
Live int32 `json:"live" validate:"required,oneof=1 4 8 12 24"`
Mode int32 `json:"mode" validate:"required,oneof=1 2"`
Expire int32 `json:"expire"`
DailyLimit int32 `json:"daily_limit" validate:"min=100"`
Quota int32 `json:"quota" validate:"min=500"`
name string
price *decimal.Decimal
}
func (c *CreateResourceData) GetType() trade2.Type {
return trade2.TypePurchase
}
func (c *CreateResourceData) GetSubject() string {
switch c.Type {
case resource2.TypeShort:
return c.Short.GetSubject()
case resource2.TypeLong:
return c.Long.GetSubject()
}
panic("类型对应的数据为空")
}
func (c *CreateResourceData) GetAmount() decimal.Decimal {
switch c.Type {
case resource2.TypeShort:
return c.Short.GetAmount()
case resource2.TypeLong:
return c.Long.GetAmount()
}
panic("类型对应的数据为空")
}
func (c *CreateResourceData) Serialize() (string, error) {
bytes, err := json.Marshal(c)
return string(bytes), err
}
func (c *CreateResourceData) Deserialize(str string) error {
return json.Unmarshal([]byte(str), c)
}
func (data *CreateShortResourceData) GetSubject() string {
if data.name == "" {
var mode string
switch data.Mode {
@@ -317,7 +210,7 @@ func (data *CreateShortResourceData) GetName() string {
return data.name
}
func (data *CreateShortResourceData) GetPrice() decimal.Decimal {
func (data *CreateShortResourceData) GetAmount() decimal.Decimal {
if data.price == nil {
var factor int32
switch data.Mode {
@@ -340,18 +233,7 @@ func (data *CreateShortResourceData) GetPrice() decimal.Decimal {
return *data.price
}
type CreateLongResourceData struct {
Live int32 `json:"live" validate:"required,oneof=1 4 8 12 24"`
Mode int32 `json:"mode" validate:"required,oneof=1 2"`
Expire int32 `json:"expire"`
DailyLimit int32 `json:"daily_limit" validate:"min=100"`
Quota int32 `json:"quota" validate:"min=500"`
name string
price *decimal.Decimal
}
func (data *CreateLongResourceData) GetName() string {
func (data *CreateLongResourceData) GetSubject() string {
if data.name == "" {
var mode string
switch data.Mode {
@@ -365,7 +247,7 @@ func (data *CreateLongResourceData) GetName() string {
return data.name
}
func (data *CreateLongResourceData) GetPrice() decimal.Decimal {
func (data *CreateLongResourceData) GetAmount() decimal.Decimal {
if data.price == nil {
var factor int32 = 0
switch resource2.Mode(data.Mode) {
@@ -399,72 +281,85 @@ func (data *CreateLongResourceData) GetPrice() decimal.Decimal {
return *data.price
}
type CreateResourceData struct {
Type resource2.Type `json:"type" validate:"required"`
Short *CreateShortResourceData `json:"short,omitempty"`
Long *CreateLongResourceData `json:"long,omitempty"`
}
type ResourceOnTradeComplete struct{}
func (data *CreateResourceData) GetName() string {
switch data.Type {
case resource2.TypeShort:
return data.Short.GetName()
case resource2.TypeLong:
return data.Long.GetName()
default:
panic("未处理的 resource type 枚举值")
func (r ResourceOnTradeComplete) Check(t trade2.Type) (trade2.ProductInfo, bool) {
if t == trade2.TypePurchase {
return &CreateResourceData{}, true
}
return nil, false
}
func (data *CreateResourceData) GetPrice() decimal.Decimal {
switch data.Type {
case resource2.TypeShort:
return data.Short.GetPrice()
case resource2.TypeLong:
return data.Long.GetPrice()
default:
panic("未处理的 resource type 枚举值")
}
func (r ResourceOnTradeComplete) OnTradeComplete(info trade2.ProductInfo, trade *m.Trade) error {
return Resource.CreateResourceByTrade(trade.UserID, time.Time(*trade.CompletedAt), info.(*CreateResourceData), trade)
}
func (s *CreateResourceData) ToData() (CreateTypeResourceDataInter, error) {
switch s.Type {
case resource2.TypeShort:
return s.Short, nil
case resource2.TypeLong:
return s.Long, nil
}
return nil, fmt.Errorf("不支持的套餐类型")
}
type PrepareResourceData struct {
CreateResourceData
PaymentMethod trade2.Method `json:"payment_method" validate:"required"`
PaymentPlatform trade2.Platform `json:"payment_platform" validate:"required"`
}
type PrepareResourceCache struct {
Uid int32 `json:"uid"`
TradeId int32 `json:"trade_id"`
BillId int32 `json:"bill_id"`
*PrepareResourceData
}
func (c PrepareResourceCache) MarshalBinary() (data []byte, err error) {
data, err = json.Marshal(c)
if err != nil {
return nil, err
}
return data, nil
}
func (c PrepareResourceCache) UnmarshalBinary(data []byte) error {
if err := json.Unmarshal(data, &c); err != nil {
return err
}
return nil
}
// type CreateResourceData struct {
// Type resource2.Type `json:"type" validate:"required"`
// Short *CreateShortResourceData `json:"short,omitempty"`
// Long *CreateLongResourceData `json:"long,omitempty"`
// }
//
// func (data *CreateResourceData) GetSubject() string {
// switch data.Type {
// case resource2.TypeShort:
// return data.Short.GetSubject()
// case resource2.TypeLong:
// return data.Long.GetSubject()
// default:
// panic("未处理的 resource type 枚举值")
// }
// }
//
// func (data *CreateResourceData) GetAmount() decimal.Decimal {
// switch data.Type {
// case resource2.TypeShort:
// return data.Short.GetAmount()
// case resource2.TypeLong:
// return data.Long.GetAmount()
// default:
// panic("未处理的 resource type 枚举值")
// }
// }
//
// func (data *CreateResourceData) ToData() (CreateResourceData, error) {
// switch data.Type {
// case resource2.TypeShort:
// return data.Short, nil
// case resource2.TypeLong:
// return data.Long, nil
// }
//
// return nil, fmt.Errorf("不支持的套餐类型")
// }
//
// type PrepareResourceData struct {
// CreateResourceData
// PaymentMethod trade2.Method `json:"payment_method" validate:"required"`
// PaymentPlatform trade2.Platform `json:"payment_platform" validate:"required"`
// }
//
// type PrepareResourceCache struct {
// Uid int32 `json:"uid"`
// TradeId int32 `json:"trade_id"`
// BillId int32 `json:"bill_id"`
// *PrepareResourceData
// }
//
// func (c PrepareResourceCache) MarshalBinary() (data []byte, err error) {
// data, err = json.Marshal(c)
// if err != nil {
// return nil, err
// }
// return data, nil
// }
//
// func (c PrepareResourceCache) UnmarshalBinary(data []byte) error {
// if err := json.Unmarshal(data, &c); err != nil {
// return err
// }
// return nil
// }
type ResourceServiceErr string

423
web/services/trade.go
View File

@@ -12,7 +12,6 @@ import (
"platform/pkg/env"
"platform/pkg/u"
"platform/web/core"
bill2 "platform/web/domains/bill"
coupon2 "platform/web/domains/coupon"
trade2 "platform/web/domains/trade"
g "platform/web/globals"
@@ -27,30 +26,35 @@ import (
"gorm.io/gorm"
)
var ComplementEvents = []trade2.CompleteEvent{
ResourceOnTradeComplete{},
UserOnTradeComplete{},
}
var Trade = &tradeService{}
type tradeService struct {
}
func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *TradeCreateData) (*TradeCreateResult, error) {
var subject = data.Subject
var expire = data.ExpireAt
var tType = data.Type
var method = data.Method
var platform = data.Platform
var amount = data.Amount
func (s *tradeService) CreateTrade(uid int32, now time.Time, data *CreateTradeData) (*CreateTradeResult, error) {
platform := data.Platform
method := data.Method
tType := data.Product.GetType()
subject := data.Product.GetSubject()
amount := data.Product.GetAmount()
expire := time.Now().Add(30 * time.Minute)
// 实际支付金额，只在创建真实订单时使用
var amountReal = data.Amount
var amountReal = data.Product.GetAmount()
if env.RunMode == "debug" {
amountReal = decimal.NewFromFloat(0.01)
}
// 附加优惠券
if data.CouponCode != "" {
if data.CouponCode != nil {
coupon, err := q.Coupon.
Where(
q.Coupon.Code.Eq(data.CouponCode),
q.Coupon.Code.Eq(*data.CouponCode),
q.Coupon.Status.Eq(int32(coupon2.StatusUnused)),
).
Take()
@@ -100,13 +104,13 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
}
// 生成订单号
tradeNo, err := ID.GenSerial(context.Background())
var tradeNo, err = ID.GenSerial()
if err != nil {
return nil, err
return nil, core.NewServErr("生成订单号失败", err)
}
// 创建支付订单
var payUrl string
// 提交支付订单
var paymentUrl string
switch {
// 支付宝 + 电脑网站
@@ -125,7 +129,7 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
if err != nil {
return nil, err
}
payUrl = resp.String()
paymentUrl = resp.String()
// 微信 + 电脑网站
case method == trade2.MethodWeChat && platform == trade2.PlatformDesktop:
@@ -143,10 +147,13 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
if err != nil {
return nil, err
}
payUrl = *resp.CodeUrl
paymentUrl = *resp.CodeUrl
// 商福通 + 电脑网站
case (method == trade2.MethodSftAlipay || method == trade2.MethodSftWeChat) && platform == trade2.PlatformDesktop:
case
method == trade2.MethodSftAlipay && platform == trade2.PlatformDesktop,
method == trade2.MethodSftWeChat && platform == trade2.PlatformDesktop:
var payType g.SftPayType
switch method {
case trade2.MethodSftAlipay:
@@ -169,10 +176,12 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
if err != nil {
return nil, err
}
payUrl = u.Z(u.Z(resp.PayInfo).QrCodeUrl)
paymentUrl = u.Z(u.Z(resp.PayInfo).QrCodeUrl)
// 商福通 + 手机网站
case (method == trade2.MethodSftAlipay || method == trade2.MethodSftWeChat) && platform == trade2.PlatformMobile:
case
method == trade2.MethodSftAlipay && platform == trade2.PlatformMobile,
method == trade2.MethodSftWeChat && platform == trade2.PlatformMobile:
var payType g.SftPayType
switch method {
case trade2.MethodSftAlipay:
@@ -195,7 +204,7 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
if err != nil {
return nil, err
}
payUrl = u.Z(u.Z(resp.PayInfo).PayUrl)
paymentUrl = u.Z(u.Z(resp.PayInfo).PayUrl)
// 不支持的支付方式
default:
@@ -203,172 +212,245 @@ func (s *tradeService) CreateTrade(q *q.Query, uid int32, now time.Time, data *T
return nil, ErrTransactionNotSupported
}
// 保存交易订单
var trade = m.Trade{
UserID: uid,
InnerNo: tradeNo,
Subject: subject,
Type: int32(tType),
Method: int32(method),
Platform: int32(platform),
Amount: amount,
PayURL: &payUrl,
}
err = q.Trade.Create(&trade)
// 保存订单
err = q.Trade.Create(&m.Trade{
UserID: uid,
InnerNo: tradeNo,
Type: int32(tType),
Subject: subject,
Amount: amount,
Method: int32(method),
Platform: int32(platform),
PaymentURL: &paymentUrl,
})
if err != nil {
return nil, err
return nil, core.NewServErr("保存交易订单失败", err)
}
// 保存用户帐单
var billType bill2.Type
switch tType {
case trade2.TypeRecharge:
billType = bill2.TypeRecharge
case trade2.TypePurchase:
billType = bill2.TypeConsume
}
var bill = m.Bill{
BillNo: ID.GenReadable("bil"),
UserID: uid,
TradeID: &trade.ID,
Info: &subject,
Type: int32(billType),
Amount: amount,
}
err = q.Bill.
Omit(q.Bill.ResourceID, q.Bill.RefundID).
Create(&bill)
// 缓存产品数据
serialized, err := data.Product.Serialize()
if err != nil {
return nil, err
return nil, core.NewServErr("序列化产品信息失败", err)
}
// 提交异步任务更新订单状态
err = g.Redis.Set(
context.Background(),
tradeProductKey(tradeNo),
serialized,
time.Duration(env.TradeExpire+10)*time.Second,
).Err()
if err != nil {
return nil, core.NewServErr("保存购买信息失败", err)
}
// 提交异步关闭事件
_, err = g.Asynq.Enqueue(tasks.NewCancelTrade(tasks.CancelTradeData{
TradeNo: tradeNo,
Method: method,
}))
if err != nil {
return nil, err
return nil, core.NewServErr("提交异步关闭事件失败", err)
}
return &TradeCreateResult{
TradeNo: tradeNo,
PayURL: payUrl,
Bill: &bill,
Trade: &trade,
return &CreateTradeResult{
PaymentUrl: paymentUrl,
TradeNo: tradeNo,
}, nil
}
func (s *tradeService) OnTradeCreated(q *q.Query, data *OnTradeCreateData) (*m.Trade, error) {
var transId = data.TransId
func (s *tradeService) OnTradeCompleted(data *OnTradeCompletedData) error {
// 更新交易状态
var trade = new(m.Trade)
var err = g.Redsync.WithLock(tradeLockKey(data.TradeNo), func() error {
return q.Q.Transaction(func(q *q.Query) (err error) {
trade, err = completeTrade(q, data)
return
})
})
if err != nil {
return core.NewServErr("处理交易失败", err)
}
// 处理交易完成事件
err = completeTradeAfter(trade)
if err != nil {
return core.NewServErr("处理交易完成事件失败", err)
}
return nil
}
func completeTrade(q *q.Query, data *OnTradeCompletedData) (*m.Trade, error) {
var tradeNo = data.TradeNo
var transId = data.TransId
var payment = data.Payment
var paidAt = data.Time
var acquirer = data.Acquirer
var paidAt = data.Time
// 获取交易信息
trade, err := q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
First()
Take()
if err != nil {
return nil, err
return nil, core.NewBizErr("获取交易信息失败", err)
}
// 检查交易状态
switch trade2.Status(trade.Status) {
case trade2.StatusCanceled:
return nil, core.NewBizErr("交易已取消")
case trade2.StatusSuccess:
return nil, core.NewBizErr("交易已完成")
// 如果是未支付，则更新支付状态
case trade2.StatusPending:
trade.Status = int32(trade2.StatusSuccess)
trade.OuterNo = &transId
trade.Payment = payment
trade.Acquirer = u.P(int32(acquirer))
trade.PaidAt = u.P(orm.LocalDateTime(paidAt))
trade.PayURL = u.P("")
_, err = q.Trade.
Where(q.Trade.ID.Eq(trade.ID)).
Updates(trade)
if err != nil {
return nil, err
}
}
// 更新交易信息
trade.Status = int32(trade2.StatusSuccess)
trade.OuterNo = &transId
trade.Payment = payment
trade.Acquirer = u.P(int32(acquirer))
trade.CompletedAt = u.P(orm.LocalDateTime(paidAt))
_, err = q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
Updates(trade)
if err != nil {
return nil, core.NewServErr("更新交易信息失败", err)
}
return trade, nil
}
func completeTradeAfter(trade *m.Trade) error {
func (s *tradeService) CancelTrade(tradeNo string, method trade2.Method) error {
switch method {
case trade2.MethodAlipay:
resp, err := g.Alipay.TradeCancel(context.Background(), alipay.TradeCancel{
OutTradeNo: tradeNo,
})
if err != nil {
return err
}
if resp.Code != alipay.CodeSuccess {
slog.Warn("支付宝交易取消失败", "code", resp.Code, "sub_code", resp.SubCode, "msg", resp.Msg)
return errors.New("交易取消失败")
}
case trade2.MethodWeChat:
resp, err := g.WechatPay.Native.CloseOrder(context.Background(), native.CloseOrderRequest{
Mchid: &env.WechatPayMchId,
OutTradeNo: &tradeNo,
})
if err != nil {
return err
}
if resp.Response.StatusCode != http.StatusNoContent {
body, _ := io.ReadAll(resp.Response.Body)
slog.Warn("微信交易取消失败", "code", resp.Response.StatusCode, "body", string(body))
return errors.New("交易取消失败")
}
case trade2.MethodSft, trade2.MethodSftAlipay, trade2.MethodSftWeChat:
resp, err := g.SFTPay.OrderClose(&g.OrderCloseReq{
MchOrderNo: &tradeNo,
})
if err != nil {
return err
}
if resp.State != "TRADE_CLOSE" {
slog.Warn("商福通交易取消失败", "state", resp.State)
return errors.New("交易取消失败")
}
default:
return ErrTransactionNotSupported
// 恢复购买信息
productData, err := g.Redis.Get(context.Background(), tradeProductKey(trade.InnerNo)).Result()
if err != nil {
return core.NewServErr("恢复购买信息失败", err)
}
// 执行资源创建
for _, event := range ComplementEvents {
info, ok := event.Check(trade2.Type(trade.Type))
if !ok {
continue
}
err = info.Deserialize(productData)
if err != nil {
return core.NewServErr("反序列化购买信息失败", err)
}
err = event.OnTradeComplete(info, trade)
if err != nil {
return core.NewServErr("处理交易完成事件失败", err)
}
}
return nil
}
func (s *tradeService) CancelTrade(tradeNo string, method trade2.Method, now time.Time) error {
err := g.Redsync.WithLock(tradeLockKey(tradeNo), func() error {
switch method {
case trade2.MethodAlipay:
resp, err := g.Alipay.TradeCancel(context.Background(), alipay.TradeCancel{
OutTradeNo: tradeNo,
})
if err != nil {
return err
}
if resp.Code != alipay.CodeSuccess {
slog.Warn("支付宝交易取消失败", "code", resp.Code, "sub_code", resp.SubCode, "msg", resp.Msg)
return errors.New("交易取消失败")
}
case trade2.MethodWeChat:
resp, err := g.WechatPay.Native.CloseOrder(context.Background(), native.CloseOrderRequest{
Mchid: &env.WechatPayMchId,
OutTradeNo: &tradeNo,
})
if err != nil {
return err
}
if resp.Response.StatusCode != http.StatusNoContent {
body, _ := io.ReadAll(resp.Response.Body)
slog.Warn("微信交易取消失败", "code", resp.Response.StatusCode, "body", string(body))
return errors.New("交易取消失败")
}
case trade2.MethodSft, trade2.MethodSftAlipay, trade2.MethodSftWeChat:
resp, err := g.SFTPay.OrderClose(&g.OrderCloseReq{
MchOrderNo: &tradeNo,
})
if err != nil {
return err
}
if resp.State != "TRADE_CLOSE" {
slog.Warn("商福通交易取消失败", "state", resp.State)
return errors.New("交易取消失败")
}
default:
return ErrTransactionNotSupported
}
err := q.Q.Transaction(func(q *q.Query) error {
return cancelTrade(q, tradeNo, now)
})
if err != nil {
return err
}
return nil
})
if err != nil {
return core.NewServErr("处理交易取消失败", err)
}
return nil
}
func (s *tradeService) OnTradeCanceled(q *q.Query, tradeNo string, now time.Time) error {
_, err := q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
Select(q.Trade.Status, q.Trade.CancelAt, q.Trade.PayURL).
Updates(m.Trade{
Status: int32(trade2.StatusCanceled),
CancelAt: u.P(orm.LocalDateTime(now)),
PayURL: u.P(""),
})
err := g.Redsync.WithLock(tradeLockKey(tradeNo), func() error {
return cancelTrade(q, tradeNo, now)
})
if err != nil {
return err
return core.NewServErr("处理交易取消失败", err)
}
return nil
}
func cancelTrade(q *q.Query, tradeNo string, now time.Time) error {
// 获取交易信息
var status trade2.Status
err := q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
Select(q.Trade.Status).
Scan(&status)
if err != nil {
return core.NewBizErr("获取交易信息失败", err)
}
func (s *tradeService) SendRefundTrade(tradeNo string, method trade2.Method) error {
// 检查交易状态
switch status {
case trade2.StatusCanceled:
return core.NewBizErr("交易已取消")
case trade2.StatusSuccess:
return core.NewBizErr("交易已完成")
case trade2.StatusPending:
}
// 更新交易状态
_, err = q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
UpdateSimple(
q.Trade.Status.Value(int32(trade2.StatusCanceled)),
q.Trade.CanceledAt.Value(orm.LocalDateTime(now)),
)
if err != nil {
return core.NewServErr("更新交易状态失败", err)
}
return nil
}
func (s *tradeService) RefundTrade(tradeNo string, method trade2.Method) error {
panic("todo")
}
func (s *tradeService) OnTradeRefunded(q *q.Query, tradeNo string, now time.Time) error {
@@ -410,6 +492,7 @@ func (s *tradeService) CheckTrade(data *CheckTradeData) (*CheckTradeResult, erro
case alipay.TradeStatusSuccess, alipay.TradeStatusFinished:
result.Status = trade2.StatusSuccess
result.Success = &TradeSuccessResult{}
result.Success.Acquirer = trade2.AcquirerAlipay
result.Success.Payment, err = decimal.NewFromString(resp.TotalAmount)
if err != nil {
@@ -455,6 +538,7 @@ func (s *tradeService) CheckTrade(data *CheckTradeData) (*CheckTradeResult, erro
case "SUCCESS", "REFUND":
result.Status = trade2.StatusSuccess
result.Success = &TradeSuccessResult{}
result.Success.Acquirer = trade2.AcquirerWeChat
result.Success.Payment = decimal.NewFromInt(*resp.Amount.PayerTotal).Div(decimal.NewFromInt(100))
result.Success.Time, err = time.Parse(time.RFC3339, *resp.SuccessTime)
@@ -490,6 +574,7 @@ func (s *tradeService) CheckTrade(data *CheckTradeData) (*CheckTradeResult, erro
case g.SftTradeSuccess, g.SftTradeRefund, g.SftRefundIng:
result.Status = trade2.StatusSuccess
result.Success = &TradeSuccessResult{}
switch resp.PayType {
case "WECHAT":
result.Success.Acquirer = trade2.AcquirerWeChat
@@ -512,8 +597,7 @@ func (s *tradeService) CheckTrade(data *CheckTradeData) (*CheckTradeResult, erro
return result, nil
}
func (s *tradeService) CheckTradeIfCreated(data *CheckTradeData) (*TradeSuccessResult, error) {
func (s *tradeService) ConfirmTradeCompleted(data *CheckTradeData) (*TradeSuccessResult, error) {
rs, err := Trade.CheckTrade(&CheckTradeData{
TradeNo: data.TradeNo,
Method: data.Method,
@@ -521,19 +605,18 @@ func (s *tradeService) CheckTradeIfCreated(data *CheckTradeData) (*TradeSuccessR
if err != nil {
return nil, err
}
switch rs.Status {
case trade2.StatusPending:
return nil, core.NewBizErr("订单未支付")
case trade2.StatusCanceled:
return nil, core.NewBizErr("订单已关闭")
case trade2.StatusSuccess:
// pass
}
return rs.Success, nil
}
func (s *tradeService) CheckTradeIfCanceled(data *CheckTradeData) error {
func (s *tradeService) ConfirmTradeCanceled(data *CheckTradeData) error {
rs, err := Trade.CheckTrade(&CheckTradeData{
TradeNo: data.TradeNo,
Method: data.Method,
@@ -541,33 +624,55 @@ func (s *tradeService) CheckTradeIfCanceled(data *CheckTradeData) error {
if err != nil {
return err
}
switch rs.Status {
case trade2.StatusPending:
return core.NewBizErr("订单未支付")
case trade2.StatusSuccess:
return core.NewBizErr("订单已关闭")
case trade2.StatusCanceled:
// pass
}
return nil
}
func (s *tradeService) ConfirmTradeRefunded(data *CheckTradeData) error {
rs, err := Trade.CheckTrade(&CheckTradeData{
TradeNo: data.TradeNo,
Method: data.Method,
})
if err != nil {
return err
}
type TradeCreateData struct {
Subject string
Amount decimal.Decimal
ExpireAt time.Time
Type trade2.Type
Method trade2.Method
Platform trade2.Platform
CouponCode string
switch rs.Status {
case trade2.StatusPending:
return core.NewBizErr("订单未支付")
case trade2.StatusCanceled:
return core.NewBizErr("订单已关闭")
case trade2.StatusSuccess:
}
return core.NewBizErr("订单状态异常")
}
type TradeCreateResult struct {
TradeNo string
PayURL string
Bill *m.Bill
Trade *m.Trade
func tradeProductKey(no string) string {
return fmt.Sprintf("trade:%s:product", no)
}
func tradeLockKey(no string) string {
return fmt.Sprintf("trade:%s:lock", no)
}
type CreateTradeData struct {
Platform trade2.Platform `json:"platform" validate:"required"`
Method trade2.Method `json:"method" validate:"required"`
CouponCode *string `json:"coupon_code"`
Product trade2.ProductInfo
}
type CreateTradeResult struct {
TradeNo string
PaymentUrl string
}
type CheckTradeData struct {
@@ -588,7 +693,7 @@ type TradeSuccessResult struct {
Time time.Time
}
type OnTradeCreateData struct {
type OnTradeCompletedData struct {
TradeNo string
TradeSuccessResult
}

115
web/services/user.go
View File

@@ -1,54 +1,107 @@
package services
import (
"encoding/json"
"fmt"
"github.com/shopspring/decimal"
"platform/web/core"
bill2 "platform/web/domains/bill"
trade2 "platform/web/domains/trade"
g "platform/web/globals"
m "platform/web/models"
q "platform/web/queries"
"time"
)
var User = &userService{}
type userService struct{}
func (s *userService) RechargeConfirm(tradeNo string, verified *TradeSuccessResult) error {
func (s *userService) UpdateBalanceByTrade(uid int32, info *RechargeProductInfo, trade *m.Trade) (err error) {
err = g.Redsync.WithLock(userBalanceKey(uid), func() error {
return q.Q.Transaction(func(q *q.Query) error {
err := q.Q.Transaction(func(tx *q.Query) error {
err = updateBalance(q, uid, info)
if err != nil {
return err
}
// 更新交易状态
trade, err := Trade.OnTradeCreated(tx, &OnTradeCreateData{
TradeNo: tradeNo,
TradeSuccessResult: *verified,
// 生成账单
err = q.Bill.Create(bill2.NewForRecharge(uid, Bill.GenNo(), info.GetSubject(), info.GetAmount(), trade))
if err != nil {
return core.NewServErr("生成账单失败", err)
}
return nil
})
if err != nil {
return err
}
// 更新用户余额
user, err := tx.User.
Where(tx.User.ID.Eq(trade.UserID)).Take()
if err != nil {
return err
}
_, err = tx.User.
Where(tx.User.ID.Eq(user.ID)).
UpdateSimple(tx.User.Balance.Value(user.Balance.Add(trade.Amount)))
if err != nil {
return err
}
return nil
})
if err != nil {
return err
return core.NewServErr("更新用户余额失败")
}
return nil
}
func updateBalance(q *q.Query, uid int32, info *RechargeProductInfo) (err error) {
// 更新余额
user, err := q.User.
Where(q.User.ID.Eq(uid)).Take()
if err != nil {
return core.NewServErr("查询用户失败", err)
}
var amount = user.Balance.Add(info.GetAmount())
if amount.IsNegative() {
return core.NewServErr("用户余额不足")
}
_, err = q.User.
Where(q.User.ID.Eq(user.ID)).
UpdateSimple(q.User.Balance.Value(amount))
if err != nil {
return core.NewServErr("更新用户余额失败", err)
}
return nil
}
func (s *userService) RechargeCancel(tradeNo string, now time.Time) error {
panic("not implemented")
func userBalanceKey(uid int32) string {
return fmt.Sprintf("user:%d:balance", uid)
}
func (s *userService) RechargeRefund(tradeNo string, now time.Time) error {
panic("not implemented")
type RechargeProductInfo struct {
Amount int `json:"amount"`
}
func (r *RechargeProductInfo) GetType() trade2.Type {
return trade2.TypeRecharge
}
func (r *RechargeProductInfo) GetSubject() string {
return fmt.Sprintf("账户充值 - " + r.GetAmount().StringFixed(2) + "元")
}
func (r *RechargeProductInfo) GetAmount() decimal.Decimal {
return decimal.NewFromInt(int64(r.Amount)).Div(decimal.NewFromInt(100))
}
func (r *RechargeProductInfo) Serialize() (string, error) {
bytes, err := json.Marshal(r)
return string(bytes), err
}
func (r *RechargeProductInfo) Deserialize(str string) error {
return json.Unmarshal([]byte(str), r)
}
type UserOnTradeComplete struct{}
func (u UserOnTradeComplete) Check(t trade2.Type) (trade2.ProductInfo, bool) {
if t == trade2.TypeRecharge {
return &RechargeProductInfo{}, true
}
return nil, false
}
func (u UserOnTradeComplete) OnTradeComplete(info trade2.ProductInfo, trade *m.Trade) error {
return User.UpdateBalanceByTrade(trade.UserID, info.(*RechargeProductInfo), trade)
}