feat: 不轮询清单与批量开关轮询
All checks were successful
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Successful in 9m35s

- 新增不轮询清单 tb_card_polling_pause(迁移 000256 补写存量),所有改 enable_polling 的入口同事务写清单
- 卡、设备勾选批量开关轮询(单次 500,逐项结果,开启跳过风险停机与已销户)与 CSV 文件导入
- 订单套餐生效、改有效期后自动恢复轮询并按规则评估复机
- 不轮询清单查询与导出;卡、设备列表与导出增加是否轮询
- 失败告警停机被拒视图、导出与批量关闭轮询;开关轮询影响说明

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
邹进
2026-10-26 03:07:20 +09:00
parent a4e3fe4d8f
commit 7ddb9312e3
45 changed files with 2250 additions and 50 deletions

View File

@@ -6,6 +6,7 @@ package asset
import (
"context"
stderrors "errors"
stopresumedomain "github.com/break/junhong_cmp_fiber/internal/domain/stopresume"
"strconv"
"time"
@@ -55,6 +56,9 @@ type Service struct {
associationStore *postgres.PhoneAssetAssociationStore
auditWriter *infraAudit.Writer
packageExpiryQuery PackageExpiryResolver
pollingRestorer PollingRestorer
resumeEvaluator AssetResumeEvaluator
logger *zap.Logger
}
// SetPackageExpiryQuery 注入套餐最终到期查询,供资产详情统一投影使用。
@@ -991,6 +995,7 @@ func (s *Service) UpdatePackageExpiresAt(ctx context.Context, assetType string,
s.recordPackageAdjustmentFailure(ctx, constants.AuditActionPackageUsageExpiresAtUpdated, "修改资产套餐过期时间失败", before, assetType, assetID, assetIdentifier, beforeData, map[string]any{"package_usage_id": packageUsageID, "expires_at": expiresAt}, err)
return nil, err
}
s.restorePollingAfterExpiryChange(ctx, assetType, assetID)
return s.buildAssetPackageResponse(ctx, updated, constants.OwnerTypePlatform), nil
}
@@ -1475,3 +1480,47 @@ func packageStatusName(status int) string {
return "未知"
}
}
// PollingRestorer 是套餐生效类入口自动恢复轮询的能力(改有效期后资产有生效套餐时恢复)。
type PollingRestorer interface {
RestoreAssetPolling(ctx context.Context, assetType string, assetID uint, source string) bool
}
// AssetResumeEvaluator 是恢复轮询后按规则评估复机的能力。
type AssetResumeEvaluator interface {
ResumeCardIfStopped(ctx context.Context, carrierType string, carrierID uint) error
}
// SetPollingRestorer 注入改有效期后的自动恢复轮询与复机评估。
func (s *Service) SetPollingRestorer(restorer PollingRestorer, evaluator AssetResumeEvaluator, logger *zap.Logger) {
if logger == nil {
logger = zap.NewNop()
}
s.pollingRestorer, s.resumeEvaluator, s.logger = restorer, evaluator, logger
}
// restorePollingAfterExpiryChange 改有效期保存后,资产有生效中主套餐时恢复关闭轮询的卡或设备(来源"改有效期"),再按规则评估复机。
func (s *Service) restorePollingAfterExpiryChange(ctx context.Context, assetType string, assetID uint) {
if s.pollingRestorer == nil || assetID == 0 {
return
}
column := "iot_card_id"
if assetType == constants.AssetTypeDevice {
column = "device_id"
}
var active int64
if err := s.db.WithContext(ctx).Model(&model.PackageUsage{}).
Where(column+" = ? AND status = ? AND master_usage_id IS NULL", assetID, constants.PackageUsageStatusActive).
Count(&active).Error; err != nil || active == 0 {
return
}
if !s.pollingRestorer.RestoreAssetPolling(ctx, assetType, assetID, constants.PollingToggleSourceExpiryChange) || s.resumeEvaluator == nil {
return
}
resumeCtx := stopresumedomain.WithScene(context.WithoutCancel(ctx), constants.StopResumeSceneActivation)
stopresumedomain.RunAfterCommit(resumeCtx, s.resumeEvaluator, func() {
if err := s.resumeEvaluator.ResumeCardIfStopped(resumeCtx, assetType, assetID); err != nil {
s.logger.Warn("改有效期恢复轮询后复机评估失败", zap.String("asset_type", assetType), zap.Uint("asset_id", assetID), zap.Error(err))
}
})
}

View File

