feat: 轮询系统重构（分片队列 + 停复机统一 + Handler 拆分）

【核心变更】

1. 停复机逻辑统一（StopResumeService）
   - 新增 EvaluateAndAct 统一入口，封装三条件停复机判断
   - 停机条件：无套餐(no_package) / 流量耗尽(traffic_exhausted) / 未实名(not_realname)
   - 复机条件：stop_reason 合规 + 有套餐且未耗尽 + 已实名或行业卡
   - 修复设备套餐 Bug：hasValidPackage 按 device_id 查套餐，而非仅 iot_card_id
   - 设备维度停复机加幂等锁（Redis SetNX，TTL 30s），防止多卡并发重复调 Gateway

2. Redis 分片队列（PollingQueueManager）
   - 新建 queue_manager.go，封装所有轮询 Redis 操作
   - 16 分片 Sorted Set，Key 格式：polling:shard:{shardID}:queue:{taskType}
   - Lua 脚本原子出队（ZRANGEBYSCORE + 分批 ZREM），消除竞态窗口
   - 新增背压检测：队列深度超 50 万时 Scheduler 跳过该分片
   - RemoveFromAllQueues 覆盖 4 种任务类型（含 protect）

3. Handler 拆分（polling_handler.go 1360行 → 5个专注文件）
   - polling_base.go：共享基类（并发控制/卡缓存/重入队）
   - polling_realname_handler.go：实名采集，实名 0→1 时立即触发复机
   - polling_carddata_handler.go：流量采集，保留跨月边界检测逻辑
   - polling_package_handler.go：套餐采集，委托 EvaluateAndAct 决策
   - polling_protect_handler.go：保护期一致性检查，保护期内强制修正

4. 配置管理（PollingConfigManager）
   - 新建 config_manager.go，从 scheduler.go 提取配置职责
   - 内存缓存 + 5 分钟定时刷新，刷新失败保留原缓存
   - 修复 getCardCondition：停机卡返回 suspended，不再错配 activated 配置

5. 渐进式初始化（CardInitializer）
   - 新建 initializer.go，分批加载（每批 10 万），批次间 sleep 500ms
   - 过滤 enable_polling=false 的卡，初始化完成前 Scheduler 不出队

6. 卡生命周期服务（PollingLifecycleService）
   - 新建 lifecycle_service.go，替代已删除的 callbacks.go 和 api_callback.go
   - OnCardCreated/OnCardEnabled/OnCardStatusChanged 入队前检查 enable_polling

7. Scheduler 精简（1000+行 → 227行）
   - 保留纯调度循环：scheduleLoop + processShardSchedule + enqueueBatch
   - 保留每 10 秒触发套餐过期检测和流量重置
   - 移除所有 DB 操作、配置加载、卡初始化逻辑

8. 轮询管控 API（enable_polling）
   - 新增 PUT /api/admin/assets/:id/polling-status 接口
   - 支持对设备/卡维度开关轮询，关闭后从所有分片队列移除

9. 数据库迁移
   - 000103：tb_device 新增 enable_polling 字段（boolean, NOT NULL, DEFAULT true）
   - 000104：新增 suspended 轮询配置，为 activated 配置补全 protect_check_interval

【文件统计】
- 新增：19 个文件（handler × 5、polling 组件 × 4、迁移 × 3 等）
- 修改：20 个文件（bootstrap 注入、store 接口、monitoring 适配分片等）
- 删除：3 个文件（polling_handler.go、callbacks.go、api_callback.go）

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

internal/task/polling_card_cache.go

