开始增加支付-1

backend/internal/modules/order/repository.go

@@ -307,6 +307,93 @@ func (r *Repository) Pay(userID uint64, orderID uint64) error {
 	return nil
 }
 
+func (r *Repository) ConfirmPaidFromChannel(orderID uint64, providerBizNo string) error {
+	var newConvID uint64
+	err := r.db.Transaction(func(tx *gorm.DB) error {
+		var order model.RentalOrder
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
+			return err
+		}
+		if order.Status == "pending_handoff" || order.Status == "renting" {
+			return nil
+		}
+		if order.Status != "pending_payment" {
+			return ErrOrderCannotPay
+		}
+
+		var listing model.RentalListing
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&listing, order.ListingID).Error; err != nil {
+			return err
+		}
+		if listing.Status != "published" || listing.ReviewStatus != "approved" || !listing.InTransaction {
+			return ErrListingUnavailable
+		}
+		var account model.GameAccount
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&account, order.AccountID).Error; err != nil {
+			return err
+		}
+
+		orderID := order.ID
+		total := order.RentAmount + order.DepositAmount
+		if err := wallet.AppendEntries(tx, wallet.Entry{
+			UserID:      order.RenterID,
+			OrderID:     &orderID,
+			Direction:   "in",
+			Amount:      total,
+			BalanceType: "frozen",
+			BizType:     "channel_order_lock",
+			BizNo:       firstNonEmpty(providerBizNo, order.OrderNo),
+			Remark:      "渠道支付成功冻结租金和押金",
+		}); err != nil {
+			return err
+		}
+
+		order.Status = "pending_handoff"
+		order.HandoffStatus = "pending_owner"
+		listing.Status = "rented"
+		account.Status = "rented"
+		conv, err := chat.EnsureOrderConversation(tx, order)
+		if err != nil {
+			return err
+		}
+		newConvID = conv.ID
+		if err := notification.Append(tx,
+			notification.Entry{
+				UserID:  order.OwnerID,
+				Type:    "order",
+				Title:   "收到新的租号订单",
+				Content: "租客已完成支付，请尽快提交交接说明。",
+				BizType: "order",
+				BizID:   &orderID,
+			},
+			notification.Entry{
+				UserID:  order.RenterID,
+				Type:    "order",
+				Title:   "订单支付成功",
+				Content: "支付金额已冻结，等待号主提交交接说明。",
+				BizType: "order",
+				BizID:   &orderID,
+			},
+		); err != nil {
+			return err
+		}
+		if err := tx.Save(&order).Error; err != nil {
+			return err
+		}
+		if err := tx.Save(&listing).Error; err != nil {
+			return err
+		}
+		return tx.Save(&account).Error
+	})
+	if err != nil {
+		return err
+	}
+	if newConvID > 0 && r.chatRepo != nil {
+		r.chatRepo.NotifyNewConversation(newConvID)
+	}
+	return nil
+}
+
 func (r *Repository) Cancel(userID uint64, orderID uint64) error {
 	return r.db.Transaction(func(tx *gorm.DB) error {
 		var order model.RentalOrder
@@ -1067,6 +1154,15 @@ func isTerminalStatus(status string) bool {
 	return status == "completed" || status == "cancelled" || status == "closed"
 }
 
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
 func (r *Repository) findHandoffRecord(id uint64) (*HandoffRecordDTO, error) {
 	var record model.HandoffRecord
 	if err := r.db.First(&record, id).Error; err != nil {

backend/internal/modules/payment/dto.go

@@ -0,0 +1,40 @@
+package payment
+
+import "time"
+
+type StartPaymentRequest struct {
+	PayWay    string `json:"pay_way"`
+	JSPayFlag string `json:"jspay_flag"`
+}
+
+type WalletRechargePaymentRequest struct {
+	Amount    float64 `json:"amount"`
+	PayWay    string  `json:"pay_way"`
+	JSPayFlag string  `json:"jspay_flag"`
+}
+
+type PaymentDTO struct {
+	ID              uint64     `json:"id"`
+	PaymentNo       string     `json:"payment_no"`
+	OrderID         uint64     `json:"order_id"`
+	OrderNo         string     `json:"order_no"`
+	Provider        string     `json:"provider"`
+	ThirdOrderID    string     `json:"third_order_id"`
+	ProviderOrderID string     `json:"provider_order_id"`
+	PayWay          string     `json:"pay_way"`
+	JSPayFlag       string     `json:"jspay_flag"`
+	AmountCent      int64      `json:"amount_cent"`
+	Status          string     `json:"status"`
+	TDCode          string     `json:"td_code,omitempty"`
+	JSPayURL        string     `json:"jspay_url,omitempty"`
+	JSPayInfo       string     `json:"jspay_info,omitempty"`
+	Paid            bool       `json:"paid"`
+	PaidAt          *time.Time `json:"paid_at,omitempty"`
+	CreatedAt       time.Time  `json:"created_at"`
+	UpdatedAt       time.Time  `json:"updated_at"`
+}
+
+type NotifyResult struct {
+	OK      bool
+	Message string
+}

backend/internal/modules/payment/handler.go

@@ -0,0 +1,155 @@
+package payment
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"strconv"
+
+	"hfb_sys/backend/internal/integrations/payment/leshua"
+	"hfb_sys/backend/internal/middleware"
+	"hfb_sys/backend/internal/modules/order"
+	"hfb_sys/backend/pkg/response"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type Handler struct {
+	service *Service
+}
+
+func NewHandler(service *Service) *Handler {
+	return &Handler{service: service}
+}
+
+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(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(userID, orderID)
+	if err != nil {
+		writePaymentError(c, err)
+		return
+	}
+	response.OK(c, item)
+}
+
+func (h *Handler) WalletRecharge(c *gin.Context) {
+	userID, ok := currentUserID(c)
+	if !ok {
+		response.Unauthorized(c, "缺少用户上下文")
+		return
+	}
+	var req WalletRechargePaymentRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.BadRequest(c, "充值金额不正确")
+		return
+	}
+	item, err := h.service.StartWalletRecharge(userID, req, c.ClientIP())
+	if err != nil {
+		writePaymentError(c, err)
+		return
+	}
+	response.OK(c, item)
+}
+
+func (h *Handler) WalletRechargeQuery(c *gin.Context) {
+	userID, ok := currentUserID(c)
+	if !ok {
+		response.Unauthorized(c, "缺少用户上下文")
+		return
+	}
+	paymentID, ok := parseID(c)
+	if !ok {
+		return
+	}
+	item, err := h.service.QueryWalletRecharge(userID, paymentID)
+	if err != nil {
+		writePaymentError(c, err)
+		return
+	}
+	response.OK(c, item)
+}
+
+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
+	}
+	result, err := h.service.HandleLeshuaNotify(params)
+	if err != nil || result == nil || !result.OK {
+		c.String(http.StatusOK, "FAIL")
+		return
+	}
+	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 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, 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", "支付处理失败")
+	}
+}

backend/internal/modules/payment/repository.go

@@ -0,0 +1,516 @@
+package payment
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+
+	"hfb_sys/backend/internal/config"
+	"hfb_sys/backend/internal/integrations/payment/leshua"
+	"hfb_sys/backend/internal/model"
+	"hfb_sys/backend/internal/modules/order"
+	"hfb_sys/backend/internal/modules/wallet"
+
+	"gorm.io/datatypes"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type Repository struct {
+	db         *gorm.DB
+	cfg        config.PaymentConfig
+	orderRepo  *order.Repository
+	walletRepo *wallet.Repository
+	leshua     *leshua.Client
+	provider   string
+	isMockMode bool
+}
+
+func NewRepository(db *gorm.DB, cfg config.PaymentConfig, orderRepo *order.Repository, walletRepo *wallet.Repository) *Repository {
+	provider := cfg.Provider
+	if provider == "" {
+		provider = "mock"
+	}
+	return &Repository{
+		db:         db,
+		cfg:        cfg,
+		orderRepo:  orderRepo,
+		walletRepo: walletRepo,
+		leshua:     leshua.NewClient(cfg.Leshua),
+		provider:   provider,
+		isMockMode: provider != "leshua",
+	}
+}
+
+func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentRequest, clientIP string) (*PaymentDTO, error) {
+	payment, orderRow, err := r.preparePayment(userID, orderID, req)
+	if err != nil {
+		return nil, err
+	}
+	if payment.Status == "paid" {
+		dto := toDTO(*payment)
+		return &dto, nil
+	}
+	if r.isMockMode {
+		if err := r.confirmPaid(payment, "2", time.Now(), map[string]string{
+			"mock":            "true",
+			"third_order_id":  payment.ThirdOrderID,
+			"leshua_order_id": payment.ProviderOrderID,
+			"status":          "2",
+		}); err != nil {
+			return nil, err
+		}
+		latest, err := r.findPaymentByID(payment.ID)
+		if err != nil {
+			return nil, err
+		}
+		dto := toDTO(*latest)
+		return &dto, nil
+	}
+	if payment.Status == "paying" && (payment.TDCode != "" || payment.JSPayURL != "" || payment.JSPayInfo != "") {
+		dto := toDTO(*payment)
+		return &dto, nil
+	}
+
+	resp, rawReq, err := r.leshua.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+		ThirdOrderID: payment.ThirdOrderID,
+		AmountCent:   payment.AmountCent,
+		PayWay:       payment.PayWay,
+		JSPayFlag:    payment.JSPayFlag,
+		NotifyURL:    r.cfg.Leshua.NotifyURL,
+		JumpURL:      r.cfg.Leshua.JumpURL,
+		ClientIP:     clientIP,
+		Body:         "租号订单 " + orderRow.OrderNo,
+		Attach:       orderRow.OrderNo,
+	})
+	if err != nil {
+		_ = r.markPaymentFailed(payment.ID, nil, err.Error())
+		return nil, err
+	}
+	if resp.RespCode != "0" || resp.ResultCode != "0" {
+		_ = r.markPaymentFailed(payment.ID, resp.Raw, resp.ErrorMessage)
+		return nil, ErrPaymentUnavailable
+	}
+	if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+		"status":            "paying",
+		"provider_order_id": resp.ProviderOrderID,
+		"pay_way":           firstNonEmpty(resp.PayWay, payment.PayWay),
+		"td_code":           resp.TDCode,
+		"jspay_url":         resp.JSPayURL,
+		"jspay_info":        resp.JSPayInfo,
+		"raw_request":       jsonMap(rawReq),
+		"raw_response":      jsonMap(resp.Raw),
+	}).Error; err != nil {
+		return nil, err
+	}
+	latest, err := r.findPaymentByID(payment.ID)
+	if err != nil {
+		return nil, err
+	}
+	dto := toDTO(*latest)
+	return &dto, nil
+}
+
+func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymentRequest, clientIP string) (*PaymentDTO, error) {
+	amountCent := moneyCent(req.Amount)
+	if userID == 0 || amountCent <= 0 {
+		return nil, ErrPaymentCannotStart
+	}
+	payment, err := r.createWalletRechargePayment(userID, amountCent, req)
+	if err != nil {
+		return nil, err
+	}
+	if r.isMockMode {
+		if err := r.confirmPaid(payment, "2", time.Now(), map[string]string{
+			"mock":            "true",
+			"third_order_id":  payment.ThirdOrderID,
+			"leshua_order_id": payment.ProviderOrderID,
+			"status":          "2",
+		}); err != nil {
+			return nil, err
+		}
+		latest, err := r.findPaymentByID(payment.ID)
+		if err != nil {
+			return nil, err
+		}
+		dto := toDTO(*latest)
+		return &dto, nil
+	}
+	resp, rawReq, err := r.leshua.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+		ThirdOrderID: payment.ThirdOrderID,
+		AmountCent:   payment.AmountCent,
+		PayWay:       payment.PayWay,
+		JSPayFlag:    payment.JSPayFlag,
+		NotifyURL:    r.cfg.Leshua.NotifyURL,
+		JumpURL:      r.cfg.Leshua.JumpURL,
+		ClientIP:     clientIP,
+		Body:         "钱包充值 " + payment.PaymentNo,
+		Attach:       payment.PaymentNo,
+	})
+	if err != nil {
+		_ = r.markPaymentFailed(payment.ID, nil, err.Error())
+		return nil, err
+	}
+	if resp.RespCode != "0" || resp.ResultCode != "0" {
+		_ = r.markPaymentFailed(payment.ID, resp.Raw, resp.ErrorMessage)
+		return nil, ErrPaymentUnavailable
+	}
+	if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+		"status":            "paying",
+		"provider_order_id": resp.ProviderOrderID,
+		"pay_way":           firstNonEmpty(resp.PayWay, payment.PayWay),
+		"td_code":           resp.TDCode,
+		"jspay_url":         resp.JSPayURL,
+		"jspay_info":        resp.JSPayInfo,
+		"raw_request":       jsonMap(rawReq),
+		"raw_response":      jsonMap(resp.Raw),
+	}).Error; err != nil {
+		return nil, err
+	}
+	latest, err := r.findPaymentByID(payment.ID)
+	if err != nil {
+		return nil, err
+	}
+	dto := toDTO(*latest)
+	return &dto, nil
+}
+
+func (r *Repository) QueryWalletRecharge(userID uint64, paymentID uint64) (*PaymentDTO, error) {
+	var payment model.PaymentOrder
+	if err := r.db.Where("id = ? AND user_id = ? AND order_id = 0", paymentID, userID).First(&payment).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, ErrPaymentNotFound
+		}
+		return nil, err
+	}
+	if payment.Status == "paid" || r.isMockMode {
+		dto := toDTO(payment)
+		return &dto, nil
+	}
+	resp, err := r.leshua.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	if err != nil {
+		return nil, err
+	}
+	if err := r.applyChannelStatus(&payment, resp.Status, resp.PayTime, resp.Raw); err != nil {
+		return nil, err
+	}
+	latest, err := r.findPaymentByID(payment.ID)
+	if err != nil {
+		return nil, err
+	}
+	dto := toDTO(*latest)
+	return &dto, nil
+}
+
+func (r *Repository) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
+	var payment model.PaymentOrder
+	if err := r.db.Where("order_id = ? AND user_id = ?", orderID, userID).Order("id DESC").First(&payment).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, ErrPaymentNotFound
+		}
+		return nil, err
+	}
+	if payment.Status == "paid" || r.isMockMode {
+		dto := toDTO(payment)
+		return &dto, nil
+	}
+	resp, err := r.leshua.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	if err != nil {
+		return nil, err
+	}
+	if err := r.applyChannelStatus(&payment, resp.Status, resp.PayTime, resp.Raw); err != nil {
+		return nil, err
+	}
+	latest, err := r.findPaymentByID(payment.ID)
+	if err != nil {
+		return nil, err
+	}
+	dto := toDTO(*latest)
+	return &dto, nil
+}
+
+func (r *Repository) HandleLeshuaNotify(params map[string]string) (*NotifyResult, error) {
+	if !r.isMockMode && !r.leshua.VerifyNotify(params) {
+		return nil, ErrPaymentVerifyFailed
+	}
+	thirdOrderID := params["third_order_id"]
+	if thirdOrderID == "" {
+		return nil, ErrPaymentNotFound
+	}
+	var payment model.PaymentOrder
+	if err := r.db.Where("third_order_id = ?", thirdOrderID).First(&payment).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, ErrPaymentNotFound
+		}
+		return nil, err
+	}
+	if amount := parseCent(params["amount"]); amount > 0 && amount != payment.AmountCent {
+		return nil, ErrPaymentVerifyFailed
+	}
+	if err := r.applyChannelStatus(&payment, params["status"], params["pay_time"], params); err != nil {
+		return nil, err
+	}
+	return &NotifyResult{OK: true, Message: "000000"}, nil
+}
+
+func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaymentRequest) (*model.PaymentOrder, *model.RentalOrder, error) {
+	var paymentID uint64
+	var orderRow model.RentalOrder
+	err := r.db.Transaction(func(tx *gorm.DB) error {
+		var row model.RentalOrder
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("id = ? AND renter_id = ?", orderID, userID).
+			First(&row).Error; err != nil {
+			return err
+		}
+		if row.Status != "pending_payment" {
+			return ErrPaymentCannotStart
+		}
+		amountCent := moneyCent(row.RentAmount + row.DepositAmount)
+		if amountCent <= 0 {
+			return ErrPaymentCannotStart
+		}
+		var existing model.PaymentOrder
+		err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("order_id = ?", row.ID).
+			Order("id DESC").
+			First(&existing).Error
+		if err == nil {
+			existing.PayWay = firstNonEmpty(req.PayWay, existing.PayWay, r.cfg.Leshua.PayWay, "ZFBZF")
+			existing.JSPayFlag = firstNonEmpty(req.JSPayFlag, existing.JSPayFlag, r.cfg.Leshua.JSPayFlag, "2")
+			existing.AmountCent = amountCent
+			existing.Provider = r.provider
+			existing.MerchantID = r.cfg.Leshua.MerchantID
+			if r.isMockMode && existing.ProviderOrderID == "" {
+				existing.ProviderOrderID = "MOCK" + existing.ThirdOrderID
+			}
+			if err := tx.Save(&existing).Error; err != nil {
+				return err
+			}
+			paymentID = existing.ID
+			orderRow = row
+			return nil
+		}
+		if err != gorm.ErrRecordNotFound {
+			return err
+		}
+		paymentNo, err := newPaymentNo()
+		if err != nil {
+			return err
+		}
+		payment := model.PaymentOrder{
+			PaymentNo:       paymentNo,
+			OrderID:         row.ID,
+			OrderNo:         row.OrderNo,
+			UserID:          row.RenterID,
+			Provider:        r.provider,
+			MerchantID:      r.cfg.Leshua.MerchantID,
+			ThirdOrderID:    row.OrderNo,
+			ProviderOrderID: "",
+			PayWay:          firstNonEmpty(req.PayWay, r.cfg.Leshua.PayWay, "ZFBZF"),
+			JSPayFlag:       firstNonEmpty(req.JSPayFlag, r.cfg.Leshua.JSPayFlag, "2"),
+			AmountCent:      amountCent,
+			Status:          "created",
+		}
+		if r.isMockMode {
+			payment.ProviderOrderID = "MOCK" + row.OrderNo
+			payment.TDCode = "mock://leshua/pay/" + row.OrderNo
+		}
+		if err := tx.Create(&payment).Error; err != nil {
+			return err
+		}
+		paymentID = payment.ID
+		orderRow = row
+		return nil
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+	payment, err := r.findPaymentByID(paymentID)
+	if err != nil {
+		return nil, nil, err
+	}
+	return payment, &orderRow, nil
+}
+
+func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64, req WalletRechargePaymentRequest) (*model.PaymentOrder, error) {
+	paymentNo, err := newPaymentNo()
+	if err != nil {
+		return nil, err
+	}
+	payment := model.PaymentOrder{
+		PaymentNo:       paymentNo,
+		OrderID:         0,
+		OrderNo:         paymentNo,
+		UserID:          userID,
+		Provider:        r.provider,
+		MerchantID:      r.cfg.Leshua.MerchantID,
+		ThirdOrderID:    paymentNo,
+		ProviderOrderID: "",
+		PayWay:          firstNonEmpty(req.PayWay, r.cfg.Leshua.PayWay, "ZFBZF"),
+		JSPayFlag:       firstNonEmpty(req.JSPayFlag, r.cfg.Leshua.JSPayFlag, "2"),
+		AmountCent:      amountCent,
+		Status:          "created",
+	}
+	if r.isMockMode {
+		payment.ProviderOrderID = "MOCK" + paymentNo
+		payment.TDCode = "mock://leshua/recharge/" + paymentNo
+	}
+	if err := r.db.Create(&payment).Error; err != nil {
+		return nil, err
+	}
+	return &payment, nil
+}
+
+func (r *Repository) applyChannelStatus(payment *model.PaymentOrder, status string, payTime string, raw map[string]string) error {
+	switch status {
+	case "2", "30":
+		paidAt := parseLeshuaTime(payTime)
+		if paidAt == nil {
+			now := time.Now()
+			paidAt = &now
+		}
+		return r.confirmPaid(payment, status, *paidAt, raw)
+	case "6":
+		return r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+			"status":       "closed",
+			"raw_response": jsonMap(raw),
+			"notified_at":  time.Now(),
+		}).Error
+	case "8":
+		return r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+			"status":       "failed",
+			"raw_response": jsonMap(raw),
+			"notified_at":  time.Now(),
+		}).Error
+	default:
+		return r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+			"status":       "paying",
+			"raw_response": jsonMap(raw),
+			"notified_at":  time.Now(),
+		}).Error
+	}
+}
+
+func (r *Repository) confirmPaid(payment *model.PaymentOrder, status string, paidAt time.Time, raw map[string]string) error {
+	if payment.Status != "paid" {
+		if payment.OrderID == 0 {
+			if r.walletRepo == nil {
+				return ErrDependencyUnavailable
+			}
+			if err := r.walletRepo.ConfirmRechargeFromChannel(payment.UserID, firstNonEmpty(payment.ProviderOrderID, payment.PaymentNo), payment.AmountCent); err != nil {
+				return err
+			}
+		} else {
+			if r.orderRepo == nil {
+				return ErrDependencyUnavailable
+			}
+			if err := r.orderRepo.ConfirmPaidFromChannel(payment.OrderID, firstNonEmpty(payment.ProviderOrderID, payment.PaymentNo)); err != nil {
+				return err
+			}
+		}
+	}
+	return r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
+		"status":            "paid",
+		"provider_order_id": firstNonEmpty(raw["leshua_order_id"], payment.ProviderOrderID),
+		"raw_response":      jsonMap(raw),
+		"paid_at":           paidAt,
+		"notified_at":       time.Now(),
+	}).Error
+}
+
+func (r *Repository) markPaymentFailed(paymentID uint64, raw map[string]string, message string) error {
+	if raw == nil {
+		raw = map[string]string{"error": message}
+	}
+	return r.db.Model(&model.PaymentOrder{}).Where("id = ?", paymentID).Updates(map[string]any{
+		"status":       "failed",
+		"raw_response": jsonMap(raw),
+	}).Error
+}
+
+func (r *Repository) findPaymentByID(paymentID uint64) (*model.PaymentOrder, error) {
+	var payment model.PaymentOrder
+	if err := r.db.First(&payment, paymentID).Error; err != nil {
+		return nil, err
+	}
+	return &payment, nil
+}
+
+func toDTO(payment model.PaymentOrder) PaymentDTO {
+	return PaymentDTO{
+		ID:              payment.ID,
+		PaymentNo:       payment.PaymentNo,
+		OrderID:         payment.OrderID,
+		OrderNo:         payment.OrderNo,
+		Provider:        payment.Provider,
+		ThirdOrderID:    payment.ThirdOrderID,
+		ProviderOrderID: payment.ProviderOrderID,
+		PayWay:          payment.PayWay,
+		JSPayFlag:       payment.JSPayFlag,
+		AmountCent:      payment.AmountCent,
+		Status:          payment.Status,
+		TDCode:          payment.TDCode,
+		JSPayURL:        payment.JSPayURL,
+		JSPayInfo:       payment.JSPayInfo,
+		Paid:            payment.Status == "paid",
+		PaidAt:          payment.PaidAt,
+		CreatedAt:       payment.CreatedAt,
+		UpdatedAt:       payment.UpdatedAt,
+	}
+}
+
+func moneyCent(value float64) int64 {
+	return int64(math.Round(value * 100))
+}
+
+func parseCent(value string) int64 {
+	var amount int64
+	_, _ = fmt.Sscanf(value, "%d", &amount)
+	return amount
+}
+
+func parseLeshuaTime(value string) *time.Time {
+	if value == "" {
+		return nil
+	}
+	for _, layout := range []string{"2006-01-02 15:04:05", time.RFC3339} {
+		parsed, err := time.ParseInLocation(layout, value, time.Local)
+		if err == nil {
+			return &parsed
+		}
+	}
+	return nil
+}
+
+func jsonMap(value map[string]string) datatypes.JSON {
+	if value == nil {
+		return nil
+	}
+	raw, err := json.Marshal(value)
+	if err != nil {
+		return nil
+	}
+	return datatypes.JSON(raw)
+}
+
+func newPaymentNo() (string, error) {
+	buf := make([]byte, 4)
+	if _, err := rand.Read(buf); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("PAY%d%s", time.Now().UnixNano(), hex.EncodeToString(buf)), nil
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}

