huang
b9c3875c08
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 7m3s
Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode) Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
478 lines
15 KiB
Go
478 lines
15 KiB
Go
// Package asset 提供统一的资产查询与操作服务
|
||
// 资产包含两种类型：IoT卡(card)和设备(device)
|
||
// 支持资产解析、实时状态查询、网关刷新、套餐查询等功能
|
||
package asset
|
||
|
||
import (
|
||
"context"
|
||
"sort"
|
||
|
||
"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
|
||
deviceSimBindingStore *postgres.DeviceSimBindingStore
|
||
shopStore *postgres.ShopStore
|
||
redis *redis.Client
|
||
iotCardService IotCardRefresher
|
||
}
|
||
|
||
// New 创建资产服务实例
|
||
func New(
|
||
db *gorm.DB,
|
||
deviceStore *postgres.DeviceStore,
|
||
iotCardStore *postgres.IotCardStore,
|
||
packageUsageStore *postgres.PackageUsageStore,
|
||
packageStore *postgres.PackageStore,
|
||
deviceSimBindingStore *postgres.DeviceSimBindingStore,
|
||
shopStore *postgres.ShopStore,
|
||
redisClient *redis.Client,
|
||
iotCardService IotCardRefresher,
|
||
) *Service {
|
||
return &Service{
|
||
db: db,
|
||
deviceStore: deviceStore,
|
||
iotCardStore: iotCardStore,
|
||
packageUsageStore: packageUsageStore,
|
||
packageStore: packageStore,
|
||
deviceSimBindingStore: deviceSimBindingStore,
|
||
shopStore: shopStore,
|
||
redis: redisClient,
|
||
iotCardService: iotCardService,
|
||
}
|
||
}
|
||
|
||
// 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,
|
||
}
|
||
|
||
// 查绑定卡
|
||
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))
|
||
for _, b := range bindings {
|
||
cardIDs = append(cardIDs, b.IotCardID)
|
||
slotMap[b.IotCardID] = b.SlotPosition
|
||
}
|
||
cards, _ := s.iotCardStore.GetByIDs(ctx, cardIDs)
|
||
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],
|
||
})
|
||
}
|
||
}
|
||
|
||
// 查当前主套餐
|
||
s.fillPackageInfo(ctx, resp, "device", device.ID)
|
||
|
||
// 查 shop 名称
|
||
s.fillShopName(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)
|
||
|
||
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
|
||
}
|
||
}
|
||
|
||
// 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))
|
||
for _, b := range bindings {
|
||
cardIDs = append(cardIDs, b.IotCardID)
|
||
slotMap[b.IotCardID] = b.SlotPosition
|
||
}
|
||
cards, _ := s.iotCardStore.GetByIDs(ctx, cardIDs)
|
||
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],
|
||
})
|
||
}
|
||
}
|
||
resp.DeviceProtectStatus = s.getDeviceProtectStatus(ctx, id)
|
||
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
|
||
}
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// 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)
|
||
|
||
return s.GetRealtimeStatus(ctx, "device", id)
|
||
|
||
default:
|
||
return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
|
||
}
|
||
}
|
||
|
||
// GetPackages 获取资产的所有套餐列表
|
||
func (s *Service) GetPackages(ctx context.Context, assetType string, id uint) ([]*dto.AssetPackageResponse, error) {
|
||
// 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, _ := s.packageStore.GetByIDsUnscoped(ctx, pkgIDs)
|
||
pkgMap := make(map[uint]*model.Package, len(packages))
|
||
for _, p := range packages {
|
||
pkgMap[p.ID] = p
|
||
}
|
||
|
||
result := 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: u.ActivatedAt,
|
||
ExpiresAt: u.ExpiresAt,
|
||
MasterUsageID: u.MasterUsageID,
|
||
Priority: u.Priority,
|
||
CreatedAt: u.CreatedAt,
|
||
}
|
||
result = append(result, item)
|
||
}
|
||
|
||
// 按 created_at DESC 排序
|
||
sort.Slice(result, func(i, j int) bool {
|
||
return result[i].CreatedAt.After(result[j].CreatedAt)
|
||
})
|
||
|
||
return result, 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 {
|
||
return nil, errors.New(errors.CodeNotFound, "当前无生效套餐")
|
||
}
|
||
|
||
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: usage.ActivatedAt,
|
||
ExpiresAt: 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"
|
||
}
|
||
|
||
// 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 "未知"
|
||
}
|
||
}
|