支持后台支付配置管理

backend/internal/modules/payment/repository.go

@@ -10,10 +10,10 @@ import (
 	"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/paymentconfig"
 	"hfb_sys/backend/internal/modules/wallet"
 
 	"gorm.io/datatypes"
@@ -23,12 +23,16 @@ import (
 
 type Repository struct {
 	db         *gorm.DB
-	cfg        config.PaymentConfig
+	configRepo *paymentconfig.Repository
 	orderRepo  *order.Repository
 	walletRepo *wallet.Repository
-	leshua     *leshua.Client
-	provider   string
-	isMockMode bool
+}
+
+type runtimePaymentConfig struct {
+	ID         uint64
+	Provider   string
+	MerchantID string
+	Leshua     leshua.Config
 }
 
 const (
@@ -47,32 +51,104 @@ var refundBizTypes = []string{
 	"rent_refund",
 }
 
-func NewRepository(db *gorm.DB, cfg config.PaymentConfig, orderRepo *order.Repository, walletRepo *wallet.Repository) *Repository {
-	provider := cfg.Provider
-	if provider == "" {
-		provider = "mock"
-	}
+func NewRepository(db *gorm.DB, configRepo *paymentconfig.Repository, orderRepo *order.Repository, walletRepo *wallet.Repository) *Repository {
 	return &Repository{
 		db:         db,
-		cfg:        cfg,
+		configRepo: configRepo,
 		orderRepo:  orderRepo,
 		walletRepo: walletRepo,
-		leshua:     leshua.NewClient(cfg.Leshua),
-		provider:   provider,
-		isMockMode: provider != "leshua",
+	}
+}
+
+func (c runtimePaymentConfig) isMockMode() bool {
+	return c.Provider != "leshua"
+}
+
+func (c runtimePaymentConfig) client() *leshua.Client {
+	return leshua.NewClient(c.Leshua)
+}
+
+func (r *Repository) defaultRuntimeConfig() (*runtimePaymentConfig, error) {
+	if r.configRepo == nil {
+		return nil, ErrPaymentUnavailable
+	}
+	dto, err := r.configRepo.FindDefaultAny(true)
+	if err != nil {
+		return nil, err
+	}
+	return runtimeConfigFromDTO(dto), nil
+}
+
+func (r *Repository) runtimeConfigForPayment(payment *model.PaymentOrder) (*runtimePaymentConfig, error) {
+	provider := firstNonEmpty(payment.Provider, "mock")
+	merchantID := payment.MerchantID
+	if r.configRepo != nil && merchantID != "" {
+		dto, err := r.configRepo.FindByProviderMerchant(provider, merchantID, true)
+		if err == nil {
+			return runtimeConfigFromDTO(dto), nil
+		}
+		if err != paymentconfig.ErrConfigNotFound {
+			return nil, err
+		}
+	}
+	if provider != "leshua" {
+		return &runtimePaymentConfig{
+			Provider:   provider,
+			MerchantID: merchantID,
+		}, nil
+	}
+	if r.configRepo == nil {
+		return nil, ErrPaymentUnavailable
+	}
+	dto, err := r.configRepo.FindDefaultByProvider(provider, true)
+	if err != nil {
+		return nil, err
+	}
+	return runtimeConfigFromDTO(dto), nil
+}
+
+func runtimeConfigFromDTO(dto *paymentconfig.ConfigDTO) *runtimePaymentConfig {
+	provider := firstNonEmpty(dto.Provider, "mock")
+	payWay := firstNonEmpty(dto.PayWay, "ZFBZF")
+	jsPayFlag := firstNonEmpty(dto.JSPayFlag, "2")
+	signType := firstNonEmpty(dto.SignType, "MD5")
+	return &runtimePaymentConfig{
+		ID:         dto.ID,
+		Provider:   provider,
+		MerchantID: dto.MerchantID,
+		Leshua: leshua.Config{
+			GatewayURL: dto.GatewayURL,
+			MerchantID: dto.MerchantID,
+			SignKey:    dto.SignKey,
+			NotifyKey:  dto.NotifyKey,
+			NotifyURL:  dto.NotifyURL,
+			JumpURL:    dto.JumpURL,
+			PayWay:     payWay,
+			JSPayFlag:  jsPayFlag,
+			SignType:   signType,
+		},
 	}
 }
 
 func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentRequest, clientIP string) (*PaymentDTO, error) {
-	payment, orderRow, err := r.preparePayment(userID, orderID, req)
+	defaultConfig, err := r.defaultRuntimeConfig()
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	payment, orderRow, err := r.preparePayment(userID, orderID, req, *defaultConfig)
 	if err != nil {
 		return nil, err
 	}
+	runtimeConfig, err := r.runtimeConfigForPayment(payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
 	if payment.Status == "paid" {
+		r.recordConfigUsage(runtimeConfig, payment)
 		dto := toDTO(*payment)
 		return &dto, nil
 	}
-	if r.isMockMode {
+	if runtimeConfig.isMockMode() {
 		if err := r.confirmPaid(payment, "2", time.Now(), map[string]string{
 			"mock":            "true",
 			"third_order_id":  payment.ThirdOrderID,
@@ -85,21 +161,24 @@ func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentReques
 		if err != nil {
 			return nil, err
 		}
+		r.recordConfigUsage(runtimeConfig, latest)
 		dto := toDTO(*latest)
 		return &dto, nil
 	}
 	if payment.Status == "paying" && (payment.TDCode != "" || payment.JSPayURL != "" || payment.JSPayInfo != "") {
+		r.recordConfigUsage(runtimeConfig, payment)
 		dto := toDTO(*payment)
 		return &dto, nil
 	}
 
-	resp, rawReq, err := r.leshua.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+	client := runtimeConfig.client()
+	resp, rawReq, err := client.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,
+		NotifyURL:    runtimeConfig.Leshua.NotifyURL,
+		JumpURL:      runtimeConfig.Leshua.JumpURL,
 		ClientIP:     clientIP,
 		Body:         "租号订单 " + orderRow.OrderNo,
 		Attach:       orderRow.OrderNo,
@@ -128,6 +207,7 @@ func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentReques
 	if err != nil {
 		return nil, err
 	}
+	r.recordConfigUsage(runtimeConfig, latest)
 	dto := toDTO(*latest)
 	return &dto, nil
 }
@@ -137,11 +217,15 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 	if userID == 0 || req.Amount < MinWalletRechargeAmount || amountCent <= 0 {
 		return nil, ErrPaymentCannotStart
 	}
-	payment, err := r.createWalletRechargePayment(userID, amountCent, req)
+	runtimeConfig, err := r.defaultRuntimeConfig()
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	payment, err := r.createWalletRechargePayment(userID, amountCent, req, *runtimeConfig)
 	if err != nil {
 		return nil, err
 	}
-	if r.isMockMode {
+	if runtimeConfig.isMockMode() {
 		if err := r.confirmPaid(payment, "2", time.Now(), map[string]string{
 			"mock":            "true",
 			"third_order_id":  payment.ThirdOrderID,
@@ -154,16 +238,18 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 		if err != nil {
 			return nil, err
 		}
+		r.recordConfigUsage(runtimeConfig, latest)
 		dto := toDTO(*latest)
 		return &dto, nil
 	}
-	resp, rawReq, err := r.leshua.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+	client := runtimeConfig.client()
+	resp, rawReq, err := client.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,
+		NotifyURL:    runtimeConfig.Leshua.NotifyURL,
+		JumpURL:      runtimeConfig.Leshua.JumpURL,
 		ClientIP:     clientIP,
 		Body:         "钱包充值 " + payment.PaymentNo,
 		Attach:       payment.PaymentNo,
@@ -192,6 +278,7 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 	if err != nil {
 		return nil, err
 	}
+	r.recordConfigUsage(runtimeConfig, latest)
 	dto := toDTO(*latest)
 	return &dto, nil
 }
@@ -204,11 +291,15 @@ func (r *Repository) QueryWalletRecharge(userID uint64, paymentID uint64) (*Paym
 		}
 		return nil, err
 	}
-	if payment.Status == "paid" || r.isMockMode {
+	runtimeConfig, err := r.runtimeConfigForPayment(&payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	if payment.Status == "paid" || runtimeConfig.isMockMode() {
 		dto := toDTO(payment)
 		return &dto, nil
 	}
-	resp, err := r.leshua.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	resp, err := runtimeConfig.client().QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
 	if err != nil {
 		return nil, err
 	}
@@ -231,11 +322,15 @@ func (r *Repository) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
 		}
 		return nil, err
 	}
-	if payment.Status == "paid" || r.isMockMode {
+	runtimeConfig, err := r.runtimeConfigForPayment(&payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	if payment.Status == "paid" || runtimeConfig.isMockMode() {
 		dto := toDTO(payment)
 		return &dto, nil
 	}
-	resp, err := r.leshua.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	resp, err := runtimeConfig.client().QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
 	if err != nil {
 		return nil, err
 	}
@@ -251,48 +346,32 @@ func (r *Repository) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
 }
 
 func (r *Repository) HandleLeshuaNotify(params map[string]string, rawPayload string, contentType string) (*NotifyResult, error) {
-	var verify leshua.VerifyNotifyResult
-	if !r.isMockMode {
-		verify = r.leshua.VerifyNotifyDetail(params)
-		if !verify.OK {
-			log.Printf(
-				"[payment] leshua notify verify failed third_order_id=%s got=%s expected=%s keys=%v base_string=%s",
-				params["third_order_id"],
-				verify.Got,
-				verify.Expected["notify_key"],
-				verify.ParamKeys,
-				verify.BaseString["notify_key"],
-			)
-			if err := r.recordNotifyDiagnostic(params, rawPayload, contentType, verify, "verify_failed"); err != nil {
-				log.Printf("[payment] leshua notify diagnostic save failed third_order_id=%s err=%v", params["third_order_id"], err)
-			}
-			return nil, ErrPaymentVerifyFailed
-		}
-		log.Printf("[payment] leshua notify verified third_order_id=%s matched_key=%s", params["third_order_id"], verify.MatchedKey)
-	}
 	// 退款通知会携带 merchant_refund_id 或 leshua_refund_id。
 	if params["merchant_refund_id"] != "" || params["leshua_refund_id"] != "" {
 		return r.HandleRefundNotify(params, rawPayload, contentType)
 	}
-	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
-		}
+
+	payment, err := r.findPaymentForNotify(params)
+	if err != nil {
 		return nil, err
 	}
+	runtimeConfig, err := r.runtimeConfigForPayment(payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType)
+	if err != nil {
+		return nil, err
+	}
+
 	if amount := parseCent(params["amount"]); amount > 0 && amount != payment.AmountCent {
-		if err := r.recordNotifyDiagnostic(params, rawPayload, contentType, verify, "amount_mismatch"); err != nil {
+		if err := r.recordNotifyDiagnostic(payment.ID, params, rawPayload, contentType, verify, "amount_mismatch"); err != nil {
 			log.Printf("[payment] leshua notify diagnostic save failed third_order_id=%s err=%v", params["third_order_id"], err)
 		}
 		return nil, ErrPaymentVerifyFailed
 	}
 	raw := withNotifyDiagnostic(params, rawPayload, contentType, verify, "verified")
-	if err := r.applyChannelStatus(&payment, params["status"], params["pay_time"], raw, channelSourceNotify); err != nil {
+	if err := r.applyChannelStatus(payment, params["status"], params["pay_time"], raw, channelSourceNotify); err != nil {
 		return nil, err
 	}
 	return &NotifyResult{OK: true, Message: "000000"}, nil
@@ -307,9 +386,13 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		}
 		return nil, err
 	}
+	runtimeConfig, err := r.runtimeConfigForPayment(&originalPayment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
 
 	var existingRefund model.PaymentOrder
-	err := r.db.Where("order_id = ? AND biz_type = ? AND status NOT IN ('failed')", orderID, bizType).Order("id DESC").First(&existingRefund).Error
+	err = r.db.Where("order_id = ? AND biz_type = ? AND status NOT IN ('failed')", orderID, bizType).Order("id DESC").First(&existingRefund).Error
 	if err == nil {
 		dto := toRefundDTO(existingRefund)
 		return &dto, nil
@@ -329,8 +412,8 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		OrderID:         orderID,
 		OrderNo:         originalPayment.OrderNo,
 		UserID:          originalPayment.UserID,
-		Provider:        r.provider,
-		MerchantID:      r.cfg.Leshua.MerchantID,
+		Provider:        runtimeConfig.Provider,
+		MerchantID:      runtimeConfig.MerchantID,
 		ThirdOrderID:    merchantRefundID,
 		ProviderOrderID: "",
 		PayWay:          originalPayment.PayWay,
@@ -340,7 +423,7 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		Status:          "refunding",
 	}
 
-	if r.isMockMode {
+	if runtimeConfig.isMockMode() {
 		refundOrder.ProviderOrderID = "MOCKREF" + merchantRefundID
 		refundOrder.Status = "refunded"
 		now := time.Now()
@@ -351,6 +434,7 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		if err := r.db.Create(&refundOrder).Error; err != nil {
 			return nil, err
 		}
+		r.recordConfigUsage(runtimeConfig, &refundOrder)
 		if err := r.updateOrderRefundStatus(orderID, refundAmountCent); err != nil {
 			log.Printf("[payment] mock update order refund status failed order_id=%d err=%v", orderID, err)
 		}
@@ -361,16 +445,17 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 	if err := r.db.Create(&refundOrder).Error; err != nil {
 		return nil, err
 	}
+	r.recordConfigUsage(runtimeConfig, &refundOrder)
 	if err := r.markOrderRefunding(orderID, refundAmountCent); err != nil {
 		log.Printf("[payment] mark order refunding failed order_id=%d err=%v", orderID, err)
 	}
 
-	resp, rawReq, err := r.leshua.CreateRefund(context.Background(), leshua.CreateRefundRequest{
+	resp, rawReq, err := runtimeConfig.client().CreateRefund(context.Background(), leshua.CreateRefundRequest{
 		ThirdOrderID:     originalPayment.ThirdOrderID,
 		LeshuaOrderID:    originalPayment.ProviderOrderID,
 		MerchantRefundID: merchantRefundID,
 		RefundAmountCent: refundAmountCent,
-		NotifyURL:        r.cfg.Leshua.NotifyURL,
+		NotifyURL:        runtimeConfig.Leshua.NotifyURL,
 		Attach:           originalPayment.OrderNo,
 	})
 	if err != nil {
@@ -425,11 +510,15 @@ func (r *Repository) QueryRefundStatus(orderID uint64) (*RefundDTO, error) {
 		}
 		return nil, err
 	}
-	if payment.Status == "refunded" || payment.Status == "failed" || r.isMockMode {
+	runtimeConfig, err := r.runtimeConfigForPayment(&payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	if payment.Status == "refunded" || payment.Status == "failed" || runtimeConfig.isMockMode() {
 		dto := toRefundDTO(payment)
 		return &dto, nil
 	}
-	resp, err := r.leshua.QueryRefund(context.Background(), leshua.QueryRefundRequest{
+	resp, err := runtimeConfig.client().QueryRefund(context.Background(), leshua.QueryRefundRequest{
 		ThirdOrderID:     payment.ThirdOrderID,
 		MerchantRefundID: payment.ThirdOrderID,
 		LeshuaRefundID:   payment.ProviderOrderID,
@@ -465,25 +554,19 @@ func (r *Repository) QueryRefundStatus(orderID uint64) (*RefundDTO, error) {
 
 // HandleRefundNotify 处理乐刷退款通知。
 func (r *Repository) HandleRefundNotify(params map[string]string, rawPayload string, contentType string) (*NotifyResult, error) {
-	var verify leshua.VerifyNotifyResult
-	if !r.isMockMode {
-		verify = r.leshua.VerifyNotifyDetail(params)
-		if !verify.OK {
-			log.Printf("[payment] refund notify verify failed merchant_refund_id=%s", params["merchant_refund_id"])
-			return nil, ErrPaymentVerifyFailed
-		}
-	}
-	merchantRefundID := params["merchant_refund_id"]
-	if merchantRefundID == "" {
-		return nil, ErrPaymentNotFound
-	}
-	var payment model.PaymentOrder
-	if err := r.db.Where("third_order_id = ?", merchantRefundID).First(&payment).Error; err != nil {
-		if err == gorm.ErrRecordNotFound {
-			return nil, ErrPaymentNotFound
-		}
+	payment, err := r.findRefundPaymentForNotify(params)
+	if err != nil {
 		return nil, err
 	}
+	runtimeConfig, err := r.runtimeConfigForPayment(payment)
+	if err != nil {
+		return nil, ErrPaymentUnavailable
+	}
+	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType)
+	if err != nil {
+		return nil, err
+	}
+
 	raw := withNotifyDiagnostic(params, rawPayload, contentType, verify, "verified")
 	status := params["status"]
 	switch status {
@@ -570,7 +653,7 @@ func toRefundDTO(payment model.PaymentOrder) RefundDTO {
 	}
 }
 
-func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaymentRequest) (*model.PaymentOrder, *model.RentalOrder, error) {
+func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaymentRequest, runtimeConfig runtimePaymentConfig) (*model.PaymentOrder, *model.RentalOrder, error) {
 	var paymentID uint64
 	var orderRow model.RentalOrder
 	err := r.db.Transaction(func(tx *gorm.DB) error {
@@ -593,12 +676,12 @@ func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaym
 			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.PayWay = firstNonEmpty(req.PayWay, existing.PayWay, runtimeConfig.Leshua.PayWay, "ZFBZF")
+			existing.JSPayFlag = firstNonEmpty(req.JSPayFlag, existing.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2")
 			existing.AmountCent = amountCent
-			existing.Provider = r.provider
-			existing.MerchantID = r.cfg.Leshua.MerchantID
-			if r.isMockMode && existing.ProviderOrderID == "" {
+			existing.Provider = firstNonEmpty(existing.Provider, runtimeConfig.Provider)
+			existing.MerchantID = firstNonEmpty(existing.MerchantID, runtimeConfig.MerchantID)
+			if existing.Provider != "leshua" && existing.ProviderOrderID == "" {
 				existing.ProviderOrderID = "MOCK" + existing.ThirdOrderID
 			}
 			if err := tx.Save(&existing).Error; err != nil {
@@ -620,17 +703,17 @@ func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaym
 			OrderID:         row.ID,
 			OrderNo:         row.OrderNo,
 			UserID:          row.RenterID,
-			Provider:        r.provider,
-			MerchantID:      r.cfg.Leshua.MerchantID,
+			Provider:        runtimeConfig.Provider,
+			MerchantID:      runtimeConfig.MerchantID,
 			ThirdOrderID:    row.OrderNo,
 			ProviderOrderID: "",
-			PayWay:          firstNonEmpty(req.PayWay, r.cfg.Leshua.PayWay, "ZFBZF"),
-			JSPayFlag:       firstNonEmpty(req.JSPayFlag, r.cfg.Leshua.JSPayFlag, "2"),
+			PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.Leshua.PayWay, "ZFBZF"),
+			JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2"),
 			AmountCent:      amountCent,
 			BizType:         "order_pay",
 			Status:          "created",
 		}
-		if r.isMockMode {
+		if runtimeConfig.isMockMode() {
 			payment.ProviderOrderID = "MOCK" + row.OrderNo
 			payment.TDCode = "mock://leshua/pay/" + row.OrderNo
 		}
@@ -651,7 +734,7 @@ func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaym
 	return payment, &orderRow, nil
 }
 
-func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64, req WalletRechargePaymentRequest) (*model.PaymentOrder, error) {
+func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64, req WalletRechargePaymentRequest, runtimeConfig runtimePaymentConfig) (*model.PaymentOrder, error) {
 	paymentNo, err := newPaymentNo()
 	if err != nil {
 		return nil, err
@@ -661,17 +744,17 @@ func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64
 		OrderID:         0,
 		OrderNo:         paymentNo,
 		UserID:          userID,
-		Provider:        r.provider,
-		MerchantID:      r.cfg.Leshua.MerchantID,
+		Provider:        runtimeConfig.Provider,
+		MerchantID:      runtimeConfig.MerchantID,
 		ThirdOrderID:    paymentNo,
 		ProviderOrderID: "",
-		PayWay:          firstNonEmpty(req.PayWay, r.cfg.Leshua.PayWay, "ZFBZF"),
-		JSPayFlag:       firstNonEmpty(req.JSPayFlag, r.cfg.Leshua.JSPayFlag, "2"),
+		PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.Leshua.PayWay, "ZFBZF"),
+		JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2"),
 		AmountCent:      amountCent,
 		BizType:         "wallet_recharge",
 		Status:          "created",
 	}
-	if r.isMockMode {
+	if runtimeConfig.isMockMode() {
 		payment.ProviderOrderID = "MOCK" + paymentNo
 		payment.TDCode = "mock://leshua/recharge/" + paymentNo
 	}
@@ -758,6 +841,70 @@ func (r *Repository) findPaymentByID(paymentID uint64) (*model.PaymentOrder, err
 	return &payment, nil
 }
 
+func (r *Repository) findPaymentForNotify(params map[string]string) (*model.PaymentOrder, error) {
+	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
+	}
+	return &payment, nil
+}
+
+func (r *Repository) findRefundPaymentForNotify(params map[string]string) (*model.PaymentOrder, error) {
+	merchantRefundID := params["merchant_refund_id"]
+	if merchantRefundID == "" {
+		return nil, ErrPaymentNotFound
+	}
+	var payment model.PaymentOrder
+	if err := r.db.Where("third_order_id = ?", merchantRefundID).First(&payment).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, ErrPaymentNotFound
+		}
+		return nil, err
+	}
+	return &payment, nil
+}
+
+func (r *Repository) verifyNotify(payment *model.PaymentOrder, runtimeConfig *runtimePaymentConfig, params map[string]string, rawPayload string, contentType string) (leshua.VerifyNotifyResult, error) {
+	var verify leshua.VerifyNotifyResult
+	if runtimeConfig.isMockMode() {
+		return verify, nil
+	}
+	verify = runtimeConfig.client().VerifyNotifyDetail(params)
+	if !verify.OK {
+		log.Printf(
+			"[payment] leshua notify verify failed payment_id=%d third_order_id=%s got=%s expected=%s keys=%v base_string=%s",
+			payment.ID,
+			params["third_order_id"],
+			verify.Got,
+			verify.Expected["notify_key"],
+			verify.ParamKeys,
+			verify.BaseString["notify_key"],
+		)
+		if err := r.recordNotifyDiagnostic(payment.ID, params, rawPayload, contentType, verify, "verify_failed"); err != nil {
+			log.Printf("[payment] leshua notify diagnostic save failed payment_id=%d err=%v", payment.ID, err)
+		}
+		return verify, ErrPaymentVerifyFailed
+	}
+	log.Printf("[payment] leshua notify verified payment_id=%d third_order_id=%s matched_key=%s", payment.ID, params["third_order_id"], verify.MatchedKey)
+	return verify, nil
+}
+
+func (r *Repository) recordConfigUsage(runtimeConfig *runtimePaymentConfig, payment *model.PaymentOrder) {
+	if r.configRepo == nil || runtimeConfig == nil || payment == nil || runtimeConfig.ID == 0 {
+		return
+	}
+	if err := r.configRepo.RecordUsage(runtimeConfig.ID, payment.ID, runtimeConfig.Provider, runtimeConfig.MerchantID, payment.AmountCent, payment.BizType); err != nil {
+		log.Printf("[payment] record config usage failed config_id=%d payment_id=%d err=%v", runtimeConfig.ID, payment.ID, err)
+	}
+}
+
 func toDTO(payment model.PaymentOrder) PaymentDTO {
 	return PaymentDTO{
 		ID:              payment.ID,
@@ -827,14 +974,13 @@ func withRawSource(raw map[string]string, source string) map[string]string {
 	return out
 }
 
-func (r *Repository) recordNotifyDiagnostic(params map[string]string, rawPayload string, contentType string, verify leshua.VerifyNotifyResult, status string) error {
-	thirdOrderID := params["third_order_id"]
-	if thirdOrderID == "" {
+func (r *Repository) recordNotifyDiagnostic(paymentID uint64, params map[string]string, rawPayload string, contentType string, verify leshua.VerifyNotifyResult, status string) error {
+	if paymentID == 0 {
 		return nil
 	}
 	raw := withNotifyDiagnostic(params, rawPayload, contentType, verify, status)
 	return r.db.Model(&model.PaymentOrder{}).
-		Where("third_order_id = ?", thirdOrderID).
+		Where("id = ?", paymentID).
 		Update("raw_response", jsonMap(raw)).Error
 }