backend/internal/modules/payment/service.go

@@ -0,0 +1,66 @@
+package payment
+
+import "errors"
+
+var (
+	ErrDependencyUnavailable = errors.New("dependency unavailable")
+	ErrPaymentUnavailable    = errors.New("payment unavailable")
+	ErrPaymentCannotStart    = errors.New("payment cannot start")
+	ErrPaymentVerifyFailed   = errors.New("payment verify failed")
+	ErrPaymentNotFound       = errors.New("payment not found")
+)
+
+type Service struct {
+	repo *Repository
+}
+
+func NewService(repo *Repository) *Service {
+	return &Service{repo: repo}
+}
+
+func (s *Service) Start(userID uint64, orderID uint64, req StartPaymentRequest, clientIP string) (*PaymentDTO, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	if userID == 0 || orderID == 0 {
+		return nil, ErrPaymentCannotStart
+	}
+	return s.repo.Start(userID, orderID, req, clientIP)
+}
+
+func (s *Service) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	if userID == 0 || orderID == 0 {
+		return nil, ErrPaymentNotFound
+	}
+	return s.repo.Query(userID, orderID)
+}
+
+func (s *Service) StartWalletRecharge(userID uint64, req WalletRechargePaymentRequest, clientIP string) (*PaymentDTO, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	if userID == 0 || req.Amount <= 0 {
+		return nil, ErrPaymentCannotStart
+	}
+	return s.repo.StartWalletRecharge(userID, req, clientIP)
+}
+
+func (s *Service) QueryWalletRecharge(userID uint64, paymentID uint64) (*PaymentDTO, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	if userID == 0 || paymentID == 0 {
+		return nil, ErrPaymentNotFound
+	}
+	return s.repo.QueryWalletRecharge(userID, paymentID)
+}
+
+func (s *Service) HandleLeshuaNotify(params map[string]string) (*NotifyResult, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	return s.repo.HandleLeshuaNotify(params)
+}

