98017ac053
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 9m37s
- 轮询配置新增套餐状态、资产状态、重置日前窗口与窗口内流量间隔（迁移 248），间隔三态：正数按间隔、0 不检查、空继承 - 配置按 priority, id 排序合并；在库与已销售无套餐未匹配时告警不入队 - 新增优先级整体重排、匹配预览、立即重算到期时间（异步只提前）、分层统计与重置日前加密统计接口 - 已切换日快照计量的卡流量按观测时间归属，激活前用量只记已结算 - 订单购买与实名激活补齐资产级激活锁，激活前对已切换卡结算一次流量，失败只告警不阻塞，结算不触发通道阈值判定
208 lines
9.5 KiB
Go
208 lines
9.5 KiB
Go
package cardobservation
|
|
|
|
import (
|
|
"context"
|
|
"strconv"
|
|
"time"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
|
|
cardflow "github.com/break/junhong_cmp_fiber/internal/domain/cardflow"
|
|
domain "github.com/break/junhong_cmp_fiber/internal/domain/cardobservation"
|
|
carrierthresholddomain "github.com/break/junhong_cmp_fiber/internal/domain/carrierthreshold"
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"github.com/break/junhong_cmp_fiber/pkg/outboxid"
|
|
)
|
|
|
|
// TrafficIncrementedEvent 是卡流量正增量的可靠领域事实。
|
|
type TrafficIncrementedEvent struct {
|
|
EventID string `json:"event_id"`
|
|
CardID uint `json:"card_id"`
|
|
IncrementMB float64 `json:"increment_mb"`
|
|
ObservedAt time.Time `json:"observed_at"`
|
|
Source string `json:"source"`
|
|
Scene string `json:"scene"`
|
|
RequestID string `json:"request_id,omitempty"`
|
|
CorrelationID string `json:"correlation_id,omitempty"`
|
|
}
|
|
|
|
// ApplyTrafficObservation 串行应用流量读数，并在正增量时同事务写 Outbox。
|
|
func (s *Service) ApplyTrafficObservation(ctx context.Context, observation domain.TrafficObservation) (domain.TrafficDecision, error) {
|
|
if s == nil || s.db == nil || s.eventWriter == nil {
|
|
return domain.TrafficDecision{}, errors.New(errors.CodeInternalError, "卡流量观测能力未完整配置")
|
|
}
|
|
var decision domain.TrafficDecision
|
|
var auditedCard *model.IotCard
|
|
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var card model.IotCard
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("id = ?", observation.CardID).First(&card).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return errors.New(errors.CodeNotFound, "IoT卡不存在")
|
|
}
|
|
return errors.Wrap(errors.CodeDatabaseError, err, "锁定IoT卡流量事实失败")
|
|
}
|
|
auditedCard = &card
|
|
nextDecision, decisionErr := domain.ApplyTraffic(domain.CardTrafficSnapshot{
|
|
CardID: card.ID, DataUsageMB: card.DataUsageMB, CurrentMonthUsageMB: card.CurrentMonthUsageMB,
|
|
CurrentMonthStartDate: card.CurrentMonthStartDate, LastMonthTotalMB: card.LastMonthTotalMB,
|
|
LastGatewayReadingMB: card.LastGatewayReadingMB,
|
|
}, observation)
|
|
if decisionErr != nil {
|
|
return decisionErr
|
|
}
|
|
decision = nextDecision
|
|
// 已切换日快照算法的卡：增量、通道阈值与本月用量改由快照决定；读数为 0 或无效时不写快照、不产生增量。
|
|
switched := s.trafficCalc.Switched(card.ID)
|
|
var flow *switchedFlowOutcome
|
|
if switched && cardflow.ValidReading(observation.GatewayReadingMB) {
|
|
outcome, flowErr := s.applySwitchedFlow(ctx, tx, &card, observation, decision)
|
|
if flowErr != nil {
|
|
return flowErr
|
|
}
|
|
flow = outcome
|
|
}
|
|
if switched {
|
|
decision.IncrementMB = 0
|
|
if flow != nil {
|
|
decision.IncrementMB = flow.EmitMB
|
|
decision.CurrentMonthUsageMB = flow.MonthMaxMB
|
|
}
|
|
}
|
|
updates := map[string]any{
|
|
"last_data_check_at": observation.Metadata.ObservedAt, "last_sync_time": observation.Metadata.ObservedAt,
|
|
"current_month_start_date": decision.CurrentMonthStartDate, "last_month_total_mb": decision.LastMonthTotalMB,
|
|
"current_month_usage_mb": decision.CurrentMonthUsageMB, "data_usage_mb": decision.DataUsageMB,
|
|
}
|
|
if decision.ReadingAccepted {
|
|
updates["last_gateway_reading_mb"] = decision.LastGatewayReadingMB
|
|
}
|
|
result := tx.Model(&model.IotCard{}).
|
|
Where("id = ? AND last_gateway_reading_mb = ?", card.ID, card.LastGatewayReadingMB).
|
|
Updates(updates)
|
|
if result.Error != nil {
|
|
return errors.Wrap(errors.CodeDatabaseError, result.Error, "更新卡流量事实失败")
|
|
}
|
|
if result.RowsAffected != 1 {
|
|
return errors.New(errors.CodeConflict, "卡流量基线已被其他请求更新")
|
|
}
|
|
if decision.IncrementMB > 0 {
|
|
// 未切换卡沿用卡表基线算法的增量；已切换卡的增量已替换为按月对账结果，每次观测最多一条 V1 事件。
|
|
eventID := outboxid.Stable("card-traffic:", strconv.FormatUint(uint64(card.ID), 10)+":"+observation.Metadata.ObservationID+":incremented")
|
|
if err := s.eventWriter.AppendTraffic(ctx, tx, TrafficIncrementedEvent{
|
|
EventID: eventID, CardID: card.ID, IncrementMB: decision.IncrementMB,
|
|
ObservedAt: observation.Metadata.ObservedAt, Source: observation.Metadata.Source,
|
|
Scene: observation.Metadata.Scene, RequestID: observation.Metadata.RequestID,
|
|
CorrelationID: observation.Metadata.CorrelationID,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
evaluateThreshold := decision.ReadingAccepted
|
|
if switched {
|
|
evaluateThreshold = switchedThresholdEvaluable(flow, decision.ReadingAccepted)
|
|
}
|
|
if observation.Metadata.Scene == constants.CardObservationScenePreActivationSettlement {
|
|
// 激活前结算只记已结算用量，不触发停复机评估；下一次正常轮询观测照常判定。
|
|
evaluateThreshold = false
|
|
}
|
|
if evaluateThreshold && s.channelThreshold != nil {
|
|
// 未切换卡只使用本次已接受的网关累计读数，异常下降保护命中的观测不参与判定；
|
|
// 已切换卡读数有效且未被重置日防旧值处理即判定，不再受卡表基线影响。
|
|
// 判定失败必须回滚整个流量事务，与既有流量事实保持同事务语义。
|
|
if err := s.channelThreshold.EvaluateInTx(ctx, tx, carrierthresholddomain.Evaluation{
|
|
CardID: card.ID, CarrierID: card.CarrierID,
|
|
ReadingMB: thresholdReading(switched, flow, observation, decision), ObservedAt: observation.Metadata.ObservedAt,
|
|
// 观测来源是判定端获取触发来源的唯一位置：命中留痕据此区分自动判定、人工同步与回调。
|
|
Source: observation.Metadata.Source,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
stateChanged := decision.IncrementMB != 0 || decision.CrossMonth || decision.LastGatewayReadingMB != card.LastGatewayReadingMB
|
|
if actionCode, audited := manualRefreshAuditAction(ctx); observation.Metadata.Source == constants.CardObservationSourceManualSync && stateChanged && audited {
|
|
if s.auditWriter == nil {
|
|
return errors.New(errors.CodeInternalError, "卡状态统一审计能力未配置")
|
|
}
|
|
if err := s.auditWriter.WriteCardStateAudit(ctx, tx, StateAudit{
|
|
ActionCode: actionCode,
|
|
Summary: "人工刷新 IoT 卡流量",
|
|
Card: &card,
|
|
BeforeData: map[string]any{
|
|
"data_usage_mb": card.DataUsageMB, "current_month_usage_mb": card.CurrentMonthUsageMB,
|
|
"current_month_start_date": card.CurrentMonthStartDate, "last_month_total_mb": card.LastMonthTotalMB,
|
|
"last_gateway_reading_mb": card.LastGatewayReadingMB,
|
|
},
|
|
AfterData: map[string]any{
|
|
"data_usage_mb": decision.DataUsageMB, "current_month_usage_mb": decision.CurrentMonthUsageMB,
|
|
"current_month_start_date": decision.CurrentMonthStartDate, "last_month_total_mb": decision.LastMonthTotalMB,
|
|
"last_gateway_reading_mb": decision.LastGatewayReadingMB, "increment_mb": decision.IncrementMB,
|
|
},
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
} else if workerObservationAudited(ctx) && stateChanged {
|
|
if s.auditWriter == nil {
|
|
return errors.New(errors.CodeInternalError, "卡状态统一审计能力未配置")
|
|
}
|
|
if err := s.auditWriter.WriteCardStateAudit(ctx, tx, StateAudit{
|
|
ActionCode: constants.AuditActionIotCardWorkerTrafficSynced,
|
|
Summary: "Worker 同步 IoT 卡流量事实", Card: &card,
|
|
IntegrationID: observation.Metadata.ObservationID,
|
|
BeforeData: map[string]any{
|
|
"data_usage_mb": card.DataUsageMB, "current_month_usage_mb": card.CurrentMonthUsageMB,
|
|
"current_month_start_date": card.CurrentMonthStartDate, "last_month_total_mb": card.LastMonthTotalMB,
|
|
"last_gateway_reading_mb": card.LastGatewayReadingMB,
|
|
},
|
|
AfterData: map[string]any{
|
|
"data_usage_mb": decision.DataUsageMB, "current_month_usage_mb": decision.CurrentMonthUsageMB,
|
|
"current_month_start_date": decision.CurrentMonthStartDate, "last_month_total_mb": decision.LastMonthTotalMB,
|
|
"last_gateway_reading_mb": decision.LastGatewayReadingMB, "increment_mb": decision.IncrementMB,
|
|
},
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if workerObservationAudited(ctx) && auditedCard != nil && s.auditWriter != nil {
|
|
s.auditWriter.WriteCardStateFailure(ctx, StateAudit{
|
|
ActionCode: constants.AuditActionIotCardWorkerTrafficSynced,
|
|
Summary: "Worker 同步 IoT 卡流量事实失败", Card: auditedCard,
|
|
IntegrationID: observation.Metadata.ObservationID,
|
|
}, err)
|
|
}
|
|
return domain.TrafficDecision{}, err
|
|
}
|
|
if s.cache != nil {
|
|
s.cache.Invalidate(ctx, observation.CardID)
|
|
}
|
|
if auditedCard != nil && !s.trafficCalc.Switched(auditedCard.ID) {
|
|
s.writeUnswitchedSnapshot(ctx, auditedCard, observation)
|
|
}
|
|
return decision, nil
|
|
}
|
|
|
|
// switchedThresholdEvaluable 判定已切换卡本次是否做通道阈值判定：读数有效且本次未被防旧值按 0 处理；
|
|
// 第一次切换观测仍按卡表基线算法是否接受读数判定。
|
|
func switchedThresholdEvaluable(flow *switchedFlowOutcome, oldAccepted bool) bool {
|
|
if flow == nil {
|
|
return false
|
|
}
|
|
if flow.FirstSwitch {
|
|
return oldAccepted
|
|
}
|
|
return !flow.StaleGuarded
|
|
}
|
|
|
|
// thresholdReading 返回通道阈值判定使用的网关累计读数：已切换卡（非第一次切换观测）用本次读数。
|
|
func thresholdReading(switched bool, flow *switchedFlowOutcome, observation domain.TrafficObservation, decision domain.TrafficDecision) float64 {
|
|
if switched && flow != nil && !flow.FirstSwitch {
|
|
return observation.GatewayReadingMB
|
|
}
|
|
return decision.LastGatewayReadingMB
|
|
}
|