junhong_cmp_fiber/internal/infrastructure/payment/wechat_native.go

// Package payment 提供代理在线充值使用的支付渠道薄适配器。
package payment

import (
	"context"
	"strings"
	"time"

	"github.com/ArtisanCloud/PowerWeChat/v3/src/kernel"
	sdkpayment "github.com/ArtisanCloud/PowerWeChat/v3/src/payment"
	orderRequest "github.com/ArtisanCloud/PowerWeChat/v3/src/payment/order/request"
	"go.uber.org/zap"

	agentrecharge "github.com/break/junhong_cmp_fiber/internal/application/agentrecharge"
	"github.com/break/junhong_cmp_fiber/internal/infrastructure/integrationlog"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	apperrors "github.com/break/junhong_cmp_fiber/pkg/errors"
	wechatpay "github.com/break/junhong_cmp_fiber/pkg/wechat"
)

// WechatNativeAdapter 使用现有 PowerWeChat 实现 Native 预下单与查单。
type WechatNativeAdapter struct {
	cache       kernel.CacheInterface
	integration *integrationlog.Repository
	logger      *zap.Logger
}

// NewWechatNativeAdapter 创建微信 Native 支付适配器。
func NewWechatNativeAdapter(cache kernel.CacheInterface, integration *integrationlog.Repository, logger *zap.Logger) *WechatNativeAdapter {
	return &WechatNativeAdapter{cache: cache, integration: integration, logger: logger}
}

// Available 判断配置是否完整支持微信 Native 预下单、验签与查单。
func (a *WechatNativeAdapter) Available(config *model.WechatConfig) bool {
	return wechatConfigComplete(config, true)
}

// PreCreate 创建微信 Native 扫码支付单。
func (a *WechatNativeAdapter) PreCreate(ctx context.Context, request agentrecharge.OnlinePaymentRequest) (agentrecharge.OnlinePaymentResult, error) {
	app, err := a.paymentApp(request.Config)
	if err != nil {
		return agentrecharge.OnlinePaymentResult{}, err
	}
	attempt, err := a.startAttempt(ctx, request.PaymentNo, constants.IntegrationOperationPaymentPreCreate, request.Config.ID, request.Amount)
	if err != nil {
		return agentrecharge.OnlinePaymentResult{}, err
	}
	startedAt := time.Now()
	response, callErr := app.Order.TransactionNative(ctx, &orderRequest.RequestNativePrepay{
		Description: request.Description,
		OutTradeNo:  request.PaymentNo,
		TimeExpire:  request.ExpireAt.Format(time.RFC3339),
		Amount:      &orderRequest.NativeAmount{Total: int(request.Amount), Currency: "CNY"},
	})
	if callErr != nil {
		return agentrecharge.OnlinePaymentResult{}, a.completeUnknown(ctx, attempt.IntegrationID, startedAt, callErr)
	}
	if response == nil || strings.TrimSpace(response.CodeURL) == "" {
		err = apperrors.New(apperrors.CodeWechatPayFailed, "微信 Native 预下单未返回付款内容")
		_, completeErr := a.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
			Result: constants.IntegrationResultFailed, ProviderCode: "empty_code_url", ProviderMessage: err.Error(),
			ResponseSummary: map[string]any{"success": false}, DurationMS: time.Since(startedAt).Milliseconds(),
		})
		if completeErr != nil {
			return agentrecharge.OnlinePaymentResult{}, completeErr
		}
		return agentrecharge.OnlinePaymentResult{}, err
	}
	if _, err = a.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
		Result: constants.IntegrationResultSuccess, ResponseSummary: map[string]any{"success": true},
		DurationMS: time.Since(startedAt).Milliseconds(), StateChanged: true,
	}); err != nil {
		return agentrecharge.OnlinePaymentResult{}, err
	}
	return agentrecharge.OnlinePaymentResult{QRContent: response.CodeURL}, nil
}