backend/internal/modules/wallet/repository.go

@@ -81,6 +81,42 @@ func (r *Repository) Recharge(userID uint64, amount float64) (*AccountDTO, error
 	return r.Account(userID)
 }
 
+func (r *Repository) ConfirmRechargeFromChannel(userID uint64, bizNo string, amountCent int64) error {
+	if userID == 0 || amountCent <= 0 || bizNo == "" {
+		return ErrInvalidAmount
+	}
+	amount := roundWalletMoney(float64(amountCent) / 100)
+	return r.db.Transaction(func(tx *gorm.DB) error {
+		if err := ensureAccount(tx, userID); err != nil {
+			return err
+		}
+		var account model.WalletAccount
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("user_id = ?", userID).
+			First(&account).Error; err != nil {
+			return err
+		}
+		var existing int64
+		if err := tx.Model(&model.WalletLedger{}).
+			Where("user_id = ? AND biz_type = ? AND biz_no = ?", userID, "channel_recharge", bizNo).
+			Count(&existing).Error; err != nil {
+			return err
+		}
+		if existing > 0 {
+			return nil
+		}
+		return AppendEntries(tx, Entry{
+			UserID:      userID,
+			Direction:   "in",
+			Amount:      amount,
+			BalanceType: "available",
+			BizType:     "channel_recharge",
+			BizNo:       bizNo,
+			Remark:      "渠道充值入账",
+		})
+	})
+}
+
 func (r *Repository) AdminLedger(query AdminLedgerQuery) (*PaginatedResult, error) {
 	db := r.db.Table("wallet_ledger AS wl").
 		Select(`wl.id, wl.ledger_no, wl.user_id, COALESCE(u.phone, '') AS user_phone,