break
aab56a6998
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 14m13s
新增 000228 成对迁移 tb_polling_priority_item：卡、任务类型、状态、触发类型、来源订单/套餐使用记录、
触发次数与来源集合、尝试次数、失败原因、人工原因与操作者、店铺快照与各时间列；以活动项部分唯一索引
uq_polling_priority_item_active（仅 deleted_at IS NULL AND status IN ('pending','processing') 占键位）
表达「同卡同任务类型至多一条活动项」，另有状态/时间索引与全列注释；down 守卫在存在活动项或未终态行时
拒绝回滚并给出中文原因。
新增优先轮询请求可靠事件 polling.priority.requested（载荷版本 v1、事件键前缀 prio:）与消费者：只在原
业务事务内追加、幂等键稳定；消费者按卡 × 纳入任务类型（realname/carddata/card_status/package）逐条
建项并在提交后下发执行提示，重复投递只合并触发次数、来源集合与最近触发时间，不新建行也不重复调用。
触发点为四类自动场景 purchase_activated / renewal_activated（按同载体更早套餐使用记录判定）/
queue_activated / addon_activated 与「无有效套餐」no_valid_package（仅在普通套餐轮询来源且存在待生效
套餐使用记录时追加；事件通道显式拒绝 manual_trigger）；入队对象恒为卡，绑定设备资产在触发事务内冻结
在用卡快照逐卡建项，不使用设备当前卡槽口径。
轮询共享基类新增认领接缝：四个 Handler（realname/carddata/card_status/package）在并发信号量之后、调用
上游之前探测活动项——待执行条件认领、执行中且 90 秒租约未到期则跳过并延后、无活动项时行为与既有完全
等价；超租约允许相邻执行接管，尝试次数只在真正发起执行后累加，未达上限（3）回到活动态按既有间隔重排，
达上限或业务校验类失败进入失败终态并保留可安全展示原因；执行前校验卡自身与绑定设备的轮询开关。未引入
通用卡级锁与 Redis 活动标记，分片队列的出队、入队与移除路径未改动。
提示通道按任务类型独立键（polling:priority:{taskType}），与既有手动触发队列分离；调度器在同一周期内先
排空优先提示、再排空手动触发队列，提示排空不受分片背压跳过影响；未新建调度设施或异步任务类型。
新增人工优先入队与只读查询三条路由 POST /api/admin/polling-priority-items、
GET /api/admin/polling-priority-items、GET /api/admin/polling-priority-items/:id：人工入队复用既有轮询
权限判定（抽取为同包共享函数），原因必填，不受每日 500 次上限与 24 小时去重约束，重复抑制由活动项合并
承担；读侧按店铺快照下推数据范围，越权与不存在不可区分，不提供优先级分级、有效期或人工重触发入口。
新增 7 个审计动作（enqueue/claim/fail/retry/complete/dequeue/manual_denied）与资源
polling_priority_item，并按（操作者类型，来源）注册，人工侧与 Worker 侧均通过来源校验。
同步 OpenAPI 文档装配三处与路由注册；归档 Change 至
openspec/changes/archive/2026-09-17-add-priority-polling-queue/ 并同步主 Spec（新增
priority-polling-queue、polling-operations 追加单次执行互斥 Requirement 与三条路由索引）与上下文健康
证据（requirement-evidence 150 行、入口矩阵 http 403 / async 56）。
本机验证：junhong_cmp_test 与隔离 Redis DB 15，未连生产、未启动 Worker/API、未调用运营商上游；迁移
up/down/up 与 down 守卫实测（含 dirty=true 记账口径与 force 恢复），A–F 批 94 PASS、接缝 63 PASS、
提示通道 12 PASS、清理零残留 20 PASS。成功路径 Complete、真并发互斥、尝试上限第 3 次判定、HTTP 层权限
矩阵、通道阈值持锁复机边界与三类生效触发点生产集成留待测试部署验证（见
docs/verification/add-priority-polling-queue-verification.md 第 4 节）。自动化测试按项目决策为 N/A，
未新增 *_test.go。
901 lines
34 KiB
Go
901 lines
34 KiB
Go
package task
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"strconv"
|
||
"time"
|
||
|
||
"github.com/bytedance/sonic"
|
||
"github.com/hibiken/asynq"
|
||
"github.com/redis/go-redis/v9"
|
||
"go.uber.org/zap"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/clause"
|
||
|
||
cardObservationApp "github.com/break/junhong_cmp_fiber/internal/application/cardobservation"
|
||
priorityapp "github.com/break/junhong_cmp_fiber/internal/application/prioritypolling"
|
||
packagedomain "github.com/break/junhong_cmp_fiber/internal/domain/package"
|
||
"github.com/break/junhong_cmp_fiber/internal/infrastructure/audit"
|
||
"github.com/break/junhong_cmp_fiber/internal/infrastructure/commissiondelivery"
|
||
"github.com/break/junhong_cmp_fiber/internal/infrastructure/messaging/outbox"
|
||
"github.com/break/junhong_cmp_fiber/internal/model"
|
||
packagepkg "github.com/break/junhong_cmp_fiber/internal/service/package"
|
||
"github.com/break/junhong_cmp_fiber/internal/service/packageprice"
|
||
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
||
"github.com/break/junhong_cmp_fiber/pkg/auditcontext"
|
||
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
||
pkgerrors "github.com/break/junhong_cmp_fiber/pkg/errors"
|
||
)
|
||
|
||
// AutoPurchasePayload 充值后自动购包任务载荷
|
||
type AutoPurchasePayload struct {
|
||
RechargeOrderID uint `json:"recharge_order_id"`
|
||
RequestID string `json:"request_id,omitempty"`
|
||
CorrelationID string `json:"correlation_id,omitempty"`
|
||
ParentEventID string `json:"parent_event_id,omitempty"`
|
||
}
|
||
|
||
// AutoPurchaseHandler 充值后自动购包任务处理器
|
||
type AutoPurchaseHandler struct {
|
||
db *gorm.DB
|
||
orderStore *postgres.OrderStore
|
||
rechargeOrderStore *postgres.RechargeOrderStore
|
||
paymentStore *postgres.PaymentStore
|
||
walletStore *postgres.AssetWalletStore
|
||
walletTransactionStore *postgres.AssetWalletTransactionStore
|
||
packageUsageStore *postgres.PackageUsageStore
|
||
shopPackageAllocationStore *postgres.ShopPackageAllocationStore // 用于查询卖家成本价
|
||
iotCardStore *postgres.IotCardStore // 用于获取卡的系列ID
|
||
deviceStore *postgres.DeviceStore // 用于获取设备的系列ID
|
||
redis *redis.Client
|
||
asynqClient *asynq.Client // 用于事务提交成功后触发佣金计算任务
|
||
logger *zap.Logger
|
||
observationSeriesEvents cardObservationApp.SeriesEventWriter
|
||
priorityEvents priorityapp.PriorityEventWriter
|
||
auditWriter *audit.Writer
|
||
}
|
||
|
||
// NewAutoPurchaseHandler 创建充值后自动购包处理器
|
||
func NewAutoPurchaseHandler(
|
||
db *gorm.DB,
|
||
orderStore *postgres.OrderStore,
|
||
rechargeOrderStore *postgres.RechargeOrderStore,
|
||
paymentStore *postgres.PaymentStore,
|
||
walletStore *postgres.AssetWalletStore,
|
||
walletTransactionStore *postgres.AssetWalletTransactionStore,
|
||
packageUsageStore *postgres.PackageUsageStore,
|
||
redisClient *redis.Client,
|
||
asynqClient *asynq.Client,
|
||
logger *zap.Logger,
|
||
observationSeriesEvents cardObservationApp.SeriesEventWriter,
|
||
priorityEvents priorityapp.PriorityEventWriter,
|
||
auditWriter *audit.Writer,
|
||
) *AutoPurchaseHandler {
|
||
if orderStore == nil {
|
||
orderStore = postgres.NewOrderStore(db, redisClient)
|
||
}
|
||
if rechargeOrderStore == nil {
|
||
rechargeOrderStore = postgres.NewRechargeOrderStore(db, redisClient)
|
||
}
|
||
if paymentStore == nil {
|
||
paymentStore = postgres.NewPaymentStore(db, redisClient)
|
||
}
|
||
if walletStore == nil {
|
||
walletStore = postgres.NewAssetWalletStore(db, redisClient)
|
||
}
|
||
if walletTransactionStore == nil {
|
||
walletTransactionStore = postgres.NewAssetWalletTransactionStore(db, redisClient)
|
||
}
|
||
if packageUsageStore == nil {
|
||
packageUsageStore = postgres.NewPackageUsageStore(db, redisClient)
|
||
}
|
||
|
||
return &AutoPurchaseHandler{
|
||
db: db,
|
||
orderStore: orderStore,
|
||
rechargeOrderStore: rechargeOrderStore,
|
||
paymentStore: paymentStore,
|
||
walletStore: walletStore,
|
||
walletTransactionStore: walletTransactionStore,
|
||
packageUsageStore: packageUsageStore,
|
||
shopPackageAllocationStore: postgres.NewShopPackageAllocationStore(db),
|
||
iotCardStore: postgres.NewIotCardStore(db, redisClient),
|
||
deviceStore: postgres.NewDeviceStore(db, redisClient),
|
||
redis: redisClient,
|
||
asynqClient: asynqClient,
|
||
logger: logger,
|
||
observationSeriesEvents: observationSeriesEvents,
|
||
priorityEvents: priorityEvents,
|
||
auditWriter: auditWriter,
|
||
}
|
||
}
|
||
|
||
// ProcessTask 处理充值后自动购包任务
|
||
func (h *AutoPurchaseHandler) ProcessTask(ctx context.Context, task *asynq.Task) error {
|
||
var payload AutoPurchasePayload
|
||
if err := sonic.Unmarshal(task.Payload(), &payload); err != nil {
|
||
h.logger.Error("解析自动购包任务载荷失败", zap.Error(err))
|
||
return asynq.SkipRetry
|
||
}
|
||
if payload.RechargeOrderID == 0 {
|
||
h.logger.Error("自动购包任务载荷无效", zap.Uint("recharge_order_id", payload.RechargeOrderID))
|
||
return asynq.SkipRetry
|
||
}
|
||
|
||
rechargeOrder, err := h.rechargeOrderStore.GetByID(ctx, payload.RechargeOrderID)
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
h.logger.Warn("充值订单不存在，跳过自动购包", zap.Uint("recharge_order_id", payload.RechargeOrderID))
|
||
return asynq.SkipRetry
|
||
}
|
||
h.logger.Error("查询充值订单失败", zap.Uint("recharge_order_id", payload.RechargeOrderID), zap.Error(err))
|
||
return err
|
||
}
|
||
correlationID := payload.CorrelationID
|
||
if correlationID == "" {
|
||
correlationID = rechargeOrder.RechargeOrderNo
|
||
}
|
||
ctx = auditcontext.With(ctx, auditcontext.Context{
|
||
ActorKind: constants.AuditActorSystemTask, ActorID: constants.TaskTypeAutoPurchaseAfterRecharge,
|
||
ActorName: "充值后自动购包任务", Source: constants.AuditSourceWorker,
|
||
RequestID: payload.RequestID, CorrelationID: correlationID, ParentEventID: payload.ParentEventID,
|
||
})
|
||
|
||
if rechargeOrder.AutoPurchaseStatus == constants.AutoPurchaseStatusSuccess {
|
||
return nil
|
||
}
|
||
if rechargeOrder.AutoPurchaseStatus == constants.AutoPurchaseStatusFailed {
|
||
return nil
|
||
}
|
||
|
||
packageIDs, err := parseLinkedPackageIDs(rechargeOrder.LinkedPackageIDs)
|
||
if err != nil {
|
||
h.logger.Error("解析关联套餐ID失败", zap.Uint("recharge_order_id", rechargeOrder.ID), zap.Error(err))
|
||
h.markAutoPurchaseFailedIfFinalRetry(ctx, rechargeOrder.ID)
|
||
return asynq.SkipRetry
|
||
}
|
||
if len(packageIDs) == 0 {
|
||
h.logger.Error("关联套餐ID为空，无法自动购包", zap.Uint("recharge_order_id", rechargeOrder.ID))
|
||
h.markAutoPurchaseFailedIfFinalRetry(ctx, rechargeOrder.ID)
|
||
return asynq.SkipRetry
|
||
}
|
||
|
||
packages, totalAmount, err := h.loadPackages(ctx, packageIDs)
|
||
if err != nil {
|
||
h.logger.Error("加载关联套餐失败", zap.Uint("recharge_order_id", rechargeOrder.ID), zap.Error(err))
|
||
h.markAutoPurchaseFailedIfFinalRetry(ctx, rechargeOrder.ID)
|
||
return err
|
||
}
|
||
|
||
// 获取资产系列ID，用于差价佣金和一次性佣金计算
|
||
var seriesID *uint
|
||
if rechargeOrder.LinkedCarrierID != nil && *rechargeOrder.LinkedCarrierID > 0 {
|
||
if rechargeOrder.LinkedCarrierType == "card" || rechargeOrder.LinkedCarrierType == constants.AssetWalletResourceTypeIotCard {
|
||
if card, cardErr := h.iotCardStore.GetByID(ctx, *rechargeOrder.LinkedCarrierID); cardErr == nil {
|
||
seriesID = card.SeriesID
|
||
} else {
|
||
h.logger.Warn("自动购包获取卡系列ID失败",
|
||
zap.Uint("card_id", *rechargeOrder.LinkedCarrierID),
|
||
zap.Error(cardErr))
|
||
}
|
||
} else if rechargeOrder.LinkedCarrierType == "device" || rechargeOrder.LinkedCarrierType == constants.AssetWalletResourceTypeDevice {
|
||
if device, deviceErr := h.deviceStore.GetByID(ctx, *rechargeOrder.LinkedCarrierID); deviceErr == nil {
|
||
seriesID = device.SeriesID
|
||
} else {
|
||
h.logger.Warn("自动购包获取设备系列ID失败",
|
||
zap.Uint("device_id", *rechargeOrder.LinkedCarrierID),
|
||
zap.Error(deviceErr))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 获取卖家成本价，用于差价佣金链式计算的起点
|
||
// 平台直销（ShopIDTag == 0）时成本价为 0，差价佣金计算会直接跳过
|
||
var sellerCostPrice int64
|
||
if rechargeOrder.ShopIDTag > 0 && len(packages) > 0 {
|
||
allocation, allocErr := h.shopPackageAllocationStore.GetByShopAndPackageForSystem(ctx, rechargeOrder.ShopIDTag, packages[0].ID)
|
||
if allocErr == nil {
|
||
sellerCostPrice = allocation.CostPrice
|
||
} else {
|
||
h.logger.Warn("自动购包获取卖家成本价失败，差价佣金将计算为0",
|
||
zap.Uint("shop_id", rechargeOrder.ShopIDTag),
|
||
zap.Uint("package_id", packages[0].ID),
|
||
zap.Error(allocErr))
|
||
}
|
||
}
|
||
|
||
if err := h.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
wallet, walletErr := h.walletStore.GetByID(ctx, rechargeOrder.AssetWalletID)
|
||
if walletErr != nil {
|
||
if walletErr == gorm.ErrRecordNotFound {
|
||
return errors.New("资产钱包不存在")
|
||
}
|
||
return walletErr
|
||
}
|
||
if wallet.GetAvailableBalance() < totalAmount {
|
||
return errors.New("钱包余额不足")
|
||
}
|
||
|
||
if err = h.walletStore.DeductBalanceWithTx(ctx, tx, wallet.ID, totalAmount, wallet.Version); err != nil {
|
||
return err
|
||
}
|
||
|
||
now := time.Now()
|
||
order, orderItems, buildErr := h.buildOrderAndItems(ctx, rechargeOrder, packages, totalAmount, seriesID, sellerCostPrice, now)
|
||
if buildErr != nil {
|
||
return buildErr
|
||
}
|
||
|
||
if err = tx.Create(order).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, item := range orderItems {
|
||
item.OrderID = order.ID
|
||
}
|
||
if err = tx.CreateInBatches(orderItems, 100).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
payment := &model.Payment{
|
||
PaymentNo: order.OrderNo,
|
||
OrderID: order.ID,
|
||
OrderType: model.PaymentOrderTypePackage,
|
||
PaymentMethod: model.PaymentByWallet,
|
||
Amount: totalAmount,
|
||
Status: model.PaymentRecordStatusPaid,
|
||
}
|
||
if err = tx.Create(payment).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
refType := constants.ReferenceTypeOrder
|
||
walletTx := &model.AssetWalletTransaction{
|
||
AssetWalletID: wallet.ID,
|
||
ResourceType: wallet.ResourceType,
|
||
ResourceID: wallet.ResourceID,
|
||
UserID: rechargeOrder.UserID,
|
||
TransactionType: constants.AssetTransactionTypeDeduct,
|
||
Amount: -totalAmount,
|
||
BalanceBefore: wallet.Balance,
|
||
BalanceAfter: wallet.Balance - totalAmount,
|
||
Status: constants.TransactionStatusSuccess,
|
||
ReferenceType: &refType,
|
||
ReferenceNo: &order.OrderNo,
|
||
Creator: rechargeOrder.UserID,
|
||
ShopIDTag: wallet.ShopIDTag,
|
||
EnterpriseIDTag: wallet.EnterpriseIDTag,
|
||
}
|
||
if err = h.walletTransactionStore.CreateWithTx(ctx, tx, walletTx); err != nil {
|
||
return err
|
||
}
|
||
|
||
if err = h.activatePackages(ctx, tx, order, packages, now); err != nil {
|
||
return err
|
||
}
|
||
if h.observationSeriesEvents == nil {
|
||
return pkgerrors.New(pkgerrors.CodeInternalError, "自动购包观测 Outbox Writer 未配置")
|
||
}
|
||
resourceType, resourceID := orderObservationResource(order)
|
||
if resourceID == 0 {
|
||
return pkgerrors.New(pkgerrors.CodeInvalidParam, "自动购包观测事件缺少载体")
|
||
}
|
||
if err = commissiondelivery.AppendCommissionCalculate(ctx, tx, outbox.NewRepository(), order.ID); err != nil {
|
||
return err
|
||
}
|
||
requestID := "card-observation:auto-purchase:" + strconv.FormatUint(uint64(order.ID), 10)
|
||
if err = h.observationSeriesEvents.AppendSeriesRequested(ctx, tx, cardObservationApp.SeriesRequestedEvent{
|
||
EventID: requestID, Scene: constants.CardObservationScenePackageChanged,
|
||
ResourceType: resourceType, ResourceID: resourceID,
|
||
SyncTypes: []string{constants.CardObservationSyncTypeRealname, constants.CardObservationSyncTypeTraffic, constants.CardObservationSyncTypeNetwork},
|
||
Source: constants.CardObservationSourceBusinessEvent, OccurredAt: now,
|
||
RequestID: requestID, CorrelationID: requestID,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
|
||
if err = tx.Model(&model.RechargeOrder{}).
|
||
Where("id = ?", rechargeOrder.ID).
|
||
Update("auto_purchase_status", constants.AutoPurchaseStatusSuccess).Error; err != nil {
|
||
return err
|
||
}
|
||
if h.auditWriter == nil {
|
||
return pkgerrors.New(pkgerrors.CodeInvalidStatus, "自动购包统一审计接缝未配置")
|
||
}
|
||
return h.appendAutoPurchaseAudit(ctx, tx, rechargeOrder, order, payment, wallet, walletTx, packages)
|
||
}); err != nil {
|
||
h.logger.Error("自动购包任务执行失败",
|
||
zap.Uint("recharge_record_id", rechargeOrder.ID),
|
||
zap.Error(err),
|
||
)
|
||
h.markAutoPurchaseFailedIfFinalRetry(ctx, rechargeOrder.ID)
|
||
return err
|
||
}
|
||
|
||
h.logger.Info("自动购包任务执行成功", zap.Uint("recharge_record_id", rechargeOrder.ID))
|
||
return nil
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) appendAutoPurchaseAudit(ctx context.Context, tx *gorm.DB, recharge *model.RechargeOrder, order *model.Order, payment *model.Payment, wallet *model.AssetWallet, walletTx *model.AssetWalletTransaction, packages []*model.Package) error {
|
||
rechargeID := strconv.FormatUint(uint64(recharge.ID), 10)
|
||
resources := []audit.ResourceInput{{
|
||
Type: constants.AuditResourceRechargeOrder, ID: &rechargeID, Key: recharge.RechargeOrderNo, DisplayName: recharge.RechargeOrderNo,
|
||
Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRoleRechargeTarget,
|
||
IdentitySnapshot: map[string]any{
|
||
"id": recharge.ID, "recharge_order_no": recharge.RechargeOrderNo, "user_id": recharge.UserID,
|
||
"asset_wallet_id": recharge.AssetWalletID, "resource_type": recharge.ResourceType,
|
||
"resource_id": recharge.ResourceID, "amount": recharge.Amount, "status": recharge.Status,
|
||
},
|
||
BeforeData: map[string]any{"auto_purchase_status": recharge.AutoPurchaseStatus},
|
||
AfterData: map[string]any{"auto_purchase_status": constants.AutoPurchaseStatusSuccess},
|
||
SubjectVisibility: constants.AuditSubjectResult, SubjectSummary: "充值后自动购包已完成",
|
||
}}
|
||
orderResource := audit.OrderResource(order, constants.AuditResourceRelationAffected, constants.AuditResourceRoleRechargeAutoPurchaseOrder)
|
||
orderResource.SubjectVisibility = constants.AuditSubjectResult
|
||
orderResource.SubjectSummary = "充值后自动购包已完成"
|
||
resources = append(resources, orderResource)
|
||
walletID := strconv.FormatUint(uint64(wallet.ID), 10)
|
||
resources = append(resources, audit.ResourceInput{
|
||
Type: constants.AuditResourceAssetWallet, ID: &walletID, Key: walletID, DisplayName: "资产钱包 " + walletID,
|
||
Relation: constants.AuditResourceRelationAffected, Role: constants.AuditResourceRoleRechargeWallet,
|
||
IdentitySnapshot: map[string]any{"id": wallet.ID, "resource_type": wallet.ResourceType, "resource_id": wallet.ResourceID, "currency": wallet.Currency},
|
||
BeforeData: map[string]any{"balance": walletTx.BalanceBefore}, AfterData: map[string]any{"balance": walletTx.BalanceAfter},
|
||
SubjectVisibility: constants.AuditSubjectResult, SubjectSummary: "充值后自动购包已完成",
|
||
})
|
||
walletTxID := strconv.FormatUint(uint64(walletTx.ID), 10)
|
||
resources = append(resources, audit.ResourceInput{
|
||
Type: constants.AuditResourceAssetWalletTransaction, ID: &walletTxID, Key: walletTxID, DisplayName: "资产钱包流水 " + walletTxID,
|
||
Relation: constants.AuditResourceRelationAffected, Role: constants.AuditResourceRoleRechargeWalletTransaction,
|
||
IdentitySnapshot: map[string]any{
|
||
"id": walletTx.ID, "asset_wallet_id": walletTx.AssetWalletID, "resource_type": walletTx.ResourceType,
|
||
"resource_id": walletTx.ResourceID, "transaction_type": walletTx.TransactionType,
|
||
"reference_type": walletTx.ReferenceType, "reference_no": walletTx.ReferenceNo, "status": walletTx.Status,
|
||
},
|
||
AfterData: map[string]any{"amount": walletTx.Amount, "balance_before": walletTx.BalanceBefore, "balance_after": walletTx.BalanceAfter},
|
||
})
|
||
resources = append(resources, audit.PaymentResource(payment, constants.AuditResourceRelationReference, constants.AuditResourceRoleOrderPayment, nil, nil))
|
||
for _, pkg := range packages {
|
||
resources = append(resources, audit.PackageResource(pkg, constants.AuditResourceRelationReference, constants.AuditResourceRoleOrderPackage, nil, nil))
|
||
}
|
||
var usages []model.PackageUsage
|
||
if err := tx.WithContext(ctx).Where("order_id = ?", order.ID).Order("id ASC").Find(&usages).Error; err != nil {
|
||
return pkgerrors.Wrap(pkgerrors.CodeDatabaseError, err, "查询自动购包套餐权益审计快照失败")
|
||
}
|
||
for i := range usages {
|
||
resources = append(resources, audit.PackageUsageResource(&usages[i], constants.AuditResourceRelationAffected, constants.AuditResourceRolePackageUsageTarget, nil, nil))
|
||
}
|
||
return h.auditWriter.Append(ctx, tx, audit.AppendInput{
|
||
ActionCode: constants.AuditActionAssetRechargeAutoPurchased, Summary: "充值后自动购包已完成",
|
||
ScopeType: constants.AuditScopePlatform, Result: constants.AuditResultSuccess,
|
||
CorrelationID: recharge.RechargeOrderNo, Resources: resources,
|
||
})
|
||
}
|
||
|
||
func orderObservationResource(order *model.Order) (string, uint) {
|
||
if order != nil && order.DeviceID != nil {
|
||
return constants.CardObservationResourceTypeDevice, *order.DeviceID
|
||
}
|
||
if order != nil && order.IotCardID != nil {
|
||
return constants.CardObservationResourceTypeCard, *order.IotCardID
|
||
}
|
||
return "", 0
|
||
}
|
||
|
||
// NewAutoPurchaseTask 创建充值后自动购包任务
|
||
func NewAutoPurchaseTask(rechargeOrderID uint) (*asynq.Task, error) {
|
||
payloadBytes, err := sonic.Marshal(AutoPurchasePayload{RechargeOrderID: rechargeOrderID})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return asynq.NewTask(constants.TaskTypeAutoPurchaseAfterRecharge, payloadBytes,
|
||
asynq.MaxRetry(3),
|
||
asynq.Timeout(2*time.Minute),
|
||
asynq.Queue(constants.QueueForTaskType(constants.TaskTypeAutoPurchaseAfterRecharge)),
|
||
), nil
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) markAutoPurchaseFailedIfFinalRetry(ctx context.Context, rechargeOrderID uint) {
|
||
retryCount, ok := asynq.GetRetryCount(ctx)
|
||
if !ok {
|
||
return
|
||
}
|
||
maxRetry, ok := asynq.GetMaxRetry(ctx)
|
||
if !ok {
|
||
return
|
||
}
|
||
if retryCount < maxRetry-1 {
|
||
return
|
||
}
|
||
|
||
if err := h.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var recharge model.RechargeOrder
|
||
if err := tx.WithContext(ctx).First(&recharge, rechargeOrderID).Error; err != nil {
|
||
return err
|
||
}
|
||
result := tx.WithContext(ctx).Model(&model.RechargeOrder{}).
|
||
Where("id = ? AND auto_purchase_status <> ?", rechargeOrderID, constants.AutoPurchaseStatusFailed).
|
||
Update("auto_purchase_status", constants.AutoPurchaseStatusFailed)
|
||
if result.Error != nil || result.RowsAffected == 0 {
|
||
return result.Error
|
||
}
|
||
if h.auditWriter == nil {
|
||
return pkgerrors.New(pkgerrors.CodeInvalidStatus, "自动购包统一审计接缝未配置")
|
||
}
|
||
rechargeID := strconv.FormatUint(uint64(recharge.ID), 10)
|
||
return h.auditWriter.Append(ctx, tx, audit.AppendInput{
|
||
ActionCode: constants.AuditActionAssetRechargeAutoPurchased, Summary: "充值后自动购包失败",
|
||
ScopeType: constants.AuditScopePlatform, Result: constants.AuditResultFailed,
|
||
CorrelationID: recharge.RechargeOrderNo,
|
||
Resources: []audit.ResourceInput{{
|
||
Type: constants.AuditResourceRechargeOrder, ID: &rechargeID, Key: recharge.RechargeOrderNo, DisplayName: recharge.RechargeOrderNo,
|
||
Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRoleRechargeTarget,
|
||
IdentitySnapshot: map[string]any{
|
||
"id": recharge.ID, "recharge_order_no": recharge.RechargeOrderNo, "user_id": recharge.UserID,
|
||
"asset_wallet_id": recharge.AssetWalletID, "resource_type": recharge.ResourceType,
|
||
"resource_id": recharge.ResourceID, "amount": recharge.Amount, "status": recharge.Status,
|
||
},
|
||
BeforeData: map[string]any{"auto_purchase_status": recharge.AutoPurchaseStatus},
|
||
AfterData: map[string]any{"auto_purchase_status": constants.AutoPurchaseStatusFailed},
|
||
SubjectVisibility: constants.AuditSubjectResult, SubjectSummary: "充值后自动购包失败",
|
||
}},
|
||
})
|
||
}); err != nil {
|
||
h.logger.Error("更新自动购包失败状态失败",
|
||
zap.Uint("recharge_record_id", rechargeOrderID),
|
||
zap.Error(err),
|
||
)
|
||
return
|
||
}
|
||
|
||
h.logger.Warn("自动购包达到最大重试次数，已标记失败", zap.Uint("recharge_record_id", rechargeOrderID))
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) loadPackages(ctx context.Context, packageIDs []uint) ([]*model.Package, int64, error) {
|
||
packages := make([]*model.Package, 0, len(packageIDs))
|
||
if err := h.db.WithContext(ctx).Where("id IN ?", packageIDs).Find(&packages).Error; err != nil {
|
||
return nil, 0, err
|
||
}
|
||
if len(packages) != len(packageIDs) {
|
||
return nil, 0, gorm.ErrRecordNotFound
|
||
}
|
||
|
||
totalAmount := int64(0)
|
||
for _, pkg := range packages {
|
||
if pkg.IsGift {
|
||
return nil, 0, errors.New("赠送套餐不能进入自动购包链路")
|
||
}
|
||
totalAmount += packageprice.PackageEffectiveRetailPrice(pkg)
|
||
}
|
||
|
||
if err := validatePackageTypeMix(packages); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
return packages, totalAmount, nil
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) buildOrderAndItems(
|
||
ctx context.Context,
|
||
rechargeOrder *model.RechargeOrder,
|
||
packages []*model.Package,
|
||
totalAmount int64,
|
||
seriesID *uint,
|
||
sellerCostPrice int64,
|
||
now time.Time,
|
||
) (*model.Order, []*model.OrderItem, error) {
|
||
orderType, iotCardID, deviceID, err := parseLinkedCarrier(rechargeOrder.LinkedOrderType, rechargeOrder.LinkedCarrierType, rechargeOrder.LinkedCarrierID)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
|
||
generation := rechargeOrder.Generation
|
||
if generation <= 0 {
|
||
generation = 1
|
||
}
|
||
|
||
var sellerShopID *uint
|
||
if rechargeOrder.ShopIDTag > 0 {
|
||
shopID := rechargeOrder.ShopIDTag
|
||
sellerShopID = &shopID
|
||
}
|
||
|
||
paidAmount := totalAmount
|
||
operatorAccountID, operatorAccountName := h.buildPersonalCustomerOperatorSnapshot(ctx, rechargeOrder.UserID)
|
||
order := &model.Order{
|
||
BaseModel: model.BaseModel{
|
||
Creator: rechargeOrder.UserID,
|
||
Updater: rechargeOrder.UserID,
|
||
},
|
||
OrderNo: h.orderStore.GenerateOrderNo(),
|
||
OrderType: orderType,
|
||
BuyerType: model.BuyerTypePersonal,
|
||
BuyerID: rechargeOrder.UserID,
|
||
IotCardID: iotCardID,
|
||
DeviceID: deviceID,
|
||
TotalAmount: totalAmount,
|
||
PaymentMethod: model.PaymentMethodWallet,
|
||
PaymentStatus: model.PaymentStatusPaid,
|
||
PaidAt: &now,
|
||
CommissionStatus: model.CommissionStatusPending,
|
||
CommissionConfigVersion: 0,
|
||
Source: constants.OrderSourceClient,
|
||
Generation: generation,
|
||
ActualPaidAmount: &paidAmount,
|
||
OperatorAccountID: operatorAccountID,
|
||
OperatorAccountType: model.OperatorAccountTypePersonalCustomer,
|
||
OperatorAccountName: operatorAccountName,
|
||
SellerShopID: sellerShopID,
|
||
SeriesID: seriesID,
|
||
SellerCostPrice: sellerCostPrice,
|
||
}
|
||
|
||
items := make([]*model.OrderItem, 0, len(packages))
|
||
for _, pkg := range packages {
|
||
unitPrice := packageprice.PackageEffectiveRetailPrice(pkg)
|
||
items = append(items, &model.OrderItem{
|
||
BaseModel: model.BaseModel{
|
||
Creator: rechargeOrder.UserID,
|
||
Updater: rechargeOrder.UserID,
|
||
},
|
||
PackageID: pkg.ID,
|
||
PackageName: pkg.PackageName,
|
||
Quantity: 1,
|
||
UnitPrice: unitPrice,
|
||
Amount: unitPrice,
|
||
PackagePriceConfigStatus: pkg.PriceConfigStatus,
|
||
PackageIsGift: pkg.IsGift,
|
||
})
|
||
}
|
||
|
||
return order, items, nil
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) buildPersonalCustomerOperatorSnapshot(ctx context.Context, customerID uint) (*uint, string) {
|
||
if customerID == 0 {
|
||
return nil, ""
|
||
}
|
||
|
||
var customer model.PersonalCustomer
|
||
if err := h.db.WithContext(ctx).Where("id = ?", customerID).First(&customer).Error; err != nil {
|
||
id := customerID
|
||
return &id, ""
|
||
}
|
||
|
||
id := customerID
|
||
return &id, customer.Nickname
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) activatePackages(
|
||
ctx context.Context,
|
||
tx *gorm.DB,
|
||
order *model.Order,
|
||
packages []*model.Package,
|
||
now time.Time,
|
||
) error {
|
||
carrierType := constants.AssetWalletResourceTypeIotCard
|
||
carrierID := uint(0)
|
||
if order.OrderType == model.OrderTypeSingleCard && order.IotCardID != nil {
|
||
carrierID = *order.IotCardID
|
||
} else if order.OrderType == model.OrderTypeDevice && order.DeviceID != nil {
|
||
carrierType = constants.AssetWalletResourceTypeDevice
|
||
carrierID = *order.DeviceID
|
||
} else {
|
||
return errors.New("无效的订单载体")
|
||
}
|
||
// 在查询既有记录前锁定载体，避免并发任务同时判定不存在而重复创建套餐使用记录。
|
||
if err := h.lockPackageCarrier(ctx, tx, carrierType, carrierID); err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, pkg := range packages {
|
||
var existingUsage model.PackageUsage
|
||
err := tx.Where("order_id = ? AND package_id = ?", order.ID, pkg.ID).First(&existingUsage).Error
|
||
if err == nil {
|
||
continue
|
||
}
|
||
if err != gorm.ErrRecordNotFound {
|
||
return err
|
||
}
|
||
|
||
if pkg.PackageType == constants.PackageTypeFormal {
|
||
if err = h.activateMainPackage(ctx, tx, order, pkg, carrierType, carrierID, now); err != nil {
|
||
return err
|
||
}
|
||
continue
|
||
}
|
||
if pkg.PackageType == constants.PackageTypeAddon {
|
||
if err = h.activateAddonPackage(ctx, tx, order, pkg, carrierType, carrierID, now); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) activateMainPackage(
|
||
ctx context.Context,
|
||
tx *gorm.DB,
|
||
order *model.Order,
|
||
pkg *model.Package,
|
||
carrierType string,
|
||
carrierID uint,
|
||
now time.Time,
|
||
) error {
|
||
terms, err := h.resolvePackageTerms(ctx, tx, pkg, order.SellerShopID)
|
||
if err != nil {
|
||
h.logger.Error("自动购包生成套餐计时快照失败", zap.Uint("package_id", pkg.ID), zap.Error(err))
|
||
return err
|
||
}
|
||
if err := h.lockPackageCarrier(ctx, tx, carrierType, carrierID); err != nil {
|
||
return err
|
||
}
|
||
|
||
hasCurrentMain, err := packagepkg.HasCurrentMainPackageForQueue(tx.WithContext(ctx), carrierType, carrierID, now)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
var status int
|
||
var priority int
|
||
var activatedAt time.Time
|
||
var expiresAt time.Time
|
||
var nextResetAt *time.Time
|
||
var pendingRealnameActivation bool
|
||
if terms.ExpiryBase == constants.PackageExpiryBaseFromActivation {
|
||
realnamed, realnameErr := h.isCarrierRealnamed(ctx, tx, carrierType, carrierID)
|
||
if realnameErr != nil {
|
||
return realnameErr
|
||
}
|
||
pendingRealnameActivation = !realnamed
|
||
}
|
||
|
||
if hasCurrentMain {
|
||
status = constants.PackageUsageStatusPending
|
||
var maxPriority int
|
||
tx.Model(&model.PackageUsage{}).
|
||
Where(carrierType+"_id = ?", carrierID).
|
||
Select("COALESCE(MAX(priority), 0)").
|
||
Scan(&maxPriority)
|
||
priority = maxPriority + 1
|
||
} else {
|
||
priority = 1
|
||
if pendingRealnameActivation {
|
||
status = constants.PackageUsageStatusPending
|
||
} else {
|
||
status = constants.PackageUsageStatusActive
|
||
activatedAt = now
|
||
expiresAt = packagepkg.CalculateExpiryTime(terms.CalendarType, activatedAt, terms.DurationMonths, terms.DurationDays)
|
||
nextResetAt = packagepkg.CalculateNextResetTime(pkg.DataResetCycle, terms.CalendarType, now, activatedAt)
|
||
}
|
||
}
|
||
|
||
virtualTotalMBSnapshot, displayGainRatioSnapshot, enableVirtualDataSnapshot := model.BuildPackageUsageSnapshotValues(pkg)
|
||
retailAmount := order.TotalAmount
|
||
usage := &model.PackageUsage{
|
||
BaseModel: model.BaseModel{
|
||
Creator: order.Creator,
|
||
Updater: order.Creator,
|
||
},
|
||
OrderID: order.ID,
|
||
OrderNo: order.OrderNo,
|
||
PackageID: pkg.ID,
|
||
PackageName: pkg.PackageName,
|
||
UsageType: order.OrderType,
|
||
DataLimitMB: pkg.RealDataMB,
|
||
VirtualTotalMBSnapshot: virtualTotalMBSnapshot,
|
||
DisplayGainRatioSnapshot: displayGainRatioSnapshot,
|
||
EnableVirtualDataSnapshot: enableVirtualDataSnapshot,
|
||
Status: status,
|
||
Priority: priority,
|
||
DataResetCycle: pkg.DataResetCycle,
|
||
PendingRealnameActivation: pendingRealnameActivation,
|
||
Generation: order.Generation,
|
||
PaidAmount: &order.SellerCostPrice,
|
||
RetailAmount: &retailAmount,
|
||
PackagePriceConfigStatus: pkg.PriceConfigStatus,
|
||
PackageIsGift: pkg.IsGift,
|
||
}
|
||
terms.Apply(usage)
|
||
|
||
if carrierType == constants.AssetWalletResourceTypeIotCard {
|
||
usage.IotCardID = carrierID
|
||
} else {
|
||
usage.DeviceID = carrierID
|
||
}
|
||
|
||
if status == constants.PackageUsageStatusActive {
|
||
usage.ActivatedAt = &activatedAt
|
||
usage.ExpiresAt = &expiresAt
|
||
usage.NextResetAt = nextResetAt
|
||
}
|
||
|
||
if err = tx.Omit("status", "pending_realname_activation").Create(usage).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
if err = tx.Model(usage).Updates(map[string]any{
|
||
"status": usage.Status,
|
||
"pending_realname_activation": usage.PendingRealnameActivation,
|
||
}).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
// 仅在生效状态分支追加优先轮询请求：待生效（含等待实名激活）不属于触发场景。
|
||
if status == constants.PackageUsageStatusActive {
|
||
triggerType, classifyErr := packagepkg.ResolveActivationTriggerType(ctx, tx, carrierType, carrierID, usage.ID)
|
||
if classifyErr != nil {
|
||
return classifyErr
|
||
}
|
||
return packagepkg.AppendActivatedPriorityRequested(ctx, tx, h.priorityEvents, usage, carrierType, carrierID, triggerType, activatedAt)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// isCarrierRealnamed 查询自动购包载体是否已满足实名激活条件。
|
||
func (h *AutoPurchaseHandler) isCarrierRealnamed(ctx context.Context, tx *gorm.DB, carrierType string, carrierID uint) (bool, error) {
|
||
switch carrierType {
|
||
case constants.AssetWalletResourceTypeIotCard, "card":
|
||
var card model.IotCard
|
||
if err := tx.WithContext(ctx).Select("real_name_status").First(&card, carrierID).Error; err != nil {
|
||
return false, err
|
||
}
|
||
return card.RealNameStatus == constants.RealNameStatusVerified, nil
|
||
case constants.AssetWalletResourceTypeDevice:
|
||
var count int64
|
||
subQuery := tx.WithContext(ctx).Model(&model.DeviceSimBinding{}).
|
||
Select("iot_card_id").Where("device_id = ? AND bind_status = ?", carrierID, constants.BindStatusBound)
|
||
if err := tx.WithContext(ctx).Model(&model.IotCard{}).
|
||
Where("id IN (?) AND real_name_status = ?", subQuery, constants.RealNameStatusVerified).
|
||
Count(&count).Error; err != nil {
|
||
return false, err
|
||
}
|
||
return count > 0, nil
|
||
default:
|
||
return false, pkgerrors.New(pkgerrors.CodeInvalidParam, "无效的套餐载体类型")
|
||
}
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) lockPackageCarrier(ctx context.Context, tx *gorm.DB, carrierType string, carrierID uint) error {
|
||
switch carrierType {
|
||
case constants.AssetWalletResourceTypeIotCard, "card":
|
||
var card model.IotCard
|
||
return tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}).First(&card, carrierID).Error
|
||
case constants.AssetWalletResourceTypeDevice:
|
||
var device model.Device
|
||
return tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}).First(&device, carrierID).Error
|
||
default:
|
||
return errors.New("无效的套餐载体类型")
|
||
}
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) activateAddonPackage(
|
||
ctx context.Context,
|
||
tx *gorm.DB,
|
||
order *model.Order,
|
||
pkg *model.Package,
|
||
carrierType string,
|
||
carrierID uint,
|
||
now time.Time,
|
||
) error {
|
||
terms, err := h.resolvePackageTerms(ctx, tx, pkg, order.SellerShopID)
|
||
if err != nil {
|
||
h.logger.Error("自动购包生成加油包计时快照失败", zap.Uint("package_id", pkg.ID), zap.Error(err))
|
||
return err
|
||
}
|
||
mainPackage, err := packagepkg.FindAttachableMainPackageForAddon(tx, carrierType, carrierID, now)
|
||
if err == gorm.ErrRecordNotFound {
|
||
return errors.New("必须有主套餐才能购买加油包")
|
||
}
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
var maxPriority int
|
||
tx.Model(&model.PackageUsage{}).
|
||
Where(carrierType+"_id = ?", carrierID).
|
||
Select("COALESCE(MAX(priority), 0)").
|
||
Scan(&maxPriority)
|
||
|
||
priority := maxPriority + 1
|
||
expiresAt := mainPackage.ExpiresAt
|
||
|
||
virtualTotalMBSnapshot, displayGainRatioSnapshot, enableVirtualDataSnapshot := model.BuildPackageUsageSnapshotValues(pkg)
|
||
addonRetailAmount := order.TotalAmount
|
||
usage := &model.PackageUsage{
|
||
BaseModel: model.BaseModel{
|
||
Creator: order.Creator,
|
||
Updater: order.Creator,
|
||
},
|
||
OrderID: order.ID,
|
||
OrderNo: order.OrderNo,
|
||
PackageID: pkg.ID,
|
||
PackageName: pkg.PackageName,
|
||
UsageType: order.OrderType,
|
||
DataLimitMB: pkg.RealDataMB,
|
||
VirtualTotalMBSnapshot: virtualTotalMBSnapshot,
|
||
DisplayGainRatioSnapshot: displayGainRatioSnapshot,
|
||
EnableVirtualDataSnapshot: enableVirtualDataSnapshot,
|
||
Status: constants.PackageUsageStatusActive,
|
||
Priority: priority,
|
||
MasterUsageID: &mainPackage.ID,
|
||
ActivatedAt: &now,
|
||
ExpiresAt: expiresAt,
|
||
DataResetCycle: pkg.DataResetCycle,
|
||
Generation: order.Generation,
|
||
PaidAmount: &order.SellerCostPrice,
|
||
RetailAmount: &addonRetailAmount,
|
||
PackagePriceConfigStatus: pkg.PriceConfigStatus,
|
||
PackageIsGift: pkg.IsGift,
|
||
}
|
||
terms.Apply(usage)
|
||
|
||
if carrierType == constants.AssetWalletResourceTypeIotCard {
|
||
usage.IotCardID = carrierID
|
||
} else {
|
||
usage.DeviceID = carrierID
|
||
}
|
||
|
||
if err := tx.Create(usage).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
// 加油包立即生效：以生效状态提交后追加优先轮询请求。
|
||
return packagepkg.AppendActivatedPriorityRequested(ctx, tx, h.priorityEvents, usage, carrierType, carrierID,
|
||
constants.PollingPriorityTriggerAddonActivated, now)
|
||
}
|
||
|
||
func (h *AutoPurchaseHandler) resolvePackageTerms(ctx context.Context, tx *gorm.DB, pkg *model.Package, sellerShopID *uint) (packagedomain.TermsSnapshot, error) {
|
||
return packagepkg.ResolveTermsFromTx(ctx, tx, pkg, sellerShopID)
|
||
}
|
||
|
||
func parseLinkedPackageIDs(raw []byte) ([]uint, error) {
|
||
var packageIDs []uint
|
||
if len(raw) == 0 {
|
||
return nil, nil
|
||
}
|
||
if err := sonic.Unmarshal(raw, &packageIDs); err != nil {
|
||
return nil, err
|
||
}
|
||
return packageIDs, nil
|
||
}
|
||
|
||
func parseLinkedCarrier(linkedOrderType string, linkedCarrierType string, linkedCarrierID *uint) (string, *uint, *uint, error) {
|
||
if linkedCarrierID == nil || *linkedCarrierID == 0 {
|
||
return "", nil, nil, errors.New("关联载体ID为空")
|
||
}
|
||
|
||
if linkedOrderType == model.OrderTypeSingleCard || linkedCarrierType == "card" || linkedCarrierType == constants.AssetWalletResourceTypeIotCard {
|
||
id := *linkedCarrierID
|
||
return model.OrderTypeSingleCard, &id, nil, nil
|
||
}
|
||
if linkedOrderType == model.OrderTypeDevice || linkedCarrierType == "device" || linkedCarrierType == constants.AssetWalletResourceTypeDevice {
|
||
id := *linkedCarrierID
|
||
return model.OrderTypeDevice, nil, &id, nil
|
||
}
|
||
|
||
return "", nil, nil, errors.New("关联载体类型无效")
|
||
}
|
||
|
||
func validatePackageTypeMix(packages []*model.Package) error {
|
||
hasFormal := false
|
||
hasAddon := false
|
||
|
||
for _, pkg := range packages {
|
||
switch pkg.PackageType {
|
||
case constants.PackageTypeFormal:
|
||
hasFormal = true
|
||
case constants.PackageTypeAddon:
|
||
hasAddon = true
|
||
}
|
||
|
||
if hasFormal && hasAddon {
|
||
return errors.New("不允许在同一订单中同时购买正式套餐和加油包")
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|