tyc-server/pkg/core/payment/wechatpayService.go

535 lines
15 KiB
Go
Raw Normal View History

2025-05-27 18:35:01 +08:00
package payment
import (
"context"
"errors"
"fmt"
"net/http"
"sort"
"strings"
"time"
"github.com/wechatpay-apiv3/wechatpay-go/core"
"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
"github.com/wechatpay-apiv3/wechatpay-go/core/downloader"
"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
"github.com/wechatpay-apiv3/wechatpay-go/core/option"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/app"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/h5"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"
"github.com/wechatpay-apiv3/wechatpay-go/services/refunddomestic"
"github.com/wechatpay-apiv3/wechatpay-go/utils"
)
const (
TradeStateSuccess = "SUCCESS" // 支付成功
TradeStateRefund = "REFUND" // 转入退款
TradeStateNotPay = "NOTPAY" // 未支付
TradeStateClosed = "CLOSED" // 已关闭
TradeStateRevoked = "REVOKED" // 已撤销(付款码支付)
TradeStateUserPaying = "USERPAYING" // 用户支付中(付款码支付)
TradeStatePayError = "PAYERROR" // 支付失败(其他原因,如银行返回失败)
)
// WechatPayConfig 微信支付配置
type WechatPayConfig struct {
AppID string `json:"app_id"` // 应用ID
MchID string `json:"mch_id"` // 商户号
MchAPIv3Key string `json:"mch_api_v3_key"` // 商户APIv3密钥
SerialNo string `json:"serial_no"` // 商户证书序列号
PrivateKey string `json:"private_key"` // 商户私钥
NotifyURL string `json:"notify_url"` // 支付通知地址
RefundURL string `json:"refund_url"` // 退款通知地址
}
// WechatPayService 微信支付服务
type WechatPayService struct {
config WechatPayConfig
client *core.Client
jsapiService *jsapi.JsapiApiService
}
// NewWechatPayService 创建微信支付服务
func NewWechatPayService(config *WechatPayConfig) (*WechatPayService, error) {
if err := validateWechatPayConfig(config); err != nil {
return nil, err
}
// 加载商户私钥
privateKey, err := utils.LoadPrivateKey(config.PrivateKey)
if err != nil {
return nil, fmt.Errorf("加载商户私钥失败: %w", err)
}
// 创建微信支付客户端
opts := []core.ClientOption{
option.WithWechatPayAutoAuthCipher(config.MchID, config.SerialNo, privateKey, config.MchAPIv3Key),
}
client, err := core.NewClient(context.Background(), opts...)
if err != nil {
return nil, fmt.Errorf("创建微信支付客户端失败: %w", err)
}
// 下载并加载微信支付平台证书
certDownloader, err := downloader.NewCertificateDownloader(context.Background(), config.MchID, privateKey, config.MchAPIv3Key, config.SerialNo)
if err != nil {
return nil, fmt.Errorf("创建证书下载器失败: %w", err)
}
if err := certDownloader.DownloadCertificates(context.Background()); err != nil {
return nil, fmt.Errorf("下载微信支付平台证书失败: %w", err)
}
return &WechatPayService{
config: *config,
client: client,
jsapiService: &jsapi.JsapiApiService{Client: client},
}, nil
}
// CreateOrder 创建支付订单
func (w *WechatPayService) CreateOrder(order *Order) (*OrderResult, error) {
if err := validateCreateOrder(order); err != nil {
return nil, err
}
switch order.Platform {
case PlatformApp:
return w.createAppOrder(order)
case PlatformH5:
return w.createH5Order(order)
case PlatformMiniProg:
return w.createJsapiOrder(order)
default:
return nil, errors.New("不支持的支付平台")
}
}
// createAppOrder 创建APP支付订单
func (w *WechatPayService) createAppOrder(order *Order) (*OrderResult, error) {
svc := app.AppApiService{Client: w.client}
amount := &app.Amount{
Total: core.Int64(int64(order.Amount * 100)), // 转换为分
Currency: core.String("CNY"),
}
req := app.PrepayRequest{
Appid: core.String(w.config.AppID),
Mchid: core.String(w.config.MchID),
Description: core.String(order.Subject),
OutTradeNo: core.String(order.OutTradeNo),
NotifyUrl: core.String(w.config.NotifyURL),
Amount: amount,
}
resp, _, err := svc.Prepay(context.Background(), req)
if err != nil {
return nil, fmt.Errorf("创建APP支付订单失败: %w", err)
}
// 生成支付参数
params, err := w.generateAppPayParams(resp.PrepayId)
if err != nil {
return nil, err
}
return &OrderResult{
OrderNo: order.OutTradeNo,
PayParams: params,
ExpireTime: time.Now().Add(30 * time.Minute),
CreateTime: time.Now(),
}, nil
}
// createH5Order 创建H5支付订单
func (w *WechatPayService) createH5Order(order *Order) (*OrderResult, error) {
svc := h5.H5ApiService{Client: w.client}
amount := &h5.Amount{
Total: core.Int64(int64(order.Amount * 100)), // 转换为分
Currency: core.String("CNY"),
}
req := h5.PrepayRequest{
Appid: core.String(w.config.AppID),
Mchid: core.String(w.config.MchID),
Description: core.String(order.Subject),
OutTradeNo: core.String(order.OutTradeNo),
NotifyUrl: core.String(w.config.NotifyURL),
Amount: amount,
SceneInfo: &h5.SceneInfo{
PayerClientIp: core.String("127.0.0.1"), // TODO: 获取真实IP
H5Info: &h5.H5Info{
Type: core.String("Wap"),
},
},
}
resp, _, err := svc.Prepay(context.Background(), req)
if err != nil {
return nil, fmt.Errorf("创建H5支付订单失败: %w", err)
}
return &OrderResult{
OrderNo: order.OutTradeNo,
PayParams: resp.H5Url,
ExpireTime: time.Now().Add(30 * time.Minute),
CreateTime: time.Now(),
}, nil
}
// createJsapiOrder 创建小程序支付订单
func (w *WechatPayService) createJsapiOrder(order *Order) (*OrderResult, error) {
if order.OpenID == "" {
return nil, errors.New("小程序支付必须提供OpenID")
}
svc := jsapi.JsapiApiService{Client: w.client}
amount := &jsapi.Amount{
Total: core.Int64(int64(order.Amount * 100)), // 转换为分
Currency: core.String("CNY"),
}
req := jsapi.PrepayRequest{
Appid: core.String(w.config.AppID),
Mchid: core.String(w.config.MchID),
Description: core.String(order.Subject),
OutTradeNo: core.String(order.OutTradeNo),
NotifyUrl: core.String(w.config.NotifyURL),
Amount: amount,
Payer: &jsapi.Payer{
Openid: core.String(order.OpenID),
},
}
resp, _, err := svc.Prepay(context.Background(), req)
if err != nil {
return nil, fmt.Errorf("创建小程序支付订单失败: %w", err)
}
// 生成支付参数
params, err := w.generateJsapiPayParams(resp.PrepayId)
if err != nil {
return nil, err
}
return &OrderResult{
OrderNo: order.OutTradeNo,
PayParams: params,
ExpireTime: time.Now().Add(30 * time.Minute),
CreateTime: time.Now(),
}, nil
}
// Refund 申请退款
func (w *WechatPayService) Refund(refund *Refund) (*RefundResult, error) {
if err := validateRefund(refund); err != nil {
return nil, err
}
svc := refunddomestic.RefundsApiService{Client: w.client}
amount := &refunddomestic.AmountReq{
Refund: core.Int64(int64(refund.RefundAmount * 100)), // 转换为分
Total: core.Int64(int64(refund.TotalAmount * 100)), // 转换为分
Currency: core.String("CNY"),
}
req := refunddomestic.CreateRequest{
OutTradeNo: core.String(refund.OrderNo),
OutRefundNo: core.String(refund.RefundNo),
Reason: core.String(refund.Reason),
NotifyUrl: core.String(refund.NotifyURL),
Amount: amount,
}
resp, _, err := svc.Create(context.Background(), req)
if err != nil {
return nil, fmt.Errorf("申请退款失败: %w", err)
}
return &RefundResult{
OrderNo: refund.OrderNo,
RefundNo: refund.RefundNo,
RefundID: *resp.RefundId,
Status: string(*resp.Status),
RefundTime: time.Now(),
RefundAmount: refund.RefundAmount,
}, nil
}
// QueryOrder 查询订单
func (w *WechatPayService) QueryOrder(query *OrderQuery) (*OrderQueryResult, error) {
if err := validateOrderQuery(query); err != nil {
return nil, err
}
var resp *payments.Transaction
var err error
if query.TransactionID != "" {
resp, _, err = w.jsapiService.QueryOrderById(context.Background(),
jsapi.QueryOrderByIdRequest{
TransactionId: core.String(query.TransactionID),
})
} else {
resp, _, err = w.jsapiService.QueryOrderByOutTradeNo(context.Background(),
jsapi.QueryOrderByOutTradeNoRequest{
OutTradeNo: core.String(query.OrderNo),
Mchid: core.String(w.config.MchID),
})
}
if err != nil {
return nil, fmt.Errorf("查询订单失败: %w", err)
}
// 转换支付状态
status := convertWechatPayStatus(*resp.TradeState)
// 解析支付时间
payTime, _ := time.Parse(time.RFC3339, *resp.SuccessTime)
return &OrderQueryResult{
OrderNo: *resp.OutTradeNo,
TransactionID: *resp.TransactionId,
Status: status,
Amount: float64(*resp.Amount.Total) / 100, // 转换为元
PayTime: payTime,
PayMethod: MethodWechat,
Platform: getWechatPayPlatform(*resp.TradeType),
}, nil
}
// HandlePaymentNotification 处理支付结果通知
func (w *WechatPayService) HandlePaymentNotification(r *http.Request) (*OrderQueryResult, error) {
// 初始化通知处理器
handler := notify.NewNotifyHandler(w.config.MchAPIv3Key, verifiers.NewSHA256WithRSAVerifier(downloader.MgrInstance().GetCertificateVisitor(w.config.MchID)))
// 解析通知数据
transaction := new(payments.Transaction)
notifyReq, err := handler.ParseNotifyRequest(context.Background(), r, transaction)
if err != nil {
return nil, fmt.Errorf("解析支付通知失败: %w", err)
}
// 验证通知数据
if notifyReq.EventType != "TRANSACTION.SUCCESS" {
return nil, errors.New("非支付成功通知")
}
// 转换支付状态
status := convertWechatPayStatus(*transaction.TradeState)
// 解析支付时间
payTime, _ := time.Parse(time.RFC3339, *transaction.SuccessTime)
return &OrderQueryResult{
OrderNo: *transaction.OutTradeNo,
TransactionID: *transaction.TransactionId,
Status: status,
Amount: float64(*transaction.Amount.Total) / 100, // 转换为元
PayTime: payTime,
PayMethod: MethodWechat,
Platform: getWechatPayPlatform(*transaction.TradeType),
}, nil
}
// 生成APP支付参数
func (w *WechatPayService) generateAppPayParams(prepayID *string) (map[string]string, error) {
if prepayID == nil {
return nil, errors.New("预支付ID不能为空")
}
params := make(map[string]string)
params["appid"] = w.config.AppID
params["partnerid"] = w.config.MchID
params["prepayid"] = *prepayID
params["package"] = "Sign=WXPay"
nonce, err := utils.GenerateNonce()
if err != nil {
return nil, fmt.Errorf("生成随机字符串失败: %w", err)
}
params["noncestr"] = nonce
params["timestamp"] = fmt.Sprintf("%d", time.Now().Unix())
// 生成签名
sign, err := w.signParams(params)
if err != nil {
return nil, err
}
params["sign"] = sign
return params, nil
}
// 生成小程序支付参数
func (w *WechatPayService) generateJsapiPayParams(prepayID *string) (map[string]string, error) {
if prepayID == nil {
return nil, errors.New("预支付ID不能为空")
}
params := make(map[string]string)
params["appId"] = w.config.AppID
params["timeStamp"] = fmt.Sprintf("%d", time.Now().Unix())
nonce, err := utils.GenerateNonce()
if err != nil {
return nil, fmt.Errorf("生成随机字符串失败: %w", err)
}
params["nonceStr"] = nonce
params["package"] = "prepay_id=" + *prepayID
params["signType"] = "RSA"
// 生成签名
sign, err := w.signParams(params)
if err != nil {
return nil, err
}
params["paySign"] = sign
return params, nil
}
// 签名参数
func (w *WechatPayService) signParams(params map[string]string) (string, error) {
// 按字典序排序参数
var keys []string
for k := range params {
keys = append(keys, k)
}
sort.Strings(keys)
var pairs []string
for _, k := range keys {
pairs = append(pairs, fmt.Sprintf("%s=%s", k, params[k]))
}
message := strings.Join(pairs, "&")
// 使用商户私钥签名
privateKey, err := utils.LoadPrivateKey(w.config.PrivateKey)
if err != nil {
return "", fmt.Errorf("加载商户私钥失败: %w", err)
}
signature, err := utils.SignSHA256WithRSA(message, privateKey)
if err != nil {
return "", fmt.Errorf("签名失败: %w", err)
}
return signature, nil
}
// 转换微信支付状态
func convertWechatPayStatus(tradeState string) PaymentStatus {
switch tradeState {
case "SUCCESS":
return StatusSuccess
case "REFUND":
return StatusRefunded
case "NOTPAY":
return StatusPending
case "CLOSED":
return StatusClosed
case "PAYERROR":
return StatusFailed
default:
return StatusPending
}
}
// 获取微信支付平台
func getWechatPayPlatform(tradeType string) PaymentPlatform {
switch tradeType {
case "APP":
return PlatformApp
case "JSAPI":
return PlatformMiniProg
case "NATIVE", "MWEB":
return PlatformH5
default:
return PlatformApp
}
}
// 验证微信支付配置
func validateWechatPayConfig(config *WechatPayConfig) error {
if config == nil {
return errors.New("配置不能为空")
}
if config.AppID == "" {
return errors.New("应用ID不能为空")
}
if config.MchID == "" {
return errors.New("商户号不能为空")
}
if config.MchAPIv3Key == "" {
return errors.New("商户APIv3密钥不能为空")
}
if config.SerialNo == "" {
return errors.New("商户证书序列号不能为空")
}
if config.PrivateKey == "" {
return errors.New("商户私钥不能为空")
}
if config.NotifyURL == "" {
return errors.New("支付通知地址不能为空")
}
return nil
}
// 验证创建订单参数
func validateCreateOrder(order *Order) error {
if order == nil {
return errors.New("订单信息不能为空")
}
if order.OutTradeNo == "" {
return errors.New("商户订单号不能为空")
}
if order.Subject == "" {
return errors.New("商品描述不能为空")
}
if order.Amount <= 0 {
return errors.New("支付金额必须大于0")
}
if order.NotifyURL == "" {
return errors.New("通知地址不能为空")
}
return nil
}
// 验证退款参数
func validateRefund(refund *Refund) error {
if refund == nil {
return errors.New("退款信息不能为空")
}
if refund.OrderNo == "" {
return errors.New("商户订单号不能为空")
}
if refund.RefundNo == "" {
return errors.New("商户退款单号不能为空")
}
if refund.RefundAmount <= 0 {
return errors.New("退款金额必须大于0")
}
if refund.TotalAmount <= 0 {
return errors.New("订单总金额必须大于0")
}
if refund.RefundAmount > refund.TotalAmount {
return errors.New("退款金额不能大于订单总金额")
}
if refund.NotifyURL == "" {
return errors.New("退款通知地址不能为空")
}
return nil
}
// 验证订单查询参数
func validateOrderQuery(query *OrderQuery) error {
if query == nil {
return errors.New("查询参数不能为空")
}
if query.OrderNo == "" && query.TransactionID == "" {
return errors.New("商户订单号和交易号不能同时为空")
}
return nil
}
// GenerateOutTradeNo 生成商户订单号
func (w *WechatPayService) GenerateOutTradeNo() string {
return GenerateOrderNo(WechatPrefix)
}