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

web/services/trade.go

@@ -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 {