Files
junhong_cmp_fiber/internal/service/asset/traffic_adjustment.go
邹进 3f593b912d
Some checks failed
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Failing after 4m7s
feat: 记录查询列表补齐 ICCID、设备号、套餐名称、运营商名称与操作人
分页后按当前页 ID 批量查主键补齐展示字段,不在分页查询中关联,也不在记录表冗余:
- 采集成功记录补 ICCID、运营商名称;采集失败、卡日流量补运营商名称
- 套餐日流量详单、冲正流水补套餐名称、ICCID、设备号与 IMEI
- 冲正流水(含资产详情)补操作人用户名;退款后处理尝试记录补设备号与 IMEI
2026-11-07 17:07:27 +09:00

220 lines
9.5 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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,
}
}