package asset import ( "context" "strings" "go.uber.org/zap" "gorm.io/gorm" stopresumedomain "github.com/break/junhong_cmp_fiber/internal/domain/stopresume" "github.com/break/junhong_cmp_fiber/internal/model" "github.com/break/junhong_cmp_fiber/internal/model/dto" "github.com/break/junhong_cmp_fiber/internal/query/recorddisplay" "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/middleware" ) // legacyUsageEditReason 是旧"修改资产套餐已用量"接口改走冲正流水时记录的原因。 const legacyUsageEditReason = "后台修改资产套餐已用量" // TrafficAdjustmentEvaluator 在冲正提交后按最新套餐、流量、实名事实评估卡的停复机。 type TrafficAdjustmentEvaluator interface { EvaluateAndAct(ctx context.Context, card *model.IotCard) error } // SetTrafficAdjustmentEvaluator 注入冲正提交后的停复机判断。 func (s *Service) SetTrafficAdjustmentEvaluator(evaluator TrafficAdjustmentEvaluator) { s.trafficAdjustmentEvaluator = evaluator } // trafficAdjustment 是一次冲正的输入。 type trafficAdjustment struct { PackageUsageID uint DeltaMB int64 Reason string RefObservationID string RefEventID string } // AdjustPackageTraffic 人工冲正套餐流量:锁套餐行、按锁定后的当前已用量加减、退回后不得小于 0, // 同事务写冲正流水、更新已用量并按阈值重算状态(已过期、已失效只改已用量)、写审计;提交后走停复机判断。 // 冲正不修改卡日快照与已结算。 func (s *Service) AdjustPackageTraffic(ctx context.Context, assetType string, assetID uint, assetIdentifier string, req *dto.AdjustAssetPackageTrafficRequest) (*dto.PackageTrafficAdjustmentItem, error) { if req == nil || req.DeltaMB == 0 || strings.TrimSpace(req.Reason) == "" { return nil, errors.New(errors.CodeInvalidParam, "冲正调整量不能为 0,原因必填") } return s.adjustPackageTraffic(ctx, assetType, assetID, assetIdentifier, trafficAdjustment{ PackageUsageID: req.PackageUsageID, DeltaMB: req.DeltaMB, Reason: strings.TrimSpace(req.Reason), RefObservationID: strings.TrimSpace(req.RefObservationID), RefEventID: strings.TrimSpace(req.RefEventID), }, nil) } // adjustPackageTraffic 执行冲正;targetUsageMB 非空时按"改成该已用量"计算调整量(旧接口兼容)。 func (s *Service) adjustPackageTraffic(ctx context.Context, assetType string, assetID uint, assetIdentifier string, input trafficAdjustment, targetUsageMB *int64) (*dto.PackageTrafficAdjustmentItem, error) { operatorID := middleware.GetUserIDFromContext(ctx) if operatorID == 0 { return nil, errors.New(errors.CodeUnauthorized, "未授权访问") } carrierType, err := normalizeAssetCarrierType(assetType) if err != nil { return nil, err } var record model.PackageUsageAdjustment var before, updated *model.PackageUsage err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { store := postgres.NewPackageUsageStore(tx, nil) locked, lockErr := store.LockByIDForCarrier(ctx, input.PackageUsageID, carrierType, assetID) if lockErr != nil { return wrapPackageUsageNotFound(lockErr) } before = locked delta := input.DeltaMB if targetUsageMB != nil { delta = *targetUsageMB - locked.DataUsageMB } if delta == 0 { if targetUsageMB != nil { // 旧接口改成与当前相同的已用量:不产生冲正流水。 return nil } return errors.New(errors.CodeInvalidParam, "冲正调整量不能为 0") } after := locked.DataUsageMB + delta if after < 0 { return errors.New(errors.CodeInvalidParam, "退回后套餐已用量不能小于 0") } nextStatus := statusForManualDataUsage(locked, after) if _, updateErr := store.UpdateDataUsageForCarrier(ctx, locked.ID, carrierType, assetID, after, nextStatus); updateErr != nil { return errors.Wrap(errors.CodeDatabaseError, updateErr, "冲正套餐已用量失败") } afterStatus := locked.Status if nextStatus != nil { afterStatus = *nextStatus } record = model.PackageUsageAdjustment{ PackageUsageID: locked.ID, IotCardID: locked.IotCardID, DeviceID: locked.DeviceID, DeltaMB: delta, BeforeUsageMB: locked.DataUsageMB, AfterUsageMB: after, BeforeStatus: locked.Status, AfterStatus: afterStatus, Reason: input.Reason, RefObservationID: input.RefObservationID, RefEventID: input.RefEventID, OperatorID: operatorID, } if createErr := tx.WithContext(ctx).Create(&record).Error; createErr != nil { return errors.Wrap(errors.CodeDatabaseError, createErr, "写入冲正流水失败") } var loadErr error if updated, loadErr = store.GetByIDForCarrier(ctx, locked.ID, carrierType, assetID); loadErr != nil { return errors.Wrap(errors.CodeDatabaseError, loadErr, "查询套餐使用记录失败") } afterData := packageUsageTrafficAuditData(updated) afterData["adjustment_id"], afterData["delta_mb"], afterData["reason"] = record.ID, delta, input.Reason return s.appendPackageAdjustmentAudit(ctx, tx, constants.AuditActionPackageUsageTrafficAdjusted, "人工冲正套餐流量", constants.AuditResultSuccess, updated, assetType, assetID, assetIdentifier, packageUsageTrafficAuditData(locked), afterData, nil) }) if err != nil { if before != nil { s.recordPackageAdjustmentFailure(ctx, constants.AuditActionPackageUsageTrafficAdjusted, "人工冲正套餐流量失败", before, assetType, assetID, assetIdentifier, packageUsageTrafficAuditData(before), map[string]any{"package_usage_id": input.PackageUsageID, "delta_mb": input.DeltaMB, "reason": input.Reason}, err) } return nil, err } if record.ID == 0 { return nil, nil } s.evaluateAfterAdjustment(ctx, carrierType, assetID) item := toTrafficAdjustmentItem(record) return &item, nil } // evaluateAfterAdjustment 冲正提交后对载体下的卡调用停复机判断,不直接复机或停机。 func (s *Service) evaluateAfterAdjustment(ctx context.Context, carrierType string, carrierID uint) { if s.trafficAdjustmentEvaluator == nil { return } evalCtx := stopresumedomain.WithScene(context.WithoutCancel(ctx), constants.StopResumeSceneUsage) var cards []*model.IotCard query := s.db.WithContext(evalCtx).Model(&model.IotCard{}) if carrierType == constants.AssetTypeDevice { query = query.Where("id IN (?)", s.db.Model(&model.DeviceSimBinding{}).Select("iot_card_id"). Where("device_id = ? AND bind_status = ?", carrierID, constants.BindStatusBound)) } else { query = query.Where("id = ?", carrierID) } if err := query.Find(&cards).Error; err != nil { s.adjustmentLogger().Warn("冲正后查询载体下的卡失败,未做停复机判断", zap.String("carrier_type", carrierType), zap.Uint("carrier_id", carrierID), zap.Error(err)) return } for _, card := range cards { if err := s.trafficAdjustmentEvaluator.EvaluateAndAct(evalCtx, card); err != nil { s.adjustmentLogger().Warn("冲正后停复机判断失败", zap.Uint("card_id", card.ID), zap.Error(err)) } } } func (s *Service) adjustmentLogger() *zap.Logger { if s.logger == nil { return zap.NewNop() } return s.logger } // ListPackageTrafficAdjustments 分页查询套餐的冲正流水,按时间倒序。 func (s *Service) ListPackageTrafficAdjustments(ctx context.Context, assetType string, assetID uint, req *dto.PackageTrafficAdjustmentListRequest) (*dto.PackageTrafficAdjustmentListResponse, error) { carrierType, err := normalizeAssetCarrierType(assetType) if err != nil { return nil, err } if _, err := s.packageUsageStore.GetByIDForCarrier(ctx, req.PackageUsageID, carrierType, assetID); err != nil { return nil, wrapPackageUsageNotFound(err) } page, size := req.Page, req.PageSize if page <= 0 { page = 1 } if size <= 0 { size = 20 } query := s.db.WithContext(ctx).Model(&model.PackageUsageAdjustment{}).Where("package_usage_id = ?", req.PackageUsageID) if req.StartTime != "" || req.EndTime != "" { from, to, err := parseRecordTimeRange(req.StartTime, req.EndTime) if err != nil { return nil, err } query = query.Where("created_at >= ? AND created_at < ?", from, to) } var total int64 if err := query.Count(&total).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询冲正流水失败") } var rows []model.PackageUsageAdjustment if err := query.Order("created_at DESC, id DESC").Offset((page - 1) * size).Limit(size).Find(&rows).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询冲正流水失败") } operatorIDs := make([]uint, 0, len(rows)) for _, row := range rows { operatorIDs = append(operatorIDs, row.OperatorID) } display, err := recorddisplay.Load(ctx, s.db, recorddisplay.Request{OperatorIDs: operatorIDs}) if err != nil { return nil, err } items := make([]dto.PackageTrafficAdjustmentItem, 0, len(rows)) for _, row := range rows { item := toTrafficAdjustmentItem(row) item.OperatorName = display.OperatorName(row.OperatorID) items = append(items, item) } return &dto.PackageTrafficAdjustmentListResponse{Items: items, Total: total}, nil } func toTrafficAdjustmentItem(row model.PackageUsageAdjustment) dto.PackageTrafficAdjustmentItem { return dto.PackageTrafficAdjustmentItem{ ID: row.ID, PackageUsageID: row.PackageUsageID, DeltaMB: row.DeltaMB, BeforeUsageMB: row.BeforeUsageMB, AfterUsageMB: row.AfterUsageMB, BeforeStatus: row.BeforeStatus, AfterStatus: row.AfterStatus, Reason: row.Reason, RefObservationID: row.RefObservationID, RefEventID: row.RefEventID, OperatorID: row.OperatorID, CreatedAt: row.CreatedAt, } }