401 lines
8.8 KiB
Go
401 lines
8.8 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"platform/pkg/env"
|
|
"platform/pkg/u"
|
|
"platform/web/core"
|
|
g "platform/web/globals"
|
|
m "platform/web/models"
|
|
q "platform/web/queries"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/smartwalle/alipay/v3"
|
|
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var Transaction = &transactionService{}
|
|
|
|
type transactionService struct {
|
|
}
|
|
|
|
func (s *transactionService) PrepareTransaction(ctx context.Context, q *q.Query, uid int32, data *TransactionPrepareData) (*TransactionPrepareResult, error) {
|
|
var subject = data.Subject
|
|
var expire = data.ExpireAt
|
|
var tType = data.Type
|
|
var method = data.Method
|
|
var amount = data.Amount
|
|
|
|
// 实际支付金额，只在创建真实订单时使用
|
|
var amountReal = data.Amount
|
|
if env.RunMode == "debug" {
|
|
amountReal = 0.01
|
|
}
|
|
|
|
// 附加优惠券
|
|
if data.CouponCode != "" {
|
|
coupon, err := q.Coupon.WithContext(ctx).
|
|
Where(
|
|
q.Coupon.Code.Eq(data.CouponCode),
|
|
q.Coupon.Status.Eq(0),
|
|
).
|
|
Take()
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, errors.New("优惠券不存在或已失效")
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
var expireAt = time.Time(coupon.ExpireAt)
|
|
if !expireAt.IsZero() && expireAt.Before(time.Now()) {
|
|
_, err = q.Coupon.
|
|
Where(q.Coupon.ID.Eq(coupon.ID)).
|
|
Update(q.Coupon.Status, 2)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return nil, errors.New("优惠券已过期")
|
|
}
|
|
|
|
if data.Amount < coupon.MinAmount {
|
|
return nil, errors.New("订单金额未达到使用优惠券的条件")
|
|
}
|
|
|
|
switch {
|
|
// 该优惠券不属于当前用户
|
|
default:
|
|
return nil, errors.New("优惠券不属于当前用户")
|
|
|
|
// 公开优惠券
|
|
case coupon.UserID == 0:
|
|
amount = amount - coupon.Amount
|
|
|
|
// 指定用户的优惠券
|
|
case coupon.UserID == uid:
|
|
amount = amount - coupon.Amount
|
|
if time.Time(coupon.ExpireAt).IsZero() {
|
|
_, err = q.Coupon.
|
|
Where(q.Coupon.ID.Eq(coupon.ID)).
|
|
Update(q.Coupon.Status, 1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 生成订单号
|
|
tradeNo, err := ID.GenSerial(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 创建支付订单
|
|
var payUrl string
|
|
switch method {
|
|
|
|
// 调用支付宝支付接口
|
|
case TransactionMethodAlipay:
|
|
resp, err := g.Alipay.TradePagePay(alipay.TradePagePay{
|
|
QRPayMode: "4",
|
|
Trade: alipay.Trade{
|
|
ProductCode: "FAST_INSTANT_TRADE_PAY",
|
|
OutTradeNo: tradeNo,
|
|
Subject: subject,
|
|
TotalAmount: strconv.FormatFloat(amountReal, 'f', 2, 64),
|
|
TimeExpire: expire.Format("2006-01-02 15:04:05"),
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payUrl = resp.String()
|
|
|
|
// 调用微信支付接口
|
|
case TransactionMethodWeChat:
|
|
resp, _, err := g.WechatPay.Native.Prepay(ctx, native.PrepayRequest{
|
|
Appid: &env.WechatPayAppId,
|
|
Mchid: &env.WechatPayMchId,
|
|
OutTradeNo: &tradeNo,
|
|
Description: &subject,
|
|
TimeExpire: &expire,
|
|
NotifyUrl: &env.WechatPayCallbackUrl,
|
|
Amount: &native.Amount{
|
|
Total: u.P(int64(amountReal * 100)),
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payUrl = *resp.CodeUrl
|
|
|
|
// 不支持的支付方式
|
|
default:
|
|
return nil, ErrTransactionNotSupported
|
|
}
|
|
|
|
// 保存交易订单
|
|
var tradeType int
|
|
var billType int
|
|
switch tType {
|
|
case TransactionTypeRecharge:
|
|
tradeType = 2
|
|
billType = 3
|
|
case TransactionTypePurchase:
|
|
tradeType = 1
|
|
billType = 1
|
|
}
|
|
|
|
var trade = m.Trade{
|
|
UserID: uid,
|
|
InnerNo: tradeNo,
|
|
Subject: subject,
|
|
Method: int32(method),
|
|
Type: int32(tradeType),
|
|
Amount: amount,
|
|
PayURL: payUrl,
|
|
}
|
|
err = q.Trade.Create(&trade)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 保存用户帐单
|
|
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)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &TransactionPrepareResult{
|
|
TradeNo: tradeNo,
|
|
PayURL: payUrl,
|
|
Bill: &bill,
|
|
Trade: &trade,
|
|
}, nil
|
|
}
|
|
|
|
func (s *transactionService) VerifyTransaction(ctx context.Context, data *TransactionVerifyData) (*TransactionVerifyResult, error) {
|
|
var tradeNo = data.TradeNo
|
|
var method = data.Method
|
|
|
|
// 检查交易号是否存在
|
|
var transId string
|
|
var paidAt time.Time
|
|
var payment float64
|
|
switch method {
|
|
|
|
// 检查支付宝交易
|
|
case TransactionMethodAlipay:
|
|
resp, err := g.Alipay.TradeQuery(ctx, alipay.TradeQuery{
|
|
OutTradeNo: tradeNo,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.Code != alipay.CodeSuccess {
|
|
slog.Warn("支付宝交易查询失败", "code", resp.Code, "sub_code", resp.SubCode, "msg", resp.Msg)
|
|
return nil, errors.New("交易查询失败")
|
|
}
|
|
if resp.TradeStatus != alipay.TradeStatusSuccess {
|
|
return nil, ErrTransactionNotPaid
|
|
}
|
|
|
|
transId = resp.TradeNo
|
|
payment, err = strconv.ParseFloat(resp.TotalAmount, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
paidAt, err = time.Parse("2006-01-02 15:04:05", resp.SendPayDate)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 检查微信交易
|
|
case TransactionMethodWeChat:
|
|
resp, _, err := g.WechatPay.Native.QueryOrderByOutTradeNo(ctx, native.QueryOrderByOutTradeNoRequest{
|
|
OutTradeNo: &tradeNo,
|
|
Mchid: &env.WechatPayMchId,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if *resp.TradeState != "SUCCESS" {
|
|
return nil, ErrTransactionNotPaid
|
|
}
|
|
|
|
transId = *resp.TransactionId
|
|
payment = float64(*resp.Amount.PayerTotal) / 100
|
|
paidAt, err = time.Parse(time.RFC3339, *resp.SuccessTime)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 不支持的支付方式
|
|
default:
|
|
return nil, ErrTransactionNotSupported
|
|
}
|
|
|
|
return &TransactionVerifyResult{
|
|
TransId: transId,
|
|
Payment: payment,
|
|
Time: paidAt,
|
|
}, nil
|
|
}
|
|
|
|
func (s *transactionService) CompleteTransaction(ctx context.Context, q *q.Query, data *TransactionCompleteData) (*TransactionCompleteResult, error) {
|
|
var transId = data.TransId
|
|
var tradeNo = data.TradeNo
|
|
var payment = data.Payment
|
|
var paidAt = data.Time
|
|
|
|
// 获取交易信息
|
|
trade, err := q.Trade.WithContext(ctx).
|
|
Where(q.Trade.InnerNo.Eq(tradeNo)).
|
|
First()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 检查交易状态
|
|
if trade.Status != 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
// 更新交易状态
|
|
trade.Status = 1
|
|
trade.OuterNo = transId
|
|
trade.Payment = payment
|
|
trade.PaidAt = core.LocalDateTime(paidAt)
|
|
trade.PayURL = ""
|
|
_, err = q.Trade.WithContext(ctx).Updates(trade)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &TransactionCompleteResult{
|
|
Trade: trade,
|
|
}, nil
|
|
}
|
|
|
|
func (s *transactionService) RevokeTransaction(ctx context.Context, tradeNo string, method TransactionMethod) error {
|
|
|
|
switch method {
|
|
|
|
case TransactionMethodAlipay:
|
|
resp, err := g.Alipay.TradeCancel(ctx, 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 TransactionMethodWeChat:
|
|
resp, err := g.WechatPay.Native.CloseOrder(ctx, 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("交易取消失败")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *transactionService) FinishTransaction(ctx context.Context, q *q.Query, tradeNo string, time 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: 2,
|
|
CancelAt: core.LocalDateTime(time),
|
|
PayURL: "",
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type TransactionType int32
|
|
|
|
const (
|
|
TransactionTypePurchase TransactionType = iota + 1
|
|
TransactionTypeRecharge
|
|
)
|
|
|
|
type TransactionMethod int32
|
|
|
|
const (
|
|
TransactionMethodAlipay TransactionMethod = iota
|
|
TransactionMethodWeChat
|
|
)
|
|
|
|
type TransactionPrepareData struct {
|
|
Subject string
|
|
Amount float64
|
|
ExpireAt time.Time
|
|
Type TransactionType
|
|
Method TransactionMethod
|
|
CouponCode string
|
|
}
|
|
|
|
type TransactionPrepareResult struct {
|
|
TradeNo string
|
|
PayURL string
|
|
Bill *m.Bill
|
|
Trade *m.Trade
|
|
}
|
|
|
|
type TransactionVerifyData struct {
|
|
TradeNo string
|
|
Method TransactionMethod
|
|
}
|
|
|
|
type TransactionVerifyResult struct {
|
|
TransId string
|
|
Payment float64
|
|
Time time.Time
|
|
}
|
|
|
|
type TransactionCompleteData struct {
|
|
TradeNo string
|
|
TransactionVerifyResult
|
|
}
|
|
|
|
type TransactionCompleteResult struct {
|
|
Trade *m.Trade
|
|
}
|
|
|
|
var (
|
|
ErrTransactionNotPaid = core.NewErr("transaction", "交易未完成")
|
|
ErrTransactionNotSupported = core.NewErr("transaction", "不支持的支付方式")
|
|
)
|