// Query 查询微信 Native 支付单状态。
func (a *WechatNativeAdapter) Query(ctx context.Context, paymentNo string, config *model.WechatConfig) (agentrecharge.OnlinePaymentQueryResult, error) {
	app, err := a.queryPaymentApp(config)
	if err != nil {
		return agentrecharge.OnlinePaymentQueryResult{}, err
	}
	attempt, err := a.startAttempt(ctx, paymentNo, constants.IntegrationOperationPaymentQuery, config.ID, 0)
	if err != nil {
		return agentrecharge.OnlinePaymentQueryResult{}, err
	}
	startedAt := time.Now()
	info, callErr := wechatpay.NewPaymentService(app, a.logger).QueryOrder(ctx, paymentNo)
	if callErr != nil {
		return agentrecharge.OnlinePaymentQueryResult{}, a.completeUnknown(ctx, attempt.IntegrationID, startedAt, callErr)
	}
	result := agentrecharge.OnlinePaymentQueryResult{
		State: mapWechatTradeState(info.TradeState), ThirdPartyTradeNo: info.TransactionID, Amount: info.TotalAmount,
	}
	if paidAt, parseErr := time.Parse(time.RFC3339, info.SuccessTime); parseErr == nil {
		result.PaidAt = &paidAt
	}
	if _, err = a.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
		Result: constants.IntegrationResultSuccess, ProviderCode: info.TradeState,
		ResponseSummary: map[string]any{"state": result.State, "has_trade_no": result.ThirdPartyTradeNo != ""},
		DurationMS:      time.Since(startedAt).Milliseconds(),
	}); err != nil {
		return agentrecharge.OnlinePaymentQueryResult{}, err
	}
	return result, nil
}

func (a *WechatNativeAdapter) paymentApp(config *model.WechatConfig) (*sdkpayment.Payment, error) {
	if !a.Available(config) {
		return nil, apperrors.New(apperrors.CodeNoPaymentConfig, "微信 Native 支付配置不可用")
	}
	app, err := wechatpay.NewPaymentAppFromConfig(config, config.OaAppID, a.cache, a.logger)
	if err != nil {
		return nil, apperrors.Wrap(apperrors.CodeNoPaymentConfig, err, "微信 Native 支付配置不可用")
	}
	return app, nil
}

func (a *WechatNativeAdapter) queryPaymentApp(config *model.WechatConfig) (*sdkpayment.Payment, error) {
	if !wechatConfigComplete(config, false) {
		return nil, apperrors.New(apperrors.CodeNoPaymentConfig, "微信查单配置不可用")
	}
	app, err := wechatpay.NewPaymentAppFromConfig(config, config.OaAppID, a.cache, a.logger)
	if err != nil {
		return nil, apperrors.Wrap(apperrors.CodeNoPaymentConfig, err, "微信查单配置不可用")
	}
	return app, nil
}

func wechatConfigComplete(config *model.WechatConfig, requireActive bool) bool {
	return config != nil && (!requireActive || config.IsActive) && config.ProviderType == model.ProviderTypeWechat &&
		config.OaAppID != "" && config.WxMchID != "" && config.WxAPIV3Key != "" &&
		config.WxCertContent != "" && config.WxKeyContent != "" && config.WxSerialNo != "" && config.WxNotifyURL != ""
}

func (a *WechatNativeAdapter) startAttempt(ctx context.Context, paymentNo, operation string, configID uint, amount int64) (*model.IntegrationLog, error) {
	resourceID := paymentNo
	return a.integration.Start(ctx, integrationlog.Attempt{
		Provider: constants.IntegrationProviderWechatPay, Direction: constants.IntegrationDirectionOutbound,
		Operation: operation, ResourceType: constants.IntegrationResourceTypeAgentRechargePayment,
		ResourceID: &resourceID, ExternalID: &resourceID,
		RequestSummary: map[string]any{"payment_config_id": configID, "amount": amount},
	})
}

func (a *WechatNativeAdapter) completeUnknown(ctx context.Context, integrationID string, startedAt time.Time, cause error) error {
	_, err := a.integration.Complete(ctx, integrationID, integrationlog.Completion{
		Result: constants.IntegrationResultUnknown, ProviderCode: "request_unknown", ProviderMessage: cause.Error(),
		ResponseSummary: map[string]any{"success": false}, DurationMS: time.Since(startedAt).Milliseconds(),
		RecoveryStrategy: "使用原支付单号主动查单，确认不存在或关闭后才允许关闭本地支付单",
	})
	if err != nil {
		return err
	}
	return apperrors.Wrap(apperrors.CodeTimeout, cause, "微信支付请求结果未知")
}

func mapWechatTradeState(state string) string {
	switch state {
	case "SUCCESS":
		return agentrecharge.OnlinePaymentStatePaid
	case "CLOSED", "REVOKED", "PAYERROR":
		return agentrecharge.OnlinePaymentStateClosed
	case "NOTPAY", "USERPAYING":
		return agentrecharge.OnlinePaymentStatePending
	default:
		return agentrecharge.OnlinePaymentStateUnknown
	}
}