huang
67e0840695
当前激活的微信支付配置 provider_type = wechat_v2，但 CreateRecharge 硬编码使用 V3（PowerWeChat）路径，导致初始化失败。 新增 createJSAPIPayOrder 方法，根据 provider_type 路由到对应通道： - wechat_v2 → NewPaymentV2ServiceFromConfig - wechat（默认）→ NewPaymentAppFromConfig（V3） 与 client_order.Service.newPaymentProvider 保持相同的路由逻辑。
688 lines
20 KiB
Go
688 lines
20 KiB
Go
package app
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"math/rand"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/break/junhong_cmp_fiber/internal/middleware"
|
||
"github.com/break/junhong_cmp_fiber/internal/model"
|
||
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
||
asset "github.com/break/junhong_cmp_fiber/internal/service/asset"
|
||
rechargeSvc "github.com/break/junhong_cmp_fiber/internal/service/recharge"
|
||
wechatConfigSvc "github.com/break/junhong_cmp_fiber/internal/service/wechat_config"
|
||
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
||
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
||
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
||
"github.com/break/junhong_cmp_fiber/pkg/response"
|
||
"github.com/break/junhong_cmp_fiber/pkg/wechat"
|
||
"github.com/gofiber/fiber/v2"
|
||
"github.com/redis/go-redis/v9"
|
||
"go.uber.org/zap"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// ClientWalletHandler C 端钱包处理器
|
||
// 提供 C1~C5 钱包详情、流水、充值前校验、充值下单、充值记录接口
|
||
type ClientWalletHandler struct {
|
||
assetService *asset.Service
|
||
personalDeviceStore *postgres.PersonalCustomerDeviceStore
|
||
walletStore *postgres.AssetWalletStore
|
||
transactionStore *postgres.AssetWalletTransactionStore
|
||
rechargeStore *postgres.AssetRechargeStore
|
||
rechargeService *rechargeSvc.Service
|
||
openIDStore *postgres.PersonalCustomerOpenIDStore
|
||
wechatConfigService *wechatConfigSvc.Service
|
||
redis *redis.Client
|
||
logger *zap.Logger
|
||
db *gorm.DB
|
||
iotCardStore *postgres.IotCardStore
|
||
deviceStore *postgres.DeviceStore
|
||
}
|
||
|
||
// NewClientWalletHandler 创建 C 端钱包处理器
|
||
func NewClientWalletHandler(
|
||
assetService *asset.Service,
|
||
personalDeviceStore *postgres.PersonalCustomerDeviceStore,
|
||
walletStore *postgres.AssetWalletStore,
|
||
transactionStore *postgres.AssetWalletTransactionStore,
|
||
rechargeStore *postgres.AssetRechargeStore,
|
||
rechargeService *rechargeSvc.Service,
|
||
openIDStore *postgres.PersonalCustomerOpenIDStore,
|
||
wechatConfigService *wechatConfigSvc.Service,
|
||
redisClient *redis.Client,
|
||
logger *zap.Logger,
|
||
db *gorm.DB,
|
||
iotCardStore *postgres.IotCardStore,
|
||
deviceStore *postgres.DeviceStore,
|
||
) *ClientWalletHandler {
|
||
return &ClientWalletHandler{
|
||
assetService: assetService,
|
||
personalDeviceStore: personalDeviceStore,
|
||
walletStore: walletStore,
|
||
transactionStore: transactionStore,
|
||
rechargeStore: rechargeStore,
|
||
rechargeService: rechargeService,
|
||
openIDStore: openIDStore,
|
||
wechatConfigService: wechatConfigService,
|
||
redis: redisClient,
|
||
logger: logger,
|
||
db: db,
|
||
iotCardStore: iotCardStore,
|
||
deviceStore: deviceStore,
|
||
}
|
||
}
|
||
|
||
type resolvedWalletAssetContext struct {
|
||
CustomerID uint
|
||
Identifier string
|
||
Asset *dto.AssetResolveResponse
|
||
Generation int
|
||
ResourceType string
|
||
SkipPermissionCtx context.Context
|
||
}
|
||
|
||
// GetWalletDetail C1 钱包详情
|
||
// GET /api/c/v1/wallet/detail
|
||
func (h *ClientWalletHandler) GetWalletDetail(c *fiber.Ctx) error {
|
||
var req dto.WalletDetailRequest
|
||
if err := c.QueryParser(&req); err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
resolved, err := h.resolveAssetFromIdentifier(c, req.Identifier)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
wallet, err := h.getOrCreateWallet(resolved)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
resp := &dto.WalletDetailResponse{
|
||
WalletID: wallet.ID,
|
||
ResourceType: wallet.ResourceType,
|
||
ResourceID: wallet.ResourceID,
|
||
Balance: wallet.Balance,
|
||
FrozenBalance: wallet.FrozenBalance,
|
||
UpdatedAt: wallet.UpdatedAt.Format(time.RFC3339),
|
||
}
|
||
|
||
return response.Success(c, resp)
|
||
}
|
||
|
||
// GetWalletTransactions C2 钱包流水列表
|
||
// GET /api/c/v1/wallet/transactions
|
||
func (h *ClientWalletHandler) GetWalletTransactions(c *fiber.Ctx) error {
|
||
var req dto.WalletTransactionListRequest
|
||
if err := c.QueryParser(&req); err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
if req.Page < 1 {
|
||
req.Page = 1
|
||
}
|
||
if req.PageSize < 1 {
|
||
req.PageSize = constants.DefaultPageSize
|
||
}
|
||
if req.PageSize > constants.MaxPageSize {
|
||
req.PageSize = constants.MaxPageSize
|
||
}
|
||
|
||
resolved, err := h.resolveAssetFromIdentifier(c, req.Identifier)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
wallet, err := h.walletStore.GetByResourceTypeAndID(resolved.SkipPermissionCtx, resolved.ResourceType, resolved.Asset.AssetID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return response.SuccessWithPagination(c, []dto.WalletTransactionItem{}, 0, req.Page, req.PageSize)
|
||
}
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询钱包失败")
|
||
}
|
||
|
||
var txType *string
|
||
if strings.TrimSpace(req.TransactionType) != "" {
|
||
v := strings.TrimSpace(req.TransactionType)
|
||
txType = &v
|
||
}
|
||
|
||
startTime, err := parseOptionalTime(req.StartTime)
|
||
if err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
endTime, err := parseOptionalTime(req.EndTime)
|
||
if err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
if startTime != nil && endTime != nil && endTime.Before(*startTime) {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
offset := (req.Page - 1) * req.PageSize
|
||
list, err := h.transactionStore.ListByResourceIDWithFilter(
|
||
resolved.SkipPermissionCtx,
|
||
wallet.ResourceType,
|
||
wallet.ResourceID,
|
||
txType,
|
||
startTime,
|
||
endTime,
|
||
offset,
|
||
req.PageSize,
|
||
)
|
||
if err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询钱包流水失败")
|
||
}
|
||
|
||
total, err := h.transactionStore.CountByResourceIDWithFilter(
|
||
resolved.SkipPermissionCtx,
|
||
wallet.ResourceType,
|
||
wallet.ResourceID,
|
||
txType,
|
||
startTime,
|
||
endTime,
|
||
)
|
||
if err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询钱包流水总数失败")
|
||
}
|
||
|
||
items := make([]dto.WalletTransactionItem, 0, len(list))
|
||
for _, tx := range list {
|
||
if tx == nil {
|
||
continue
|
||
}
|
||
|
||
remark := ""
|
||
if tx.Remark != nil {
|
||
remark = *tx.Remark
|
||
}
|
||
|
||
items = append(items, dto.WalletTransactionItem{
|
||
TransactionID: tx.ID,
|
||
Type: tx.TransactionType,
|
||
Amount: tx.Amount,
|
||
BalanceAfter: tx.BalanceAfter,
|
||
CreatedAt: tx.CreatedAt.Format(time.RFC3339),
|
||
Remark: remark,
|
||
})
|
||
}
|
||
|
||
return response.SuccessWithPagination(c, items, total, req.Page, req.PageSize)
|
||
}
|
||
|
||
// GetRechargeCheck C3 充值前校验
|
||
// GET /api/c/v1/wallet/recharge-check
|
||
func (h *ClientWalletHandler) GetRechargeCheck(c *fiber.Ctx) error {
|
||
var req dto.ClientRechargeCheckRequest
|
||
if err := c.QueryParser(&req); err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
resolved, err := h.resolveAssetFromIdentifier(c, req.Identifier)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
check, err := h.rechargeService.GetRechargeCheck(resolved.SkipPermissionCtx, resolved.ResourceType, resolved.Asset.AssetID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
resp := &dto.ClientRechargeCheckResponse{
|
||
NeedForceRecharge: check.NeedForceRecharge,
|
||
ForceRechargeAmount: check.ForceRechargeAmount,
|
||
TriggerType: check.TriggerType,
|
||
MinAmount: check.MinAmount,
|
||
MaxAmount: check.MaxAmount,
|
||
Message: check.Message,
|
||
}
|
||
|
||
return response.Success(c, resp)
|
||
}
|
||
|
||
// CreateRecharge C4 创建充值订单
|
||
// POST /api/c/v1/wallet/recharge
|
||
func (h *ClientWalletHandler) CreateRecharge(c *fiber.Ctx) error {
|
||
var req dto.ClientCreateRechargeRequest
|
||
if err := c.BodyParser(&req); err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
if req.PaymentMethod != constants.RechargeMethodWechat {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
resolved, err := h.resolveAssetFromIdentifier(c, req.Identifier)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
wallet, err := h.getOrCreateWallet(resolved)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
config, err := h.wechatConfigService.GetActiveConfig(resolved.SkipPermissionCtx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if config == nil {
|
||
return errors.New(errors.CodeWechatConfigUnavailable)
|
||
}
|
||
|
||
appID, err := pickAppIDByType(config, req.AppType)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
openID, err := h.findOpenIDByCustomerAndAppID(resolved.SkipPermissionCtx, resolved.CustomerID, appID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
rechargeNo := generateClientRechargeNo()
|
||
|
||
// 先初始化微信支付实例并创建预支付订单，确认支付通道可用
|
||
// 避免先写入充值记录后支付初始化失败，导致产生孤儿记录
|
||
payResult, err := h.createJSAPIPayOrder(
|
||
resolved.SkipPermissionCtx,
|
||
config,
|
||
appID,
|
||
rechargeNo,
|
||
"资产钱包充值",
|
||
openID,
|
||
int(req.Amount),
|
||
)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 支付通道确认可用后，再创建充值记录
|
||
recharge := &model.AssetRechargeRecord{
|
||
UserID: resolved.CustomerID,
|
||
AssetWalletID: wallet.ID,
|
||
ResourceType: resolved.ResourceType,
|
||
ResourceID: resolved.Asset.AssetID,
|
||
RechargeNo: rechargeNo,
|
||
Amount: req.Amount,
|
||
PaymentMethod: constants.RechargeMethodWechat,
|
||
PaymentConfigID: &config.ID,
|
||
Status: constants.RechargeStatusPending,
|
||
ShopIDTag: wallet.ShopIDTag,
|
||
EnterpriseIDTag: wallet.EnterpriseIDTag,
|
||
OperatorType: constants.OperatorTypePersonalCustomer,
|
||
Generation: resolved.Generation,
|
||
}
|
||
if err := h.rechargeStore.Create(resolved.SkipPermissionCtx, recharge); err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "创建充值记录失败")
|
||
}
|
||
|
||
payConfig := buildClientRechargePayConfig(appID, payResult)
|
||
resp := &dto.ClientRechargeResponse{
|
||
Recharge: dto.ClientRechargeResult{
|
||
RechargeID: recharge.ID,
|
||
RechargeNo: recharge.RechargeNo,
|
||
Amount: recharge.Amount,
|
||
Status: recharge.Status,
|
||
},
|
||
PayConfig: payConfig,
|
||
}
|
||
|
||
return response.Success(c, resp)
|
||
}
|
||
|
||
// GetRechargeList C5 充值记录列表
|
||
// GET /api/c/v1/wallet/recharges
|
||
func (h *ClientWalletHandler) GetRechargeList(c *fiber.Ctx) error {
|
||
var req dto.ClientRechargeListRequest
|
||
if err := c.QueryParser(&req); err != nil {
|
||
return errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
if req.Page < 1 {
|
||
req.Page = 1
|
||
}
|
||
if req.PageSize < 1 {
|
||
req.PageSize = constants.DefaultPageSize
|
||
}
|
||
if req.PageSize > constants.MaxPageSize {
|
||
req.PageSize = constants.MaxPageSize
|
||
}
|
||
|
||
resolved, err := h.resolveAssetFromIdentifier(c, req.Identifier)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
query := h.db.WithContext(resolved.SkipPermissionCtx).
|
||
Model(&model.AssetRechargeRecord{}).
|
||
Where("resource_type = ? AND resource_id = ? AND generation = ?", resolved.ResourceType, resolved.Asset.AssetID, resolved.Generation)
|
||
if req.Status != nil {
|
||
query = query.Where("status = ?", *req.Status)
|
||
}
|
||
|
||
var total int64
|
||
if err := query.Count(&total).Error; err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询充值记录总数失败")
|
||
}
|
||
|
||
var records []*model.AssetRechargeRecord
|
||
offset := (req.Page - 1) * req.PageSize
|
||
if err := query.Order("created_at DESC").Offset(offset).Limit(req.PageSize).Find(&records).Error; err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询充值记录失败")
|
||
}
|
||
|
||
items := make([]dto.ClientRechargeListItem, 0, len(records))
|
||
for _, record := range records {
|
||
if record == nil {
|
||
continue
|
||
}
|
||
items = append(items, dto.ClientRechargeListItem{
|
||
RechargeID: record.ID,
|
||
RechargeNo: record.RechargeNo,
|
||
Amount: record.Amount,
|
||
Status: record.Status,
|
||
PaymentMethod: record.PaymentMethod,
|
||
CreatedAt: record.CreatedAt.Format(time.RFC3339),
|
||
AutoPurchaseStatus: record.AutoPurchaseStatus,
|
||
})
|
||
}
|
||
|
||
return response.SuccessWithPagination(c, items, total, req.Page, req.PageSize)
|
||
}
|
||
|
||
// resolveAssetFromIdentifier 统一执行资产解析与归属校验
|
||
func (h *ClientWalletHandler) resolveAssetFromIdentifier(c *fiber.Ctx, identifier string) (*resolvedWalletAssetContext, error) {
|
||
customerID, ok := middleware.GetCustomerID(c)
|
||
if !ok || customerID == 0 {
|
||
return nil, errors.New(errors.CodeUnauthorized)
|
||
}
|
||
|
||
identifier = strings.TrimSpace(identifier)
|
||
if identifier == "" {
|
||
identifier = strings.TrimSpace(c.Query("identifier"))
|
||
}
|
||
if identifier == "" {
|
||
return nil, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
skipPermissionCtx := context.WithValue(c.UserContext(), constants.ContextKeySubordinateShopIDs, []uint{})
|
||
assetInfo, err := h.assetService.Resolve(skipPermissionCtx, identifier)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
owned, ownErr := h.isCustomerOwnAsset(skipPermissionCtx, customerID, assetInfo.VirtualNo)
|
||
if ownErr != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, ownErr, "查询资产归属失败")
|
||
}
|
||
if !owned {
|
||
return nil, errors.New(errors.CodeForbidden, "无权限操作该资产或资源不存在")
|
||
}
|
||
|
||
resourceType, mapErr := mapAssetTypeToWalletResource(assetInfo.AssetType)
|
||
if mapErr != nil {
|
||
return nil, mapErr
|
||
}
|
||
|
||
generation, genErr := h.getAssetGeneration(skipPermissionCtx, assetInfo.AssetType, assetInfo.AssetID)
|
||
if genErr != nil {
|
||
return nil, genErr
|
||
}
|
||
|
||
return &resolvedWalletAssetContext{
|
||
CustomerID: customerID,
|
||
Identifier: identifier,
|
||
Asset: assetInfo,
|
||
Generation: generation,
|
||
ResourceType: resourceType,
|
||
SkipPermissionCtx: skipPermissionCtx,
|
||
}, nil
|
||
}
|
||
|
||
func (h *ClientWalletHandler) isCustomerOwnAsset(ctx context.Context, customerID uint, virtualNo string) (bool, error) {
|
||
records, err := h.personalDeviceStore.GetByCustomerID(ctx, customerID)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
for _, record := range records {
|
||
if record == nil {
|
||
continue
|
||
}
|
||
if record.Status == constants.StatusEnabled && record.VirtualNo == virtualNo {
|
||
return true, nil
|
||
}
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (h *ClientWalletHandler) getAssetGeneration(ctx context.Context, assetType string, assetID uint) (int, error) {
|
||
switch assetType {
|
||
case "card":
|
||
card, err := h.iotCardStore.GetByID(ctx, assetID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return 0, errors.New(errors.CodeAssetNotFound)
|
||
}
|
||
return 0, errors.Wrap(errors.CodeDatabaseError, err, "查询卡信息失败")
|
||
}
|
||
return card.Generation, nil
|
||
case "device":
|
||
device, err := h.deviceStore.GetByID(ctx, assetID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return 0, errors.New(errors.CodeAssetNotFound)
|
||
}
|
||
return 0, errors.Wrap(errors.CodeDatabaseError, err, "查询设备信息失败")
|
||
}
|
||
return device.Generation, nil
|
||
default:
|
||
return 0, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
func (h *ClientWalletHandler) getOrCreateWallet(resolved *resolvedWalletAssetContext) (*model.AssetWallet, error) {
|
||
wallet, err := h.walletStore.GetByResourceTypeAndID(resolved.SkipPermissionCtx, resolved.ResourceType, resolved.Asset.AssetID)
|
||
if err == nil {
|
||
return wallet, nil
|
||
}
|
||
if err != gorm.ErrRecordNotFound {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询钱包失败")
|
||
}
|
||
|
||
shopIDTag := uint(0)
|
||
if resolved.Asset.ShopID != nil {
|
||
shopIDTag = *resolved.Asset.ShopID
|
||
}
|
||
|
||
newWallet := &model.AssetWallet{
|
||
ResourceType: resolved.ResourceType,
|
||
ResourceID: resolved.Asset.AssetID,
|
||
Balance: 0,
|
||
FrozenBalance: 0,
|
||
Currency: "CNY",
|
||
Status: constants.AssetWalletStatusNormal,
|
||
Version: 0,
|
||
ShopIDTag: shopIDTag,
|
||
}
|
||
if createErr := h.walletStore.Create(resolved.SkipPermissionCtx, newWallet); createErr != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, createErr, "创建钱包失败")
|
||
}
|
||
|
||
wallet, err = h.walletStore.GetByResourceTypeAndID(resolved.SkipPermissionCtx, resolved.ResourceType, resolved.Asset.AssetID)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询钱包失败")
|
||
}
|
||
return wallet, nil
|
||
}
|
||
|
||
func (h *ClientWalletHandler) findOpenIDByCustomerAndAppID(ctx context.Context, customerID uint, appID string) (string, error) {
|
||
list, err := h.openIDStore.ListByCustomerID(ctx, customerID)
|
||
if err != nil {
|
||
return "", errors.Wrap(errors.CodeDatabaseError, err, "查询微信授权信息失败")
|
||
}
|
||
for _, item := range list {
|
||
if item == nil {
|
||
continue
|
||
}
|
||
if item.AppID == appID && strings.TrimSpace(item.OpenID) != "" {
|
||
return item.OpenID, nil
|
||
}
|
||
}
|
||
return "", errors.New(errors.CodeOpenIDNotFound)
|
||
}
|
||
|
||
func mapAssetTypeToWalletResource(assetType string) (string, error) {
|
||
switch assetType {
|
||
case "card":
|
||
return constants.AssetWalletResourceTypeIotCard, nil
|
||
case "device":
|
||
return constants.AssetWalletResourceTypeDevice, nil
|
||
default:
|
||
return "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
func parseOptionalTime(value string) (*time.Time, error) {
|
||
v := strings.TrimSpace(value)
|
||
if v == "" {
|
||
return nil, nil
|
||
}
|
||
|
||
layouts := []string{time.RFC3339, "2006-01-02 15:04:05", "2006-01-02"}
|
||
for _, layout := range layouts {
|
||
t, err := time.Parse(layout, v)
|
||
if err == nil {
|
||
return &t, nil
|
||
}
|
||
}
|
||
|
||
return nil, fmt.Errorf("invalid time format")
|
||
}
|
||
|
||
func pickAppIDByType(config *model.WechatConfig, appType string) (string, error) {
|
||
switch appType {
|
||
case "official_account":
|
||
if strings.TrimSpace(config.OaAppID) == "" {
|
||
return "", errors.New(errors.CodeWechatConfigUnavailable)
|
||
}
|
||
return config.OaAppID, nil
|
||
case "miniapp":
|
||
if strings.TrimSpace(config.MiniappAppID) == "" {
|
||
return "", errors.New(errors.CodeWechatConfigUnavailable)
|
||
}
|
||
return config.MiniappAppID, nil
|
||
default:
|
||
return "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
// createJSAPIPayOrder 根据支付配置的提供者类型路由到对应支付通道，发起 JSAPI 预下单。
|
||
// 与 client_order.Service.newPaymentProvider 保持相同的路由逻辑，支持 wechat_v2 和 wechat（v3）。
|
||
func (h *ClientWalletHandler) createJSAPIPayOrder(
|
||
ctx context.Context,
|
||
config *model.WechatConfig,
|
||
appID, orderNo, description, openID string,
|
||
amount int,
|
||
) (*wechat.JSAPIPayResult, error) {
|
||
switch config.ProviderType {
|
||
case model.ProviderTypeWechatV2:
|
||
// 微信 v2：仅需 APIv2Key，无需证书序列号
|
||
svc, err := wechat.NewPaymentV2ServiceFromConfig(config, appID, h.logger)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeWechatPayFailed, err, "初始化微信 v2 支付实例失败")
|
||
}
|
||
return svc.CreateJSAPIOrder(ctx, orderNo, description, openID, amount)
|
||
default:
|
||
// 微信 v3（PowerWeChat）：需要证书序列号和 API v3 Key
|
||
cache := wechat.NewRedisCache(h.redis)
|
||
paymentApp, err := wechat.NewPaymentAppFromConfig(config, appID, cache, h.logger)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeWechatPayFailed, err, "初始化微信支付实例失败")
|
||
}
|
||
return wechat.NewPaymentService(paymentApp, h.logger).CreateJSAPIOrder(ctx, orderNo, description, openID, amount)
|
||
}
|
||
}
|
||
|
||
func generateClientRechargeNo() string {
|
||
timestamp := time.Now().Format("20060102150405")
|
||
randomNum := rand.Intn(1000000)
|
||
return fmt.Sprintf("%s%s%06d", constants.AssetRechargeOrderPrefix, timestamp, randomNum)
|
||
}
|
||
|
||
func buildClientRechargePayConfig(appID string, result *wechat.JSAPIPayResult) dto.ClientRechargePayConfig {
|
||
resp := dto.ClientRechargePayConfig{AppID: appID}
|
||
if result == nil || result.PayConfig == nil {
|
||
return resp
|
||
}
|
||
|
||
if cfg, ok := result.PayConfig.(map[string]any); ok {
|
||
resp.Timestamp = getStringFromAnyMap(cfg, "timeStamp", "timestamp")
|
||
resp.NonceStr = getStringFromAnyMap(cfg, "nonceStr", "nonce_str")
|
||
resp.PackageVal = getStringFromAnyMap(cfg, "package")
|
||
resp.SignType = getStringFromAnyMap(cfg, "signType", "sign_type")
|
||
resp.PaySign = getStringFromAnyMap(cfg, "paySign", "pay_sign")
|
||
if appIDVal := getStringFromAnyMap(cfg, "appId", "app_id"); appIDVal != "" {
|
||
resp.AppID = appIDVal
|
||
}
|
||
return resp
|
||
}
|
||
|
||
if cfg, ok := result.PayConfig.(map[string]string); ok {
|
||
resp.Timestamp = cfg["timeStamp"]
|
||
if resp.Timestamp == "" {
|
||
resp.Timestamp = cfg["timestamp"]
|
||
}
|
||
resp.NonceStr = cfg["nonceStr"]
|
||
if resp.NonceStr == "" {
|
||
resp.NonceStr = cfg["nonce_str"]
|
||
}
|
||
resp.PackageVal = cfg["package"]
|
||
resp.SignType = cfg["signType"]
|
||
if resp.SignType == "" {
|
||
resp.SignType = cfg["sign_type"]
|
||
}
|
||
resp.PaySign = cfg["paySign"]
|
||
if resp.PaySign == "" {
|
||
resp.PaySign = cfg["pay_sign"]
|
||
}
|
||
if cfg["appId"] != "" {
|
||
resp.AppID = cfg["appId"]
|
||
} else if cfg["app_id"] != "" {
|
||
resp.AppID = cfg["app_id"]
|
||
}
|
||
}
|
||
|
||
return resp
|
||
}
|
||
|
||
func getStringFromAnyMap(m map[string]any, keys ...string) string {
|
||
for _, key := range keys {
|
||
val, ok := m[key]
|
||
if !ok || val == nil {
|
||
continue
|
||
}
|
||
switch v := val.(type) {
|
||
case string:
|
||
if v != "" {
|
||
return v
|
||
}
|
||
case fmt.Stringer:
|
||
text := v.String()
|
||
if text != "" {
|
||
return text
|
||
}
|
||
default:
|
||
text := fmt.Sprintf("%v", v)
|
||
if text != "" && text != "<nil>" {
|
||
return text
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|