@@ -253,6 +253,9 @@ func (s *Service) List(ctx context.Context, req *dto.ListDeviceRequest) (*dto.Li
if req.HasActivePackage != nil {
filters["has_active_package"] = *req.HasActivePackage
}
if req.EnablePolling != nil {
filters["enable_polling"] = *req.EnablePolling
}
if req.AuthorizedEnterpriseID != nil {
filters["authorized_enterprise_id"] = *req.AuthorizedEnterpriseID
}

View File

@@ -3,6 +3,7 @@ package iot_card
import (
"context"
stderrors "errors"
"github.com/break/junhong_cmp_fiber/internal/infrastructure/pollingpause"
"strings"
"time"
@@ -265,6 +266,9 @@ func (s *Service) ListStandalone(ctx context.Context, req *dto.ListStandaloneIot
if req.RealNameStatus != nil {
filters["real_name_status"] = *req.RealNameStatus
}
if req.EnablePolling != nil {
filters["enable_polling"] = *req.EnablePolling
}
if req.AuthorizedEnterpriseID != nil {
filters["authorized_enterprise_id"] = *req.AuthorizedEnterpriseID
}
@@ -1717,6 +1721,12 @@ func (s *Service) UpdatePollingStatus(ctx context.Context, cardID uint, enablePo
return appErr
}
beforePolling := card.EnablePolling
if enablePolling && !beforePolling && pollingpause.IsRiskExtend(card.GatewayExtend) {
// 风险停机、已销户的卡必须关闭轮询,不能开启。
denyErr := errors.New(errors.CodeForbidden, pollingpause.RiskEnableDeniedReason(card.GatewayExtend))
s.recordPollingStatusFailure(ctx, constants.AuditActionIotCardPollingStatusUpdated, constants.AuditResultDenied, card, enablePolling, denyErr)
return denyErr
}
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if beforePolling != enablePolling {
result := tx.Model(&model.IotCard{}).Where("id = ? AND enable_polling = ?", card.ID, beforePolling).Update("enable_polling", enablePolling)
@@ -1726,6 +1736,9 @@ func (s *Service) UpdatePollingStatus(ctx context.Context, cardID uint, enablePo
if result.RowsAffected == 0 {
return errors.New(errors.CodeConflict, "轮询状态已变更,请刷新后重试")
}
if err := pollingpause.Record(ctx, tx, pollingpause.CardChange(card, enablePolling), constants.PollingToggleSourceSingle); err != nil {
return err
}
}
return s.appendPollingStatusAudit(ctx, tx, card, beforePolling, enablePolling)
})
@@ -1758,14 +1771,36 @@ func (s *Service) BatchUpdatePollingStatus(ctx context.Context, cardIDs []uint,
return nil
}
cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
// 设备级联:清单来源记"设备级联",原因沿用设备变更的原因。
origin := pollingpause.OriginFrom(ctx, constants.PollingToggleSourceCascade)
origin.Source = constants.PollingToggleSourceCascade
ctx = pollingpause.WithOrigin(ctx, origin)
loaded, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
if err != nil {
return err
}
// 开启时跳过风险停机、已销户的卡:这类卡必须保持关闭轮询。
cards := make([]*model.IotCard, 0, len(loaded))
cardIDs = make([]uint, 0, len(loaded))
for _, card := range loaded {
if card == nil || (enablePolling && pollingpause.IsRiskExtend(card.GatewayExtend)) {
continue
}
cards = append(cards, card)
cardIDs = append(cardIDs, card.ID)
}
if len(cardIDs) == 0 {
return nil
}
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if updateErr := tx.Model(&model.IotCard{}).Where("id IN ?", cardIDs).Update("enable_polling", enablePolling).Error; updateErr != nil {
return errors.Wrap(errors.CodeDatabaseError, updateErr, "批量更新 IoT 卡轮询状态失败")
}
for _, card := range cards {
if err := pollingpause.Record(ctx, tx, pollingpause.CardChange(card, enablePolling), constants.PollingToggleSourceCascade); err != nil {
return err
}
}
return s.appendBatchPollingStatusAudit(ctx, tx, cards, enablePolling)
})
if err != nil {

View File

@@ -73,6 +73,8 @@ type Service struct {
queueClient *queue.Client
logger *zap.Logger
resumeCallback packagepkg.ResumeCallback
// pollingRestorer 订单套餐生效后自动恢复关闭轮询的卡或设备;未注入时不恢复。
pollingRestorer PollingRestorer
assetIdentifierStore *postgres.AssetIdentifierStore
personalCustomerStore *postgres.PersonalCustomerStore
personalCustomerPhoneStore *postgres.PersonalCustomerPhoneStore
@@ -167,6 +169,45 @@ func (s *Service) SetResumeCallback(callback packagepkg.ResumeCallback) {
s.resumeCallback = callback
}
// PollingRestorer 是套餐生效类入口自动恢复轮询的能力。
type PollingRestorer interface {
RestoreAssetPolling(ctx context.Context, assetType string, assetID uint, source string) bool
}
// SetPollingRestorer 注入订单套餐生效后自动恢复轮询的能力。
func (s *Service) SetPollingRestorer(restorer PollingRestorer) {
s.pollingRestorer = restorer
}
// afterOrderActivated 订单事务提交后:本单直接激活了主套餐时,先把关闭轮询的卡或设备恢复轮询(来源"支付或下单生效",
// 风险停机或已销户不恢复),再按规则评估复机。resume=true 时(支付确认)总是评估;否则只在恢复了轮询时评估。
func (s *Service) afterOrderActivated(ctx context.Context, order *model.Order, resume bool) {
if order == nil {
return
}
assetType, assetID := constants.AssetTypeIotCard, uint(0)
if order.OrderType == model.OrderTypeSingleCard && order.IotCardID != nil {
assetID = *order.IotCardID
} else if order.OrderType == model.OrderTypeDevice && order.DeviceID != nil {
assetType, assetID = constants.AssetTypeDevice, *order.DeviceID
}
if assetID == 0 {
return
}
restored := false
if s.pollingRestorer != nil {
var activated int64
if err := s.db.WithContext(ctx).Model(&model.PackageUsage{}).
Where("order_id = ? AND status = ? AND master_usage_id IS NULL", order.ID, constants.PackageUsageStatusActive).
Count(&activated).Error; err == nil && activated > 0 {
restored = s.pollingRestorer.RestoreAssetPolling(ctx, assetType, assetID, constants.PollingToggleSourceOrder)
}
}
if resume || restored {
s.tryResumeAfterPayment(ctx, order)
}
}
// CreateAdminOrder 后台订单创建(仅支持 wallet/offline,立即扣款或激活)
// 与 CreateH5Order 的核心区别:后台订单不创建待支付状态,wallet 立即扣款,offline 立即激活
// POST /api/admin/orders
@@ -1233,6 +1274,7 @@ func (s *Service) createOrderWithWalletPayment(ctx context.Context, order *model
if existingOrderID > 0 {
return existingOrderID, nil
}
s.afterOrderActivated(ctx, order, false)
// 3. 事务外:所有已支付且适用差价佣金的订单都进入佣金计算
@@ -1245,7 +1287,7 @@ func (s *Service) createOrderWithActivation(ctx context.Context, order *model.Or
}
release := s.prepareActivation(ctx, order)
defer release()
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(order).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "创建代购订单失败")
}
@@ -1270,6 +1312,10 @@ func (s *Service) createOrderWithActivation(ctx context.Context, order *model.Or
}
return s.appendOrderAudit(ctx, tx, constants.AuditActionOrderCreated, "创建并完成订单", order, nil, orderStateData(order))
})
if err == nil {
s.afterOrderActivated(ctx, order, false)
}
return err
}
// CreatePendingOrder 在同一事务中创建待支付订单、冻结个人资产钱包、创建明细和审计事件。
@@ -1928,6 +1974,7 @@ func (s *Service) WalletPay(ctx context.Context, orderID uint, buyerType string,
if err != nil {
return err
}
s.afterOrderActivated(ctx, order, false)
return nil
}
@@ -2043,7 +2090,7 @@ func (s *Service) HandlePaymentCallback(ctx context.Context, orderNo string, pay
}
if shouldResumeAfterPayment {
s.tryResumeAfterPayment(ctx, order)
s.afterOrderActivated(ctx, order, true)
}
return nil
}
@@ -2167,7 +2214,7 @@ func (s *Service) HandlePaymentRecordCallback(ctx context.Context, paymentNo str
}
if shouldResumeAfterPayment {
s.tryResumeAfterPayment(ctx, order)
s.afterOrderActivated(ctx, order, true)
}
return nil
}

