package exchange import ( "context" "time" "gorm.io/gorm" "gorm.io/gorm/clause" "github.com/break/junhong_cmp_fiber/internal/model" "github.com/break/junhong_cmp_fiber/pkg/constants" "github.com/break/junhong_cmp_fiber/pkg/errors" ) // packageUsageStateChange 记录换货迁移中套餐使用记录状态字段的前后值,供换货审计使用。 type packageUsageStateChange struct { Before map[string]any After map[string]any } // migratedMainPlan 是旧资产主套餐迁移后的目标状态。 type migratedMainPlan struct { usage *model.PackageUsage updates map[string]any // 为空表示状态字段原样保留 pending bool // 迁移后为待生效,参与排队 } func carrierColumn(assetType string) string { if assetType == constants.ExchangeAssetTypeIotCard { return "iot_card_id" } return "device_id" } func liveUsageStatuses() []int { return []int{constants.PackageUsageStatusPending, constants.PackageUsageStatusActive, constants.PackageUsageStatusDepleted} } // lockLiveUsagesWithTx 锁定载体上待生效、生效中、已用完的套餐使用记录,按优先级、创建时间、标识排序。 func lockLiveUsagesWithTx(ctx context.Context, tx *gorm.DB, column string, assetID uint, mainOnly bool) ([]*model.PackageUsage, error) { query := tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}). Where(column+" = ?", assetID). Where("status IN ?", liveUsageStatuses()) if mainOnly { query = query.Where("master_usage_id IS NULL") } var rows []*model.PackageUsage if err := query.Order("priority ASC, created_at ASC, id ASC").Find(&rows).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "锁定套餐使用记录失败") } return rows, nil } // isCurrentMainUsage 与 FindCurrentMainPackageForQueue 口径一致:生效中或已用完且未到期。 func isCurrentMainUsage(usage *model.PackageUsage, now time.Time) bool { if usage.Status != constants.PackageUsageStatusActive && usage.Status != constants.PackageUsageStatusDepleted { return false } return usage.ExpiresAt == nil || usage.ExpiresAt.After(now) } func isExpiredOccupyingUsage(usage *model.PackageUsage, now time.Time) bool { return (usage.Status == constants.PackageUsageStatusActive || usage.Status == constants.PackageUsageStatusDepleted) && !isCurrentMainUsage(usage, now) } // isUsageStarted 判断套餐是否已开始:有生效时间、有到期时间、有用量、有日流量记录或已用完。 // 老系统迁移数据可能只有固定到期时间、没有生效时间,按已开始处理以保留原到期日。 func isUsageStarted(usage *model.PackageUsage, hasDailyRecord bool) bool { return usage.ActivatedAt != nil || usage.ExpiresAt != nil || usage.DataUsageMB > 0 || hasDailyRecord || usage.Status == constants.PackageUsageStatusDepleted } func loadDailyRecordUsageIDsWithTx(ctx context.Context, tx *gorm.DB, usages []*model.PackageUsage) (map[uint]bool, error) { result := make(map[uint]bool) if len(usages) == 0 { return result, nil } ids := make([]uint, 0, len(usages)) for _, usage := range usages { ids = append(ids, usage.ID) } var withRecords []uint if err := tx.WithContext(ctx).Model(&model.PackageUsageDailyRecord{}). Where("package_usage_id IN ?", ids).Distinct().Pluck("package_usage_id", &withRecords).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询套餐日流量记录失败") } for _, id := range withRecords { result[id] = true } return result, nil } // resetToPendingUpdates 生成"改为待生效并清空生效周期"的字段更新。 func resetToPendingUpdates(pendingRealname, clearUsage bool) map[string]any { updates := map[string]any{ "status": constants.PackageUsageStatusPending, "activated_at": nil, "expires_at": nil, "last_reset_at": nil, "next_reset_at": nil, "pending_realname_activation": pendingRealname, } if clearUsage { updates["data_usage_mb"] = int64(0) } return updates } // isCleanPendingUsage 判断记录是否已是目标待生效状态,避免无变化的写入与审计。 func isCleanPendingUsage(usage *model.PackageUsage, pendingRealname bool) bool { return usage.Status == constants.PackageUsageStatusPending && usage.PendingRealnameActivation == pendingRealname && usage.ActivatedAt == nil && usage.ExpiresAt == nil && usage.LastResetAt == nil && usage.NextResetAt == nil } // planMigratedMains 按"是否已开始、新资产实名条件、新资产是否已有当前主套餐"决定旧资产主套餐的迁移状态。 // realnameSatisfied 仅在存在未开始的主套餐时被调用。 func planMigratedMains(oldMains []*model.PackageUsage, dailyRecords map[uint]bool, newHasCurrent bool, now time.Time, realnameSatisfied func() (bool, error)) ([]migratedMainPlan, *model.PackageUsage, error) { plans := make([]migratedMainPlan, 0, len(oldMains)) var promoted *model.PackageUsage for _, usage := range oldMains { if isExpiredOccupyingUsage(usage, now) { plans = append(plans, migratedMainPlan{usage: usage}) continue } if !isUsageStarted(usage, dailyRecords[usage.ID]) { satisfied, err := realnameSatisfied() if err != nil { return nil, nil, err } var updates map[string]any if !isCleanPendingUsage(usage, !satisfied) { updates = resetToPendingUpdates(!satisfied, false) } plans = append(plans, migratedMainPlan{usage: usage, updates: updates, pending: true}) continue } if !newHasCurrent && promoted == nil && isCurrentMainUsage(usage, now) { promoted = usage plans = append(plans, migratedMainPlan{usage: usage}) continue } plans = append(plans, migratedMainPlan{usage: usage, updates: resetToPendingUpdates(false, true), pending: true}) } return plans, promoted, nil } // buildMainQueueOrder 迁移后新资产主套餐顺序:当前主套餐 → 新资产原有待生效 → 迁入的待生效。 func buildMainQueueOrder(newMains []*model.PackageUsage, promoted *model.PackageUsage, plans []migratedMainPlan, now time.Time) []*model.PackageUsage { ordered := make([]*model.PackageUsage, 0, len(newMains)+len(plans)) for _, usage := range newMains { if isCurrentMainUsage(usage, now) { ordered = append(ordered, usage) } } if promoted != nil { ordered = append(ordered, promoted) } for _, usage := range newMains { if usage.Status == constants.PackageUsageStatusPending { ordered = append(ordered, usage) } } for _, plan := range plans { if plan.pending { ordered = append(ordered, plan.usage) } } return ordered } func usageStateSnapshot(usage *model.PackageUsage) map[string]any { return map[string]any{ "status": usage.Status, "priority": usage.Priority, "data_usage_mb": usage.DataUsageMB, "activated_at": usage.ActivatedAt, "expires_at": usage.ExpiresAt, "last_reset_at": usage.LastResetAt, "next_reset_at": usage.NextResetAt, "pending_realname_activation": usage.PendingRealnameActivation, } } func recordStateChange(changes map[uint]*packageUsageStateChange, usage *model.PackageUsage, updates map[string]any) { change, ok := changes[usage.ID] if !ok { change = &packageUsageStateChange{Before: usageStateSnapshot(usage), After: usageStateSnapshot(usage)} changes[usage.ID] = change } for key, value := range updates { change.After[key] = value } } func applyUsageUpdatesWithTx(ctx context.Context, tx *gorm.DB, id uint, updates map[string]any) error { values := make(map[string]any, len(updates)+1) for key, value := range updates { values[key] = value } values["updated_at"] = time.Now() if err := tx.WithContext(ctx).Model(&model.PackageUsage{}).Where("id = ?", id).Updates(values).Error; err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "更新迁移套餐状态失败") } return nil } // applyMigratedMainPlansWithTx 写入迁移主套餐的目标状态并重排新资产主套餐优先级。 func applyMigratedMainPlansWithTx(ctx context.Context, tx *gorm.DB, plans []migratedMainPlan, ordered []*model.PackageUsage) (map[uint]*packageUsageStateChange, error) { changes := make(map[uint]*packageUsageStateChange) pendingUpdates := make(map[uint]map[string]any) for _, plan := range plans { if len(plan.updates) > 0 { pendingUpdates[plan.usage.ID] = plan.updates recordStateChange(changes, plan.usage, plan.updates) } } for index, usage := range ordered { priority := index + 1 if usage.Priority == priority { continue } updates := pendingUpdates[usage.ID] if updates == nil { updates = make(map[string]any) pendingUpdates[usage.ID] = updates } updates["priority"] = priority recordStateChange(changes, usage, map[string]any{"priority": priority}) } for id, updates := range pendingUpdates { if err := applyUsageUpdatesWithTx(ctx, tx, id, updates); err != nil { return nil, err } } return changes, nil } // newAssetRealnameSatisfiedWithTx 判断新资产是否满足实名条件。 // 口径同 StopResumeService.isRealnameOK:行业卡、已实名、或适用实名策略为无需实名;设备看自身策略与已绑定卡。 func newAssetRealnameSatisfiedWithTx(ctx context.Context, tx *gorm.DB, asset *resolvedExchangeAsset) (bool, error) { if asset.AssetType == constants.ExchangeAssetTypeIotCard { return cardRealnameSatisfiedWithTx(ctx, tx, asset.AssetID) } return deviceRealnameSatisfiedWithTx(ctx, tx, asset.AssetID) } func cardRealnameSatisfiedWithTx(ctx context.Context, tx *gorm.DB, cardID uint) (bool, error) { var card model.IotCard if err := tx.WithContext(ctx).Select("id", "card_category", "real_name_status", "realname_policy", "is_standalone"). First(&card, cardID).Error; err != nil { return false, errors.Wrap(errors.CodeDatabaseError, err, "查询新卡实名条件失败") } if card.CardCategory == constants.CardCategoryIndustry || card.RealNameStatus == constants.RealNameStatusVerified { return true, nil } if card.IsStandalone { return card.RealnamePolicy == constants.RealnamePolicyNone, nil } var device model.Device err := tx.WithContext(ctx).Select("devices.realname_policy").Table("tb_device AS devices"). Joins("JOIN tb_device_sim_binding AS bindings ON bindings.device_id = devices.id"). Where("bindings.iot_card_id = ? AND bindings.bind_status = ? AND bindings.deleted_at IS NULL", cardID, constants.BindStatusBound). Where("devices.deleted_at IS NULL"). Take(&device).Error if err == gorm.ErrRecordNotFound { return card.RealnamePolicy == constants.RealnamePolicyNone, nil } if err != nil { return false, errors.Wrap(errors.CodeDatabaseError, err, "查询新卡绑定设备实名策略失败") } return device.RealnamePolicy == constants.RealnamePolicyNone, nil } func deviceRealnameSatisfiedWithTx(ctx context.Context, tx *gorm.DB, deviceID uint) (bool, error) { var device model.Device if err := tx.WithContext(ctx).Select("id", "realname_policy").First(&device, deviceID).Error; err != nil { return false, errors.Wrap(errors.CodeDatabaseError, err, "查询新设备实名条件失败") } if device.RealnamePolicy == constants.RealnamePolicyNone { return true, nil } var count int64 if err := tx.WithContext(ctx).Model(&model.IotCard{}). Joins("JOIN tb_device_sim_binding AS bindings ON bindings.iot_card_id = tb_iot_card.id"). Where("bindings.device_id = ? AND bindings.bind_status = ? AND bindings.deleted_at IS NULL", deviceID, constants.BindStatusBound). Where("tb_iot_card.card_category = ? OR tb_iot_card.real_name_status = ?", constants.CardCategoryIndustry, constants.RealNameStatusVerified). Count(&count).Error; err != nil { return false, errors.Wrap(errors.CodeDatabaseError, err, "查询新设备绑定卡实名条件失败") } return count > 0, nil }