huang
02b10f87cf
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 7m8s
新增退款申请全生命周期管理：创建/列表/详情/审批通过/拒绝/退回/重新提交 审批通过后异步执行佣金全额回扣（扣减各代理佣金钱包）和资产重置（套餐失效+停机+世代重置） 新增 tb_refund_request 表（迁移 000093）、RefundRequest Model、8 个 DTO 新增 Store/Service/Handler/路由注册，仅平台用户可访问
734 lines
23 KiB
Go
734 lines
23 KiB
Go
// Package asset 提供统一的资产查询与操作服务
|
||
// 资产包含两种类型：IoT卡(card)和设备(device)
|
||
// 支持资产解析、实时状态查询、网关刷新、套餐查询等功能
|
||
package asset
|
||
|
||
import (
|
||
"context"
|
||
stderrors "errors"
|
||
"sort"
|
||
"time"
|
||
|
||
"github.com/break/junhong_cmp_fiber/internal/gateway"
|
||
"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/logger"
|
||
"github.com/break/junhong_cmp_fiber/pkg/middleware"
|
||
"github.com/redis/go-redis/v9"
|
||
"go.uber.org/zap"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// IotCardRefresher 用于调用 RefreshCardDataFromGateway，避免循环依赖
|
||
type IotCardRefresher interface {
|
||
RefreshCardDataFromGateway(ctx context.Context, iccid string) error
|
||
}
|
||
|
||
// Service 资产查询与操作服务
|
||
type Service struct {
|
||
db *gorm.DB
|
||
deviceStore *postgres.DeviceStore
|
||
iotCardStore *postgres.IotCardStore
|
||
packageUsageStore *postgres.PackageUsageStore
|
||
packageStore *postgres.PackageStore
|
||
packageSeriesStore *postgres.PackageSeriesStore
|
||
deviceSimBindingStore *postgres.DeviceSimBindingStore
|
||
shopStore *postgres.ShopStore
|
||
redis *redis.Client
|
||
iotCardService IotCardRefresher
|
||
gatewayClient *gateway.Client // 用于调用 sync-info 同步设备信息（可为 nil，失败时仅记录日志）
|
||
}
|
||
|
||
// New 创建资产服务实例
|
||
func New(
|
||
db *gorm.DB,
|
||
deviceStore *postgres.DeviceStore,
|
||
iotCardStore *postgres.IotCardStore,
|
||
packageUsageStore *postgres.PackageUsageStore,
|
||
packageStore *postgres.PackageStore,
|
||
packageSeriesStore *postgres.PackageSeriesStore,
|
||
deviceSimBindingStore *postgres.DeviceSimBindingStore,
|
||
shopStore *postgres.ShopStore,
|
||
redisClient *redis.Client,
|
||
iotCardService IotCardRefresher,
|
||
gatewayClient *gateway.Client,
|
||
) *Service {
|
||
return &Service{
|
||
db: db,
|
||
deviceStore: deviceStore,
|
||
iotCardStore: iotCardStore,
|
||
packageUsageStore: packageUsageStore,
|
||
packageStore: packageStore,
|
||
packageSeriesStore: packageSeriesStore,
|
||
deviceSimBindingStore: deviceSimBindingStore,
|
||
shopStore: shopStore,
|
||
redis: redisClient,
|
||
iotCardService: iotCardService,
|
||
gatewayClient: gatewayClient,
|
||
}
|
||
}
|
||
|
||
// Resolve 通过任意标识符解析资产
|
||
// 优先匹配设备（virtual_no/imei/sn），未命中则匹配卡（virtual_no/iccid/msisdn）
|
||
func (s *Service) Resolve(ctx context.Context, identifier string) (*dto.AssetResolveResponse, error) {
|
||
// 先查 Device
|
||
device, err := s.deviceStore.GetByIdentifier(ctx, identifier)
|
||
if err == nil && device != nil {
|
||
return s.buildDeviceResolveResponse(ctx, device)
|
||
}
|
||
|
||
// 未找到设备，查 IotCard（virtual_no/iccid/msisdn）
|
||
var card model.IotCard
|
||
query := s.db.WithContext(ctx).
|
||
Where("virtual_no = ? OR iccid = ? OR msisdn = ?", identifier, identifier, identifier)
|
||
query = middleware.ApplyShopFilter(ctx, query)
|
||
if err := query.First(&card).Error; err == nil {
|
||
return s.buildCardResolveResponse(ctx, &card)
|
||
}
|
||
|
||
return nil, errors.New(errors.CodeNotFound, "未找到匹配的资产")
|
||
}
|
||
|
||
// buildDeviceResolveResponse 构建设备类型的资产解析响应
|
||
func (s *Service) buildDeviceResolveResponse(ctx context.Context, device *model.Device) (*dto.AssetResolveResponse, error) {
|
||
resp := &dto.AssetResolveResponse{
|
||
AssetType: "device",
|
||
AssetID: device.ID,
|
||
VirtualNo: device.VirtualNo,
|
||
Status: device.Status,
|
||
BatchNo: device.BatchNo,
|
||
ShopID: device.ShopID,
|
||
SeriesID: device.SeriesID,
|
||
FirstCommissionPaid: device.FirstCommissionPaid,
|
||
AccumulatedRecharge: device.AccumulatedRecharge,
|
||
ActivatedAt: device.ActivatedAt,
|
||
CreatedAt: device.CreatedAt,
|
||
UpdatedAt: device.UpdatedAt,
|
||
DeviceName: device.DeviceName,
|
||
IMEI: device.IMEI,
|
||
SN: device.SN,
|
||
DeviceModel: device.DeviceModel,
|
||
DeviceType: device.DeviceType,
|
||
MaxSimSlots: device.MaxSimSlots,
|
||
Manufacturer: device.Manufacturer,
|
||
OnlineStatus: device.OnlineStatus,
|
||
LastOnlineTime: device.LastOnlineTime,
|
||
SoftwareVersion: device.SoftwareVersion,
|
||
SwitchMode: device.SwitchMode,
|
||
LastGatewaySyncAt: device.LastGatewaySyncAt,
|
||
}
|
||
|
||
// 查绑定卡
|
||
bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, device.ID)
|
||
if err == nil && len(bindings) > 0 {
|
||
resp.BoundCardCount = len(bindings)
|
||
cardIDs := make([]uint, 0, len(bindings))
|
||
slotMap := make(map[uint]int, len(bindings))
|
||
isCurrentMap := make(map[uint]bool, len(bindings))
|
||
for _, b := range bindings {
|
||
cardIDs = append(cardIDs, b.IotCardID)
|
||
slotMap[b.IotCardID] = b.SlotPosition
|
||
isCurrentMap[b.IotCardID] = b.IsCurrent
|
||
}
|
||
cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
|
||
if err != nil {
|
||
logger.GetAppLogger().Warn("查询设备绑定卡信息失败，结果可能不完整",
|
||
zap.Uints("card_ids", cardIDs),
|
||
zap.Error(err))
|
||
}
|
||
for _, c := range cards {
|
||
resp.Cards = append(resp.Cards, dto.BoundCardInfo{
|
||
CardID: c.ID,
|
||
ICCID: c.ICCID,
|
||
MSISDN: c.MSISDN,
|
||
NetworkStatus: c.NetworkStatus,
|
||
RealNameStatus: c.RealNameStatus,
|
||
SlotPosition: slotMap[c.ID],
|
||
IsCurrent: isCurrentMap[c.ID],
|
||
})
|
||
}
|
||
}
|
||
|
||
// 查当前主套餐
|
||
s.fillPackageInfo(ctx, resp, "device", device.ID)
|
||
|
||
// 查 shop 名称
|
||
s.fillShopName(ctx, resp)
|
||
|
||
// 查套餐系列名称
|
||
s.fillSeriesName(ctx, resp)
|
||
|
||
// 查 Redis 保护期
|
||
resp.DeviceProtectStatus = s.getDeviceProtectStatus(ctx, device.ID)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// buildCardResolveResponse 构建卡类型的资产解析响应
|
||
func (s *Service) buildCardResolveResponse(ctx context.Context, card *model.IotCard) (*dto.AssetResolveResponse, error) {
|
||
resp := &dto.AssetResolveResponse{
|
||
AssetType: "card",
|
||
AssetID: card.ID,
|
||
VirtualNo: card.VirtualNo,
|
||
Status: card.Status,
|
||
BatchNo: card.BatchNo,
|
||
ShopID: card.ShopID,
|
||
SeriesID: card.SeriesID,
|
||
FirstCommissionPaid: card.FirstCommissionPaid,
|
||
AccumulatedRecharge: card.AccumulatedRecharge,
|
||
ActivatedAt: card.ActivatedAt,
|
||
CreatedAt: card.CreatedAt,
|
||
UpdatedAt: card.UpdatedAt,
|
||
RealNameStatus: card.RealNameStatus,
|
||
NetworkStatus: card.NetworkStatus,
|
||
ICCID: card.ICCID,
|
||
CarrierID: card.CarrierID,
|
||
CarrierType: card.CarrierType,
|
||
CarrierName: card.CarrierName,
|
||
MSISDN: card.MSISDN,
|
||
IMSI: card.IMSI,
|
||
CardCategory: card.CardCategory,
|
||
Supplier: card.Supplier,
|
||
ActivationStatus: card.ActivationStatus,
|
||
EnablePolling: card.EnablePolling,
|
||
}
|
||
|
||
// 查绑定设备
|
||
binding, err := s.deviceSimBindingStore.GetActiveBindingByCardID(ctx, card.ID)
|
||
if err == nil && binding != nil {
|
||
resp.BoundDeviceID = &binding.DeviceID
|
||
device, devErr := s.deviceStore.GetByID(ctx, binding.DeviceID)
|
||
if devErr == nil && device != nil {
|
||
resp.BoundDeviceNo = device.VirtualNo
|
||
resp.BoundDeviceName = device.DeviceName
|
||
}
|
||
}
|
||
|
||
// 查当前主套餐
|
||
s.fillPackageInfo(ctx, resp, "iot_card", card.ID)
|
||
|
||
// 查 shop 名称
|
||
s.fillShopName(ctx, resp)
|
||
|
||
// 查套餐系列名称
|
||
s.fillSeriesName(ctx, resp)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// fillPackageInfo 填充当前主套餐信息到响应中
|
||
func (s *Service) fillPackageInfo(ctx context.Context, resp *dto.AssetResolveResponse, carrierType string, carrierID uint) {
|
||
usage, err := s.packageUsageStore.GetActiveMainPackage(ctx, carrierType, carrierID)
|
||
if err != nil || usage == nil {
|
||
return
|
||
}
|
||
|
||
pkg, err := s.packageStore.GetByID(ctx, usage.PackageID)
|
||
if err != nil || pkg == nil {
|
||
return
|
||
}
|
||
|
||
resp.CurrentPackage = pkg.PackageName
|
||
ratio := safeVirtualRatio(pkg.VirtualRatio)
|
||
resp.PackageTotalMB = int64(float64(usage.DataLimitMB) / ratio)
|
||
resp.PackageUsedMB = float64(usage.DataUsageMB) / ratio
|
||
resp.PackageRemainMB = float64(usage.DataLimitMB-usage.DataUsageMB) / ratio
|
||
}
|
||
|
||
// fillShopName 填充店铺名称
|
||
func (s *Service) fillShopName(ctx context.Context, resp *dto.AssetResolveResponse) {
|
||
if resp.ShopID == nil || *resp.ShopID == 0 {
|
||
return
|
||
}
|
||
shop, err := s.shopStore.GetByID(ctx, *resp.ShopID)
|
||
if err == nil && shop != nil {
|
||
resp.ShopName = shop.ShopName
|
||
}
|
||
}
|
||
|
||
// fillSeriesName 填充套餐系列名称
|
||
func (s *Service) fillSeriesName(ctx context.Context, resp *dto.AssetResolveResponse) {
|
||
if resp.SeriesID == nil || *resp.SeriesID == 0 {
|
||
return
|
||
}
|
||
series, err := s.packageSeriesStore.GetByID(ctx, *resp.SeriesID)
|
||
if err == nil && series != nil {
|
||
resp.SeriesName = series.SeriesName
|
||
}
|
||
}
|
||
|
||
// GetRealtimeStatus 获取资产实时状态（只读DB/Redis）
|
||
func (s *Service) GetRealtimeStatus(ctx context.Context, assetType string, id uint) (*dto.AssetRealtimeStatusResponse, error) {
|
||
resp := &dto.AssetRealtimeStatusResponse{
|
||
AssetType: assetType,
|
||
AssetID: id,
|
||
}
|
||
|
||
switch assetType {
|
||
case "card":
|
||
card, err := s.iotCardStore.GetByID(ctx, id)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeNotFound, err, "卡不存在")
|
||
}
|
||
resp.NetworkStatus = card.NetworkStatus
|
||
resp.RealNameStatus = card.RealNameStatus
|
||
resp.CurrentMonthUsageMB = card.CurrentMonthUsageMB
|
||
resp.LastSyncTime = card.LastSyncTime
|
||
|
||
case "device":
|
||
// 查绑定卡状态列表
|
||
bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, id)
|
||
if err == nil && len(bindings) > 0 {
|
||
cardIDs := make([]uint, 0, len(bindings))
|
||
slotMap := make(map[uint]int, len(bindings))
|
||
isCurrentMap := make(map[uint]bool, len(bindings))
|
||
for _, b := range bindings {
|
||
cardIDs = append(cardIDs, b.IotCardID)
|
||
slotMap[b.IotCardID] = b.SlotPosition
|
||
isCurrentMap[b.IotCardID] = b.IsCurrent
|
||
}
|
||
cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
|
||
if err != nil {
|
||
logger.GetAppLogger().Warn("查询设备绑定卡信息失败，结果可能不完整",
|
||
zap.Uints("card_ids", cardIDs),
|
||
zap.Error(err))
|
||
}
|
||
for _, c := range cards {
|
||
resp.Cards = append(resp.Cards, dto.BoundCardInfo{
|
||
CardID: c.ID,
|
||
ICCID: c.ICCID,
|
||
MSISDN: c.MSISDN,
|
||
NetworkStatus: c.NetworkStatus,
|
||
RealNameStatus: c.RealNameStatus,
|
||
SlotPosition: slotMap[c.ID],
|
||
IsCurrent: isCurrentMap[c.ID],
|
||
})
|
||
}
|
||
}
|
||
resp.DeviceProtectStatus = s.getDeviceProtectStatus(ctx, id)
|
||
|
||
// 实时查询 Gateway 设备状态（不缓存，per D-05）
|
||
// Gateway 失败不阻断主流程，DeviceRealtime 始终非 nil，失败时仅填 GatewayMsg（per D-06）
|
||
resp.DeviceRealtime = s.fetchDeviceGatewayInfo(ctx, id)
|
||
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
|
||
}
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// fetchDeviceGatewayInfo 查询设备 Gateway 实时状态，始终返回非 nil 对象
|
||
// Gateway 成功时填充全量字段，失败时仅填充 GatewayMsg 供前端展示错误原因
|
||
func (s *Service) fetchDeviceGatewayInfo(ctx context.Context, deviceID uint) *dto.DeviceGatewayInfo {
|
||
if s.gatewayClient == nil {
|
||
msg := "Gateway 客户端未配置"
|
||
return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
|
||
}
|
||
|
||
device, err := s.deviceStore.GetByID(ctx, deviceID)
|
||
if err != nil {
|
||
msg := "查询设备信息失败: " + err.Error()
|
||
return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
|
||
}
|
||
|
||
// IMEI 优先，无则用 SN（与 Refresh 中 updateDeviceFromSyncInfo 保持一致）
|
||
cardNo := device.IMEI
|
||
if cardNo == "" {
|
||
cardNo = device.SN
|
||
}
|
||
if cardNo == "" {
|
||
msg := "设备缺少 IMEI 和 SN，无法查询 Gateway 实时状态"
|
||
return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
|
||
}
|
||
|
||
syncResp, syncErr := s.gatewayClient.SyncDeviceInfo(ctx, &gateway.SyncDeviceInfoReq{
|
||
CardNo: cardNo,
|
||
})
|
||
if syncErr != nil {
|
||
msg := syncErr.Error()
|
||
logger.GetAppLogger().Warn("fetchDeviceGatewayInfo: sync-info 调用失败",
|
||
zap.Uint("device_id", deviceID),
|
||
zap.Error(syncErr))
|
||
return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
|
||
}
|
||
|
||
return mapSyncRespToDeviceGatewayInfo(syncResp)
|
||
}
|
||
|
||
// mapSyncRespToDeviceGatewayInfo 将 Gateway SyncDeviceInfoResp 映射为 B 端 DeviceGatewayInfo DTO
|
||
// 使用指针字段，未赋值的字段保持 nil（omitempty）
|
||
func mapSyncRespToDeviceGatewayInfo(r *gateway.SyncDeviceInfoResp) *dto.DeviceGatewayInfo {
|
||
info := &dto.DeviceGatewayInfo{
|
||
OnlineStatus: &r.OnlineStatus,
|
||
RunTime: strPtr(r.RunTime),
|
||
ConnectTime: strPtr(r.ConnectTime),
|
||
LastOnlineTime: strPtr(r.LastOnlineTime),
|
||
LastUpdateTime: strPtr(r.LastUpdateTime),
|
||
Rsrp: &r.Rsrp,
|
||
Rsrq: &r.Rsrq,
|
||
Rssi: strPtr(r.RSSI),
|
||
Sinr: &r.Sinr,
|
||
SSID: strPtr(r.SSID),
|
||
WifiEnabled: flexBoolPtr(r.WifiEnabled),
|
||
WifiPassword: strPtr(r.WifiPassword),
|
||
IPAddress: strPtr(r.IPAddress),
|
||
WANIP: strPtr(r.WANIP),
|
||
LANIP: strPtr(r.LANIP),
|
||
MACAddress: strPtr(r.MacAddress),
|
||
DailyUsage: strPtr(r.DailyUsage),
|
||
DLStats: strPtr(r.DLStats),
|
||
ULStats: strPtr(r.ULStats),
|
||
LimitSpeed: &r.LimitSpeed,
|
||
CurrentIccid: strPtr(r.CurrentIccid),
|
||
MaxClients: &r.MaxClients,
|
||
SoftwareVersion: strPtr(r.SoftwareVersion),
|
||
SwitchMode: strPtr(r.SwitchMode),
|
||
SyncInterval: &r.SyncInterval,
|
||
DeviceID: strPtr(r.DeviceID),
|
||
DeviceName: strPtr(r.DeviceName),
|
||
DeviceType: strPtr(r.DeviceType),
|
||
IMEI: strPtr(r.IMEI),
|
||
IMSI: strPtr(r.IMSI),
|
||
Status: &r.Status,
|
||
}
|
||
if r.BatteryLevel != nil {
|
||
info.BatteryLevel = r.BatteryLevel
|
||
}
|
||
return info
|
||
}
|
||
|
||
// strPtr 将空字符串转为 nil，非空字符串返回指针
|
||
// 避免 JSON 响应中出现大量空字符串字段（omitempty 对空字符串无效）
|
||
func strPtr(s string) *string {
|
||
if s == "" {
|
||
return nil
|
||
}
|
||
return &s
|
||
}
|
||
|
||
func flexBoolPtr(fb gateway.FlexBool) *bool {
|
||
b := bool(fb)
|
||
return &b
|
||
}
|
||
|
||
// Refresh 刷新资产数据（调网关同步）
|
||
func (s *Service) Refresh(ctx context.Context, assetType string, id uint) (*dto.AssetRealtimeStatusResponse, error) {
|
||
switch assetType {
|
||
case "card":
|
||
card, err := s.iotCardStore.GetByID(ctx, id)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeNotFound, err, "卡不存在")
|
||
}
|
||
if err := s.iotCardService.RefreshCardDataFromGateway(ctx, card.ICCID); err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "刷新卡数据失败")
|
||
}
|
||
return s.GetRealtimeStatus(ctx, "card", id)
|
||
|
||
case "device":
|
||
// 检查冷却期
|
||
cooldownKey := constants.RedisDeviceRefreshCooldownKey(id)
|
||
if s.redis.Exists(ctx, cooldownKey).Val() > 0 {
|
||
return nil, errors.New(errors.CodeTooManyRequests, "刷新过于频繁，请30秒后再试")
|
||
}
|
||
|
||
// 查所有绑定卡，逐一刷新
|
||
bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, id)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "查询绑定卡失败")
|
||
}
|
||
for _, b := range bindings {
|
||
card, cardErr := s.iotCardStore.GetByID(ctx, b.IotCardID)
|
||
if cardErr != nil {
|
||
logger.GetAppLogger().Warn("刷新设备绑定卡失败：查卡失败",
|
||
zap.Uint("device_id", id),
|
||
zap.Uint("card_id", b.IotCardID),
|
||
zap.Error(cardErr))
|
||
continue
|
||
}
|
||
if refreshErr := s.iotCardService.RefreshCardDataFromGateway(ctx, card.ICCID); refreshErr != nil {
|
||
logger.GetAppLogger().Warn("刷新设备绑定卡失败：网关调用失败",
|
||
zap.Uint("device_id", id),
|
||
zap.String("iccid", card.ICCID),
|
||
zap.Error(refreshErr))
|
||
}
|
||
}
|
||
|
||
// 设置冷却 Key
|
||
s.redis.Set(ctx, cooldownKey, 1, constants.DeviceRefreshCooldownDuration)
|
||
|
||
// 刷新设备自身信息（在线状态、当前卡、固件版本等），失败不阻断刷新流程（per D-15）
|
||
if s.gatewayClient != nil {
|
||
device, devErr := s.deviceStore.GetByID(ctx, id)
|
||
if devErr == nil {
|
||
// IMEI 优先，无则用 SN（per D-3 注释说明）
|
||
cardNo := device.IMEI
|
||
if cardNo == "" {
|
||
cardNo = device.SN
|
||
}
|
||
if cardNo != "" {
|
||
if syncResp, syncErr := s.gatewayClient.SyncDeviceInfo(ctx, &gateway.SyncDeviceInfoReq{
|
||
CardNo: cardNo,
|
||
}); syncErr == nil {
|
||
s.updateDeviceFromSyncInfo(ctx, id, syncResp)
|
||
} else {
|
||
logger.GetAppLogger().Warn("sync-info 调用失败",
|
||
zap.Uint("device_id", id),
|
||
zap.Error(syncErr))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return s.GetRealtimeStatus(ctx, "device", id)
|
||
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
|
||
}
|
||
}
|
||
|
||
// updateDeviceFromSyncInfo 根据 Gateway sync-info 响应更新设备状态字段和当前卡标识
|
||
// 失败时只记录日志，不返回错误（非关键步骤）
|
||
func (s *Service) updateDeviceFromSyncInfo(ctx context.Context, deviceID uint, resp *gateway.SyncDeviceInfoResp) {
|
||
now := time.Now()
|
||
|
||
// 解析 LastOnlineTime（ISO 8601 字符串 → *time.Time）
|
||
var lastOnlineTime *time.Time
|
||
if resp.LastOnlineTime != "" {
|
||
if t, err := time.Parse(time.RFC3339, resp.LastOnlineTime); err == nil {
|
||
lastOnlineTime = &t
|
||
}
|
||
}
|
||
|
||
// 更新设备 5 个存储字段
|
||
updates := map[string]any{
|
||
"online_status": resp.OnlineStatus,
|
||
"software_version": resp.SoftwareVersion,
|
||
"switch_mode": resp.SwitchMode,
|
||
"last_gateway_sync_at": now,
|
||
}
|
||
if lastOnlineTime != nil {
|
||
updates["last_online_time"] = lastOnlineTime
|
||
}
|
||
|
||
if err := s.db.WithContext(ctx).
|
||
Model(&model.Device{}).
|
||
Where("id = ?", deviceID).
|
||
Updates(updates).Error; err != nil {
|
||
logger.GetAppLogger().Warn("sync-info 更新设备字段失败",
|
||
zap.Uint("device_id", deviceID),
|
||
zap.Error(err))
|
||
return
|
||
}
|
||
|
||
// 更新 is_current 标识（事务原子操作，per D-14 决策）
|
||
if err := s.deviceSimBindingStore.UpdateIsCurrentByDeviceID(ctx, deviceID, resp.CurrentIccid); err != nil {
|
||
logger.GetAppLogger().Warn("sync-info 更新 is_current 失败",
|
||
zap.Uint("device_id", deviceID),
|
||
zap.Error(err))
|
||
}
|
||
}
|
||
|
||
// GetPackages 获取资产的所有套餐列表（支持分页）
|
||
// page 默认 1，pageSize 默认 50，pageSize 最大 100
|
||
func (s *Service) GetPackages(ctx context.Context, assetType string, id uint, page, pageSize int) (*dto.AssetPackagesResult, error) {
|
||
// 分页参数边界处理
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 {
|
||
pageSize = 50
|
||
}
|
||
if pageSize > 100 {
|
||
pageSize = 100
|
||
}
|
||
|
||
// assetType 对应 Store 中的 carrierType：card→iot_card, device→device
|
||
carrierType := assetType
|
||
if assetType == "card" {
|
||
carrierType = "iot_card"
|
||
}
|
||
|
||
usages, err := s.packageUsageStore.ListByCarrier(ctx, carrierType, id)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "查询套餐使用记录失败")
|
||
}
|
||
|
||
// 收集所有 PackageID 并批量查询
|
||
pkgIDSet := make(map[uint]struct{}, len(usages))
|
||
for _, u := range usages {
|
||
pkgIDSet[u.PackageID] = struct{}{}
|
||
}
|
||
pkgIDs := make([]uint, 0, len(pkgIDSet))
|
||
for id := range pkgIDSet {
|
||
pkgIDs = append(pkgIDs, id)
|
||
}
|
||
packages, pkgErr := s.packageStore.GetByIDsUnscoped(ctx, pkgIDs)
|
||
if pkgErr != nil {
|
||
logger.GetAppLogger().Warn("批量查询套餐信息失败，套餐名称可能缺失",
|
||
zap.Uints("package_ids", pkgIDs),
|
||
zap.Error(pkgErr))
|
||
}
|
||
pkgMap := make(map[uint]*model.Package, len(packages))
|
||
for _, p := range packages {
|
||
pkgMap[p.ID] = p
|
||
}
|
||
|
||
all := make([]*dto.AssetPackageResponse, 0, len(usages))
|
||
for _, u := range usages {
|
||
pkg := pkgMap[u.PackageID]
|
||
ratio := 1.0
|
||
pkgName := ""
|
||
pkgType := ""
|
||
if pkg != nil {
|
||
ratio = safeVirtualRatio(pkg.VirtualRatio)
|
||
pkgName = pkg.PackageName
|
||
pkgType = pkg.PackageType
|
||
}
|
||
|
||
item := &dto.AssetPackageResponse{
|
||
PackageUsageID: u.ID,
|
||
PackageID: u.PackageID,
|
||
PackageName: pkgName,
|
||
PackageType: pkgType,
|
||
UsageType: u.UsageType,
|
||
Status: u.Status,
|
||
StatusName: packageStatusName(u.Status),
|
||
DataLimitMB: u.DataLimitMB,
|
||
VirtualLimitMB: int64(float64(u.DataLimitMB) / ratio),
|
||
DataUsageMB: u.DataUsageMB,
|
||
VirtualUsedMB: float64(u.DataUsageMB) / ratio,
|
||
VirtualRemainMB: float64(u.DataLimitMB-u.DataUsageMB) / ratio,
|
||
VirtualRatio: ratio,
|
||
ActivatedAt: nonZeroTimePtr(u.ActivatedAt),
|
||
ExpiresAt: nonZeroTimePtr(u.ExpiresAt),
|
||
MasterUsageID: u.MasterUsageID,
|
||
Priority: u.Priority,
|
||
CreatedAt: u.CreatedAt,
|
||
}
|
||
all = append(all, item)
|
||
}
|
||
|
||
// 按 created_at DESC 排序
|
||
sort.Slice(all, func(i, j int) bool {
|
||
return all[i].CreatedAt.After(all[j].CreatedAt)
|
||
})
|
||
|
||
total := int64(len(all))
|
||
offset := (page - 1) * pageSize
|
||
end := offset + pageSize
|
||
if offset >= len(all) {
|
||
offset = len(all)
|
||
}
|
||
if end > len(all) {
|
||
end = len(all)
|
||
}
|
||
items := all[offset:end]
|
||
|
||
return &dto.AssetPackagesResult{
|
||
Total: total,
|
||
Page: page,
|
||
PageSize: pageSize,
|
||
Items: items,
|
||
}, nil
|
||
}
|
||
|
||
// GetCurrentPackage 获取资产当前生效的主套餐
|
||
func (s *Service) GetCurrentPackage(ctx context.Context, assetType string, id uint) (*dto.AssetPackageResponse, error) {
|
||
carrierType := assetType
|
||
if assetType == "card" {
|
||
carrierType = "iot_card"
|
||
}
|
||
|
||
usage, err := s.packageUsageStore.GetActiveMainPackage(ctx, carrierType, id)
|
||
if err != nil {
|
||
// 记录不存在表示当前无生效套餐，属于正常业务状态，返回 nil 而非错误
|
||
// 其他 DB 错误才作为服务端错误处理
|
||
if stderrors.Is(err, gorm.ErrRecordNotFound) {
|
||
return nil, nil
|
||
}
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询当前生效套餐失败")
|
||
}
|
||
|
||
pkg, pkgErr := s.packageStore.GetByID(ctx, usage.PackageID)
|
||
ratio := 1.0
|
||
pkgName := ""
|
||
pkgType := ""
|
||
if pkgErr == nil && pkg != nil {
|
||
ratio = safeVirtualRatio(pkg.VirtualRatio)
|
||
pkgName = pkg.PackageName
|
||
pkgType = pkg.PackageType
|
||
}
|
||
|
||
return &dto.AssetPackageResponse{
|
||
PackageUsageID: usage.ID,
|
||
PackageID: usage.PackageID,
|
||
PackageName: pkgName,
|
||
PackageType: pkgType,
|
||
UsageType: usage.UsageType,
|
||
Status: usage.Status,
|
||
StatusName: packageStatusName(usage.Status),
|
||
DataLimitMB: usage.DataLimitMB,
|
||
VirtualLimitMB: int64(float64(usage.DataLimitMB) / ratio),
|
||
DataUsageMB: usage.DataUsageMB,
|
||
VirtualUsedMB: float64(usage.DataUsageMB) / ratio,
|
||
VirtualRemainMB: float64(usage.DataLimitMB-usage.DataUsageMB) / ratio,
|
||
VirtualRatio: ratio,
|
||
ActivatedAt: nonZeroTimePtr(usage.ActivatedAt),
|
||
ExpiresAt: nonZeroTimePtr(usage.ExpiresAt),
|
||
MasterUsageID: usage.MasterUsageID,
|
||
Priority: usage.Priority,
|
||
CreatedAt: usage.CreatedAt,
|
||
}, nil
|
||
}
|
||
|
||
// getDeviceProtectStatus 查询设备保护期状态
|
||
func (s *Service) getDeviceProtectStatus(ctx context.Context, deviceID uint) string {
|
||
stopKey := constants.RedisDeviceProtectKey(deviceID, "stop")
|
||
startKey := constants.RedisDeviceProtectKey(deviceID, "start")
|
||
if s.redis.Exists(ctx, stopKey).Val() > 0 {
|
||
return "stop"
|
||
}
|
||
if s.redis.Exists(ctx, startKey).Val() > 0 {
|
||
return "start"
|
||
}
|
||
return "none"
|
||
}
|
||
|
||
// nonZeroTimePtr 将非零时间转为指针，零值返回 nil（避免序列化出历史时区偏移 +08:05）
|
||
func nonZeroTimePtr(t time.Time) *time.Time {
|
||
if t.IsZero() {
|
||
return nil
|
||
}
|
||
return &t
|
||
}
|
||
|
||
// safeVirtualRatio 安全获取虚流量比例，避免除零
|
||
func safeVirtualRatio(ratio float64) float64 {
|
||
if ratio <= 0 {
|
||
return 1.0
|
||
}
|
||
return ratio
|
||
}
|
||
|
||
// packageStatusName 套餐状态码转中文名称
|
||
func packageStatusName(status int) string {
|
||
switch status {
|
||
case 0:
|
||
return "待生效"
|
||
case 1:
|
||
return "生效中"
|
||
case 2:
|
||
return "已用完"
|
||
case 3:
|
||
return "已过期"
|
||
case 4:
|
||
return "已失效"
|
||
default:
|
||
return "未知"
|
||
}
|
||
}
|