View File

@@ -3,6 +3,7 @@ package polling
import (
"context"
stderrors "errors"
"github.com/break/junhong_cmp_fiber/internal/infrastructure/pollingpause"
"strconv"
"go.uber.org/zap"
@@ -125,6 +126,9 @@ func (s *AssetPollingService) updateDevicePollingStatus(ctx context.Context, dev
if result.RowsAffected == 0 {
return errors.New(errors.CodeConflict, "轮询状态已变更,请刷新后重试")
}
if err := pollingpause.Record(ctx, tx, pollingpause.DeviceChange(device, enablePolling), constants.PollingToggleSourceSingle); err != nil {
return err
}
}
return s.appendDevicePollingAudit(ctx, tx, device, enablePolling, constants.AuditResultSuccess, nil)
})

View File

@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
stderrors "errors"
"github.com/break/junhong_cmp_fiber/internal/query/pollingalert"
"strconv"
"time"
@@ -300,6 +301,9 @@ func (s *CarrierSchedulerService) ListAlerts(ctx context.Context, req *dto.Polli
return nil, err
}
page, size := normalizePage(req.Page, req.PageSize)
if req.View == constants.PollingAlertViewStopRefused {
return s.listStopRefused(ctx, req, page, size)
}
query := s.db.WithContext(ctx).Model(&model.PollingFailureAlert{})
if req.CarrierID != nil {
query = query.Where("carrier_id = ?", *req.CarrierID)
@@ -649,3 +653,45 @@ func atoi64(s string) int64 {
value, _ := strconv.ParseInt(s, 10, 64)
return value
}
// listStopRefused 停机被拒视图:停复机方向为停机,且错误类型为终态或业务错误、或停机失败次数达到阈值。
func (s *CarrierSchedulerService) listStopRefused(ctx context.Context, req *dto.PollingFailureAlertListRequest, page, size int) (*dto.PollingFailureAlertPageResult, error) {
start, end, err := utils.ParseTimeRange(req.StartTime, req.EndTime)
if err != nil {
return nil, err
}
filter := pollingalert.StopRefusedFilter{CarrierID: req.CarrierID, Status: req.Status, ICCID: req.ICCID, StartTime: start, EndTime: end}
threshold := s.settings.Current(ctx).SRAlertFailCount
query := pollingalert.NewQuery(s.db)
total, err := query.Count(ctx, filter, threshold)
if err != nil {
return nil, err
}
rows, err := query.Page(ctx, filter, threshold, (page-1)*size, size)
if err != nil {
return nil, err
}
result := &dto.PollingFailureAlertPageResult{Total: total, Page: page, PageSize: size, List: make([]dto.PollingFailureAlertItem, 0, len(rows))}
for index := range rows {
result.List = append(result.List, StopRefusedItem(&rows[index]))
}
return result, nil
}
// StopRefusedItem 把停机被拒查询行转换为告警返回项。
func StopRefusedItem(row *pollingalert.StopRefusedRow) dto.PollingFailureAlertItem {
network, polling, hasPackage := row.NetworkStatus, row.EnablePolling, row.HasPackage
item := dto.PollingFailureAlertItem{
ID: row.ID, AlertLevel: constants.PollingAlertLevelCard, CardID: row.CardID, ICCID: row.ICCID, CarrierID: row.CarrierID,
CarrierName: row.CarrierName, CheckType: constants.CheckTypeStopResume, CheckTypeName: "停复机",
ErrorCategory: row.ErrorCategory, FailCount: row.FailCount, FirstFailedAt: row.FirstFailedAt, LastFailedAt: row.LastFailedAt,
LastError: row.LastError, Status: row.Status, StatusName: constants.PollingAlertStatusName(row.Status),
HandledBy: row.HandledBy, HandledAt: row.HandledAt, HandleRemark: row.HandleRemark,
NetworkStatus: &network, StopReason: row.StopReason, EnablePolling: &polling, HasPackage: &hasPackage, HandledByName: row.HandledByName,
}
if row.DeviceID > 0 {
deviceID := row.DeviceID
item.DeviceID = &deviceID
}
return item
}

View File

@@ -0,0 +1,295 @@
package polling
import (
"context"
stderrors "errors"
"time"
"go.uber.org/zap"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/internal/infrastructure/pollingpause"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/model/dto"
pausequery "github.com/break/junhong_cmp_fiber/internal/query/pollingpause"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/errors"
"github.com/break/junhong_cmp_fiber/pkg/middleware"
)
// 勾选批量开关轮询、告警页关闭轮询与不轮询清单查询(add-polling-pause-list-and-batch-toggle)。
// 每项独立事务(经 UpdatePollingStatus 同事务写 enable_polling、清单与审计,提交后按生命周期移入或移出轮询),部分失败不影响其他项。
// BatchUpdatePollingStatus 勾选批量开关轮询:单次最多 500、校验数据权限、逐项处理并返回结果;批量开启跳过风险停机与已销户的卡。
func (s *AssetPollingService) BatchUpdatePollingStatus(ctx context.Context, assetType string, req *dto.BatchUpdatePollingStatusRequest) (*dto.BatchUpdatePollingStatusResponse, error) {
if middleware.GetUserTypeFromContext(ctx) == constants.UserTypeEnterprise {
return nil, errors.New(errors.CodeForbidden, "企业账号无权修改轮询开关")
}
if req == nil || req.EnablePolling == nil || len(req.AssetIDs) == 0 || len(req.AssetIDs) > constants.PollingBatchMaxSize {
return nil, errors.New(errors.CodeInvalidParam, "资产数量必须为 1~500")
}
seen := make(map[uint]bool, len(req.AssetIDs))
for _, id := range req.AssetIDs {
if id == 0 || seen[id] {
return nil, errors.New(errors.CodeInvalidParam, "资产ID不能为空或重复")
}
seen[id] = true
}
ctx = pollingpause.WithOrigin(ctx, pollingpause.Origin{Source: constants.PollingToggleSourceBatch, Reason: req.Reason})
resp := &dto.BatchUpdatePollingStatusResponse{Items: make([]dto.PollingToggleItem, 0, len(req.AssetIDs)), Impact: impactFor(*req.EnablePolling)}
for _, id := range req.AssetIDs {
item := s.ToggleAsset(ctx, assetType, id, *req.EnablePolling, true)
countToggle(resp, item)
resp.Items = append(resp.Items, item)
}
return resp, nil
}
// ToggleAsset 改一个资产的轮询开关并返回逐项结果;scoped 为 true 时按当前账号数据权限查找资产。
// 来源与原因由 ctx 中的 pollingpause.Origin 决定。
func (s *AssetPollingService) ToggleAsset(ctx context.Context, assetType string, assetID uint, enable, scoped bool) dto.PollingToggleItem {
item := dto.PollingToggleItem{AssetID: assetID}
current, identifier, extend, err := s.loadToggleTarget(ctx, assetType, assetID, scoped)
item.Identifier = identifier
if err != nil {
if stderrors.Is(err, gorm.ErrRecordNotFound) {
return toggleResult(item, constants.PollingToggleItemForbidden, "无权限操作该资产或资产不存在")
}
return toggleResult(item, constants.PollingToggleItemFailed, "查询资产失败")
}
if current == enable {
return toggleResult(item, constants.PollingToggleItemSkipped, "已是目标状态")
}
if enable && assetType == constants.AssetTypeIotCard && pollingpause.IsRiskExtend(extend) {
return toggleResult(item, constants.PollingToggleItemSkipped, pollingpause.RiskEnableDeniedReason(extend))
}
if err := s.UpdatePollingStatus(ctx, assetType, assetID, enable); err != nil {
message := "修改轮询开关失败"
var appErr *errors.AppError
if stderrors.As(err, &appErr) {
message = appErr.Error()
}
s.logger.Warn("修改资产轮询开关失败", zap.String("asset_type", assetType), zap.Uint("asset_id", assetID), zap.Error(err))
return toggleResult(item, constants.PollingToggleItemFailed, message)
}
return toggleResult(item, constants.PollingToggleItemSuccess, "")
}
func (s *AssetPollingService) loadToggleTarget(ctx context.Context, assetType string, assetID uint, scoped bool) (bool, string, string, error) {
query := s.db.WithContext(ctx)
switch assetType {
case constants.AssetTypeIotCard:
query = query.Model(&model.IotCard{})
if scoped {
query = middleware.ApplyStrictShopFilter(ctx, query)
}
var card model.IotCard
if err := query.Select("id", "iccid", "enable_polling", "gateway_extend").Where("id = ?", assetID).First(&card).Error; err != nil {
return false, "", "", err
}
return card.EnablePolling, card.ICCID, card.GatewayExtend, nil
case constants.AssetTypeDevice:
query = query.Model(&model.Device{})
if scoped {
query = middleware.ApplyStrictShopFilter(ctx, query)
}
var device model.Device
if err := query.Select("id", "imei", "virtual_no", "enable_polling").Where("id = ?", assetID).First(&device).Error; err != nil {
return false, "", "", err
}
identifier := device.IMEI
if identifier == "" {
identifier = device.VirtualNo
}
return device.EnablePolling, identifier, "", nil
default:
return false, "", "", errors.New(errors.CodeInvalidParam, "资产类型无效")
}
}
// ClosePollingByAlerts 告警页勾选批量关闭轮询:关闭告警对应卡的轮询(来源"停机被拒告警处理"),成功或已关闭的告警改为"已关闭轮询"。
func (s *AssetPollingService) ClosePollingByAlerts(ctx context.Context, req *dto.ClosePollingByAlertsRequest) (*dto.BatchUpdatePollingStatusResponse, error) {
if err := pausequery.EnsureAllowed(middleware.GetUserTypeFromContext(ctx)); err != nil {
return nil, err
}
if req == nil || len(req.AlertIDs) == 0 || len(req.AlertIDs) > constants.PollingBatchMaxSize {
return nil, errors.New(errors.CodeInvalidParam, "告警数量必须为 1~500")
}
var alerts []model.PollingFailureAlert
if err := s.db.WithContext(ctx).Where("id IN ? AND alert_level = ? AND card_id > 0", req.AlertIDs, constants.PollingAlertLevelCard).
Find(&alerts).Error; err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询失败告警失败")
}
operatorID := middleware.GetUserIDFromContext(ctx)
ctx = pollingpause.WithOrigin(ctx, pollingpause.Origin{Source: constants.PollingToggleSourceAlert, Reason: req.Reason})
resp := &dto.BatchUpdatePollingStatusResponse{Items: []dto.PollingToggleItem{}, Impact: impactFor(false)}
done := map[uint]dto.PollingToggleItem{}
found := map[uint]bool{}
for _, alert := range alerts {
found[alert.ID] = true
item, ok := done[alert.CardID]
if !ok {
item = s.ToggleAsset(ctx, constants.AssetTypeIotCard, alert.CardID, false, false)
done[alert.CardID] = item
countToggle(resp, item)
resp.Items = append(resp.Items, item)
}
if item.Status != constants.PollingToggleItemSuccess && item.Status != constants.PollingToggleItemSkipped {
continue
}
now := time.Now()
if err := s.db.WithContext(ctx).Model(&model.PollingFailureAlert{}).Where("id = ?", alert.ID).Updates(map[string]any{
"status": constants.PollingAlertStatusPollingDisabled, "handled_by": operatorID, "handled_at": now,
"handle_remark": req.Reason, "updated_at": now,
}).Error; err != nil {
s.logger.Warn("更新告警为已关闭轮询失败", zap.Uint("alert_id", alert.ID), zap.Error(err))
}
}
for _, id := range req.AlertIDs {
if !found[id] {
item := toggleResult(dto.PollingToggleItem{AssetID: 0}, constants.PollingToggleItemForbidden, "告警不存在或不是卡级告警")
countToggle(resp, item)
resp.Items = append(resp.Items, item)
}
}
return resp, nil
}
// ListPauses 查询不轮询清单(仅超级管理员与平台账号)。
func (s *AssetPollingService) ListPauses(ctx context.Context, req *dto.CardPollingPauseListRequest) (*dto.CardPollingPausePageResult, error) {
if err := pausequery.EnsureAllowed(middleware.GetUserTypeFromContext(ctx)); err != nil {
return nil, err
}
filter, err := PauseFilter(req.AssetType, req.CarrierID, req.Source, req.Status, req.Identifier, req.OperatorID, req.StartTime, req.EndTime)
if err != nil {
return nil, err
}
page, size := req.Page, req.PageSize
if page <= 0 {
page = constants.DefaultPage
}
if size <= 0 {
size = constants.DefaultPageSize
}
if size > constants.MaxPageSize {
size = constants.MaxPageSize
}
query := pausequery.NewQuery(s.db)
total, err := query.Count(ctx, filter)
if err != nil {
return nil, err
}
rows, err := query.Page(ctx, filter, (page-1)*size, size)
if err != nil {
return nil, err
}
items := make([]dto.CardPollingPauseItem, 0, len(rows))
for index := range rows {
items = append(items, ToPauseItem(&rows[index]))
}
return &dto.CardPollingPausePageResult{Items: items, Total: total, Page: page, PageSize: size}, nil
}
// Impact 返回开关轮询的影响说明。
func (s *AssetPollingService) Impact() *dto.PollingToggleImpactResponse {
return &dto.PollingToggleImpactResponse{Disable: impactFor(false), Enable: impactFor(true)}
}
// PauseFilter 由请求参数构造不轮询清单筛选条件(列表与导出共用)。
func PauseFilter(assetType string, carrierID *uint, source string, status *int, identifier string, operatorID *uint, start, end string) (pausequery.Filter, error) {
filter := pausequery.Filter{AssetType: assetType, CarrierID: carrierID, Source: source, Status: status, Identifier: identifier, OperatorID: operatorID}
for _, item := range []struct {
raw string
target **time.Time
}{{start, &filter.StartTime}, {end, &filter.EndTime}} {
if item.raw == "" {
continue
}
parsed, err := time.Parse(time.RFC3339, item.raw)
if err != nil {
return filter, errors.New(errors.CodeInvalidParam, "时间格式必须为带时区的 RFC3339")
}
*item.target = &parsed
}
return filter, nil
}
// ToPauseItem 把清单查询行转换为接口返回项。
func ToPauseItem(row *pausequery.Row) dto.CardPollingPauseItem {
return dto.CardPollingPauseItem{
ID: row.ID, AssetType: row.AssetType, AssetID: row.AssetID, Identifier: row.Identifier, CarrierID: row.CarrierID,
CarrierName: row.CarrierName, EnablePolling: row.EnablePolling, GatewayExtend: row.GatewayExtend,
Status: row.Status, StatusName: constants.PollingPauseStatusName(row.Status),
CloseSource: row.CloseSource, CloseSourceName: constants.PollingToggleSourceName(row.CloseSource), CloseReason: row.CloseReason,
ClosedBy: row.ClosedBy, ClosedByName: row.ClosedByName, ClosedAt: row.ClosedAt, ImportTaskID: row.ImportTaskID,
RestoreSource: row.RestoreSource, RestoreSourceName: constants.PollingToggleSourceName(row.RestoreSource), RestoreReason: row.RestoreReason,
RestoredBy: row.RestoredBy, RestoredByName: row.RestoredByName, RestoredAt: row.RestoredAt,
}
}
func impactFor(enable bool) []string {
source := constants.PollingToggleImpactDisable
if enable {
source = constants.PollingToggleImpactEnable
}
return append([]string(nil), source...)
}
func toggleResult(item dto.PollingToggleItem, status int, reason string) dto.PollingToggleItem {
item.Status, item.StatusName, item.Reason = status, constants.PollingToggleItemStatusName(status), reason
return item
}
func countToggle(resp *dto.BatchUpdatePollingStatusResponse, item dto.PollingToggleItem) {
switch item.Status {
case constants.PollingToggleItemSuccess:
resp.SuccessCount++
case constants.PollingToggleItemSkipped:
resp.SkipCount++
default:
resp.FailCount++
}
}
// RestoreAssetPolling 套餐生效类入口自动恢复轮询(订单套餐生效、改有效期后有生效套餐):
// 卡关闭轮询且非风险停机、已销户时开启;设备关闭轮询时开启设备(级联开启设备下非风险停机、非已销户的卡),
// 设备已开启时开启设备下单独关闭的卡。返回是否恢复了任何资产。不做数据权限过滤(系统入口)。
func (s *AssetPollingService) RestoreAssetPolling(ctx context.Context, assetType string, assetID uint, source string) bool {
if s == nil || assetID == 0 {
return false
}
ctx = pollingpause.WithOrigin(ctx, pollingpause.Origin{Source: source, Reason: constants.PollingToggleSourceName(source) + ",自动恢复轮询"})
restored := false
switch assetType {
case constants.AssetTypeIotCard:
restored = s.restoreCard(ctx, assetID)
case constants.AssetTypeDevice:
item := s.ToggleAsset(ctx, constants.AssetTypeDevice, assetID, true, false)
restored = item.Status == constants.PollingToggleItemSuccess
if item.Status == constants.PollingToggleItemSkipped {
bindings, err := s.deviceBindingStore.ListByDeviceID(ctx, assetID)
if err != nil {
s.logger.Warn("自动恢复轮询查询设备绑定卡失败", zap.Uint("device_id", assetID), zap.Error(err))
return false
}
for _, binding := range bindings {
if s.restoreCard(ctx, binding.IotCardID) {
restored = true
}
}
}
}
if restored {
s.logger.Info("套餐生效后自动恢复轮询", zap.String("asset_type", assetType), zap.Uint("asset_id", assetID), zap.String("source", source))
}
return restored
}
// restoreCard 恢复单张卡的轮询;已开启、风险停机或已销户时不处理。
func (s *AssetPollingService) restoreCard(ctx context.Context, cardID uint) bool {
item := s.ToggleAsset(ctx, constants.AssetTypeIotCard, cardID, true, false)
if item.Status == constants.PollingToggleItemFailed {
s.logger.Warn("自动恢复卡轮询失败", zap.Uint("card_id", cardID), zap.String("reason", item.Reason))
}
return item.Status == constants.PollingToggleItemSuccess
}

