eta_mini_ht_api/controllers/payment/payment_controller.go

package payment

import (
	"errors"
	"eta/eta_mini_ht_api/common/exception"
	"eta/eta_mini_ht_api/common/utils/lock"
	payUtils "eta/eta_mini_ht_api/common/utils/payment"
	"eta/eta_mini_ht_api/common/utils/redis"
	"eta/eta_mini_ht_api/controllers"
	orderDomian "eta/eta_mini_ht_api/domian/order"
	userDomian "eta/eta_mini_ht_api/domian/user"
	"eta/eta_mini_ht_api/service/facade"
	"eta/eta_mini_ht_api/service/order"
	"gorm.io/gorm"
)
import "eta/eta_mini_ht_api/service/user"

type PaymentController struct {
	controllers.BaseController
}

// 支付
type PayRequest struct {
	ProductOrderNo string `json:"productOrderNo"`
}
type PayResponse struct {
	PaymentUrl   string `json:"paymentUrl"`
	PaymentToken string `json:"paymentToken"`
}

// PayOrder  支付订单
// @Summary 支付订单
// @Description 支付订单
// @Success 200 {object} controllers.BaseResponse
// @router /payOrder [post]
func (pc *PaymentController) PayOrder() {
	controllers.Wrap(&pc.BaseController, func() (result *controllers.WrapData, err error) {
		result = pc.InitWrapData("创建支付订单失败")
		payRequest := new(PayRequest)
		pc.GetPostParams(payRequest)
		if payRequest.ProductOrderNo == "" {
			pc.FailedResult("订单编号不能为空", result)
			err = exception.New(exception.IllegalOrderNo)
			return
		}
		userInfo := pc.Data["user"].(user.User)
		defer func() {
			lock.ReleaseLock(redis.GeneratePaymentKey(payRequest.ProductOrderNo), pc.Data["threadId"].(string))
		}()
		if lock.AcquireLock(redis.GeneratePaymentKey(payRequest.ProductOrderNo), 10, pc.Data["threadId"].(string)) {
			//校验商品订单状态
			var productOrder orderDomian.ProductOrderDTO
			productOrder, err = order.GetProductOrderByUser(userInfo.Id, payRequest.ProductOrderNo)
			if err != nil {
				if errors.Is(err, gorm.ErrRecordNotFound) {
					pc.FailedResult("支付失败,商品订单信息不存在", result)
					err = exception.New(exception.IllegalOrderNo)
				} else {
					pc.FailedResult("支付失败,查询商品订单失败", result)
					err = exception.New(exception.IllegalOrderNo)
				}
				return
			}
			if productOrder.Status != "pending" {
				if productOrder.Status == "closed" {
					pc.FailedResult("支付失败,商品订单已关闭", result)
					err = exception.New(exception.IllegalOrderStatus)
				} else {
					pc.FailedResult("支付失败,商品订单状态异常", result)
					err = exception.New(exception.IllegalOrderStatus)
				}
				return
			}
			//1、未发起支付,2、支付到一半退出了，3、支付中
			if productOrder.TradeNo != "" {
				tradeOrder, tradeErr := order.GetTradeOrderByNo(productOrder.TradeNo)
				if tradeErr != nil {
					err = exception.NewWithException(exception.PayTradeOrderFailed, tradeErr.Error())
					pc.FailedResult("支付失败,获取原支付订单信息失败", result)
					return
				}
				if tradeOrder.PaymentStatus != "failed" {
					err = exception.New(exception.PayTradeOrderFailed)
					pc.FailedResult("支付失败,商品订单支付中,请勿重复支付", result)
					return
				}
			}
			//检查商品状态
			err = order.CheckProductStatus(productOrder)
			if err != nil {
				pc.FailedResult("支付失败,商品状态异常", result)
				return
			}
			var officialUser userDomian.OfficialUserDTO
			officialUser, err = user.GetUserByTemplateUserId(userInfo.Id)
			if err != nil {
				pc.FailedResult("支付失败,正式用户信息不存在", result)
			}
			var payOrderDTO orderDomian.PayOrderDTO
			payOrderDTO, err = facade.PayOrder(officialUser.ID, userInfo.Id, productOrder)
			if err != nil {
				pc.FailedResult("支付订单创建失败", result)
				err = exception.NewWithException(exception.CreatePaymentOrderFailed, err.Error())
				return
			}
			//将参数填充为URL地址直接返回前端
			url, parseErr := orderDomian.CreatePaymentUrl(payOrderDTO)
			if parseErr != nil {
				pc.FailedResult("生成订单链接失败", result)
				err = exception.NewWithException(exception.CreatePaymentOrderFailed, err.Error())
				return
			}
			pc.SuccessResult("支付订单创建成功", PayResponse{
				PaymentToken: payOrderDTO.PaymentToken,
				PaymentUrl:   url,
			}, result)
			return
		} else {
			pc.FailedResult("商品订单处理中,请稍后再试", result)
			err = exception.New(exception.PaymentProcessingError)
			return
		}
	})
}

// PayOrderStatus 获取微信订单状态
// @Summary 获取微信订单状态
// @Description 获取微信订单状态
// @Success 200 {object} controllers.BaseResponse
// @router /payOrderStatus [get]
func (pc *PaymentController) PayOrderStatus(token string) {
	controllers.Wrap(&pc.BaseController, func() (result *controllers.WrapData, err error) {
		result = pc.InitWrapData("获取微信订单信息失败")
		if token == "" {
			pc.FailedResult("token", result)
			err = exception.New(exception.IllegalWechatToken)
			return
		}
		paymentParams, err := payUtils.GetPaymentParam(token)
		if err != nil {
			pc.FailedResult("微信订单信息不存在", result)
			err = exception.NewWithException(exception.GetPaymentTokenFailed, err.Error())
			return
		}

		if paymentParams.Status == payUtils.EXPIRED {
			pc.FailedResult("订单超时,请重新支付", result)
			err = exception.New(exception.GetPaymentTokenFailed)
			return
		}
		if paymentParams.Status == payUtils.USED {
			pc.FailedResult("请勿重复发起微信支付", result)
			err = exception.New(exception.GetPaymentTokenFailed)
			return
		}
		if paymentParams.Status == payUtils.PENDING {
			pc.FailedResult("微信支付发起中,请耐心等待", result)
			err = exception.New(exception.GetPaymentTokenFailed)
			return
		}
		if paymentParams.Status == payUtils.READY {
			//查询到就绪之后将token状态重置为已用
			pc.SuccessResult("支付订单创建成功", paymentParams, result)
			return
		}
		return
	})
}

//