支持拉卡拉多渠道支付和测试充值

2026-06-06 21:46:41 +08:00
parent 4d40883da6
commit ba4c56c0cc
16 changed files with 1917 additions and 157 deletions
@@ -10,7 +10,6 @@ import (
 	"math"
 	"time"

-	"hfb_sys/backend/internal/integrations/payment/leshua"
 	"hfb_sys/backend/internal/model"
 	"hfb_sys/backend/internal/modules/order"
 	"hfb_sys/backend/internal/modules/paymentconfig"
@@ -32,7 +31,11 @@ type runtimePaymentConfig struct {
 	ID         uint64
 	Provider   string
 	MerchantID string
-	Leshua     leshua.Config
+	PayWay     string
+	JSPayFlag  string
+	NotifyURL  string
+	JumpURL    string
+	Channel    channelClient
 }

 const (
@@ -61,11 +64,7 @@ func NewRepository(db *gorm.DB, configRepo *paymentconfig.Repository, orderRepo
 }

 func (c runtimePaymentConfig) isMockMode() bool {
-	return c.Provider != "leshua"
-}
-
-func (c runtimePaymentConfig) client() *leshua.Client {
-	return leshua.NewClient(c.Leshua)
+	return c.Provider == "mock"
 }

 func (r *Repository) defaultRuntimeConfig() (*runtimePaymentConfig, error) {
@@ -92,6 +91,13 @@ func (r *Repository) runtimeConfigForPayment(payment *model.PaymentOrder) (*runt
 		}
 	}
 	if provider != "leshua" {
+		if provider == "lakala" && r.configRepo != nil {
+			dto, err := r.configRepo.FindDefaultByProvider(provider, true)
+			if err != nil {
+				return nil, err
+			}
+			return runtimeConfigFromDTO(dto), nil
+		}
 		return &runtimePaymentConfig{
 			Provider:   provider,
 			MerchantID: merchantID,
@@ -111,22 +117,19 @@ 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")
+	client, err := buildChannelClient(dto)
+	if err != nil {
+		client = nil
+	}
 	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,
-		},
+		PayWay:     payWay,
+		JSPayFlag:  jsPayFlag,
+		NotifyURL:  dto.NotifyURL,
+		JumpURL:    dto.JumpURL,
+		Channel:    client,
 	}
 }

@@ -170,15 +173,18 @@ func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentReques
 		dto := toDTO(*payment)
 		return &dto, nil
 	}
+	if runtimeConfig.Channel == nil {
+		_ = r.markPaymentFailed(payment.ID, nil, "payment channel unavailable")
+		return nil, ErrPaymentUnavailable
+	}

