317 lines
9.5 KiB
Go
317 lines
9.5 KiB
Go
package payment
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"hfb_sys/backend/internal/integrations/payment/lakala"
|
|
"hfb_sys/backend/internal/integrations/payment/leshua"
|
|
"hfb_sys/backend/internal/integrations/payment/shuncheng"
|
|
"hfb_sys/backend/internal/middleware"
|
|
"hfb_sys/backend/internal/modules/order"
|
|
"hfb_sys/backend/pkg/response"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"go.uber.org/zap"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type Handler struct {
|
|
service *Service
|
|
logger *zap.Logger
|
|
}
|
|
|
|
func NewHandler(service *Service, options ...HandlerOption) *Handler {
|
|
handler := &Handler{
|
|
service: service,
|
|
logger: zap.NewNop(),
|
|
}
|
|
for _, option := range options {
|
|
option(handler)
|
|
}
|
|
if handler.logger == nil {
|
|
handler.logger = zap.NewNop()
|
|
}
|
|
return handler
|
|
}
|
|
|
|
type HandlerOption func(*Handler)
|
|
|
|
// WithHandlerLogger 为支付 HTTP 处理器注入结构化日志器。
|
|
func WithHandlerLogger(logger *zap.Logger) HandlerOption {
|
|
return func(handler *Handler) {
|
|
if logger != nil {
|
|
handler.logger = logger
|
|
}
|
|
}
|
|
}
|
|
|
|
func (h *Handler) log() *zap.Logger {
|
|
if h == nil || h.logger == nil {
|
|
return zap.NewNop()
|
|
}
|
|
return h.logger
|
|
}
|
|
|
|
func notifyLogFields(ctx context.Context, provider string, params map[string]string, contentType string, bodySize int, fields ...zap.Field) []zap.Field {
|
|
base := paymentLogFields(ctx,
|
|
zap.String("provider", provider),
|
|
zap.String("third_order_id", params["third_order_id"]),
|
|
zap.String("provider_order_id", firstNonEmpty(params["provider_order_id"], params["leshua_order_id"], params["schc_order_id"])),
|
|
zap.String("merchant_refund_id", params["merchant_refund_id"]),
|
|
zap.String("provider_refund_id", firstNonEmpty(params["provider_refund_id"], params["leshua_refund_id"], params["schc_refund_id"])),
|
|
zap.String("status", params["status"]),
|
|
zap.String("amount", params["amount"]),
|
|
zap.String("content_type", contentType),
|
|
zap.Int("body_size", bodySize),
|
|
)
|
|
return append(base, fields...)
|
|
}
|
|
|
|
func (h *Handler) Start(c *gin.Context) {
|
|
userID, ok := currentUserID(c)
|
|
if !ok {
|
|
response.Unauthorized(c, "缺少用户上下文")
|
|
return
|
|
}
|
|
orderID, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
var req StartPaymentRequest
|
|
_ = c.ShouldBindJSON(&req)
|
|
item, err := h.service.Start(c.Request.Context(), userID, orderID, req, c.ClientIP())
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, item)
|
|
}
|
|
|
|
func (h *Handler) StartMohong(c *gin.Context) {
|
|
userID, ok := currentUserID(c)
|
|
if !ok {
|
|
response.Unauthorized(c, "缺少用户上下文")
|
|
return
|
|
}
|
|
orderID, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
var req StartPaymentRequest
|
|
_ = c.ShouldBindJSON(&req)
|
|
item, err := h.service.StartMohong(c.Request.Context(), userID, orderID, req, c.ClientIP())
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, item)
|
|
}
|
|
|
|
func (h *Handler) Query(c *gin.Context) {
|
|
userID, ok := currentUserID(c)
|
|
if !ok {
|
|
response.Unauthorized(c, "缺少用户上下文")
|
|
return
|
|
}
|
|
orderID, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, err := h.service.Query(c.Request.Context(), userID, orderID)
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, item)
|
|
}
|
|
|
|
func (h *Handler) QueryMohong(c *gin.Context) {
|
|
userID, ok := currentUserID(c)
|
|
if !ok {
|
|
response.Unauthorized(c, "缺少用户上下文")
|
|
return
|
|
}
|
|
orderID, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, err := h.service.QueryMohong(c.Request.Context(), userID, orderID)
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, item)
|
|
}
|
|
|
|
func (h *Handler) QueryRefundStatus(c *gin.Context) {
|
|
orderID, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
item, err := h.service.QueryRefundStatus(c.Request.Context(), orderID)
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, item)
|
|
}
|
|
|
|
func (h *Handler) AdminList(c *gin.Context) {
|
|
query, ok := parseAdminPaymentQuery(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
result, err := h.service.AdminList(c.Request.Context(), query)
|
|
if err != nil {
|
|
writePaymentError(c, err)
|
|
return
|
|
}
|
|
response.OK(c, result)
|
|
}
|
|
|
|
func (h *Handler) LeshuaNotify(c *gin.Context) {
|
|
body, err := io.ReadAll(io.LimitReader(c.Request.Body, 1<<20))
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "FAIL")
|
|
return
|
|
}
|
|
params, err := leshua.ParsePayload(body)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, "FAIL")
|
|
return
|
|
}
|
|
rawPayload := string(body)
|
|
contentType := c.GetHeader("Content-Type")
|
|
h.log().Info("payment notify received", notifyLogFields(c.Request.Context(), "leshua", params, contentType, len(body))...)
|
|
result, err := h.service.HandleLeshuaNotify(c.Request.Context(), params, rawPayload, contentType)
|
|
if err != nil || result == nil || !result.OK {
|
|
h.log().Warn("payment notify failed", notifyLogFields(c.Request.Context(), "leshua", params, contentType, len(body), zap.Error(err))...)
|
|
c.String(http.StatusOK, "FAIL")
|
|
return
|
|
}
|
|
h.log().Info("payment notify processed", notifyLogFields(c.Request.Context(), "leshua", params, contentType, len(body))...)
|
|
c.String(http.StatusOK, result.Message)
|
|
}
|
|
|
|
func (h *Handler) LakalaNotify(c *gin.Context) {
|
|
body, err := io.ReadAll(io.LimitReader(c.Request.Body, 1<<20))
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, gin.H{"code": "FAIL", "message": "读取失败"})
|
|
return
|
|
}
|
|
params, err := lakala.ParsePayload(body)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, gin.H{"code": "FAIL", "message": "解析失败"})
|
|
return
|
|
}
|
|
rawPayload := string(body)
|
|
contentType := c.GetHeader("Content-Type")
|
|
authorization := c.GetHeader("Authorization")
|
|
h.log().Info("payment notify received", notifyLogFields(c.Request.Context(), "lakala", params, contentType, len(body))...)
|
|
result, err := h.service.HandleNotify(c.Request.Context(), "lakala", params, rawPayload, contentType, authorization)
|
|
if err != nil || result == nil || !result.OK {
|
|
h.log().Warn("payment notify failed", notifyLogFields(c.Request.Context(), "lakala", params, contentType, len(body), zap.Error(err))...)
|
|
c.JSON(http.StatusOK, gin.H{"code": "FAIL", "message": "失败"})
|
|
return
|
|
}
|
|
h.log().Info("payment notify processed", notifyLogFields(c.Request.Context(), "lakala", params, contentType, len(body))...)
|
|
c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "执行成功"})
|
|
}
|
|
|
|
func (h *Handler) ShunchengNotify(c *gin.Context) {
|
|
body, err := io.ReadAll(io.LimitReader(c.Request.Body, 1<<20))
|
|
if err != nil {
|
|
c.String(http.StatusOK, "FAIL")
|
|
return
|
|
}
|
|
params, err := shuncheng.ParsePayload(body)
|
|
if err != nil {
|
|
c.String(http.StatusOK, "FAIL")
|
|
return
|
|
}
|
|
rawPayload := string(body)
|
|
contentType := c.GetHeader("Content-Type")
|
|
authorization := c.GetHeader("Authorization")
|
|
h.log().Info("payment notify received", notifyLogFields(c.Request.Context(), "shuncheng", params, contentType, len(body))...)
|
|
result, err := h.service.HandleNotify(c.Request.Context(), "shuncheng", params, rawPayload, contentType, authorization)
|
|
if err != nil || result == nil || !result.OK {
|
|
h.log().Warn("payment notify failed", notifyLogFields(c.Request.Context(), "shuncheng", params, contentType, len(body), zap.Error(err))...)
|
|
c.String(http.StatusOK, "FAIL")
|
|
return
|
|
}
|
|
h.log().Info("payment notify processed", notifyLogFields(c.Request.Context(), "shuncheng", params, contentType, len(body))...)
|
|
c.String(http.StatusOK, result.Message)
|
|
}
|
|
|
|
func currentUserID(c *gin.Context) (uint64, bool) {
|
|
value, ok := c.Get(middleware.ContextUserID)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
userID, ok := value.(uint64)
|
|
return userID, ok
|
|
}
|
|
|
|
func parseID(c *gin.Context) (uint64, bool) {
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
response.BadRequest(c, "ID 不正确")
|
|
return 0, false
|
|
}
|
|
return id, true
|
|
}
|
|
|
|
func parseAdminPaymentQuery(c *gin.Context) (AdminPaymentQuery, bool) {
|
|
var query AdminPaymentQuery
|
|
if raw := c.Query("user_id"); raw != "" {
|
|
value, err := strconv.ParseUint(raw, 10, 64)
|
|
if err != nil || value == 0 {
|
|
response.BadRequest(c, "用户ID不正确")
|
|
return query, false
|
|
}
|
|
query.UserID = value
|
|
}
|
|
if raw := c.Query("order_id"); raw != "" {
|
|
value, err := strconv.ParseUint(raw, 10, 64)
|
|
if err != nil || value == 0 {
|
|
response.BadRequest(c, "订单ID不正确")
|
|
return query, false
|
|
}
|
|
query.OrderID = value
|
|
}
|
|
query.OrderNo = c.Query("order_no")
|
|
query.BizType = c.Query("biz_type")
|
|
query.Status = c.Query("status")
|
|
query.Provider = c.Query("provider")
|
|
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
|
|
query.Page = page
|
|
query.PageSize = pageSize
|
|
return query, true
|
|
}
|
|
|
|
func writePaymentError(c *gin.Context, err error) {
|
|
switch {
|
|
case errors.Is(err, ErrDependencyUnavailable):
|
|
response.ServiceUnavailable(c, "数据库未连接")
|
|
case errors.Is(err, ErrPaymentUnavailable):
|
|
response.Error(c, http.StatusBadGateway, "payment_unavailable", "支付渠道暂不可用")
|
|
case errors.Is(err, ErrPaymentCannotStart), errors.Is(err, order.ErrOrderCannotPay):
|
|
response.Error(c, http.StatusConflict, "payment_cannot_start", "当前订单不能支付")
|
|
case errors.Is(err, ErrRefundCannotStart):
|
|
response.Error(c, http.StatusConflict, "refund_cannot_start", "当前订单不能退款")
|
|
case errors.Is(err, ErrPaymentVerifyFailed):
|
|
response.Error(c, http.StatusForbidden, "payment_verify_failed", "支付通知验签失败")
|
|
case errors.Is(err, ErrPaymentNotFound), errors.Is(err, gorm.ErrRecordNotFound), order.IsNotFound(err):
|
|
response.Error(c, http.StatusNotFound, "payment_not_found", "支付单不存在")
|
|
case errors.Is(err, order.ErrListingUnavailable):
|
|
response.Error(c, http.StatusConflict, "listing_unavailable", "该账号暂不可租")
|
|
default:
|
|
response.Error(c, http.StatusInternalServerError, "payment_error", "支付处理失败")
|
|
}
|
|
}
|