View File

@@ -0,0 +1,142 @@
package polling
import (
"context"
stderrors "errors"
"fmt"
"math/rand"
"path/filepath"
"strings"
"time"
"github.com/hibiken/asynq"
"go.uber.org/zap"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/model/dto"
pausequery "github.com/break/junhong_cmp_fiber/internal/query/pollingpause"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/errors"
"github.com/break/junhong_cmp_fiber/pkg/middleware"
)
// PollingStatusImportPayload 是轮询开关文件导入 Worker 载荷。
type PollingStatusImportPayload struct {
TaskID uint `json:"task_id"`
}
// PollingStatusImportService 轮询开关文件导入任务的创建与查询(仅超级管理员与平台账号)。
// 逐行处理在 Worker 内执行,规则与勾选批量相同;导入只允许平台账号创建,因此 Worker 逐行处理不再按店铺过滤。
type PollingStatusImportService struct {
db *gorm.DB
queueClient TaskEnqueuer
logger *zap.Logger
}
// NewPollingStatusImportService 创建轮询开关导入服务。
func NewPollingStatusImportService(db *gorm.DB, queueClient TaskEnqueuer, logger *zap.Logger) *PollingStatusImportService {
if logger == nil {
logger = zap.NewNop()
}
return &PollingStatusImportService{db: db, queueClient: queueClient, logger: logger}
}
// CreateImport 创建导入任务并投递到 Worker;投递失败时任务标为失败。
func (s *PollingStatusImportService) CreateImport(ctx context.Context, req *dto.CreatePollingStatusImportRequest) (*dto.PollingStatusImportTaskResponse, error) {
if err := pausequery.EnsureAllowed(middleware.GetUserTypeFromContext(ctx)); err != nil {
return nil, err
}
if req == nil || req.EnablePolling == nil {
return nil, errors.New(errors.CodeInvalidParam)
}
if !strings.HasPrefix(req.FileKey, constants.PollingStatusImportStoragePrefix+"/") {
return nil, errors.New(errors.CodeInvalidParam, "导入文件Key不属于指定上传目录")
}
if !strings.EqualFold(filepath.Ext(req.FileKey), ".csv") {
return nil, errors.New(errors.CodeInvalidParam, "导入文件必须为CSV格式")
}
userID := middleware.GetUserIDFromContext(ctx)
if userID == 0 {
return nil, errors.New(errors.CodeUnauthorized)
}
now := time.Now()
task := &model.PollingStatusImportTask{
TaskNo: fmt.Sprintf("PSI%s%06d", now.Format("20060102150405"), rand.Intn(1000000)), AssetType: req.AssetType,
EnablePolling: *req.EnablePolling, Reason: req.Reason, FileName: filepath.Base(req.FileKey), StorageKey: req.FileKey,
Status: model.ImportTaskStatusPending, ResultItems: model.PollingStatusImportResults{}, Creator: userID,
CreatorName: middleware.GetUsernameFromContext(ctx), CreatedAt: now, UpdatedAt: now,
}
if err := s.db.WithContext(ctx).Create(task).Error; err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建轮询开关导入任务失败")
}
var enqueueErr error
if s.queueClient == nil {
enqueueErr = stderrors.New("任务队列未配置")
} else {
enqueueErr = s.queueClient.EnqueueTask(ctx, constants.TaskTypePollingStatusImport, PollingStatusImportPayload{TaskID: task.ID},
asynq.Queue(constants.QueueForTaskType(constants.TaskTypePollingStatusImport)), asynq.Timeout(30*time.Minute), asynq.MaxRetry(0))
}
if enqueueErr != nil {
s.logger.Error("轮询开关导入任务入队失败", zap.Uint("task_id", task.ID), zap.Error(enqueueErr))
completed := time.Now()
s.db.WithContext(ctx).Model(&model.PollingStatusImportTask{}).Where("id = ? AND status = ?", task.ID, model.ImportTaskStatusPending).
Updates(map[string]any{"status": model.ImportTaskStatusFailed, "error_message": "导入任务入队失败", "completed_at": completed, "updated_at": completed})
task.Status, task.ErrorMessage, task.CompletedAt = model.ImportTaskStatusFailed, "导入任务入队失败", &completed
}
return toImportResponse(task), nil
}
// ListImports 分页查询导入任务。
func (s *PollingStatusImportService) ListImports(ctx context.Context, req *dto.PollingStatusImportListRequest) (*dto.PollingStatusImportPageResult, error) {
if err := pausequery.EnsureAllowed(middleware.GetUserTypeFromContext(ctx)); err != nil {
return nil, err
}
page, size := normalizePage(req.Page, req.PageSize)
query := s.db.WithContext(ctx).Model(&model.PollingStatusImportTask{})
if req.Status != nil {
query = query.Where("status = ?", *req.Status)
}
var total int64
if err := query.Count(&total).Error; err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "统计轮询开关导入任务失败")
}
var rows []model.PollingStatusImportTask
if err := query.Omit("result_items").Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&rows).Error; err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询轮询开关导入任务失败")
}
items := make([]dto.PollingStatusImportTaskResponse, 0, len(rows))
for index := range rows {
items = append(items, *toImportResponse(&rows[index]))
}
return &dto.PollingStatusImportPageResult{Items: items, Total: total, Page: page, PageSize: size}, nil
}
// GetImport 查询导入任务详情与逐行结果。
func (s *PollingStatusImportService) GetImport(ctx context.Context, id uint) (*dto.PollingStatusImportTaskDetailResponse, error) {
if err := pausequery.EnsureAllowed(middleware.GetUserTypeFromContext(ctx)); err != nil {
return nil, err
}
var task model.PollingStatusImportTask
if err := s.db.WithContext(ctx).First(&task, id).Error; err != nil {
if stderrors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New(errors.CodeNotFound, "轮询开关导入任务不存在")
}
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询轮询开关导入任务失败")
}
items := make([]dto.PollingStatusImportItemResponse, 0, len(task.ResultItems))
for _, item := range task.ResultItems {
items = append(items, dto.PollingStatusImportItemResponse{Line: item.Line, Identifier: item.Identifier, AssetID: item.AssetID,
Status: item.Status, StatusName: constants.PollingToggleItemStatusName(item.Status), Reason: item.Reason})
}
return &dto.PollingStatusImportTaskDetailResponse{PollingStatusImportTaskResponse: *toImportResponse(&task), Items: items}, nil
}
func toImportResponse(task *model.PollingStatusImportTask) *dto.PollingStatusImportTaskResponse {
return &dto.PollingStatusImportTaskResponse{
ID: task.ID, TaskNo: task.TaskNo, AssetType: task.AssetType, EnablePolling: task.EnablePolling, Reason: task.Reason,
FileName: task.FileName, Status: task.Status, StatusName: model.ImportTaskStatusName(task.Status),
TotalCount: task.TotalCount, SuccessCount: task.SuccessCount, SkipCount: task.SkipCount, FailCount: task.FailCount,
ErrorMessage: task.ErrorMessage, CreatorName: task.CreatorName, CreatedAt: task.CreatedAt, StartedAt: task.StartedAt, CompletedAt: task.CompletedAt,
}
}