Some checks failed
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Failing after 4m7s
分页后按当前页 ID 批量查主键补齐展示字段,不在分页查询中关联,也不在记录表冗余: - 采集成功记录补 ICCID、运营商名称;采集失败、卡日流量补运营商名称 - 套餐日流量详单、冲正流水补套餐名称、ICCID、设备号与 IMEI - 冲正流水(含资产详情)补操作人用户名;退款后处理尝试记录补设备号与 IMEI
220 lines
9.5 KiB
Go
220 lines
9.5 KiB
Go
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,
|
||
}
|
||
}
|