1024 lines
33 KiB
Go
1024 lines
33 KiB
Go
// Package client_order 提供 C 端订单下单服务。
|
||
package client_order
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"math/rand"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"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"
|
||
"github.com/break/junhong_cmp_fiber/internal/service/purchase_validation"
|
||
"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/bytedance/sonic"
|
||
"github.com/redis/go-redis/v9"
|
||
"go.uber.org/zap"
|
||
"gorm.io/datatypes"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
const (
|
||
clientPurchaseIdempotencyTTL = 5 * time.Minute
|
||
clientPurchaseLockTTL = 10 * time.Second
|
||
)
|
||
|
||
// WechatConfigServiceInterface 微信配置服务接口。
|
||
type WechatConfigServiceInterface interface {
|
||
GetActiveConfig(ctx context.Context) (*model.WechatConfig, error)
|
||
}
|
||
|
||
// OrderWalletPayServiceInterface 订单钱包支付服务接口。
|
||
// 用于将钱包扣款、套餐激活、佣金计算等核心逻辑委托给 B 端 order.Service 处理。
|
||
type OrderWalletPayServiceInterface interface {
|
||
WalletPay(ctx context.Context, orderID uint, buyerType string, buyerID uint) error
|
||
}
|
||
|
||
// ForceRechargeRequirement 强充要求。
|
||
type ForceRechargeRequirement struct {
|
||
NeedForceRecharge bool
|
||
ForceRechargeAmount int64
|
||
}
|
||
|
||
// Service 客户端订单服务。
|
||
type Service struct {
|
||
assetService *asset.Service
|
||
purchaseValidationService *purchase_validation.Service
|
||
orderStore *postgres.OrderStore
|
||
rechargeRecordStore *postgres.AssetRechargeStore
|
||
walletStore *postgres.AssetWalletStore
|
||
personalDeviceStore *postgres.PersonalCustomerDeviceStore
|
||
openIDStore *postgres.PersonalCustomerOpenIDStore
|
||
personalCustomerStore *postgres.PersonalCustomerStore
|
||
personalCustomerPhoneStore *postgres.PersonalCustomerPhoneStore
|
||
wechatConfigService WechatConfigServiceInterface
|
||
orderPaymentService OrderWalletPayServiceInterface
|
||
packageSeriesStore *postgres.PackageSeriesStore
|
||
shopSeriesAllocationStore *postgres.ShopSeriesAllocationStore
|
||
iotCardStore *postgres.IotCardStore
|
||
deviceStore *postgres.DeviceStore
|
||
db *gorm.DB
|
||
redis *redis.Client
|
||
logger *zap.Logger
|
||
}
|
||
|
||
// New 创建客户端订单服务。
|
||
func New(
|
||
assetService *asset.Service,
|
||
purchaseValidationService *purchase_validation.Service,
|
||
orderStore *postgres.OrderStore,
|
||
rechargeRecordStore *postgres.AssetRechargeStore,
|
||
walletStore *postgres.AssetWalletStore,
|
||
personalDeviceStore *postgres.PersonalCustomerDeviceStore,
|
||
openIDStore *postgres.PersonalCustomerOpenIDStore,
|
||
personalCustomerStore *postgres.PersonalCustomerStore,
|
||
personalCustomerPhoneStore *postgres.PersonalCustomerPhoneStore,
|
||
wechatConfigService WechatConfigServiceInterface,
|
||
orderPaymentService OrderWalletPayServiceInterface,
|
||
packageSeriesStore *postgres.PackageSeriesStore,
|
||
shopSeriesAllocationStore *postgres.ShopSeriesAllocationStore,
|
||
iotCardStore *postgres.IotCardStore,
|
||
deviceStore *postgres.DeviceStore,
|
||
db *gorm.DB,
|
||
redisClient *redis.Client,
|
||
logger *zap.Logger,
|
||
) *Service {
|
||
return &Service{
|
||
assetService: assetService,
|
||
purchaseValidationService: purchaseValidationService,
|
||
orderStore: orderStore,
|
||
rechargeRecordStore: rechargeRecordStore,
|
||
walletStore: walletStore,
|
||
personalDeviceStore: personalDeviceStore,
|
||
openIDStore: openIDStore,
|
||
personalCustomerStore: personalCustomerStore,
|
||
personalCustomerPhoneStore: personalCustomerPhoneStore,
|
||
wechatConfigService: wechatConfigService,
|
||
orderPaymentService: orderPaymentService,
|
||
packageSeriesStore: packageSeriesStore,
|
||
shopSeriesAllocationStore: shopSeriesAllocationStore,
|
||
iotCardStore: iotCardStore,
|
||
deviceStore: deviceStore,
|
||
db: db,
|
||
redis: redisClient,
|
||
logger: logger,
|
||
}
|
||
}
|
||
|
||
// CreateOrder 创建客户端订单。
|
||
// 普通套餐下单：仅创建待支付订单，不发起支付，需后续调用 POST /orders/:id/pay 支付。
|
||
// 强充场景：检测到需要强充时，直接创建充值单并发起微信支付（一步完成），此时 app_type 必传。
|
||
func (s *Service) CreateOrder(ctx context.Context, customerID uint, req *dto.ClientCreateOrderRequest) (*dto.ClientCreateOrderResponse, error) {
|
||
if req == nil {
|
||
return nil, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
if s.redis == nil {
|
||
return nil, errors.New(errors.CodeInternalError, "Redis 服务未配置")
|
||
}
|
||
|
||
skipCtx := context.WithValue(ctx, constants.ContextKeySubordinateShopIDs, []uint{})
|
||
assetInfo, err := s.assetService.Resolve(skipCtx, strings.TrimSpace(req.Identifier))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if err := s.checkAssetOwnership(skipCtx, customerID, assetInfo.VirtualNo); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
validationResult, err := s.validatePurchase(skipCtx, assetInfo, req.PackageIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 暂不做实名认证拦截，由网关侧处理
|
||
// REALNAME-03: 普通卡需要实名，行业卡不需要，待后续业务明确后按卡类型分支启用
|
||
// if assetInfo.CardCategory == "normal" && assetInfo.RealNameStatus != constants.RealNameStatusVerified {
|
||
// return nil, errors.New(errors.CodeNeedRealname)
|
||
// }
|
||
|
||
// 先判断是否需要强充，避免普通下单时不必要地校验微信配置
|
||
forceRecharge := s.checkForceRechargeRequirement(skipCtx, validationResult)
|
||
|
||
businessKey := buildClientPurchaseBusinessKey(customerID, assetInfo, req.PackageIDs)
|
||
redisKey := constants.RedisClientPurchaseIdempotencyKey(businessKey)
|
||
lockKey := constants.RedisClientPurchaseLockKey(assetInfo.AssetType, assetInfo.AssetID)
|
||
|
||
lockAcquired, err := s.redis.SetNX(skipCtx, lockKey, time.Now().String(), clientPurchaseLockTTL).Result()
|
||
if err != nil {
|
||
s.logger.Warn("获取客户端购买分布式锁失败，继续尝试幂等标记",
|
||
zap.Error(err),
|
||
zap.String("lock_key", lockKey),
|
||
)
|
||
}
|
||
if err == nil && !lockAcquired {
|
||
return nil, errors.New(errors.CodeTooManyRequests, "订单正在创建中，请勿重复提交")
|
||
}
|
||
|
||
claimed, err := s.redis.SetNX(skipCtx, redisKey, "processing", clientPurchaseIdempotencyTTL).Result()
|
||
if err != nil {
|
||
if lockAcquired {
|
||
_ = s.redis.Del(skipCtx, lockKey).Err()
|
||
}
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "设置客户端购买幂等标记失败")
|
||
}
|
||
if !claimed {
|
||
if lockAcquired {
|
||
_ = s.redis.Del(skipCtx, lockKey).Err()
|
||
}
|
||
return nil, errors.New(errors.CodeTooManyRequests, "订单正在创建中，请勿重复提交")
|
||
}
|
||
|
||
created := false
|
||
defer func() {
|
||
if lockAcquired {
|
||
_ = s.redis.Del(skipCtx, lockKey).Err()
|
||
}
|
||
if !created {
|
||
_ = s.redis.Del(skipCtx, redisKey).Err()
|
||
}
|
||
}()
|
||
|
||
if forceRecharge.NeedForceRecharge {
|
||
// 强充场景需要微信支付，此时 app_type 必须传入
|
||
activeConfig, appID, err := s.resolveWechatConfig(skipCtx, req.AppType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
openID, err := s.resolveCustomerOpenID(skipCtx, customerID, appID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
paymentProvider, err := s.newPaymentProvider(activeConfig, appID, req.AppType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return s.createForceRechargeOrder(skipCtx, customerID, openID, assetInfo, validationResult, activeConfig, forceRecharge, redisKey, paymentProvider, &created)
|
||
}
|
||
|
||
return s.createPackageOrder(skipCtx, customerID, validationResult, redisKey, &created)
|
||
}
|
||
|
||
func (s *Service) checkAssetOwnership(ctx context.Context, customerID uint, virtualNo string) error {
|
||
owned, err := s.personalDeviceStore.ExistsByCustomerAndDevice(ctx, customerID, virtualNo)
|
||
if err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询资产归属失败")
|
||
}
|
||
if owned {
|
||
return nil
|
||
}
|
||
|
||
records, err := s.personalDeviceStore.GetByCustomerID(ctx, customerID)
|
||
if err != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询资产归属失败")
|
||
}
|
||
for _, record := range records {
|
||
if record == nil {
|
||
continue
|
||
}
|
||
if record.Status == constants.StatusEnabled && record.VirtualNo == virtualNo {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
return errors.New(errors.CodeForbidden, "无权限操作该资产或资源不存在")
|
||
}
|
||
|
||
func (s *Service) validatePurchase(ctx context.Context, assetInfo *dto.AssetResolveResponse, packageIDs []uint) (*purchase_validation.PurchaseValidationResult, error) {
|
||
switch assetInfo.AssetType {
|
||
case "card":
|
||
return s.purchaseValidationService.ValidateCardPurchase(ctx, assetInfo.AssetID, packageIDs)
|
||
case constants.ResourceTypeDevice:
|
||
return s.purchaseValidationService.ValidateDevicePurchase(ctx, assetInfo.AssetID, packageIDs)
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
func (s *Service) resolveWechatConfig(ctx context.Context, appType string) (*model.WechatConfig, string, error) {
|
||
activeConfig, err := s.wechatConfigService.GetActiveConfig(ctx)
|
||
if err != nil {
|
||
return nil, "", errors.Wrap(errors.CodeDatabaseError, err, "查询微信配置失败")
|
||
}
|
||
if activeConfig == nil {
|
||
return nil, "", errors.New(errors.CodeWechatPayFailed, "未找到生效的微信支付配置")
|
||
}
|
||
|
||
switch appType {
|
||
case "official_account":
|
||
if activeConfig.OaAppID == "" {
|
||
return nil, "", errors.New(errors.CodeWechatPayFailed, "公众号支付配置不完整")
|
||
}
|
||
return activeConfig, activeConfig.OaAppID, nil
|
||
case "miniapp":
|
||
if activeConfig.MiniappAppID == "" {
|
||
return nil, "", errors.New(errors.CodeWechatPayFailed, "小程序支付配置不完整")
|
||
}
|
||
return activeConfig, activeConfig.MiniappAppID, nil
|
||
default:
|
||
return nil, "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
func (s *Service) resolveCustomerOpenID(ctx context.Context, customerID uint, appID string) (string, error) {
|
||
records, err := s.openIDStore.ListByCustomerID(ctx, customerID)
|
||
if err != nil {
|
||
return "", errors.Wrap(errors.CodeDatabaseError, err, "查询微信授权信息失败")
|
||
}
|
||
|
||
for _, record := range records {
|
||
if record == nil {
|
||
continue
|
||
}
|
||
if record.AppID == appID && strings.TrimSpace(record.OpenID) != "" {
|
||
return record.OpenID, nil
|
||
}
|
||
}
|
||
|
||
return "", errors.New(errors.CodeNotFound, "未找到当前应用的微信授权信息")
|
||
}
|
||
|
||
func (s *Service) createPackageOrder(
|
||
ctx context.Context,
|
||
customerID uint,
|
||
validationResult *purchase_validation.PurchaseValidationResult,
|
||
redisKey string,
|
||
created *bool,
|
||
) (*dto.ClientCreateOrderResponse, error) {
|
||
// 查询卖家成本价，用于差价佣金链式计算的起点
|
||
// 平台直销（sellerShopID == 0）时成本价为 0，CalculateCostDiffCommission 会直接跳过
|
||
var sellerCostPrice int64
|
||
sellerShopID := resolveSellerShopID(validationResult)
|
||
if sellerShopID > 0 && len(validationResult.Packages) > 0 {
|
||
costPrice, err := s.purchaseValidationService.GetCostPrice(ctx, validationResult.Packages[0], sellerShopID)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "查询卖家成本价失败")
|
||
}
|
||
sellerCostPrice = costPrice
|
||
}
|
||
|
||
order, err := s.buildPendingOrder(ctx, customerID, validationResult, sellerCostPrice)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
items, err := s.buildOrderItems(ctx, customerID, validationResult)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if err := s.orderStore.Create(ctx, order, items); err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建订单失败")
|
||
}
|
||
|
||
s.markClientPurchaseCreated(ctx, redisKey, order.OrderNo)
|
||
*created = true
|
||
|
||
return &dto.ClientCreateOrderResponse{
|
||
OrderType: "package",
|
||
Order: &dto.ClientOrderInfo{
|
||
OrderID: order.ID,
|
||
OrderNo: order.OrderNo,
|
||
TotalAmount: order.TotalAmount,
|
||
PaymentStatus: order.PaymentStatus,
|
||
PaymentStatusName: constants.GetOrderPaymentStatusName(order.PaymentStatus),
|
||
CreatedAt: formatClientServiceTime(order.CreatedAt),
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
func (s *Service) createForceRechargeOrder(
|
||
ctx context.Context,
|
||
customerID uint,
|
||
openID string,
|
||
assetInfo *dto.AssetResolveResponse,
|
||
validationResult *purchase_validation.PurchaseValidationResult,
|
||
activeConfig *model.WechatConfig,
|
||
forceRecharge *ForceRechargeRequirement,
|
||
redisKey string,
|
||
paymentProvider PaymentProvider,
|
||
created *bool,
|
||
) (*dto.ClientCreateOrderResponse, error) {
|
||
resourceType, resourceID, err := resolveWalletResource(validationResult)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
wallet, err := s.getOrCreateWallet(ctx, resourceType, resourceID, resolveSellerShopID(validationResult))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
linkedPackageIDs, err := sonic.Marshal(extractPackageIDs(validationResult.Packages))
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "序列化关联套餐失败")
|
||
}
|
||
|
||
carrierID := resourceID
|
||
recharge := &model.AssetRechargeRecord{
|
||
UserID: customerID,
|
||
AssetWalletID: wallet.ID,
|
||
ResourceType: resourceType,
|
||
ResourceID: resourceID,
|
||
RechargeNo: generateClientRechargeNo(),
|
||
Amount: forceRecharge.ForceRechargeAmount,
|
||
PaymentMethod: model.PaymentMethodWechat,
|
||
PaymentConfigID: &activeConfig.ID,
|
||
Status: 1,
|
||
ShopIDTag: wallet.ShopIDTag,
|
||
EnterpriseIDTag: wallet.EnterpriseIDTag,
|
||
OperatorType: "personal_customer",
|
||
Generation: resolveGeneration(validationResult),
|
||
LinkedPackageIDs: datatypes.JSON(linkedPackageIDs),
|
||
LinkedOrderType: resolveOrderType(validationResult),
|
||
LinkedCarrierType: assetInfo.AssetType,
|
||
LinkedCarrierID: &carrierID,
|
||
AutoPurchaseStatus: constants.AutoPurchaseStatusPending,
|
||
}
|
||
|
||
if err := s.rechargeRecordStore.Create(ctx, recharge); err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建充值记录失败")
|
||
}
|
||
|
||
paymentResult, err := paymentProvider.CreateJSAPIPayment(ctx, recharge.RechargeNo, "余额充值", openID, int(recharge.Amount))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 微信支付创建成功后才标记幂等 key，确保支付失败时 defer 能正确清除 key
|
||
s.markClientPurchaseCreated(ctx, redisKey, recharge.RechargeNo)
|
||
*created = true
|
||
|
||
clientStatus := rechargeStatusToClientStatus(recharge.Status)
|
||
return &dto.ClientCreateOrderResponse{
|
||
OrderType: "recharge",
|
||
Recharge: &dto.ClientRechargeInfo{
|
||
RechargeID: recharge.ID,
|
||
RechargeNo: recharge.RechargeNo,
|
||
Amount: recharge.Amount,
|
||
Status: clientStatus,
|
||
StatusName: clientRechargeStatusName(clientStatus),
|
||
AutoPurchaseStatus: recharge.AutoPurchaseStatus,
|
||
},
|
||
PayConfig: buildClientPayConfigFromResult(paymentResult),
|
||
LinkedPackageInfo: buildLinkedPackageInfo(validationResult, forceRecharge),
|
||
}, nil
|
||
}
|
||
|
||
func (s *Service) fetchBuyerSnapshot(ctx context.Context, customerID uint) (phone, nickname *string) {
|
||
if customerID == 0 {
|
||
return nil, nil
|
||
}
|
||
customer, err := s.personalCustomerStore.GetByID(ctx, customerID)
|
||
if err != nil {
|
||
s.logger.Warn("fetchBuyerSnapshot: 查询个人客户失败", zap.Uint("customer_id", customerID), zap.Error(err))
|
||
} else if customer != nil && customer.Nickname != "" {
|
||
nickname = &customer.Nickname
|
||
}
|
||
|
||
phoneRecord, err := s.personalCustomerPhoneStore.GetPrimaryPhone(ctx, customerID)
|
||
if err != nil {
|
||
s.logger.Warn("fetchBuyerSnapshot: 查询买家手机号失败", zap.Uint("customer_id", customerID), zap.Error(err))
|
||
} else if phoneRecord != nil && phoneRecord.Phone != "" {
|
||
phone = &phoneRecord.Phone
|
||
}
|
||
return phone, nickname
|
||
}
|
||
|
||
func (s *Service) buildPendingOrder(ctx context.Context, customerID uint, result *purchase_validation.PurchaseValidationResult, sellerCostPrice int64) (*model.Order, error) {
|
||
orderType := resolveOrderType(result)
|
||
if orderType == "" {
|
||
return nil, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
now := time.Now()
|
||
expiresAt := now.Add(constants.OrderExpireTimeout)
|
||
order := &model.Order{
|
||
BaseModel: model.BaseModel{
|
||
Creator: customerID,
|
||
Updater: customerID,
|
||
},
|
||
OrderNo: s.orderStore.GenerateOrderNo(),
|
||
OrderType: orderType,
|
||
BuyerType: model.BuyerTypePersonal,
|
||
BuyerID: customerID,
|
||
TotalAmount: result.TotalPrice,
|
||
PaymentStatus: model.PaymentStatusPending,
|
||
CommissionStatus: model.CommissionStatusPending,
|
||
CommissionConfigVersion: 0,
|
||
Source: constants.OrderSourceClient,
|
||
Generation: resolveGeneration(result),
|
||
ExpiresAt: &expiresAt,
|
||
SellerCostPrice: sellerCostPrice,
|
||
}
|
||
|
||
if result.Card != nil {
|
||
order.IotCardID = &result.Card.ID
|
||
order.SeriesID = result.Card.SeriesID
|
||
order.SellerShopID = result.Card.ShopID
|
||
} else if result.Device != nil {
|
||
order.DeviceID = &result.Device.ID
|
||
order.SeriesID = result.Device.SeriesID
|
||
order.SellerShopID = result.Device.ShopID
|
||
}
|
||
|
||
order.BuyerPhone, order.BuyerNickname = s.fetchBuyerSnapshot(ctx, customerID)
|
||
|
||
return order, nil
|
||
}
|
||
|
||
func (s *Service) buildOrderItems(ctx context.Context, customerID uint, result *purchase_validation.PurchaseValidationResult) ([]*model.OrderItem, error) {
|
||
sellerShopID := resolveSellerShopID(result)
|
||
items := make([]*model.OrderItem, 0, len(result.Packages))
|
||
|
||
for _, pkg := range result.Packages {
|
||
if pkg == nil {
|
||
continue
|
||
}
|
||
|
||
unitPrice, err := s.purchaseValidationService.GetPurchasePrice(ctx, pkg, sellerShopID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
items = append(items, &model.OrderItem{
|
||
BaseModel: model.BaseModel{
|
||
Creator: customerID,
|
||
Updater: customerID,
|
||
},
|
||
PackageID: pkg.ID,
|
||
PackageName: pkg.PackageName,
|
||
PackageType: &pkg.PackageType,
|
||
Quantity: 1,
|
||
UnitPrice: unitPrice,
|
||
Amount: unitPrice,
|
||
})
|
||
}
|
||
|
||
return items, nil
|
||
}
|
||
|
||
func (s *Service) checkForceRechargeRequirement(ctx context.Context, result *purchase_validation.PurchaseValidationResult) *ForceRechargeRequirement {
|
||
defaultResult := &ForceRechargeRequirement{NeedForceRecharge: false}
|
||
|
||
var seriesID *uint
|
||
var sellerShopID uint
|
||
if result.Card != nil {
|
||
seriesID = result.Card.SeriesID
|
||
if result.Card.ShopID != nil {
|
||
sellerShopID = *result.Card.ShopID
|
||
}
|
||
} else if result.Device != nil {
|
||
seriesID = result.Device.SeriesID
|
||
if result.Device.ShopID != nil {
|
||
sellerShopID = *result.Device.ShopID
|
||
}
|
||
}
|
||
|
||
if seriesID == nil || *seriesID == 0 {
|
||
return defaultResult
|
||
}
|
||
|
||
series, err := s.packageSeriesStore.GetByID(ctx, *seriesID)
|
||
if err != nil {
|
||
s.logger.Warn("查询套餐系列失败", zap.Uint("series_id", *seriesID), zap.Error(err))
|
||
return defaultResult
|
||
}
|
||
|
||
config, err := series.GetOneTimeCommissionConfig()
|
||
if err != nil || config == nil || !config.Enable {
|
||
return defaultResult
|
||
}
|
||
|
||
if config.TriggerType == model.OneTimeCommissionTriggerFirstRecharge {
|
||
return &ForceRechargeRequirement{
|
||
NeedForceRecharge: true,
|
||
ForceRechargeAmount: config.Threshold,
|
||
}
|
||
}
|
||
|
||
if config.EnableForceRecharge {
|
||
amount := config.ForceAmount
|
||
if amount == 0 {
|
||
amount = config.Threshold
|
||
}
|
||
return &ForceRechargeRequirement{
|
||
NeedForceRecharge: true,
|
||
ForceRechargeAmount: amount,
|
||
}
|
||
}
|
||
|
||
if sellerShopID > 0 {
|
||
allocation, allocErr := s.shopSeriesAllocationStore.GetByShopAndSeries(ctx, sellerShopID, *seriesID)
|
||
if allocErr == nil && allocation.EnableForceRecharge {
|
||
amount := allocation.ForceRechargeAmount
|
||
if amount == 0 {
|
||
amount = config.Threshold
|
||
}
|
||
return &ForceRechargeRequirement{
|
||
NeedForceRecharge: true,
|
||
ForceRechargeAmount: amount,
|
||
}
|
||
}
|
||
}
|
||
|
||
return defaultResult
|
||
}
|
||
|
||
func (s *Service) markClientPurchaseCreated(ctx context.Context, redisKey string, value string) {
|
||
if err := s.redis.Set(ctx, redisKey, value, clientPurchaseIdempotencyTTL).Err(); err != nil {
|
||
s.logger.Warn("设置客户端购买幂等标记失败",
|
||
zap.String("redis_key", redisKey),
|
||
zap.Error(err),
|
||
)
|
||
}
|
||
}
|
||
|
||
func buildLinkedPackageInfo(result *purchase_validation.PurchaseValidationResult, forceRecharge *ForceRechargeRequirement) *dto.LinkedPackageInfo {
|
||
packageNames := make([]string, 0, len(result.Packages))
|
||
for _, pkg := range result.Packages {
|
||
if pkg == nil || pkg.PackageName == "" {
|
||
continue
|
||
}
|
||
packageNames = append(packageNames, pkg.PackageName)
|
||
}
|
||
|
||
return &dto.LinkedPackageInfo{
|
||
PackageNames: packageNames,
|
||
TotalPackageAmount: result.TotalPrice,
|
||
ForceRechargeAmount: forceRecharge.ForceRechargeAmount,
|
||
WalletCredit: forceRecharge.ForceRechargeAmount,
|
||
}
|
||
}
|
||
|
||
// getOrCreateWallet 获取或自动创建资产钱包
|
||
// 兜底机制：当钱包不存在时自动创建，避免因钱包未提前创建导致业务中断
|
||
func (s *Service) getOrCreateWallet(ctx context.Context, resourceType string, resourceID uint, shopIDTag uint) (*model.AssetWallet, error) {
|
||
wallet, err := s.walletStore.GetByResourceTypeAndID(ctx, resourceType, resourceID)
|
||
if err == nil {
|
||
return wallet, nil
|
||
}
|
||
if err != gorm.ErrRecordNotFound {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询资产钱包失败")
|
||
}
|
||
|
||
// 钱包不存在，自动创建空钱包
|
||
s.logger.Info("资产钱包不存在，自动创建",
|
||
zap.String("resource_type", resourceType),
|
||
zap.Uint("resource_id", resourceID),
|
||
zap.Uint("shop_id_tag", shopIDTag),
|
||
)
|
||
|
||
newWallet := &model.AssetWallet{
|
||
ResourceType: resourceType,
|
||
ResourceID: resourceID,
|
||
Balance: 0,
|
||
FrozenBalance: 0,
|
||
Currency: "CNY",
|
||
Status: constants.AssetWalletStatusNormal,
|
||
Version: 0,
|
||
ShopIDTag: shopIDTag,
|
||
}
|
||
if createErr := s.walletStore.Create(ctx, newWallet); createErr != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, createErr, "自动创建资产钱包失败")
|
||
}
|
||
|
||
// 重新查询获取完整数据（含数据库生成的字段）
|
||
wallet, err = s.walletStore.GetByResourceTypeAndID(ctx, resourceType, resourceID)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询资产钱包失败")
|
||
}
|
||
return wallet, nil
|
||
}
|
||
|
||
func resolveWalletResource(result *purchase_validation.PurchaseValidationResult) (string, uint, error) {
|
||
if result.Card != nil {
|
||
return constants.AssetWalletResourceTypeIotCard, result.Card.ID, nil
|
||
}
|
||
if result.Device != nil {
|
||
return constants.AssetWalletResourceTypeDevice, result.Device.ID, nil
|
||
}
|
||
return "", 0, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
func resolveOrderType(result *purchase_validation.PurchaseValidationResult) string {
|
||
if result.Card != nil {
|
||
return model.OrderTypeSingleCard
|
||
}
|
||
if result.Device != nil {
|
||
return model.OrderTypeDevice
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func resolveGeneration(result *purchase_validation.PurchaseValidationResult) int {
|
||
if result.Card != nil && result.Card.Generation > 0 {
|
||
return result.Card.Generation
|
||
}
|
||
if result.Device != nil && result.Device.Generation > 0 {
|
||
return result.Device.Generation
|
||
}
|
||
return 1
|
||
}
|
||
|
||
func resolveSellerShopID(result *purchase_validation.PurchaseValidationResult) uint {
|
||
if result.Card != nil && result.Card.ShopID != nil {
|
||
return *result.Card.ShopID
|
||
}
|
||
if result.Device != nil && result.Device.ShopID != nil {
|
||
return *result.Device.ShopID
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func extractPackageIDs(packages []*model.Package) []uint {
|
||
ids := make([]uint, 0, len(packages))
|
||
for _, pkg := range packages {
|
||
if pkg == nil {
|
||
continue
|
||
}
|
||
ids = append(ids, pkg.ID)
|
||
}
|
||
return ids
|
||
}
|
||
|
||
func buildClientPurchaseBusinessKey(customerID uint, assetInfo *dto.AssetResolveResponse, packageIDs []uint) string {
|
||
sorted := make([]uint, len(packageIDs))
|
||
copy(sorted, packageIDs)
|
||
slices.Sort(sorted)
|
||
|
||
parts := make([]string, 0, len(sorted))
|
||
for _, id := range sorted {
|
||
parts = append(parts, strconv.FormatUint(uint64(id), 10))
|
||
}
|
||
|
||
return fmt.Sprintf("%d:%s:%d:%s", customerID, assetInfo.AssetType, assetInfo.AssetID, strings.Join(parts, ","))
|
||
}
|
||
|
||
func rechargeStatusToClientStatus(status int) int {
|
||
switch status {
|
||
case 1:
|
||
return 0
|
||
case 2, 3:
|
||
return 1
|
||
default:
|
||
return 2
|
||
}
|
||
}
|
||
|
||
func clientRechargeStatusName(clientStatus int) string {
|
||
switch clientStatus {
|
||
case 0:
|
||
return "待支付"
|
||
case 1:
|
||
return "已支付"
|
||
default:
|
||
return "已关闭"
|
||
}
|
||
}
|
||
|
||
func formatClientServiceTime(t time.Time) string {
|
||
if t.IsZero() {
|
||
return ""
|
||
}
|
||
return t.Format(time.RFC3339)
|
||
}
|
||
|
||
func generateClientRechargeNo() string {
|
||
return fmt.Sprintf("CRCH%d%06d", time.Now().UnixNano()/1e6, rand.Intn(1000000))
|
||
}
|
||
|
||
// ListOrders 查询 C 端订单列表。
|
||
func (s *Service) ListOrders(ctx context.Context, customerID uint, req *dto.ClientOrderListRequest) ([]dto.ClientOrderListItem, int64, error) {
|
||
skipCtx := context.WithValue(ctx, constants.ContextKeySubordinateShopIDs, []uint{})
|
||
|
||
assetInfo, err := s.assetService.Resolve(skipCtx, strings.TrimSpace(req.Identifier))
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
if err := s.checkAssetOwnership(skipCtx, customerID, assetInfo.VirtualNo); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
generation, err := s.getAssetGeneration(skipCtx, assetInfo.AssetType, assetInfo.AssetID)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
query := s.db.WithContext(skipCtx).
|
||
Model(&model.Order{}).
|
||
Where("generation = ?", generation)
|
||
|
||
if assetInfo.AssetType == constants.ResourceTypeDevice {
|
||
query = query.Where("order_type = ? AND device_id = ?", model.OrderTypeDevice, assetInfo.AssetID)
|
||
} else {
|
||
query = query.Where("order_type = ? AND iot_card_id = ?", model.OrderTypeSingleCard, assetInfo.AssetID)
|
||
}
|
||
|
||
if req.PaymentStatus != nil {
|
||
query = query.Where("payment_status = ?", *req.PaymentStatus)
|
||
}
|
||
|
||
var total int64
|
||
if err := query.Count(&total).Error; err != nil {
|
||
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询订单总数失败")
|
||
}
|
||
|
||
var orders []*model.Order
|
||
offset := (req.Page - 1) * req.PageSize
|
||
if err := query.Order("created_at DESC").Offset(offset).Limit(req.PageSize).Find(&orders).Error; err != nil {
|
||
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询订单列表失败")
|
||
}
|
||
|
||
orderIDs := make([]uint, 0, len(orders))
|
||
for _, order := range orders {
|
||
if order != nil {
|
||
orderIDs = append(orderIDs, order.ID)
|
||
}
|
||
}
|
||
|
||
itemMap, err := s.loadOrderItemMap(skipCtx, orderIDs)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
list := make([]dto.ClientOrderListItem, 0, len(orders))
|
||
for _, order := range orders {
|
||
if order == nil {
|
||
continue
|
||
}
|
||
|
||
packageNames := make([]string, 0)
|
||
for _, item := range itemMap[order.ID] {
|
||
if item != nil && item.PackageName != "" {
|
||
packageNames = append(packageNames, item.PackageName)
|
||
}
|
||
}
|
||
|
||
list = append(list, dto.ClientOrderListItem{
|
||
OrderID: order.ID,
|
||
OrderNo: order.OrderNo,
|
||
TotalAmount: order.TotalAmount,
|
||
PaymentStatus: order.PaymentStatus,
|
||
PaymentStatusName: constants.GetOrderPaymentStatusName(order.PaymentStatus),
|
||
CreatedAt: formatClientServiceTime(order.CreatedAt),
|
||
PackageNames: packageNames,
|
||
})
|
||
}
|
||
|
||
return list, total, nil
|
||
}
|
||
|
||
// GetOrderDetail 查询 C 端订单详情。
|
||
func (s *Service) GetOrderDetail(ctx context.Context, customerID uint, orderID uint) (*dto.ClientOrderDetailResponse, error) {
|
||
order, items, err := s.orderStore.GetByIDWithItems(ctx, orderID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, errors.New(errors.CodeNotFound, "订单不存在")
|
||
}
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询订单详情失败")
|
||
}
|
||
|
||
skipCtx := context.WithValue(ctx, constants.ContextKeySubordinateShopIDs, []uint{})
|
||
virtualNo, err := s.getOrderVirtualNo(skipCtx, order)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if err := s.checkAssetOwnership(skipCtx, customerID, virtualNo); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
packages := make([]dto.ClientOrderPackageItem, 0, len(items))
|
||
for _, item := range items {
|
||
if item == nil {
|
||
continue
|
||
}
|
||
packages = append(packages, dto.ClientOrderPackageItem{
|
||
PackageID: item.PackageID,
|
||
PackageName: item.PackageName,
|
||
Price: item.UnitPrice,
|
||
Quantity: item.Quantity,
|
||
})
|
||
}
|
||
|
||
return &dto.ClientOrderDetailResponse{
|
||
OrderID: order.ID,
|
||
OrderNo: order.OrderNo,
|
||
TotalAmount: order.TotalAmount,
|
||
PaymentStatus: order.PaymentStatus,
|
||
PaymentStatusName: constants.GetOrderPaymentStatusName(order.PaymentStatus),
|
||
PaymentMethod: order.PaymentMethod,
|
||
CreatedAt: formatClientServiceTime(order.CreatedAt),
|
||
PaidAt: formatClientServiceTimePtr(order.PaidAt),
|
||
CompletedAt: nil,
|
||
Packages: packages,
|
||
}, nil
|
||
}
|
||
|
||
// PayOrder D4 对待支付的 C 端订单发起支付。
|
||
// 支持 wallet（钱包扣款）和 wechat（微信 JSAPI）两种支付方式。
|
||
// 先校验订单归属和状态，再按 payment_method 路由到对应支付逻辑：
|
||
// - wallet：委托 B 端 WalletPay（乐观锁扣款 + 激活套餐 + 佣金入队）
|
||
// - wechat：查微信配置 + OpenID → 预下单 → 更新 payment_config_id → 返回 JS 支付参数
|
||
func (s *Service) PayOrder(ctx context.Context, customerID uint, orderID uint, req *dto.ClientPayOrderRequest) (*dto.ClientPayOrderResponse, error) {
|
||
if req == nil {
|
||
return nil, errors.New(errors.CodeInvalidParam)
|
||
}
|
||
|
||
// 跳过 GORM 店铺过滤，C 端订单查询不依赖 seller_shop_id 过滤
|
||
skipCtx := context.WithValue(ctx, constants.ContextKeySubordinateShopIDs, []uint{})
|
||
|
||
order, err := s.orderStore.GetByID(skipCtx, orderID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, errors.New(errors.CodeNotFound, "订单不存在")
|
||
}
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询订单失败")
|
||
}
|
||
|
||
if order.BuyerType != model.BuyerTypePersonal || order.BuyerID != customerID {
|
||
return nil, errors.New(errors.CodeForbidden, "无权操作此订单")
|
||
}
|
||
|
||
if order.PaymentStatus != model.PaymentStatusPending {
|
||
return nil, errors.New(errors.CodeInvalidStatus, "订单状态不允许支付")
|
||
}
|
||
|
||
switch req.PaymentMethod {
|
||
case model.PaymentMethodWallet:
|
||
if err := s.orderPaymentService.WalletPay(skipCtx, orderID, model.BuyerTypePersonal, customerID); err != nil {
|
||
return nil, err
|
||
}
|
||
return &dto.ClientPayOrderResponse{PaymentMethod: model.PaymentMethodWallet}, nil
|
||
|
||
case model.PaymentMethodWechat:
|
||
activeConfig, appID, err := s.resolveWechatConfig(skipCtx, req.AppType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
openID, err := s.resolveCustomerOpenID(skipCtx, customerID, appID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
paymentProvider, err := s.newPaymentProvider(activeConfig, appID, req.AppType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 记录本次支付使用的微信配置，供支付回调验签使用
|
||
if err := s.db.WithContext(skipCtx).Model(&model.Order{}).
|
||
Where("id = ?", orderID).
|
||
Update("payment_config_id", activeConfig.ID).Error; err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "更新订单支付配置失败")
|
||
}
|
||
|
||
paymentResult, err := paymentProvider.CreateJSAPIPayment(skipCtx, order.OrderNo, "套餐购买", openID, int(order.TotalAmount))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &dto.ClientPayOrderResponse{
|
||
PaymentMethod: model.PaymentMethodWechat,
|
||
PayConfig: buildClientPayConfigFromResult(paymentResult),
|
||
}, nil
|
||
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam, "不支持的支付方式")
|
||
}
|
||
}
|
||
|
||
func (s *Service) getAssetGeneration(ctx context.Context, assetType string, assetID uint) (int, error) {
|
||
switch assetType {
|
||
case "card":
|
||
card, err := s.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 constants.ResourceTypeDevice:
|
||
device, err := s.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 (s *Service) loadOrderItemMap(ctx context.Context, orderIDs []uint) (map[uint][]*model.OrderItem, error) {
|
||
result := make(map[uint][]*model.OrderItem)
|
||
if len(orderIDs) == 0 {
|
||
return result, nil
|
||
}
|
||
|
||
var items []*model.OrderItem
|
||
if err := s.db.WithContext(ctx).Where("order_id IN ?", orderIDs).Order("id ASC").Find(&items).Error; err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询订单明细失败")
|
||
}
|
||
|
||
for _, item := range items {
|
||
if item != nil {
|
||
result[item.OrderID] = append(result[item.OrderID], item)
|
||
}
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
func (s *Service) getOrderVirtualNo(ctx context.Context, order *model.Order) (string, error) {
|
||
if order == nil {
|
||
return "", errors.New(errors.CodeNotFound, "订单不存在")
|
||
}
|
||
|
||
switch order.OrderType {
|
||
case model.OrderTypeSingleCard:
|
||
if order.IotCardID == nil || *order.IotCardID == 0 {
|
||
return "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
card, err := s.iotCardStore.GetByID(ctx, *order.IotCardID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return "", errors.New(errors.CodeAssetNotFound)
|
||
}
|
||
return "", errors.Wrap(errors.CodeDatabaseError, err, "查询卡信息失败")
|
||
}
|
||
return card.VirtualNo, nil
|
||
case model.OrderTypeDevice:
|
||
if order.DeviceID == nil || *order.DeviceID == 0 {
|
||
return "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
device, err := s.deviceStore.GetByID(ctx, *order.DeviceID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return "", errors.New(errors.CodeAssetNotFound)
|
||
}
|
||
return "", errors.Wrap(errors.CodeDatabaseError, err, "查询设备信息失败")
|
||
}
|
||
return device.VirtualNo, nil
|
||
default:
|
||
return "", errors.New(errors.CodeInvalidParam)
|
||
}
|
||
}
|
||
|
||
func formatClientServiceTimePtr(t *time.Time) *string {
|
||
if t == nil || t.IsZero() {
|
||
return nil
|
||
}
|
||
formatted := formatClientServiceTime(*t)
|
||
return &formatted
|
||
}
|