25c081fe60
Some checks failed
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Failing after 8h37m36s
- M2 批量换绑表头改为“平台登录账号”，只认手机号，细分格式、不存在、多匹配、非平台、已禁用失败原因 - M3 后台订单列表与详情返回 C 端在线购买的交易流水号、支付渠道、商户名称，详情新增全部支付单 payments - M16 预警规则不再返回 real_data_mb，预警列表/详情新增 threshold_mb，导出末列追加“阈值流量(MB)” - M23 设备导入 IMEI 必填，空 IMEI 行记为失败 - OpenSpec Change fix-august-iteration-follow-up-gaps：13/18，导入任务、导出任务的 Worker 端到端验证与前端/运营通知待部署后完成
300 lines
12 KiB
Go
300 lines
12 KiB
Go
// Package packagetrafficalert 收口套餐真流量预警的规则维护事务脚本与每日扫描用例。
|
||
//
|
||
// 规则维护是简单写：Handler → Application 事务脚本 → Persistence，事实与审计同事务。
|
||
// 每日扫描是复杂写：Application 编排 → Domain 判定 → Port/Infrastructure 原子写入预警事实、
|
||
// 可靠通知事件与审计；判定只使用套餐使用记录的真流量快照，不读取虚流量、展示量、卡级累计或通道累计。
|
||
package packagetrafficalert
|
||
|
||
import (
|
||
"context"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"gorm.io/gorm"
|
||
|
||
"github.com/break/junhong_cmp_fiber/internal/domain/packagetrafficalert"
|
||
"github.com/break/junhong_cmp_fiber/internal/infrastructure/audit"
|
||
"github.com/break/junhong_cmp_fiber/internal/model"
|
||
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
||
"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"
|
||
)
|
||
|
||
// RuleService 套餐真流量预警规则维护事务脚本。
|
||
type RuleService struct {
|
||
db *gorm.DB
|
||
store *postgres.PackageTrafficAlertStore
|
||
auditWriter *audit.Writer
|
||
}
|
||
|
||
// NewRuleService 创建套餐真流量预警规则事务脚本。
|
||
func NewRuleService(db *gorm.DB, store *postgres.PackageTrafficAlertStore, auditWriters ...*audit.Writer) *RuleService {
|
||
service := &RuleService{db: db, store: store}
|
||
if len(auditWriters) > 0 {
|
||
service.auditWriter = auditWriters[0]
|
||
}
|
||
return service
|
||
}
|
||
|
||
// Create 为套餐商品创建唯一预警规则。
|
||
// 创建一律校验套餐存在且商品真流量额度大于零：商品 real_data_mb 只用于配置合法性，
|
||
// 不作为扫描分母（分母取使用记录的真总量快照）。
|
||
func (s *RuleService) Create(ctx context.Context, request *dto.CreatePackageTrafficAlertRuleRequest) (*dto.PackageTrafficAlertRuleItem, error) {
|
||
operatorID, err := requireOperator(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if request == nil || request.PackageID == 0 {
|
||
return nil, errors.New(errors.CodeInvalidParam, "套餐商品ID不能为空")
|
||
}
|
||
if !packagetrafficalert.IsValidThresholdPercent(request.ThresholdPercent) {
|
||
return nil, errors.New(errors.CodeInvalidParam, "真流量预警阈值必须大于等于 1 且小于等于 100，允许两位小数")
|
||
}
|
||
enabled := constants.StatusEnabled
|
||
if request.Enabled != nil && !*request.Enabled {
|
||
enabled = constants.StatusDisabled
|
||
}
|
||
rule := &model.PackageTrafficAlertRule{
|
||
PackageID: request.PackageID,
|
||
ThresholdPercent: packagetrafficalert.NormalizeThresholdPercent(request.ThresholdPercent),
|
||
Enabled: enabled,
|
||
Remark: request.Remark,
|
||
BaseModel: model.BaseModel{Creator: operatorID, Updater: operatorID},
|
||
}
|
||
var response *dto.PackageTrafficAlertRuleItem
|
||
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
pkg, loadErr := s.loadPackage(ctx, tx, request.PackageID)
|
||
if loadErr != nil {
|
||
return loadErr
|
||
}
|
||
if pkg.RealDataMB <= 0 {
|
||
return errors.New(errors.CodeInvalidParam, "该套餐商品真流量额度不大于零，不能启用真流量预警规则")
|
||
}
|
||
store := s.store.WithTx(tx)
|
||
exists, existsErr := store.ExistsRuleByPackageID(ctx, request.PackageID)
|
||
if existsErr != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, existsErr, "校验套餐预警规则失败")
|
||
}
|
||
if exists {
|
||
return errors.New(errors.CodeInvalidParam, "套餐已存在真流量预警规则")
|
||
}
|
||
if createErr := store.CreateRule(ctx, rule); createErr != nil {
|
||
if isDuplicateKey(createErr) {
|
||
return errors.New(errors.CodeInvalidParam, "套餐已存在真流量预警规则")
|
||
}
|
||
return errors.Wrap(errors.CodeDatabaseError, createErr, "创建套餐真流量预警规则失败")
|
||
}
|
||
item := toRuleItem(rule, pkg.PackageName)
|
||
if auditErr := s.appendRuleAudit(ctx, tx, constants.AuditActionPackageTrafficAlertRuleCreated,
|
||
"创建套餐真流量预警规则", rule, pkg.PackageName, nil, ruleAuditSnapshot(rule, pkg.PackageName)); auditErr != nil {
|
||
return auditErr
|
||
}
|
||
response = item
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// Update 修改阈值、启停与备注。
|
||
// 修改不回填既有预警，也不改写已冻结的预警快照；结果状态为启用时同样校验商品真流量额度大于零。
|
||
func (s *RuleService) Update(ctx context.Context, ruleID uint, request *dto.UpdatePackageTrafficAlertRuleRequest) (*dto.PackageTrafficAlertRuleItem, error) {
|
||
operatorID, err := requireOperator(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if request == nil || ruleID == 0 {
|
||
return nil, errors.New(errors.CodeInvalidParam, "预警规则ID不能为空")
|
||
}
|
||
if request.ThresholdPercent != nil && !packagetrafficalert.IsValidThresholdPercent(*request.ThresholdPercent) {
|
||
return nil, errors.New(errors.CodeInvalidParam, "真流量预警阈值必须大于等于 1 且小于等于 100，允许两位小数")
|
||
}
|
||
var response *dto.PackageTrafficAlertRuleItem
|
||
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
store := s.store.WithTx(tx)
|
||
rule, lockErr := store.LockRuleByID(ctx, ruleID)
|
||
if lockErr != nil {
|
||
return ruleLookupError(lockErr)
|
||
}
|
||
before := ruleAuditSnapshot(rule, "")
|
||
if request.ThresholdPercent != nil {
|
||
rule.ThresholdPercent = packagetrafficalert.NormalizeThresholdPercent(*request.ThresholdPercent)
|
||
}
|
||
if request.Enabled != nil {
|
||
rule.Enabled = constants.StatusEnabled
|
||
if !*request.Enabled {
|
||
rule.Enabled = constants.StatusDisabled
|
||
}
|
||
}
|
||
if request.Remark != nil {
|
||
rule.Remark = *request.Remark
|
||
}
|
||
pkg, pkgErr := s.loadPackage(ctx, tx, rule.PackageID)
|
||
if pkgErr != nil {
|
||
return pkgErr
|
||
}
|
||
if rule.Enabled == constants.StatusEnabled && pkg.RealDataMB <= 0 {
|
||
return errors.New(errors.CodeInvalidParam, "该套餐商品真流量额度不大于零，不能启用真流量预警规则")
|
||
}
|
||
packageName := pkg.PackageName
|
||
if updateErr := store.UpdateRule(ctx, rule, operatorID); updateErr != nil {
|
||
return errors.Wrap(errors.CodeDatabaseError, updateErr, "更新套餐真流量预警规则失败")
|
||
}
|
||
after := ruleAuditSnapshot(rule, packageName)
|
||
if before["enabled"] != after["enabled"] {
|
||
action, summary := constants.AuditActionPackageTrafficAlertRuleEnabled, "启用套餐真流量预警规则"
|
||
if rule.Enabled != constants.StatusEnabled {
|
||
action, summary = constants.AuditActionPackageTrafficAlertRuleDisabled, "停用套餐真流量预警规则"
|
||
}
|
||
if auditErr := s.appendRuleAudit(ctx, tx, action, summary, rule, packageName,
|
||
map[string]any{"enabled": before["enabled"]}, map[string]any{"enabled": after["enabled"]}); auditErr != nil {
|
||
return auditErr
|
||
}
|
||
}
|
||
if before["threshold_percent"] != after["threshold_percent"] || before["remark"] != after["remark"] {
|
||
if auditErr := s.appendRuleAudit(ctx, tx, constants.AuditActionPackageTrafficAlertRuleUpdated,
|
||
"更新套餐真流量预警规则", rule, packageName, before, after); auditErr != nil {
|
||
return auditErr
|
||
}
|
||
}
|
||
response = toRuleItem(rule, packageName)
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return response, nil
|
||
}
|
||
|
||
// loadPackage 查询套餐商品；不存在时按参数错误返回。
|
||
func (s *RuleService) loadPackage(ctx context.Context, tx *gorm.DB, packageID uint) (*model.Package, error) {
|
||
var pkg model.Package
|
||
if err := tx.WithContext(ctx).Where("id = ?", packageID).First(&pkg).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, errors.New(errors.CodeInvalidParam, "套餐商品不存在")
|
||
}
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询套餐商品失败")
|
||
}
|
||
return &pkg, nil
|
||
}
|
||
|
||
// appendRuleAudit 在业务事务内追加预警规则事件。
|
||
func (s *RuleService) appendRuleAudit(ctx context.Context, tx *gorm.DB, action, summary string,
|
||
rule *model.PackageTrafficAlertRule, packageName string, before, after map[string]any) error {
|
||
if s.auditWriter == nil {
|
||
return errors.New(errors.CodeInvalidStatus, "套餐真流量预警规则统一审计接缝未配置")
|
||
}
|
||
var resourceID *string
|
||
if rule.ID != 0 {
|
||
value := strconv.FormatUint(uint64(rule.ID), 10)
|
||
resourceID = &value
|
||
}
|
||
displayName := packageName
|
||
if displayName == "" {
|
||
displayName = "套餐 " + strconv.FormatUint(uint64(rule.PackageID), 10)
|
||
}
|
||
// 使用 AppendAndGet：预警规则属于关键配置，「要求成功必达」的审计失败必须回滚事务（ENG-TX-001）。
|
||
if _, err := s.auditWriter.AppendAndGet(ctx, tx, audit.AppendInput{
|
||
ActionCode: action, Summary: summary, Result: constants.AuditResultSuccess,
|
||
Actor: audit.ActorInput{Kind: constants.AuditActorAccount, ID: strconv.FormatUint(uint64(middleware.GetUserIDFromContext(ctx)), 10)},
|
||
Source: constants.AuditSourceAdminAPI, ScopeType: constants.AuditScopePlatform,
|
||
Resources: []audit.ResourceInput{{
|
||
Type: constants.AuditResourcePackageTrafficAlertRule, ID: resourceID,
|
||
Key: strconv.FormatUint(uint64(rule.PackageID), 10), DisplayName: displayName,
|
||
Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRolePackageTrafficAlertRuleTarget,
|
||
IdentitySnapshot: ruleAuditIdentity(rule, packageName), BeforeData: before, AfterData: after,
|
||
}},
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// requireOperator 要求调用方已通过后台鉴权，否则拒绝写入。
|
||
func requireOperator(ctx context.Context) (uint, error) {
|
||
operatorID := middleware.GetUserIDFromContext(ctx)
|
||
if operatorID == 0 {
|
||
return 0, errors.New(errors.CodeUnauthorized)
|
||
}
|
||
return operatorID, nil
|
||
}
|
||
|
||
// ruleLookupError 把规则不存在映射为统一资源不可见错误。
|
||
func ruleLookupError(err error) error {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return errors.New(errors.CodeForbidden, constants.PlatformManagementForbiddenMessage)
|
||
}
|
||
return errors.Wrap(errors.CodeDatabaseError, err, "查询套餐真流量预警规则失败")
|
||
}
|
||
|
||
// isDuplicateKey 判断数据库错误是否为唯一键冲突。
|
||
func isDuplicateKey(err error) bool {
|
||
if err == nil {
|
||
return false
|
||
}
|
||
text := err.Error()
|
||
return strings.Contains(text, "23505") || strings.Contains(text, "duplicate key") || strings.Contains(text, "SQLSTATE 23505")
|
||
}
|
||
|
||
// ruleAuditSnapshot 返回预警规则可审计的可变字段快照。
|
||
func ruleAuditSnapshot(rule *model.PackageTrafficAlertRule, packageName string) map[string]any {
|
||
if rule == nil {
|
||
return nil
|
||
}
|
||
snapshot := map[string]any{
|
||
"package_id": rule.PackageID,
|
||
"threshold_percent": rule.ThresholdPercent,
|
||
"enabled": rule.Enabled,
|
||
"remark": rule.Remark,
|
||
}
|
||
if packageName != "" {
|
||
snapshot["package_name"] = packageName
|
||
}
|
||
return snapshot
|
||
}
|
||
|
||
// ruleAuditIdentity 返回预警规则审计身份快照，字段落在注册表白名单内。
|
||
func ruleAuditIdentity(rule *model.PackageTrafficAlertRule, packageName string) map[string]any {
|
||
if rule == nil {
|
||
return nil
|
||
}
|
||
identity := map[string]any{
|
||
"id": rule.ID, "package_id": rule.PackageID, "threshold_percent": rule.ThresholdPercent,
|
||
"enabled": rule.Enabled, "remark": rule.Remark,
|
||
}
|
||
if packageName != "" {
|
||
identity["package_name"] = packageName
|
||
}
|
||
return identity
|
||
}
|
||
|
||
// toRuleItem 把规则投影为对外响应项。
|
||
// 不返回套餐商品真流量额度：规则按百分比配置，判定分母是资产主套餐与加油包汇总，单个额度会被误读为分母。
|
||
func toRuleItem(rule *model.PackageTrafficAlertRule, packageName string) *dto.PackageTrafficAlertRuleItem {
|
||
if rule == nil {
|
||
return nil
|
||
}
|
||
return &dto.PackageTrafficAlertRuleItem{
|
||
ID: rule.ID,
|
||
PackageID: rule.PackageID,
|
||
PackageName: packageName,
|
||
ThresholdPercent: rule.ThresholdPercent,
|
||
Enabled: rule.Enabled == constants.StatusEnabled,
|
||
EnabledName: enabledName(rule.Enabled),
|
||
Remark: rule.Remark,
|
||
UpdatedAt: rule.UpdatedAt,
|
||
}
|
||
}
|
||
|
||
// enabledName 返回启停状态的中文名称。
|
||
func enabledName(enabled int) string {
|
||
if enabled == constants.StatusEnabled {
|
||
return "启用"
|
||
}
|
||
return "停用"
|
||
}
|