-	client := runtimeConfig.client()
-	resp, rawReq, err := client.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+	resp, err := runtimeConfig.Channel.CreatePayment(context.Background(), channelCreatePaymentRequest{
 		ThirdOrderID: payment.ThirdOrderID,
 		AmountCent:   payment.AmountCent,
 		PayWay:       payment.PayWay,
 		JSPayFlag:    payment.JSPayFlag,
-		NotifyURL:    runtimeConfig.Leshua.NotifyURL,
-		JumpURL:      runtimeConfig.Leshua.JumpURL,
+		NotifyURL:    runtimeConfig.NotifyURL,
+		JumpURL:      runtimeConfig.JumpURL,
 		ClientIP:     clientIP,
 		Body:         "租号订单 " + orderRow.OrderNo,
 		Attach:       orderRow.OrderNo,
@@ -187,7 +193,7 @@ func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentReques
 		_ = r.markPaymentFailed(payment.ID, nil, err.Error())
 		return nil, err
 	}
-	if resp.RespCode != "0" || resp.ResultCode != "0" {
+	if !resp.OK {
 		_ = r.markPaymentFailed(payment.ID, resp.Raw, resp.ErrorMessage)
 		return nil, ErrPaymentUnavailable
 	}
@@ -198,7 +204,7 @@ func (r *Repository) Start(userID uint64, orderID uint64, req StartPaymentReques
 		"td_code":           resp.TDCode,
 		"jspay_url":         resp.JSPayURL,
 		"jspay_info":        resp.JSPayInfo,
-		"raw_request":       jsonMap(rawReq),
+		"raw_request":       jsonMap(resp.RawRequest),
 		"raw_response":      jsonMap(withRawSource(resp.Raw, channelSourceCreate)),
 	}).Error; err != nil {
 		return nil, err
@@ -242,14 +248,17 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 		dto := toDTO(*latest)
 		return &dto, nil
 	}
-	client := runtimeConfig.client()
-	resp, rawReq, err := client.CreatePayment(context.Background(), leshua.CreatePaymentRequest{
+	if runtimeConfig.Channel == nil {
+		_ = r.markPaymentFailed(payment.ID, nil, "payment channel unavailable")
+		return nil, ErrPaymentUnavailable
+	}
+	resp, err := runtimeConfig.Channel.CreatePayment(context.Background(), channelCreatePaymentRequest{
 		ThirdOrderID: payment.ThirdOrderID,
 		AmountCent:   payment.AmountCent,
 		PayWay:       payment.PayWay,
 		JSPayFlag:    payment.JSPayFlag,
-		NotifyURL:    runtimeConfig.Leshua.NotifyURL,
-		JumpURL:      runtimeConfig.Leshua.JumpURL,
+		NotifyURL:    runtimeConfig.NotifyURL,
+		JumpURL:      runtimeConfig.JumpURL,
 		ClientIP:     clientIP,
 		Body:         "钱包充值 " + payment.PaymentNo,
 		Attach:       payment.PaymentNo,
@@ -258,7 +267,7 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 		_ = r.markPaymentFailed(payment.ID, nil, err.Error())
 		return nil, err
 	}
-	if resp.RespCode != "0" || resp.ResultCode != "0" {
+	if !resp.OK {
 		_ = r.markPaymentFailed(payment.ID, resp.Raw, resp.ErrorMessage)
 		return nil, ErrPaymentUnavailable
 	}
@@ -269,7 +278,7 @@ func (r *Repository) StartWalletRecharge(userID uint64, req WalletRechargePaymen
 		"td_code":           resp.TDCode,
 		"jspay_url":         resp.JSPayURL,
 		"jspay_info":        resp.JSPayInfo,
-		"raw_request":       jsonMap(rawReq),
+		"raw_request":       jsonMap(resp.RawRequest),
 		"raw_response":      jsonMap(withRawSource(resp.Raw, channelSourceCreate)),
 	}).Error; err != nil {
 		return nil, err
@@ -299,7 +308,10 @@ func (r *Repository) QueryWalletRecharge(userID uint64, paymentID uint64) (*Paym
 		dto := toDTO(payment)
 		return &dto, nil
 	}
-	resp, err := runtimeConfig.client().QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	if runtimeConfig.Channel == nil {
+		return nil, ErrPaymentUnavailable
+	}
+	resp, err := runtimeConfig.Channel.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
 	if err != nil {
 		return nil, err
 	}
@@ -330,7 +342,10 @@ func (r *Repository) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
 		dto := toDTO(payment)
 		return &dto, nil
 	}
-	resp, err := runtimeConfig.client().QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
+	if runtimeConfig.Channel == nil {
+		return nil, ErrPaymentUnavailable
+	}
+	resp, err := runtimeConfig.Channel.QueryPayment(context.Background(), payment.ThirdOrderID, payment.ProviderOrderID)
 	if err != nil {
 		return nil, err
 	}
@@ -346,9 +361,13 @@ func (r *Repository) Query(userID uint64, orderID uint64) (*PaymentDTO, error) {
 }

 func (r *Repository) HandleLeshuaNotify(params map[string]string, rawPayload string, contentType string) (*NotifyResult, error) {
+	return r.HandleNotify("leshua", params, rawPayload, contentType, "")
+}
+
+func (r *Repository) HandleNotify(provider string, params map[string]string, rawPayload string, contentType string, authorization string) (*NotifyResult, error) {
 	// 退款通知会携带 merchant_refund_id 或 leshua_refund_id。
-	if params["merchant_refund_id"] != "" || params["leshua_refund_id"] != "" {
-		return r.HandleRefundNotify(params, rawPayload, contentType)
+	if params["merchant_refund_id"] != "" || params["leshua_refund_id"] != "" || params["provider_refund_id"] != "" {
+		return r.HandleRefundNotify(provider, params, rawPayload, contentType, authorization)
 	}

 	payment, err := r.findPaymentForNotify(params)
@@ -359,19 +378,19 @@ func (r *Repository) HandleLeshuaNotify(params map[string]string, rawPayload str
 	if err != nil {
 		return nil, ErrPaymentUnavailable
 	}
-	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType)
+	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType, authorization)
 	if err != nil {
 		return nil, err
 	}

 	if amount := parseCent(params["amount"]); amount > 0 && amount != payment.AmountCent {
 		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)
+			log.Printf("[payment] %s notify diagnostic save failed third_order_id=%s err=%v", runtimeConfig.Provider, 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, normalizeNotifyPaymentStatus(runtimeConfig.Provider, params["status"]), params["pay_time"], raw, channelSourceNotify); err != nil {
 		return nil, err
 	}
 	return &NotifyResult{OK: true, Message: "000000"}, nil
@@ -450,36 +469,41 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		log.Printf("[payment] mark order refunding failed order_id=%d err=%v", orderID, err)
 	}

-	resp, rawReq, err := runtimeConfig.client().CreateRefund(context.Background(), leshua.CreateRefundRequest{
+	if runtimeConfig.Channel == nil {
+		_ = r.markRefundFailed(refundOrder.ID, orderID, refundAmountCent, map[string]string{"error": "payment channel unavailable"})
+		return nil, ErrPaymentUnavailable
+	}
+	resp, err := runtimeConfig.Channel.CreateRefund(context.Background(), channelCreateRefundRequest{
 		ThirdOrderID:     originalPayment.ThirdOrderID,
-		LeshuaOrderID:    originalPayment.ProviderOrderID,
+		ProviderOrderID:  originalPayment.ProviderOrderID,
 		MerchantRefundID: merchantRefundID,
 		RefundAmountCent: refundAmountCent,
-		NotifyURL:        runtimeConfig.Leshua.NotifyURL,
+		NotifyURL:        runtimeConfig.NotifyURL,
 		Attach:           originalPayment.OrderNo,
+		Remark:           remark,
 	})
 	if err != nil {
 		_ = r.markRefundFailed(refundOrder.ID, orderID, refundAmountCent, map[string]string{"error": err.Error()})
 		return nil, err
 	}
-	if resp.RespCode != "0" || resp.ResultCode != "0" {
+	if !resp.OK {
 		_ = r.markRefundFailed(refundOrder.ID, orderID, refundAmountCent, resp.Raw)
 		return nil, ErrPaymentUnavailable
 	}

 	refundStatus := "refunding"
 	var paidAt *time.Time
-	if resp.Status == "11" {
+	if resp.Status == "refunded" {
 		refundStatus = "refunded"
 		now := time.Now()
 		paidAt = &now
-	} else if resp.Status == "12" {
+	} else if resp.Status == "failed" {
 		refundStatus = "failed"
 	}
 	if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", refundOrder.ID).Updates(map[string]any{
 		"status":            refundStatus,
-		"provider_order_id": resp.LeshuaRefundID,
-		"raw_request":       jsonMap(rawReq),
+		"provider_order_id": resp.ProviderRefundID,
+		"raw_request":       jsonMap(resp.RawRequest),
 		"raw_response":      jsonMap(withRawSource(resp.Raw, channelSourceCreate)),
 		"paid_at":           paidAt,
 	}).Error; err != nil {
@@ -495,7 +519,7 @@ func (r *Repository) StartRefund(orderID uint64, refundAmountCent int64, bizType
 		_ = r.markOrderRefunding(orderID, refundAmountCent)
 	}
 	refundOrder.Status = refundStatus
-	refundOrder.ProviderOrderID = resp.LeshuaRefundID
+	refundOrder.ProviderOrderID = resp.ProviderRefundID

 	dto := toRefundDTO(refundOrder)
 	return &dto, nil
@@ -518,15 +542,18 @@ func (r *Repository) QueryRefundStatus(orderID uint64) (*RefundDTO, error) {
 		dto := toRefundDTO(payment)
 		return &dto, nil
 	}
-	resp, err := runtimeConfig.client().QueryRefund(context.Background(), leshua.QueryRefundRequest{
+	if runtimeConfig.Channel == nil {
+		return nil, ErrPaymentUnavailable
+	}
+	resp, err := runtimeConfig.Channel.QueryRefund(context.Background(), channelQueryRefundRequest{
 		ThirdOrderID:     payment.ThirdOrderID,
 		MerchantRefundID: payment.ThirdOrderID,
-		LeshuaRefundID:   payment.ProviderOrderID,
+		ProviderRefundID: payment.ProviderOrderID,
 	})
 	if err != nil {
 		return nil, err
 	}
-	if resp.Status == "11" {
+	if resp.Status == "refunded" {
 		now := time.Now()
 		if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
 			"status":       "refunded",
@@ -538,7 +565,7 @@ func (r *Repository) QueryRefundStatus(orderID uint64) (*RefundDTO, error) {
 		payment.Status = "refunded"
 		payment.PaidAt = &now
 		_ = r.updateOrderRefundStatus(orderID, payment.AmountCent)
-	} else if resp.Status == "12" {
+	} else if resp.Status == "failed" {
 		if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
 			"status":       "failed",
 			"raw_response": jsonMap(withRawSource(resp.Raw, channelSourceQuery)),
@@ -552,8 +579,8 @@ func (r *Repository) QueryRefundStatus(orderID uint64) (*RefundDTO, error) {
 	return &dto, nil
 }

-// HandleRefundNotify 处理乐刷退款通知。
-func (r *Repository) HandleRefundNotify(params map[string]string, rawPayload string, contentType string) (*NotifyResult, error) {
+// HandleRefundNotify 处理渠道退款通知。
+func (r *Repository) HandleRefundNotify(provider string, params map[string]string, rawPayload string, contentType string, authorization string) (*NotifyResult, error) {
 	payment, err := r.findRefundPaymentForNotify(params)
 	if err != nil {
 		return nil, err
@@ -562,15 +589,15 @@ func (r *Repository) HandleRefundNotify(params map[string]string, rawPayload str
 	if err != nil {
 		return nil, ErrPaymentUnavailable
 	}
-	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType)
+	verify, err := r.verifyNotify(payment, runtimeConfig, params, rawPayload, contentType, authorization)
 	if err != nil {
 		return nil, err
 	}

 	raw := withNotifyDiagnostic(params, rawPayload, contentType, verify, "verified")
-	status := params["status"]
+	status := normalizeNotifyRefundStatus(provider, params["status"])
 	switch status {
-	case "11":
+	case "refunded":
 		now := time.Now()
 		if err := r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
 			"status":       "refunded",
@@ -581,7 +608,7 @@ func (r *Repository) HandleRefundNotify(params map[string]string, rawPayload str
 			return nil, err
 		}
 		_ = r.updateOrderRefundStatus(payment.OrderID, payment.AmountCent)
-	case "12":
+	case "failed":
 		r.db.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(map[string]any{
 			"status":       "failed",
 			"notified_at":  time.Now(),
@@ -676,12 +703,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, runtimeConfig.Leshua.PayWay, "ZFBZF")
-			existing.JSPayFlag = firstNonEmpty(req.JSPayFlag, existing.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2")
+			existing.PayWay = firstNonEmpty(req.PayWay, existing.PayWay, runtimeConfig.PayWay, "ZFBZF")
+			existing.JSPayFlag = firstNonEmpty(req.JSPayFlag, existing.JSPayFlag, runtimeConfig.JSPayFlag, "2")
 			existing.AmountCent = amountCent
 			existing.Provider = firstNonEmpty(existing.Provider, runtimeConfig.Provider)
 			existing.MerchantID = firstNonEmpty(existing.MerchantID, runtimeConfig.MerchantID)
-			if existing.Provider != "leshua" && existing.ProviderOrderID == "" {
+			if existing.Provider == "mock" && existing.ProviderOrderID == "" {
 				existing.ProviderOrderID = "MOCK" + existing.ThirdOrderID
 			}
 			if err := tx.Save(&existing).Error; err != nil {
@@ -707,15 +734,15 @@ func (r *Repository) preparePayment(userID uint64, orderID uint64, req StartPaym
 			MerchantID:      runtimeConfig.MerchantID,
 			ThirdOrderID:    row.OrderNo,
 			ProviderOrderID: "",
-			PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.Leshua.PayWay, "ZFBZF"),
-			JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2"),
+			PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.PayWay, "ZFBZF"),
+			JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.JSPayFlag, "2"),
 			AmountCent:      amountCent,
 			BizType:         "order_pay",
 			Status:          "created",
 		}
 		if runtimeConfig.isMockMode() {
 			payment.ProviderOrderID = "MOCK" + row.OrderNo
-			payment.TDCode = "mock://leshua/pay/" + row.OrderNo
+			payment.TDCode = "mock://payment/pay/" + row.OrderNo
 		}
 		if err := tx.Create(&payment).Error; err != nil {
 			return err
@@ -748,15 +775,15 @@ func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64
 		MerchantID:      runtimeConfig.MerchantID,
 		ThirdOrderID:    paymentNo,
 		ProviderOrderID: "",
-		PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.Leshua.PayWay, "ZFBZF"),
-		JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.Leshua.JSPayFlag, "2"),
+		PayWay:          firstNonEmpty(req.PayWay, runtimeConfig.PayWay, "ZFBZF"),
+		JSPayFlag:       firstNonEmpty(req.JSPayFlag, runtimeConfig.JSPayFlag, "2"),
 		AmountCent:      amountCent,
 		BizType:         "wallet_recharge",
 		Status:          "created",
 	}
 	if runtimeConfig.isMockMode() {
 		payment.ProviderOrderID = "MOCK" + paymentNo
-		payment.TDCode = "mock://leshua/recharge/" + paymentNo
+		payment.TDCode = "mock://payment/recharge/" + paymentNo
 	}
 	if err := r.db.Create(&payment).Error; err != nil {
 		return nil, err
@@ -766,16 +793,16 @@ func (r *Repository) createWalletRechargePayment(userID uint64, amountCent int64

 func (r *Repository) applyChannelStatus(payment *model.PaymentOrder, status string, payTime string, raw map[string]string, source string) error {
 	switch status {
-	case "2", "30":
-		paidAt := parseLeshuaTime(payTime)
+	case "paid":
+		paidAt := parseChannelTime(payTime)
 		if paidAt == nil {
 			now := time.Now()
 			paidAt = &now
 		}
 		return r.confirmPaid(payment, status, *paidAt, raw, source)
-	case "6":
+	case "closed":
 		return r.updateChannelStatus(payment.ID, "closed", raw, source)
-	case "8":
+	case "failed":
 		return r.updateChannelStatus(payment.ID, "failed", raw, source)
 	default:
 		return r.updateChannelStatus(payment.ID, "paying", raw, source)
@@ -813,7 +840,7 @@ func (r *Repository) confirmPaid(payment *model.PaymentOrder, status string, pai
 	}
 	updates := map[string]any{
 		"status":            "paid",
-		"provider_order_id": firstNonEmpty(raw["leshua_order_id"], payment.ProviderOrderID),
+		"provider_order_id": firstNonEmpty(raw["provider_order_id"], raw["leshua_order_id"], raw["pay_order_no"], raw["trade_no"], payment.ProviderOrderID),
 		"raw_response":      jsonMap(withRawSource(raw, source)),
 		"paid_at":           paidAt,
 	}
@@ -871,28 +898,32 @@ func (r *Repository) findRefundPaymentForNotify(params map[string]string) (*mode
 	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
+func (r *Repository) verifyNotify(payment *model.PaymentOrder, runtimeConfig *runtimePaymentConfig, params map[string]string, rawPayload string, contentType string, authorization string) (channelVerifyNotifyResult, error) {
+	var verify channelVerifyNotifyResult
 	if runtimeConfig.isMockMode() {
 		return verify, nil
 	}
-	verify = runtimeConfig.client().VerifyNotifyDetail(params)
-	if !verify.OK {
+	if runtimeConfig.Channel == nil {
+		return verify, ErrPaymentUnavailable
+	}
+	verify, err := runtimeConfig.Channel.VerifyNotify(params, rawPayload, contentType, authorization)
+	if err != nil || !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] %s notify verify failed payment_id=%d third_order_id=%s got=%s expected=%s keys=%v base_string=%s",
+			runtimeConfig.Provider,
 			payment.ID,
 			params["third_order_id"],
 			verify.Got,
-			verify.Expected["notify_key"],
+			firstNonEmpty(verify.Expected["notify_key"], verify.Expected["notify_cert"], verify.Expected["error"]),
 			verify.ParamKeys,
-			verify.BaseString["notify_key"],
+			firstNonEmpty(verify.BaseString["notify_key"], verify.BaseString["notify_cert"]),
 		)
 		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)
+			log.Printf("[payment] %s notify diagnostic save failed payment_id=%d err=%v", runtimeConfig.Provider, 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)
+	log.Printf("[payment] %s notify verified payment_id=%d third_order_id=%s matched_key=%s", runtimeConfig.Provider, payment.ID, params["third_order_id"], verify.MatchedKey)
 	return verify, nil
 }

@@ -938,11 +969,11 @@ func parseCent(value string) int64 {
 	return amount
 }

-func parseLeshuaTime(value string) *time.Time {
+func parseChannelTime(value string) *time.Time {
 	if value == "" {
 		return nil
 	}
-	for _, layout := range []string{"2006-01-02 15:04:05", time.RFC3339} {
+	for _, layout := range []string{"2006-01-02 15:04:05", "20060102150405", time.RFC3339} {
 		parsed, err := time.ParseInLocation(layout, value, time.Local)
 		if err == nil {
 			return &parsed
@@ -974,7 +1005,7 @@ func withRawSource(raw map[string]string, source string) map[string]string {
 	return out
 }

-func (r *Repository) recordNotifyDiagnostic(paymentID uint64, params map[string]string, rawPayload string, contentType string, verify leshua.VerifyNotifyResult, status string) error {
+func (r *Repository) recordNotifyDiagnostic(paymentID uint64, params map[string]string, rawPayload string, contentType string, verify channelVerifyNotifyResult, status string) error {
 	if paymentID == 0 {
 		return nil
 	}
@@ -984,7 +1015,7 @@ func (r *Repository) recordNotifyDiagnostic(paymentID uint64, params map[string]
 		Update("raw_response", jsonMap(raw)).Error
 }

-func withNotifyDiagnostic(params map[string]string, rawPayload string, contentType string, verify leshua.VerifyNotifyResult, status string) map[string]string {
+func withNotifyDiagnostic(params map[string]string, rawPayload string, contentType string, verify channelVerifyNotifyResult, status string) map[string]string {
 	raw := withRawSource(params, channelSourceNotify)
 	raw["_notify_diagnostic_status"] = status
 	raw["_raw_payload"] = rawPayload