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

完善套餐与账单接口 & 完善支付数据保存，记录实付价格并关联优惠券

Browse Source
This commit is contained in:
luorijun
2026-03-26 14:39:19 +08:00
parent 5ffa151f58
commit 75ad12efb3
23 changed files with 706 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
web/services/bill.go
View File

@@ -2,6 +2,7 @@ package services
import (
m "platform/web/models"
q "platform/web/queries"
"github.com/shopspring/decimal"
)
@@ -10,34 +11,41 @@ var Bill = &billService{}
type billService struct{}
func (s *billService) GenNo() string {
return ID.GenReadable("bil")
}
func newForRecharge(uid int32, billNo string, info string, amount decimal.Decimal, trade *m.Trade) *m.Bill {
return &m.Bill{
func (s *billService) CreateForBalance(q *q.Query, uid, tradeId int32, detail *TradeDetail) error {
return q.Bill.Create(&m.Bill{
UserID: uid,
BillNo: billNo,
TradeID: &trade.ID,
BillNo: ID.GenReadable("bil"),
TradeID: &tradeId,
Type: m.BillTypeRecharge,
Info: &info,
Amount: amount,
}
Info: &detail.Subject,
Amount: detail.Amount,
Actual: detail.Actual,
})
}
func newForConsume(uid int32, billNo string, info string, amount decimal.Decimal, resource *m.Resource, trade ...*m.Trade) *m.Bill {
var bill = &m.Bill{
func (s *billService) CreateForResourceByTrade(q *q.Query, uid, tradeId, resourceId int32, detail *TradeDetail) error {
return q.Bill.Create(&m.Bill{
UserID: uid,
BillNo: billNo,
ResourceID: &resource.ID,
BillNo: ID.GenReadable("bil"),
ResourceID: &resourceId,
TradeID: &tradeId,
CouponID: detail.CouponId,
Type: m.BillTypeConsume,
Info: &info,
Amount: amount,
}
if len(trade) > 0 {
bill.TradeID = &trade[0].ID
}
return bill
Info: &detail.Subject,
Amount: detail.Amount,
Actual: detail.Actual,
})
}
func (s *billService) CreateForResourceByBalance(q *q.Query, uid, resourceId int32, couponId *int32, subject string, amount, actual decimal.Decimal) error {
return q.Bill.Create(&m.Bill{
UserID: uid,
BillNo: ID.GenReadable("bil"),
ResourceID: &resourceId,
CouponID: couponId,
Type: m.BillTypeConsume,
Info: &subject,
Amount: amount,
Actual: actual,
})
}

64
web/services/coupon.go Normal file
View File

@@ -0,0 +1,64 @@
package services
import (
"errors"
"fmt"
"platform/web/core"
m "platform/web/models"
q "platform/web/queries"
"time"
"github.com/shopspring/decimal"
"gorm.io/gorm"
)
var Coupon = &couponService{}
type couponService struct{}
func (s *couponService) GetCouponAvailableByCode(code string, amount decimal.Decimal, uid *int32) (*m.Coupon, error) {
// 获取优惠券
coupon, err := q.Coupon.Where(
q.Coupon.Code.Eq(code),
q.Coupon.Status.Eq(int(m.CouponStatusUnused)),
q.Coupon.
Where(q.Coupon.ExpireAt.Gt(time.Now())).
Or(q.Coupon.ExpireAt.IsNull()),
).Take()
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, core.NewBizErr("优惠券不存在或已失效")
}
if err != nil {
return nil, core.NewBizErr("获取优惠券数据失败", err)
}
// 检查最小使用额度
if amount.Cmp(coupon.MinAmount) < 0 {
return nil, core.NewBizErr(fmt.Sprintf("使用此优惠券的最小额度为 %s", coupon.MinAmount))
}
// 检查所属
if coupon.UserID != nil {
if uid == nil {
return nil, core.NewBizErr("检查优惠券所属用户失败")
}
if *coupon.UserID != *uid {
return nil, core.NewBizErr("优惠券不属于当前用户")
}
}
return coupon, nil
}
func (s *couponService) UseCoupon(q *q.Query, id int32) error {
_, err := q.Coupon.
Where(
q.Coupon.ID.Eq(id),
q.Coupon.Status.Eq(int(m.CouponStatusUnused)),
q.Coupon.ExpireAt.Gt(time.Now()),
).
UpdateSimple(
q.Coupon.Status.Value(int(m.CouponStatusUsed)),
)
return err
}

8
web/services/product_sku.go
View File

@@ -15,6 +15,14 @@ var ProductSku = &productSkuService{}
type productSkuService struct{}
func (s *productSkuService) All(product_code string) (result []*m.ProductSku, err error) {
return q.ProductSku.
Joins(q.ProductSku.Product).
Where(q.Product.As("Product").Code.Eq(product_code)).
Select(q.ProductSku.ALL).
Find()
}
func (s *productSkuService) Page(req *core.PageReq, productId *int32) (result []*m.ProductSku, count int64, err error) {
do := make([]gen.Condition, 0)
if productId != nil {

201
web/services/resource.go
View File

@@ -1,7 +1,6 @@
package services
import (
"encoding/json"
"errors"
"fmt"
"platform/pkg/u"
@@ -11,6 +10,7 @@ import (
"time"
"github.com/shopspring/decimal"
"gorm.io/gen/field"
"gorm.io/gorm"
)
@@ -18,6 +18,7 @@ var Resource = &resourceService{}
type resourceService struct{}
// CreateResourceByBalance 通过余额购买套餐
func (s *resourceService) CreateResourceByBalance(uid int32, now time.Time, data *CreateResourceData) error {
// 找到用户
@@ -29,16 +30,21 @@ func (s *resourceService) CreateResourceByBalance(uid int32, now time.Time, data
}
// 获取 sku
sku, err := s.GetSku(data)
sku, err := s.GetSku(data.Code())
if err != nil {
return err
}
// 检查余额
_, amount, err := s.GetPrice(sku, data.Count(), &uid)
coupon, _, amount, actual, err := s.GetPrice(sku, data.Count(), &uid, data.CouponCode)
if err != nil {
return err
}
couponId := (*int32)(nil)
if coupon != nil {
couponId = &coupon.ID
}
newBalance := user.Balance.Sub(amount)
if newBalance.IsNegative() {
return ErrBalanceNotEnough
@@ -58,49 +64,30 @@ func (s *resourceService) CreateResourceByBalance(uid int32, now time.Time, data
}
// 保存套餐
resource, err := createResource(q, uid, now, data)
resource, err := s.Create(q, uid, now, data)
if err != nil {
return core.NewServErr("创建套餐失败", err)
}
// 生成账单
err = q.Bill.Create(newForConsume(uid, Bill.GenNo(), sku.Name, amount, resource))
err = Bill.CreateForResourceByBalance(q, uid, resource.ID, couponId, sku.Name, amount, actual)
if err != nil {
return core.NewServErr("生成账单失败", err)
}
// 核销优惠券
if coupon != nil {
err = Coupon.UseCoupon(q, coupon.ID)
if err != nil {
return core.NewServErr("核销优惠券失败", err)
}
}
return nil
})
}
func (s *resourceService) CreateResourceByTrade(uid int32, now time.Time, data *CreateResourceByTradeData, trade *m.Trade) error { // 检查交易
if trade == nil {
return core.NewBizErr("交易数据不能为空")
}
if trade.Status != m.TradeStatusSuccess {
return core.NewBizErr("交易状态不正确")
}
return q.Q.Transaction(func(q *q.Query) error {
// 保存套餐
resource, err := createResource(q, uid, now, data.Req)
if err != nil {
return core.NewServErr("创建套餐失败", err)
}
// 生成账单
err = q.Bill.Create(newForConsume(uid, Bill.GenNo(), data.GetSubject(), data.GetAmount(), resource, trade))
if err != nil {
return core.NewServErr("生成账单失败", err)
}
return nil
})
}
func createResource(q *q.Query, uid int32, now time.Time, data *CreateResourceData) (*m.Resource, error) {
func (s *resourceService) Create(q *q.Query, uid int32, now time.Time, data *CreateResourceData) (*m.Resource, error) {
// 套餐基本信息
var resource = m.Resource{
UserID: uid,
@@ -162,10 +149,35 @@ func createResource(q *q.Query, uid int32, now time.Time, data *CreateResourceDa
return &resource, nil
}
func (s *resourceService) GetSku(data *CreateResourceData) (*m.ProductSku, error) {
func (s *resourceService) Update(data *UpdateResourceData) error {
if data.Active == nil {
return core.NewBizErr("更新套餐失败，active 不能为空")
}
do := make([]field.AssignExpr, 0)
if data.Active != nil {
do = append(do, q.Resource.Active.Value(*data.Active))
}
_, err := q.Resource.
Where(q.Resource.ID.Eq(data.Id)).
UpdateSimple(do...)
if err != nil {
return core.NewServErr("更新套餐失败", err)
}
return nil
}
type UpdateResourceData struct {
core.IdReq
Active *bool `json:"active"`
}
func (s *resourceService) GetSku(code string) (*m.ProductSku, error) {
sku, err := q.ProductSku.
Joins(q.ProductSku.Discount).
Where(q.ProductSku.Code.Eq(data.Code())).
Where(q.ProductSku.Code.Eq(code)).
Take()
if err != nil {
return nil, core.NewServErr("产品不可用", err)
@@ -178,43 +190,55 @@ func (s *resourceService) GetSku(data *CreateResourceData) (*m.ProductSku, error
return sku, nil
}
func (s *resourceService) GetPrice(sku *m.ProductSku, count int32, uid *int32) (decimal.Decimal, decimal.Decimal, error) {
func (s *resourceService) GetPrice(sku *m.ProductSku, count int32, uid *int32, couponCode *string) (*m.Coupon, decimal.Decimal, decimal.Decimal, decimal.Decimal, error) {
// 根据用户 id 查询特殊优惠
var uSku *m.ProductSkuUser
if uid != nil {
// 原价
price := sku.Price
amount := price.Mul(decimal.NewFromInt32(count))
// 折扣价
discount := sku.Discount.Decimal()
if uid != nil { // 用户特殊优惠
var err error
uSku, err = q.ProductSkuUser.
uSku, err := q.ProductSkuUser.
Joins(q.ProductSkuUser.Discount).
Where(
q.ProductSkuUser.UserID.Eq(*uid),
q.ProductSkuUser.ProductSkuID.Eq(sku.ID)).
Take()
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return decimal.Zero, decimal.Zero, core.NewServErr("客户特殊价查询失败", err)
return nil, decimal.Zero, decimal.Zero, decimal.Zero, core.NewServErr("客户特殊价查询失败", err)
}
if uSku.Discount == nil {
return nil, decimal.Zero, decimal.Zero, decimal.Zero, core.NewServErr("价格获取失败")
}
uDiscount := uSku.Discount.Decimal()
if uDiscount.Cmp(discount) > 0 {
discount = uDiscount
}
}
discounted := amount.Mul(discount)
if uSku.Discount == nil {
return decimal.Decimal{}, decimal.Decimal{}, core.NewServErr("价格获取失败")
// 优惠价
coupon := (*m.Coupon)(nil)
couponApplied := discounted.Copy()
if couponCode != nil {
var err error
coupon, err = Coupon.GetCouponAvailableByCode(*couponCode, discounted, uid)
if err != nil {
return nil, decimal.Zero, decimal.Zero, decimal.Zero, err
}
couponApplied = discounted.Sub(coupon.Amount)
}
// 返回计算价格
price := sku.Price
discount := sku.Discount.Decimal()
if uSku != nil {
discount = uSku.Discount.Decimal()
}
before := price.Mul(decimal.NewFromInt32(count))
after := before.Mul(discount)
return before, after, nil
return coupon, amount, discounted, couponApplied, nil
}
type CreateResourceData struct {
Type m.ResourceType `json:"type" validate:"required"`
Short *CreateShortResourceData `json:"short,omitempty"`
Long *CreateLongResourceData `json:"long,omitempty"`
Type m.ResourceType `json:"type" validate:"required"`
Short *CreateShortResourceData `json:"short,omitempty"`
Long *CreateLongResourceData `json:"long,omitempty"`
CouponCode *string `json:"coupon,omitempty"`
}
type CreateShortResourceData struct {
@@ -267,71 +291,22 @@ func (c *CreateResourceData) Code() string {
}
}
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)
}
// 交易后创建套餐
type ResourceOnTradeComplete struct{}
func (r ResourceOnTradeComplete) Check(t m.TradeType) (ProductInfo, bool) {
if t == m.TradeTypePurchase {
return &CreateResourceByTradeData{}, true
}
return nil, false
}
func (r ResourceOnTradeComplete) OnTradeComplete(info ProductInfo, trade *m.Trade) error {
return Resource.CreateResourceByTrade(trade.UserID, time.Time(*trade.CompletedAt), info.(*CreateResourceByTradeData), trade)
}
type CreateResourceByTradeData struct {
Subject string `json:"subject"`
Amount decimal.Decimal `json:"amount"`
Req *CreateResourceData `json:"data"`
}
func (e CreateResourceByTradeData) GetType() m.TradeType {
return m.TradeTypePurchase
}
func (e CreateResourceByTradeData) GetSubject() string {
return e.Subject
}
func (e CreateResourceByTradeData) GetAmount() decimal.Decimal {
return e.Amount
}
func (e CreateResourceByTradeData) Serialize() (string, error) {
bytes, err := json.Marshal(e)
return string(bytes), err
}
func (e *CreateResourceByTradeData) Deserialize(str string) error {
return json.Unmarshal([]byte(str), e)
}
func NewCreateResourceByTradeData(req *CreateResourceData) (*CreateResourceByTradeData, error) {
sku, err := Resource.GetSku(req)
func (c *CreateResourceData) TradeDetail() (*TradeDetail, error) {
sku, err := Resource.GetSku(c.Code())
if err != nil {
return nil, err
}
_, amount, err := Resource.GetPrice(sku, req.Count(), nil)
coupon, _, amount, actual, err := Resource.GetPrice(sku, c.Count(), nil, c.CouponCode)
if err != nil {
return nil, err
}
return &CreateResourceByTradeData{
Subject: sku.Name,
Amount: amount,
Req: req,
return &TradeDetail{
m.TradeTypePurchase,
sku.Name,
amount, actual,
&coupon.ID, c,
}, nil
}

560
web/services/trade.go
View File

@@ -2,6 +2,7 @@ package services
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
@@ -23,7 +24,6 @@ import (
"github.com/smartwalle/alipay/v3"
"github.com/wechatpay-apiv3/wechatpay-go/services/partnerpayments/h5"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
"gorm.io/gorm"
)
var Trade = &tradeService{}
@@ -32,72 +32,17 @@ type tradeService struct {
}
// 创建交易
func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTradeData, product ProductInfo) (*CreateTradeResult, error) {
platform := payment.Platform
method := payment.Method
tType := product.GetType()
expire := time.Now().Add(30 * time.Minute)
subject := product.GetSubject()
amount := product.GetAmount()
// 实际支付金额，只在创建真实订单时使用
amountReal := amount
if env.RunMode == env.RunModeDev {
amountReal = decimal.NewFromFloat(0.01)
func (s *tradeService) Create(uid int32, tradeData *CreateTradeData, productData *CreateResourceData) (*CreateTradeResult, error) {
detail, err := productData.TradeDetail()
if err != nil {
return nil, core.NewServErr("获取产品支付信息失败", err)
}
// 附加优惠券
if payment.CouponCode != nil {
coupon, err := q.Coupon.
Where(
q.Coupon.Code.Eq(*payment.CouponCode),
q.Coupon.Status.Eq(int(m.CouponStatusUnused)),
).
Take()
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("优惠券不存在或已失效")
}
return nil, err
}
expireAt := time.Time(u.Z(coupon.ExpireAt))
if !expireAt.IsZero() && expireAt.Before(now) {
_, err = q.Coupon.
Where(q.Coupon.ID.Eq(coupon.ID)).
Update(q.Coupon.Status, m.CouponStatusExpired)
if err != nil {
return nil, err
}
return nil, errors.New("优惠券已过期")
}
if amount.Cmp(coupon.MinAmount) < 0 {
return nil, errors.New("订单金额未达到使用优惠券的条件")
}
if coupon.UserID != nil {
switch *coupon.UserID {
// 指定用户的优惠券
case uid:
amount = amount.Sub(coupon.Amount)
if expireAt.IsZero() {
_, err = q.Coupon.
Where(q.Coupon.ID.Eq(coupon.ID)).
Update(q.Coupon.Status, int(m.CouponStatusUsed))
if err != nil {
return nil, err
}
}
// 该优惠券不属于当前用户
default:
return nil, errors.New("优惠券不属于当前用户")
}
} else {
// 公开优惠券
amount = amount.Sub(coupon.Amount)
}
}
now := time.Now()
platform := tradeData.Platform
method := tradeData.Method
expireIn := time.Duration(env.TradeExpire) * time.Second
expireAt := now.Add(expireIn)
// 生成订单号
tradeNo, err := ID.GenSerial()
@@ -105,6 +50,12 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
return nil, core.NewServErr("生成订单号失败", err)
}
// 实际支付金额，只在创建真实订单时使用
amountReal := detail.Actual
if env.RunMode == env.RunModeDev {
amountReal = decimal.NewFromFloat(0.01)
}
// 提交支付订单
var paymentUrl string
switch {
@@ -117,9 +68,9 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
Trade: alipay.Trade{
ProductCode: "FAST_INSTANT_TRADE_PAY",
OutTradeNo: tradeNo,
Subject: subject,
Subject: detail.Subject,
TotalAmount: amountReal.StringFixed(2),
TimeExpire: expire.Format("2006-01-02 15:04:05"),
TimeExpire: expireAt.Format("2006-01-02 15:04:05"),
},
})
if err != nil {
@@ -133,8 +84,8 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
Appid: &env.WechatPayAppId,
Mchid: &env.WechatPayMchId,
OutTradeNo: &tradeNo,
Description: &subject,
TimeExpire: &expire,
Description: &detail.Subject,
TimeExpire: &expireAt,
NotifyUrl: &env.WechatPayCallbackUrl,
Amount: &native.Amount{
Total: u.P(amountReal.Mul(decimal.NewFromInt(100)).Round(0).IntPart()),
@@ -151,8 +102,8 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
SpAppid: &env.WechatPayAppId,
SpMchid: &env.WechatPayMchId,
OutTradeNo: &tradeNo,
Description: &subject,
TimeExpire: &expire,
Description: &detail.Subject,
TimeExpire: &expireAt,
NotifyUrl: &env.WechatPayCallbackUrl,
Amount: &h5.Amount{
Total: u.P(amountReal.Mul(decimal.NewFromInt(100)).Round(0).IntPart()),
@@ -174,18 +125,17 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
payType = g.SftAlipay
case m.TradeMethodSftWechat:
payType = g.SftWeChat
default:
panic("unhandled default case")
}
resp, err := g.SFTPay.PaymentScanPay(&g.PaymentScanPayReq{
MchOrderNo: tradeNo,
Subject: subject,
Body: subject,
Subject: detail.Subject,
Body: detail.Subject,
Amount: amountReal.Mul(decimal.NewFromInt(100)).Round(0).IntPart(),
PayType: payType,
Currency: "cny",
ClientIp: "123.52.74.23",
OrderTimeout: u.P(expire.Format("2006-01-02 15:04:05")),
OrderTimeout: u.P(expireAt.Format("2006-01-02 15:04:05")),
})
if err != nil {
return nil, err
@@ -196,24 +146,24 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
case
method == m.TradeMethodSftAlipay && platform == m.TradePlatformMobile,
method == m.TradeMethodSftWechat && platform == m.TradePlatformMobile:
var payType g.SftPayType
switch method {
case m.TradeMethodSftAlipay:
payType = g.SftAlipay
case m.TradeMethodSftWechat:
payType = g.SftWeChat
default:
panic("unhandled default case")
}
resp, err := g.SFTPay.PaymentH5Pay(&g.PaymentH5PayReq{
MchOrderNo: tradeNo,
Subject: subject,
Body: subject,
Subject: detail.Subject,
Body: detail.Subject,
Amount: amountReal.Mul(decimal.NewFromInt(100)).Round(0).IntPart(),
PayType: payType,
Currency: "cny",
ClientIp: "123.52.74.23",
OrderTimeout: u.P(expire.Format("2006-01-02 15:04:05")),
OrderTimeout: u.P(expireAt.Format("2006-01-02 15:04:05")),
})
if err != nil {
return nil, err
@@ -230,9 +180,9 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
err = q.Trade.Create(&m.Trade{
UserID: uid,
InnerNo: tradeNo,
Type: tType,
Subject: subject,
Amount: amount,
Type: detail.Type,
Subject: detail.Subject,
Amount: detail.Actual,
Method: method,
Platform: platform,
PaymentURL: &paymentUrl,
@@ -242,7 +192,7 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
}
// 缓存产品数据
serialized, err := product.Serialize()
serialized, err := json.Marshal(detail)
if err != nil {
return nil, core.NewServErr("序列化产品信息失败", err)
}
@@ -251,286 +201,233 @@ func (s *tradeService) CreateTrade(uid int32, now time.Time, payment *CreateTrad
context.Background(),
tradeProductKey(tradeNo),
serialized,
time.Duration(env.TradeExpire+10)*time.Second,
expireIn,
).Err()
if err != nil {
return nil, core.NewServErr("保存购买信息失败", err)
}
// 提交异步关闭事件
closeAt := now.Add(time.Duration(env.TradeExpire) * time.Second)
_, err = g.Asynq.Enqueue(e.NewCancelTrade(e.CompleteTradeData{
TradeNo: tradeNo,
Method: method,
}), asynq.ProcessAt(closeAt))
_, err = g.Asynq.Enqueue(e.NewCloseTradeTask(uid, tradeNo, method), asynq.ProcessAt(expireAt))
if err != nil {
return nil, core.NewServErr("提交异步关闭事件失败", err)
}
return &CreateTradeResult{
PaymentUrl: paymentUrl,
TradeNo: tradeNo,
PayUrl: paymentUrl,
TradeNo: tradeNo,
}, nil
}
// 完成交易
func (s *tradeService) CompleteTrade(data *ModifyTradeData) error {
return g.Redsync.WithLock(tradeLockKey(data.TradeNo), func() error {
func (s *tradeService) CompleteTrade(user *m.User, ref *TradeRef) error {
// 检查订单状态
result, err := s.CheckTrade(data)
if err != nil {
return core.NewServErr("检查订单状态失败", err)
}
if result.Status != m.TradeStatusSuccess {
switch result.Status {
case m.TradeStatusPending:
return core.NewBizErr("订单未支付")
case m.TradeStatusCanceled:
return core.NewBizErr("订单已过期")
}
}
// 更新交易状态
trade, err := completeTrade(&OnTradeCompletedData{
data.TradeNo,
result.TransId,
result.Success,
})
if err != nil {
return core.NewServErr("处理交易失败", err)
}
// 处理交易完成事件
err = afterTradeComplete(trade)
if err != nil {
return core.NewServErr("处理交易完成事件失败", err)
}
return nil
})
}
func (s *tradeService) OnTradeCompleted(data *OnTradeCompletedData) error {
return g.Redsync.WithLock(tradeLockKey(data.TradeNo), func() error {
// 更新交易状态
trade, err := completeTrade(data)
if err != nil {
return core.NewServErr("处理交易失败", err)
}
// 处理交易完成事件
err = afterTradeComplete(trade)
if err != nil {
return core.NewServErr("处理交易完成事件失败", err)
}
return nil
})
}
func completeTrade(data *OnTradeCompletedData) (*m.Trade, error) {
var trade = new(m.Trade)
var err = q.Q.Transaction(func(tx *q.Query) error {
var tradeNo = data.TradeNo
var transId = data.TransId
var payment = data.Payment
var acquirer = data.Acquirer
var paidAt = data.Time
// 获取交易信息
var err error
trade, err = q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
Take()
if err != nil {
return core.NewBizErr("获取交易信息失败", err)
}
// 检查交易状态
switch trade.Status {
case m.TradeStatusCanceled:
return core.NewBizErr("交易已取消")
case m.TradeStatusSuccess:
return nil // 跳过更新交易信息
case m.TradeStatusPending:
}
// 更新交易信息
trade.Status = m.TradeStatusSuccess
trade.OuterNo = &transId
trade.Payment = payment
trade.Acquirer = u.P(acquirer)
trade.CompletedAt = u.P(paidAt)
rs, err := q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo), q.Trade.Status.Eq(int(m.TradeStatusPending))).
Updates(trade)
if rs.RowsAffected == 0 {
return core.NewBizErr("交易状态已发生变化")
}
if err != nil {
return core.NewServErr("更新交易信息失败", err)
}
return nil
})
// 检查订单状态
result, err := s.CheckTrade(ref)
if err != nil {
return nil, err
} else {
return trade, err
return core.NewServErr("检查订单状态失败", err)
}
if result.Status != m.TradeStatusSuccess {
switch result.Status {
case m.TradeStatusPending:
return core.NewBizErr("订单未支付")
case m.TradeStatusCanceled:
return core.NewBizErr("订单已过期")
}
}
// 更新交易状态
err = s.OnCompleteTrade(user, ref.TradeNo, result.TransId, &result.Success)
if err != nil {
return core.NewServErr("处理交易失败", err)
}
return nil
}
func afterTradeComplete(trade *m.Trade) error {
func (s *tradeService) OnCompleteTrade(user *m.User, interNo string, outerNo string, result *TradeSuccessResult) error {
// 获取交易信息
trade, err := q.Trade.
Where(q.Trade.InnerNo.Eq(interNo)).
Take()
if err != nil {
return core.NewBizErr("获取交易信息失败", err)
}
// 检查交易状态
switch trade.Status {
case m.TradeStatusCanceled:
return core.NewBizErr("交易已取消")
case m.TradeStatusSuccess:
return nil // 跳过更新交易信息
case m.TradeStatusPending:
}
// 恢复购买信息
productData, err := g.Redis.Get(context.Background(), tradeProductKey(trade.InnerNo)).Result()
detailStr, err := g.Redis.Get(context.Background(), tradeProductKey(interNo)).Result()
if err != nil {
return core.NewServErr("恢复购买信息失败", err)
}
// 执行资源创建
var ComplementEvents = []CompleteEvent{
ResourceOnTradeComplete{},
UserOnTradeComplete{},
var detail TradeDetail
if err := json.Unmarshal([]byte(detailStr), &detail); err != nil {
return core.NewServErr("解析购买信息失败", err)
}
for _, event := range ComplementEvents {
info, ok := event.Check(trade.Type)
if !ok {
continue
err = q.Q.Transaction(func(q *q.Query) error {
// 更新交易信息
_, err := q.Trade.
Where(
q.Trade.InnerNo.Eq(interNo),
q.Trade.Status.Eq(int(m.TradeStatusPending)),
).
UpdateSimple(
q.Trade.Status.Value(int(m.TradeStatusSuccess)),
q.Trade.OuterNo.Value(outerNo),
q.Trade.Payment.Value(result.Actual),
q.Trade.Acquirer.Value(int(result.Acquirer)),
q.Trade.CompletedAt.Value(result.Time),
)
if err != nil {
return core.NewServErr("更新交易信息失败", err)
}
err = info.Deserialize(productData)
if err != nil {
return core.NewServErr("反序列化购买信息失败", err)
switch trade.Type {
case m.TradeTypeRecharge:
// 更新用户余额
if err := User.UpdateBalance(q, user, detail.Actual); err != nil {
return err
}
// 生成账单
err = Bill.CreateForBalance(q, user.ID, trade.ID, &detail)
if err != nil {
return core.NewServErr("生成账单失败", err)
}
case m.TradeTypePurchase:
data, ok := detail.Product.(*CreateResourceData)
if !ok {
return core.NewServErr("购买信息解析失败", nil)
}
// 保存套餐
resource, err := Resource.Create(q, user.ID, result.Time, data)
if err != nil {
return core.NewServErr("创建套餐失败", err)
}
// 生成账单
err = Bill.CreateForResourceByTrade(q, user.ID, resource.ID, trade.ID, &detail)
if err != nil {
return core.NewServErr("生成账单失败", err)
}
// 核销优惠券
if detail.CouponId != nil {
err = Coupon.UseCoupon(q, *detail.CouponId)
if err != nil {
return core.NewServErr("核销优惠券失败", err)
}
}
}
err = event.OnTradeComplete(info, trade)
if err != nil {
return core.NewServErr("处理交易完成事件失败", err)
}
return nil
})
if err != nil {
return err
}
return nil
}
// 取消交易
func (s *tradeService) CancelTrade(data *ModifyTradeData, now time.Time) error {
tradeNo := data.TradeNo
method := data.Method
func (s *tradeService) CancelTrade(ref *TradeRef) error {
now := time.Now()
return g.Redsync.WithLock(tradeLockKey(tradeNo), func() error {
switch method {
case m.TradeMethodAlipay:
resp, err := g.Alipay.TradeCancel(context.Background(), alipay.TradeCancel{
OutTradeNo: tradeNo,
})
if err != nil {
return core.NewServErr("上游取消交易失败", err)
}
if resp.Code != alipay.CodeSuccess {
slog.Error("支付宝交易取消失败", "code", resp.Code, "sub_code", resp.SubCode, "msg", resp.Msg)
return errors.New("上游取消交易失败")
}
case m.TradeMethodWechat:
resp, err := g.WechatPay.Native.CloseOrder(context.Background(), native.CloseOrderRequest{
Mchid: &env.WechatPayMchId,
OutTradeNo: &tradeNo,
})
if err != nil {
return core.NewServErr("上游取消交易失败", err)
}
if resp.Response.StatusCode != http.StatusNoContent {
body, err := io.ReadAll(resp.Response.Body)
if err != nil {
slog.Error("读取微信交易取消响应失败", "error", err)
return core.NewServErr("上游取消交易失败", err)
}
slog.Error("微信交易取消失败", "code", resp.Response.StatusCode, "body", string(body))
return errors.New("上游取消交易失败")
}
case m.TradeMethodSft, m.TradeMethodSftAlipay, m.TradeMethodSftWechat:
_, err := g.SFTPay.OrderClose(&g.OrderCloseReq{
MchOrderNo: &tradeNo,
})
if err != nil {
slog.Debug(fmt.Sprintf("订单无需关闭: %s", err.Error()))
return nil
}
default:
return ErrTransactionNotSupported
}
err := cancelTrade(tradeNo, now)
switch ref.Method {
case m.TradeMethodAlipay:
resp, err := g.Alipay.TradeCancel(context.Background(), alipay.TradeCancel{
OutTradeNo: ref.TradeNo,
})
if err != nil {
return err
return core.NewServErr("上游取消交易失败", err)
}
if resp.Code != alipay.CodeSuccess {
slog.Error("支付宝交易取消失败", "code", resp.Code, "sub_code", resp.SubCode, "msg", resp.Msg)
return errors.New("上游取消交易失败")
}
return nil
})
}
func (s *tradeService) OnTradeCanceled(tradeNo string, now time.Time) error {
err := g.Redsync.WithLock(tradeLockKey(tradeNo), func() error {
return cancelTrade(tradeNo, now)
})
if err != nil {
return core.NewServErr("处理交易取消失败", err)
case m.TradeMethodWechat:
resp, err := g.WechatPay.Native.CloseOrder(context.Background(), native.CloseOrderRequest{
Mchid: &env.WechatPayMchId,
OutTradeNo: &ref.TradeNo,
})
if err != nil {
return core.NewServErr("上游取消交易失败", err)
}
if resp.Response.StatusCode != http.StatusNoContent {
body, err := io.ReadAll(resp.Response.Body)
if err != nil {
slog.Error("读取微信交易取消响应失败", "error", err)
return core.NewServErr("上游取消交易失败", err)
}
slog.Error("微信交易取消失败", "code", resp.Response.StatusCode, "body", string(body))
return errors.New("上游取消交易失败")
}
case m.TradeMethodSft, m.TradeMethodSftAlipay, m.TradeMethodSftWechat:
_, err := g.SFTPay.OrderClose(&g.OrderCloseReq{
MchOrderNo: &ref.TradeNo,
})
if err != nil {
slog.Debug(fmt.Sprintf("订单无需关闭: %s", err.Error()))
return nil
}
default:
return ErrTransactionNotSupported
}
err := s.OnCancelTrade(ref.TradeNo, now)
if err != nil {
return err
}
return nil
}
func cancelTrade(tradeNo string, now time.Time) error {
return q.Q.Transaction(func(q *q.Query) error {
// 获取交易信息
var status m.TradeStatus
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) OnCancelTrade(tradeNo string, now time.Time) error {
_, err := q.Trade.
Where(
q.Trade.InnerNo.Eq(tradeNo),
q.Trade.Status.Eq(int(m.TradeStatusPending)),
).
UpdateSimple(
q.Trade.Status.Value(int(m.TradeStatusCanceled)),
q.Trade.CanceledAt.Value(now),
)
if err != nil {
return core.NewServErr("更新交易状态失败", err)
}
// 检查交易状态
switch status {
case m.TradeStatusCanceled:
return core.NewBizErr("交易已取消")
case m.TradeStatusSuccess:
return core.NewBizErr("交易已完成")
case m.TradeStatusPending:
}
// 更新交易状态
_, err = q.Trade.
Where(q.Trade.InnerNo.Eq(tradeNo)).
UpdateSimple(
q.Trade.Status.Value(int(m.TradeStatusCanceled)),
q.Trade.CanceledAt.Value(now),
)
if err != nil {
return core.NewServErr("更新交易状态失败", err)
}
return nil
})
return nil
}
// 交易退款
func (s *tradeService) RefundTrade(data *ModifyTradeData) error {
func (s *tradeService) RefundTrade(ref *TradeRef) error {
panic("todo")
}
func (s *tradeService) OnTradeRefunded(q *q.Query, tradeNo string, now time.Time) error {
func (s *tradeService) OnRefundTrade(q *q.Query, tradeNo string, now time.Time) error {
panic("todo")
}
// 检查交易状态
func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, error) {
var tradeNo = data.TradeNo
var method = data.Method
func (s *tradeService) CheckTrade(ref *TradeRef) (*CheckTradeResult, error) {
var tradeNo = ref.TradeNo
var method = ref.Method
// 检查交易号是否存在
var result = new(CheckTradeResult)
var result CheckTradeResult
switch method {
// 支付宝
@@ -560,9 +457,8 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
case alipay.TradeStatusSuccess, alipay.TradeStatusFinished:
result.Status = m.TradeStatusSuccess
result.Success = &TradeSuccessResult{}
result.Success.Acquirer = m.TradeAcquirerAlipay
result.Success.Payment, err = decimal.NewFromString(resp.TotalAmount)
result.Success.Actual, err = decimal.NewFromString(resp.ReceiptAmount)
if err != nil {
return nil, err
}
@@ -606,9 +502,8 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
case "SUCCESS", "REFUND":
result.Status = m.TradeStatusSuccess
result.Success = &TradeSuccessResult{}
result.Success.Acquirer = m.TradeAcquirerWechat
result.Success.Payment = decimal.NewFromInt(*resp.Amount.PayerTotal).Div(decimal.NewFromInt(100))
result.Success.Actual = decimal.NewFromInt(*resp.Amount.PayerTotal).Div(decimal.NewFromInt(100))
result.Success.Time, err = time.Parse(time.RFC3339, *resp.SuccessTime)
if err != nil {
return nil, err
@@ -626,12 +521,12 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
return nil, err
}
// 填充返回值
if resp.PayOrderId == nil {
return nil, errors.New("商福通交易号不存在")
}
// 填充返回值
result.TransId = *resp.PayOrderId
switch resp.State {
case g.SftInit, g.SftTradeAwait, g.SftTradeFail:
@@ -642,7 +537,6 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
case g.SftTradeSuccess, g.SftTradeRefund, g.SftRefundIng:
result.Status = m.TradeStatusSuccess
result.Success = &TradeSuccessResult{}
switch resp.PayType {
case "WECHAT":
result.Success.Acquirer = m.TradeAcquirerWechat
@@ -651,7 +545,7 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
case "UNIONPAY":
result.Success.Acquirer = m.TradeAcquirerUnionPay
}
result.Success.Payment = decimal.NewFromInt(resp.Amount).Div(decimal.NewFromInt(100))
result.Success.Actual = decimal.NewFromInt(resp.Amount).Div(decimal.NewFromInt(100))
result.Success.Time, err = time.Parse("2006-01-02 15:04:05", *resp.PayTime)
if err != nil {
return nil, err
@@ -663,7 +557,7 @@ func (s *tradeService) CheckTrade(data *ModifyTradeData) (*CheckTradeResult, err
return nil, ErrTransactionNotSupported
}
return result, nil
return &result, nil
}
func tradeProductKey(no string) string {
@@ -675,17 +569,16 @@ func tradeLockKey(no string) string {
}
type CreateTradeData struct {
Platform m.TradePlatform `json:"platform" validate:"required"`
Method m.TradeMethod `json:"method" validate:"required"`
CouponCode *string `json:"coupon_code"`
Platform m.TradePlatform `json:"platform" validate:"required"`
Method m.TradeMethod `json:"method" validate:"required"`
}
type CreateTradeResult struct {
TradeNo string
PaymentUrl string
PayUrl string `json:"pay_url"`
TradeNo string `json:"trade_no"`
}
type ModifyTradeData struct {
type TradeRef struct {
TradeNo string `json:"trade_no" query:"trade_no" validate:"required"`
Method m.TradeMethod `json:"method" validate:"required"`
}
@@ -693,12 +586,12 @@ type ModifyTradeData struct {
type CheckTradeResult struct {
TransId string
Status m.TradeStatus
Success *TradeSuccessResult
Success TradeSuccessResult
}
type TradeSuccessResult struct {
Acquirer m.TradeAcquirer
Payment decimal.Decimal
Actual decimal.Decimal
Time time.Time
}
@@ -709,11 +602,16 @@ type OnTradeCompletedData struct {
}
type ProductInfo interface {
GetType() m.TradeType
GetSubject() string
GetAmount() decimal.Decimal
Serialize() (string, error)
Deserialize(str string) error
TradeDetail() (*TradeDetail, error)
}
type TradeDetail struct {
Type m.TradeType `json:"type"`
Subject string `json:"subject"`
Amount decimal.Decimal `json:"amount"`
Actual decimal.Decimal `json:"actual"`
CouponId *int32 `json:"coupon_id,omitempty"`
Product ProductInfo `json:"product"`
}
type CompleteEvent interface {

89
web/services/user.go
View File

@@ -1,10 +1,8 @@
package services
import (
"encoding/json"
"fmt"
"platform/web/core"
g "platform/web/globals"
m "platform/web/models"
q "platform/web/queries"
@@ -15,48 +13,29 @@ var User = &userService{}
type userService struct{}
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 = updateBalance(q, uid, info)
if err != nil {
return err
}
// 生成账单
subject := info.GetSubject()
amount := info.GetAmount()
err = q.Bill.Create(newForRecharge(uid, Bill.GenNo(), subject, amount, trade))
if err != nil {
return core.NewServErr("生成账单失败", err)
}
return nil
})
})
if err != nil {
return core.NewServErr("更新用户余额失败")
}
return nil
}
func updateBalance(q *q.Query, uid int32, info *RechargeProductInfo) error {
func (s *userService) Get(q *q.Query, uid int32) (*m.User, error) {
user, err := q.User.
Where(q.User.ID.Eq(uid)).Take()
if err != nil {
return core.NewServErr("查询用户失败", err)
return nil, core.NewServErr("查询用户失败", err)
}
return user, nil
}
amount := info.GetAmount()
func (s *userService) UpdateBalance(q *q.Query, user *m.User, amount decimal.Decimal) error {
balance := user.Balance.Add(amount)
if balance.IsNegative() {
return core.NewServErr("用户余额不足")
}
_, err = q.User.
Where(q.User.ID.Eq(user.ID)).
UpdateSimple(q.User.Balance.Value(balance))
_, err := q.User.
Where(
q.User.ID.Eq(user.ID),
q.User.Balance.Eq(user.Balance),
).
UpdateSimple(
q.User.Balance.Value(balance),
)
if err != nil {
return core.NewServErr("更新用户余额失败", err)
}
@@ -68,40 +47,16 @@ func userBalanceKey(uid int32) string {
return fmt.Sprintf("user:%d:balance", uid)
}
type RechargeProductInfo struct {
type UpdateBalanceData struct {
Amount int `json:"amount"`
}
func (r *RechargeProductInfo) GetType() m.TradeType {
return m.TradeTypeRecharge
}
func (r *RechargeProductInfo) GetSubject() string {
return fmt.Sprintf("账户充值 - %s元", 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 m.TradeType) (ProductInfo, bool) {
if t == m.TradeTypeRecharge {
return &RechargeProductInfo{}, true
}
return nil, false
}
func (u UserOnTradeComplete) OnTradeComplete(info ProductInfo, trade *m.Trade) error {
return User.UpdateBalanceByTrade(trade.UserID, info.(*RechargeProductInfo), trade)
func (c *UpdateBalanceData) TradeDetail() (*TradeDetail, error) {
amount := decimal.NewFromInt(int64(c.Amount)).Div(decimal.NewFromInt(100))
return &TradeDetail{
m.TradeTypeRecharge,
fmt.Sprintf("账户充值 - %s元", amount.StringFixed(2)),
amount, amount,
nil, c,
}, nil
}