@@ -0,0 +1,136 @@
+package task
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go.uber.org/zap"
+
+	"github.com/break/junhong_cmp_fiber/internal/model"
+	"github.com/break/junhong_cmp_fiber/pkg/constants"
+)
+
+// getCardWithCache 优先从 Redis 缓存获取卡信息，缓存 miss 时查 DB 并异步写缓存
+func (b *PollingBase) getCardWithCache(ctx context.Context, cardID uint) (*model.IotCard, error) {
+	key := constants.RedisPollingCardInfoKey(cardID)
+
+	result, err := b.redis.HGetAll(ctx, key).Result()
+	if err == nil && len(result) > 0 {
+		return parseCardFromCache(cardID, result), nil
+	}
+
+	card, err := b.iotCardStore.GetByID(ctx, cardID)
+	if err != nil {
+		return nil, err
+	}
+
+	go writeCardToCache(b, key, card)
+	return card, nil
+}
+
+// updateCardCache 更新 Redis 卡信息缓存中的指定字段
+func (b *PollingBase) updateCardCache(ctx context.Context, cardID uint, updates map[string]any) {
+	key := constants.RedisPollingCardInfoKey(cardID)
+	args := make([]any, 0, len(updates)*2)
+	for k, v := range updates {
+		args = append(args, k, v)
+	}
+	if len(args) > 0 {
+		if err := b.redis.HSet(ctx, key, args...).Err(); err != nil {
+			b.logger.Warn("更新卡缓存失败", zap.Uint("card_id", cardID), zap.Error(err))
+		}
+	}
+}
+
+// parseCardFromCache 从 Redis Hash 反序列化卡信息
+func parseCardFromCache(cardID uint, result map[string]string) *model.IotCard {
+	card := &model.IotCard{}
+	card.ID = cardID
+	if v, ok := result["iccid"]; ok {
+		card.ICCID = v
+	}
+	if v, ok := result["card_category"]; ok {
+		card.CardCategory = v
+	}
+	if v, ok := result["real_name_status"]; ok {
+		if status, err := strconv.Atoi(v); err == nil {
+			card.RealNameStatus = status
+		}
+	}
+	if v, ok := result["network_status"]; ok {
+		if status, err := strconv.Atoi(v); err == nil {
+			card.NetworkStatus = status
+		}
+	}
+	if v, ok := result["carrier_id"]; ok {
+		if id, err := strconv.ParseUint(v, 10, 64); err == nil {
+			card.CarrierID = uint(id)
+		}
+	}
+	if v, ok := result["current_month_usage_mb"]; ok {
+		if usage, err := strconv.ParseFloat(v, 64); err == nil {
+			card.CurrentMonthUsageMB = usage
+		}
+	}
+	if v, ok := result["last_gateway_reading_mb"]; ok {
+		if reading, err := strconv.ParseFloat(v, 64); err == nil {
+			card.LastGatewayReadingMB = reading
+		}
+	}
+	if v, ok := result["data_usage_mb"]; ok {
+		if usage, err := strconv.ParseInt(v, 10, 64); err == nil {
+			card.DataUsageMB = usage
+		}
+	}
+	if v, ok := result["stop_reason"]; ok {
+		card.StopReason = v
+	}
+	if v, ok := result["is_standalone"]; ok {
+		card.IsStandalone = v == "1" || v == "true"
+	} else {
+		card.IsStandalone = true
+	}
+	if v, ok := result["series_id"]; ok {
+		if id, err := strconv.ParseUint(v, 10, 64); err == nil {
+			seriesID := uint(id)
+			card.SeriesID = &seriesID
+		}
+	}
+	if v, ok := result["current_month_start_date"]; ok {
+		if ts, err := strconv.ParseInt(v, 10, 64); err == nil {
+			t := time.Unix(ts, 0)
+			card.CurrentMonthStartDate = &t
+		}
+	}
+	return card
+}
+
+// writeCardToCache 将卡信息异步写入 Redis 缓存（7 天 TTL）
+func writeCardToCache(b *PollingBase, key string, card *model.IotCard) {
+	cacheCtx := context.Background()
+	cacheData := map[string]any{
+		"id":                      card.ID,
+		"iccid":                   card.ICCID,
+		"card_category":           card.CardCategory,
+		"real_name_status":        card.RealNameStatus,
+		"network_status":          card.NetworkStatus,
+		"carrier_id":              card.CarrierID,
+		"current_month_usage_mb":  card.CurrentMonthUsageMB,
+		"last_gateway_reading_mb": card.LastGatewayReadingMB,
+		"data_usage_mb":           card.DataUsageMB,
+		"stop_reason":             card.StopReason,
+		"is_standalone":           boolToStr(card.IsStandalone),
+		"cached_at":               time.Now().Unix(),
+	}
+	if card.SeriesID != nil {
+		cacheData["series_id"] = *card.SeriesID
+	}
+	if card.CurrentMonthStartDate != nil {
+		cacheData["current_month_start_date"] = card.CurrentMonthStartDate.Unix()
+	}
+	pipe := b.redis.Pipeline()
+	pipe.HSet(cacheCtx, key, cacheData)
+	pipe.Expire(cacheCtx, key, 7*24*time.Hour)
+	_, _ = pipe.Exec(cacheCtx)
+}