1170 lines
37 KiB
Go
1170 lines
37 KiB
Go
// Package asset 提供统一的资产查询与操作服务
|
||
// 资产包含两种类型：IoT卡(card)和设备(device)
|
||
// 支持资产解析、实时状态查询、网关刷新、套餐查询等功能
|
||
package asset
|
||
|
||
import (
|
||
"context"
|
||
stderrors "errors"
|
||
"sort"
|
||
"strconv"
|
||
"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
|
||
orderStore *postgres.OrderStore
|
||
orderItemStore *postgres.OrderItemStore
|
||
exchangeOrderStore *postgres.ExchangeOrderStore
|
||
redis *redis.Client
|
||
iotCardService IotCardRefresher
|
||
gatewayClient *gateway.Client
|
||
assetIdentifierStore *postgres.AssetIdentifierStore
|
||
}
|
||
|
||
// 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,
|
||
assetIdentifierStore *postgres.AssetIdentifierStore,
|
||
orderStore *postgres.OrderStore,
|
||
orderItemStore *postgres.OrderItemStore,
|
||
exchangeOrderStore *postgres.ExchangeOrderStore,
|
||
) *Service {
|
||
return &Service{
|
||
db: db,
|
||
deviceStore: deviceStore,
|
||
iotCardStore: iotCardStore,
|
||
packageUsageStore: packageUsageStore,
|
||
packageStore: packageStore,
|
||
packageSeriesStore: packageSeriesStore,
|
||
deviceSimBindingStore: deviceSimBindingStore,
|
||
shopStore: shopStore,
|
||
orderStore: orderStore,
|
||
orderItemStore: orderItemStore,
|
||
exchangeOrderStore: exchangeOrderStore,
|
||
redis: redisClient,
|
||
iotCardService: iotCardService,
|
||
gatewayClient: gatewayClient,
|
||
assetIdentifierStore: assetIdentifierStore,
|
||
}
|
||
}
|
||
|
||
// Resolve 通过任意标识符解析资产
|
||
// 主路径：查注册表（精确匹配 ICCID 或 VirtualNo）
|
||
// Fallback：原有跨表 OR 查询（处理 IMEI/SN/MSISDN 等非注册标识符）
|
||
func (s *Service) Resolve(ctx context.Context, identifier string) (*dto.AssetResolveResponse, error) {
|
||
if s.assetIdentifierStore != nil {
|
||
regRecord, regErr := s.assetIdentifierStore.FindByIdentifier(ctx, identifier)
|
||
if regErr == nil && regRecord != nil {
|
||
switch regRecord.AssetType {
|
||
case model.AssetTypeDevice:
|
||
device, devErr := s.deviceStore.GetByID(ctx, regRecord.AssetID)
|
||
if devErr == nil && device != nil {
|
||
resp, buildErr := s.buildDeviceResolveResponse(ctx, device)
|
||
if buildErr == nil {
|
||
resp.Identifier = identifier
|
||
}
|
||
return resp, buildErr
|
||
}
|
||
case model.AssetTypeIotCard:
|
||
card, cardErr := s.iotCardStore.GetByID(ctx, regRecord.AssetID)
|
||
if cardErr == nil && card != nil {
|
||
resp, buildErr := s.buildCardResolveResponse(ctx, card)
|
||
if buildErr == nil {
|
||
resp.Identifier = identifier
|
||
}
|
||
return resp, buildErr
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
device, err := s.deviceStore.GetByIdentifier(ctx, identifier)
|
||
if err == nil && device != nil {
|
||
resp, buildErr := s.buildDeviceResolveResponse(ctx, device)
|
||
if buildErr == nil {
|
||
resp.Identifier = identifier
|
||
}
|
||
return resp, buildErr
|
||
}
|
||
|
||
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 {
|
||
resp, buildErr := s.buildCardResolveResponse(ctx, &card)
|
||
if buildErr == nil {
|
||
resp.Identifier = identifier
|
||
}
|
||
return resp, buildErr
|
||
}
|
||
|
||
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,
|
||
StatusName: constants.GetDeviceStatusName(device.Status),
|
||
BatchNo: device.BatchNo,
|
||
ShopID: device.ShopID,
|
||
SeriesID: device.SeriesID,
|
||
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,
|
||
EnablePolling: device.EnablePolling,
|
||
RealnamePolicy: device.RealnamePolicy,
|
||
}
|
||
|
||
// 查绑定卡
|
||
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,
|
||
RealNameAt: c.FirstRealnameAt,
|
||
SlotPosition: slotMap[c.ID],
|
||
IsCurrent: isCurrentMap[c.ID],
|
||
CarrierID: c.CarrierID,
|
||
CarrierType: c.CarrierType,
|
||
CarrierName: c.CarrierName,
|
||
RealnamePolicy: c.RealnamePolicy,
|
||
GatewayExtend: c.GatewayExtend,
|
||
LastSyncTime: c.LastSyncTime,
|
||
LastDataCheckAt: c.LastDataCheckAt,
|
||
LastRealNameCheckAt: c.LastRealNameCheckAt,
|
||
LastCardStatusCheckAt: c.LastCardStatusCheckAt,
|
||
})
|
||
}
|
||
|
||
// RealNameStatus 以当前使用卡为准；无当前卡则视为未实名
|
||
for _, c := range cards {
|
||
if isCurrentMap[c.ID] {
|
||
resp.RealNameStatus = c.RealNameStatus
|
||
break
|
||
}
|
||
}
|
||
// RealNameAt 取所有绑定卡中最早的实名时间
|
||
for _, c := range cards {
|
||
if c.FirstRealnameAt == nil {
|
||
continue
|
||
}
|
||
if resp.RealNameAt == nil || c.FirstRealnameAt.Before(*resp.RealNameAt) {
|
||
t := *c.FirstRealnameAt
|
||
resp.RealNameAt = &t
|
||
}
|
||
}
|
||
}
|
||
|
||
// 查当前主套餐
|
||
s.fillPackageInfo(ctx, resp, "device", device.ID)
|
||
|
||
activationStatuses, err := s.deviceStore.GetActivationStatusMap(ctx, []uint{device.ID})
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询设备激活状态失败")
|
||
}
|
||
resp.ActivationStatus = activationStatuses[device.ID]
|
||
resp.ActivationStatusName = constants.GetActivationStatusName(resp.ActivationStatus)
|
||
|
||
// 查 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,
|
||
StatusName: constants.GetIotCardStatusName(card.Status),
|
||
BatchNo: card.BatchNo,
|
||
ShopID: card.ShopID,
|
||
SeriesID: card.SeriesID,
|
||
ActivatedAt: card.ActivatedAt,
|
||
CreatedAt: card.CreatedAt,
|
||
UpdatedAt: card.UpdatedAt,
|
||
RealNameStatus: card.RealNameStatus,
|
||
RealNameAt: card.FirstRealnameAt,
|
||
RealnamePolicy: card.RealnamePolicy,
|
||
NetworkStatus: card.NetworkStatus,
|
||
GatewayExtend: card.GatewayExtend,
|
||
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,
|
||
ActivationStatusName: constants.GetActivationStatusName(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
|
||
}
|
||
|
||
resp.CurrentPackageUsageID = &usage.ID
|
||
resp.CurrentPackage = usage.PackageName
|
||
resp.CurrentPackageActivatedAt = usage.ActivatedAt
|
||
resp.CurrentPackageExpiresAt = usage.ExpiresAt
|
||
if resp.CurrentPackage == "" {
|
||
pkg, pkgErr := s.packageStore.GetByID(ctx, usage.PackageID)
|
||
if pkgErr == nil && pkg != nil {
|
||
resp.CurrentPackage = pkg.PackageName
|
||
}
|
||
}
|
||
|
||
metrics := usage.BuildTrafficMetrics()
|
||
resp.RealTotalMB = metrics.RealTotalMB
|
||
resp.RealUsedMB = metrics.RealUsedMB
|
||
resp.VirtualTotalMB = metrics.VirtualTotalMB
|
||
resp.VirtualUsedMB = metrics.VirtualUsedMB
|
||
resp.ReductionPct = metrics.ReductionPct
|
||
resp.EnableVirtualData = usage.EnableVirtualDataSnapshot
|
||
}
|
||
|
||
// 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.GatewayExtend = card.GatewayExtend
|
||
resp.RealNameStatus = card.RealNameStatus
|
||
resp.CurrentMonthUsageMB = card.CurrentMonthUsageMB
|
||
resp.LastGatewayReadingMB = card.LastGatewayReadingMB
|
||
resp.LastSyncTime = card.LastSyncTime
|
||
resp.LastDataCheckAt = card.LastDataCheckAt
|
||
resp.LastRealNameCheckAt = card.LastRealNameCheckAt
|
||
resp.LastCardStatusCheckAt = card.LastCardStatusCheckAt
|
||
|
||
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],
|
||
CarrierID: c.CarrierID,
|
||
CarrierType: c.CarrierType,
|
||
CarrierName: c.CarrierName,
|
||
RealnamePolicy: c.RealnamePolicy,
|
||
GatewayExtend: c.GatewayExtend,
|
||
LastSyncTime: c.LastSyncTime,
|
||
LastDataCheckAt: c.LastDataCheckAt,
|
||
LastRealNameCheckAt: c.LastRealNameCheckAt,
|
||
LastCardStatusCheckAt: c.LastCardStatusCheckAt,
|
||
})
|
||
}
|
||
}
|
||
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}
|
||
}
|
||
|
||
// 实时状态成功后异步回写 DB，保持 Resolve 接口的缓存与 Gateway 同步
|
||
// 使用 context.Background() 避免请求结束后 ctx 取消导致写入失败
|
||
go s.updateDeviceFromSyncInfo(context.Background(), deviceID, syncResp)
|
||
|
||
return mapSyncRespToDeviceGatewayInfo(syncResp)
|
||
}
|
||
|
||
// mapSyncRespToDeviceGatewayInfo 将 Gateway SyncDeviceInfoResp 映射为 B 端 DeviceGatewayInfo DTO
|
||
// 使用指针字段，未赋值的字段保持 nil（omitempty）
|
||
func mapSyncRespToDeviceGatewayInfo(r *gateway.SyncDeviceInfoResp) *dto.DeviceGatewayInfo {
|
||
info := &dto.DeviceGatewayInfo{
|
||
OnlineStatus: flexIntPtr(r.OnlineStatus),
|
||
RunTime: flexStrPtr(r.RunTime),
|
||
ConnectTime: flexStrPtr(r.ConnectTime),
|
||
LastOnlineTime: flexStrPtr(r.LastOnlineTime),
|
||
LastUpdateTime: flexStrPtr(r.LastUpdateTime),
|
||
Rsrp: flexIntPtr(r.Rsrp),
|
||
Rsrq: flexIntPtr(r.Rsrq),
|
||
Rssi: flexStrPtr(r.RSSI),
|
||
Sinr: flexIntPtr(r.Sinr),
|
||
SSID: flexStrPtr(r.SSID),
|
||
WifiEnabled: flexBoolPtr(r.WifiEnabled),
|
||
WifiPassword: flexStrPtr(r.WifiPassword),
|
||
IPAddress: flexStrPtr(r.IPAddress),
|
||
WANIP: flexStrPtr(r.WANIP),
|
||
LANIP: flexStrPtr(r.LANIP),
|
||
MACAddress: flexStrPtr(r.MacAddress),
|
||
DailyUsage: flexStrPtr(r.DailyUsage),
|
||
DLStats: flexStrPtr(r.DLStats),
|
||
ULStats: flexStrPtr(r.ULStats),
|
||
LimitSpeed: flexIntPtr(r.LimitSpeed),
|
||
CurrentIccid: flexStrPtr(r.CurrentIccid),
|
||
MaxClients: flexIntPtr(r.MaxClients),
|
||
ClientNumber: flexIntPtr(r.ClientNumber),
|
||
SoftwareVersion: flexStrPtr(r.SoftwareVersion),
|
||
SwitchMode: flexStrPtr(r.SwitchMode),
|
||
SyncInterval: flexIntPtr(r.SyncInterval),
|
||
DeviceID: flexStrPtr(r.DeviceID),
|
||
DeviceName: flexStrPtr(r.DeviceName),
|
||
DeviceType: flexStrPtr(r.DeviceType),
|
||
IMEI: flexStrPtr(r.IMEI),
|
||
IMSI: flexStrPtr(r.IMSI),
|
||
Status: flexIntPtr(r.Status),
|
||
}
|
||
signalQuality, signalBadReason := buildSignalSummary(info.Rsrp, info.Rsrq, info.Rssi, info.Sinr)
|
||
info.SignalQuality = strPtr(signalQuality)
|
||
info.SignalBadReason = strPtr(signalBadReason)
|
||
if r.BatteryLevel != nil {
|
||
n := int(*r.BatteryLevel)
|
||
info.BatteryLevel = &n
|
||
}
|
||
return info
|
||
}
|
||
|
||
// strPtr 将空字符串转为 nil，非空字符串返回指针
|
||
// 避免 JSON 响应中出现大量空字符串字段（omitempty 对空字符串无效）
|
||
func strPtr(s string) *string {
|
||
if s == "" {
|
||
return nil
|
||
}
|
||
return &s
|
||
}
|
||
|
||
// flexStrPtr 将 FlexString 转为字符串指针
|
||
func flexStrPtr(s gateway.FlexString) *string {
|
||
return strPtr(string(s))
|
||
}
|
||
|
||
func flexBoolPtr(fb gateway.FlexBool) *bool {
|
||
b := bool(fb)
|
||
return &b
|
||
}
|
||
|
||
func flexIntPtr(fi gateway.FlexInt) *int {
|
||
n := int(fi)
|
||
return &n
|
||
}
|
||
|
||
// 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":
|
||
totalStart := time.Now()
|
||
|
||
// 检查冷却期
|
||
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, "查询绑定卡失败")
|
||
}
|
||
|
||
cardIDs := make([]uint, 0, len(bindings))
|
||
for _, b := range bindings {
|
||
cardIDs = append(cardIDs, b.IotCardID)
|
||
}
|
||
cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "查询绑定卡详情失败")
|
||
}
|
||
|
||
cardMap := make(map[uint]*model.IotCard, len(cards))
|
||
for _, card := range cards {
|
||
cardMap[card.ID] = card
|
||
}
|
||
|
||
cardRefreshStart := time.Now()
|
||
refreshedCardCount := 0
|
||
for _, b := range bindings {
|
||
card, ok := cardMap[b.IotCardID]
|
||
if !ok {
|
||
logger.GetAppLogger().Warn("刷新设备绑定卡失败：未找到卡信息",
|
||
zap.Uint("device_id", id),
|
||
zap.Uint("card_id", b.IotCardID),
|
||
)
|
||
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))
|
||
continue
|
||
}
|
||
refreshedCardCount++
|
||
}
|
||
cardRefreshDuration := time.Since(cardRefreshStart)
|
||
|
||
// 设置冷却 Key
|
||
s.redis.Set(ctx, cooldownKey, 1, constants.DeviceRefreshCooldownDuration)
|
||
|
||
realtimeStart := time.Now()
|
||
result, realtimeErr := s.GetRealtimeStatus(ctx, "device", id)
|
||
logger.GetAppLogger().Info("资产刷新完成",
|
||
zap.Uint("device_id", id),
|
||
zap.Int("binding_count", len(bindings)),
|
||
zap.Int("refreshed_card_count", refreshedCardCount),
|
||
zap.Duration("card_refresh_duration", cardRefreshDuration),
|
||
zap.Duration("realtime_status_duration", time.Since(realtimeStart)),
|
||
zap.Duration("total_duration", time.Since(totalStart)),
|
||
)
|
||
if realtimeErr != nil {
|
||
return nil, realtimeErr
|
||
}
|
||
return result, nil
|
||
|
||
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()
|
||
|
||
// Gateway 时间字段可能返回 RFC3339 或 Unix 时间戳，统一解析后再回写数据库
|
||
lastOnlineTime := parseGatewayTime(resp.LastOnlineTime)
|
||
|
||
// 更新设备 5 个存储字段
|
||
updates := map[string]any{
|
||
"online_status": int(resp.OnlineStatus),
|
||
"software_version": string(resp.SoftwareVersion),
|
||
"switch_mode": string(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 标识（事务原子操作，按 current_slot_number 逻辑槽位更新）
|
||
if err := s.deviceSimBindingStore.UpdateIsCurrentByDeviceID(ctx, deviceID, int(resp.CurrentSlotNo)); err != nil {
|
||
logger.GetAppLogger().Warn("sync-info 更新 is_current 失败",
|
||
zap.Uint("device_id", deviceID),
|
||
zap.Int("current_slot_number", int(resp.CurrentSlotNo)),
|
||
zap.Error(err))
|
||
}
|
||
}
|
||
|
||
// parseGatewayTime 兼容解析 Gateway 时间字段
|
||
// 支持 RFC3339 字符串、Unix 秒时间戳、Unix 毫秒时间戳。
|
||
func parseGatewayTime(raw gateway.FlexString) *time.Time {
|
||
value := string(raw)
|
||
if value == "" {
|
||
return nil
|
||
}
|
||
|
||
if t, err := time.Parse(time.RFC3339, value); err == nil {
|
||
return &t
|
||
}
|
||
|
||
// 兼容网关返回的纯数字时间戳（秒或毫秒）
|
||
ts, err := strconv.ParseInt(value, 10, 64)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
|
||
var t time.Time
|
||
if len(value) >= 13 {
|
||
t = time.UnixMilli(ts)
|
||
} else {
|
||
t = time.Unix(ts, 0)
|
||
}
|
||
return &t
|
||
}
|
||
|
||
// GetPackages 获取资产的所有套餐列表（支持分页和状态筛选）
|
||
// page 默认 1，pageSize 默认 50，pageSize 最大 100
|
||
func (s *Service) GetPackages(ctx context.Context, assetType string, id uint, page, pageSize int, status *int) (*dto.AssetPackagesResult, error) {
|
||
// 分页参数边界处理
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 {
|
||
pageSize = 50
|
||
}
|
||
if pageSize > 100 {
|
||
pageSize = 100
|
||
}
|
||
if status != nil && (*status < constants.PackageUsageStatusPending || *status > constants.PackageUsageStatusInvalidated) {
|
||
return nil, errors.New(errors.CodeInvalidParam, "套餐状态非法")
|
||
}
|
||
|
||
// assetType 对应 Store 中的 carrierType：card→iot_card, device→device
|
||
carrierType := assetType
|
||
if assetType == "card" {
|
||
carrierType = "iot_card"
|
||
}
|
||
|
||
usages, err := s.packageUsageStore.ListByCarrier(ctx, carrierType, id, status)
|
||
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]
|
||
metrics := u.BuildTrafficMetrics()
|
||
pkgName := u.PackageName
|
||
pkgType := ""
|
||
expiryBase := ""
|
||
if pkg != nil {
|
||
if pkgName == "" {
|
||
pkgName = pkg.PackageName
|
||
}
|
||
pkgType = pkg.PackageType
|
||
expiryBase = pkg.ExpiryBase
|
||
}
|
||
item := &dto.AssetPackageResponse{
|
||
PackageUsageID: u.ID,
|
||
PackageID: u.PackageID,
|
||
PackageName: pkgName,
|
||
PackageType: pkgType,
|
||
ExpiryBase: expiryBase,
|
||
OrderID: u.OrderID,
|
||
OrderNo: u.OrderNo,
|
||
RefundID: u.RefundID,
|
||
RefundNo: u.RefundNo,
|
||
UsageType: u.UsageType,
|
||
Status: u.Status,
|
||
StatusName: packageStatusName(u.Status),
|
||
RealTotalMB: metrics.RealTotalMB,
|
||
RealUsedMB: metrics.RealUsedMB,
|
||
VirtualTotalMB: metrics.VirtualTotalMB,
|
||
VirtualUsedMB: metrics.VirtualUsedMB,
|
||
ReductionPct: metrics.ReductionPct,
|
||
EnableVirtualData: u.EnableVirtualDataSnapshot,
|
||
ActivatedAt: u.ActivatedAt,
|
||
ExpiresAt: u.ExpiresAt,
|
||
MasterUsageID: u.MasterUsageID,
|
||
Priority: u.Priority,
|
||
PaidAmount: u.PaidAmount,
|
||
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)
|
||
metrics := usage.BuildTrafficMetrics()
|
||
pkgName := usage.PackageName
|
||
pkgType := ""
|
||
expiryBase := ""
|
||
if pkgErr == nil && pkg != nil {
|
||
if pkgName == "" {
|
||
pkgName = pkg.PackageName
|
||
}
|
||
pkgType = pkg.PackageType
|
||
expiryBase = pkg.ExpiryBase
|
||
}
|
||
return &dto.AssetPackageResponse{
|
||
PackageUsageID: usage.ID,
|
||
PackageID: usage.PackageID,
|
||
PackageName: pkgName,
|
||
PackageType: pkgType,
|
||
ExpiryBase: expiryBase,
|
||
OrderID: usage.OrderID,
|
||
OrderNo: usage.OrderNo,
|
||
RefundID: usage.RefundID,
|
||
RefundNo: usage.RefundNo,
|
||
UsageType: usage.UsageType,
|
||
Status: usage.Status,
|
||
StatusName: packageStatusName(usage.Status),
|
||
RealTotalMB: metrics.RealTotalMB,
|
||
RealUsedMB: metrics.RealUsedMB,
|
||
VirtualTotalMB: metrics.VirtualTotalMB,
|
||
VirtualUsedMB: metrics.VirtualUsedMB,
|
||
ReductionPct: metrics.ReductionPct,
|
||
EnableVirtualData: usage.EnableVirtualDataSnapshot,
|
||
ActivatedAt: usage.ActivatedAt,
|
||
ExpiresAt: usage.ExpiresAt,
|
||
MasterUsageID: usage.MasterUsageID,
|
||
Priority: usage.Priority,
|
||
PaidAmount: usage.PaidAmount,
|
||
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
|
||
}
|
||
|
||
// GetOrders 查询资产历史订单，支持换货链跨代追溯
|
||
// page/pageSize 仅对本代订单生效；前代订单每代最多返回20条
|
||
// 最多追溯10代，超出后 truncated=true
|
||
func (s *Service) GetOrders(ctx context.Context, identifier string, page, pageSize int, includePrevious bool) (*dto.AssetOrdersResponse, error) {
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 {
|
||
pageSize = 20
|
||
}
|
||
if pageSize > 100 {
|
||
pageSize = 100
|
||
}
|
||
|
||
asset, err := s.Resolve(ctx, identifier)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
currentGeneration := s.resolveAssetGeneration(ctx, asset.AssetType, asset.AssetID)
|
||
|
||
orders, total, err := s.orderStore.ListByAssetIdentifier(ctx, identifier, page, pageSize)
|
||
if err != nil {
|
||
return nil, errors.Wrap(errors.CodeInternalError, err, "查询本代订单失败")
|
||
}
|
||
|
||
orderItems := s.fetchOrderItemsMap(ctx, orders)
|
||
currentItems := make([]*dto.AssetOrderItem, 0, len(orders))
|
||
for _, o := range orders {
|
||
currentItems = append(currentItems, buildAssetOrderItem(o, orderItems[o.ID]))
|
||
}
|
||
|
||
resp := &dto.AssetOrdersResponse{
|
||
CurrentGeneration: &dto.GenerationOrders{
|
||
Generation: currentGeneration,
|
||
Identifier: identifier,
|
||
AssetType: asset.AssetType,
|
||
Total: total,
|
||
Page: page,
|
||
PageSize: pageSize,
|
||
Items: currentItems,
|
||
},
|
||
PreviousGenerations: nil,
|
||
Truncated: false,
|
||
}
|
||
|
||
if !includePrevious {
|
||
return resp, nil
|
||
}
|
||
|
||
prevGens, truncated := s.tracePreviousGenerations(ctx, asset.AssetType, asset.AssetID)
|
||
resp.PreviousGenerations = prevGens
|
||
resp.Truncated = truncated
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *Service) resolveAssetGeneration(ctx context.Context, assetType string, assetID uint) int {
|
||
switch assetType {
|
||
case "card":
|
||
card, err := s.iotCardStore.GetByID(ctx, assetID)
|
||
if err == nil && card != nil {
|
||
return card.Generation
|
||
}
|
||
case "device":
|
||
device, err := s.deviceStore.GetByID(ctx, assetID)
|
||
if err == nil && device != nil {
|
||
return device.Generation
|
||
}
|
||
}
|
||
return 1
|
||
}
|
||
|
||
// tracePreviousGenerations 通过换货链逆向追溯前代资产的订单，最多追溯10代
|
||
func (s *Service) tracePreviousGenerations(ctx context.Context, assetType string, assetID uint) ([]*dto.PreviousGenerationOrders, bool) {
|
||
const maxDepth = 10
|
||
const prevPageSize = 20
|
||
|
||
prevGens := make([]*dto.PreviousGenerationOrders, 0)
|
||
currentType := assetType
|
||
currentID := assetID
|
||
truncated := false
|
||
|
||
for i := 0; i < maxDepth; i++ {
|
||
// 转换为 ExchangeOrder 中使用的资产类型（card→iot_card）
|
||
storeType := currentType
|
||
if storeType == "card" {
|
||
storeType = "iot_card"
|
||
}
|
||
|
||
exchOrder, err := s.exchangeOrderStore.FindByNewAssetID(ctx, storeType, currentID)
|
||
if err != nil || exchOrder == nil {
|
||
break
|
||
}
|
||
|
||
oldOrders, oldTotal, err := s.orderStore.ListByAssetIdentifier(ctx, exchOrder.OldAssetIdentifier, 1, prevPageSize)
|
||
if err != nil {
|
||
logger.GetAppLogger().Warn("查询前代订单失败",
|
||
zap.String("old_identifier", exchOrder.OldAssetIdentifier),
|
||
zap.Error(err))
|
||
oldOrders = nil
|
||
oldTotal = 0
|
||
}
|
||
|
||
oldItems := s.fetchOrderItemsMap(ctx, oldOrders)
|
||
orderItems := make([]*dto.AssetOrderItem, 0, len(oldOrders))
|
||
for _, o := range oldOrders {
|
||
orderItems = append(orderItems, buildAssetOrderItem(o, oldItems[o.ID]))
|
||
}
|
||
|
||
oldAssetType := exchOrder.OldAssetType
|
||
if oldAssetType == "iot_card" {
|
||
oldAssetType = "card"
|
||
}
|
||
|
||
oldGeneration := s.resolveAssetGeneration(ctx, oldAssetType, exchOrder.OldAssetID)
|
||
|
||
prevGens = append(prevGens, &dto.PreviousGenerationOrders{
|
||
Generation: oldGeneration,
|
||
Identifier: exchOrder.OldAssetIdentifier,
|
||
AssetType: oldAssetType,
|
||
ExchangeNo: exchOrder.ExchangeNo,
|
||
ExchangedAt: exchOrder.UpdatedAt,
|
||
Total: oldTotal,
|
||
Items: orderItems,
|
||
})
|
||
|
||
currentType = oldAssetType
|
||
currentID = exchOrder.OldAssetID
|
||
|
||
if i == maxDepth-1 {
|
||
truncated = true
|
||
}
|
||
}
|
||
|
||
return prevGens, truncated
|
||
}
|
||
|
||
// fetchOrderItemsMap 批量查询订单明细并按 orderID 分组
|
||
func (s *Service) fetchOrderItemsMap(ctx context.Context, orders []*model.Order) map[uint][]*model.OrderItem {
|
||
if len(orders) == 0 {
|
||
return nil
|
||
}
|
||
orderIDs := make([]uint, 0, len(orders))
|
||
for _, o := range orders {
|
||
orderIDs = append(orderIDs, o.ID)
|
||
}
|
||
allItems, err := s.orderItemStore.ListByOrderIDs(ctx, orderIDs)
|
||
if err != nil {
|
||
logger.GetAppLogger().Warn("批量查询订单明细失败", zap.Error(err))
|
||
return nil
|
||
}
|
||
result := make(map[uint][]*model.OrderItem, len(orders))
|
||
for _, item := range allItems {
|
||
result[item.OrderID] = append(result[item.OrderID], item)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func buildAssetOrderItem(o *model.Order, items []*model.OrderItem) *dto.AssetOrderItem {
|
||
details := make([]*dto.AssetOrderItemDetail, 0, len(items))
|
||
for _, it := range items {
|
||
details = append(details, &dto.AssetOrderItemDetail{
|
||
PackageName: it.PackageName,
|
||
Quantity: it.Quantity,
|
||
UnitPrice: it.UnitPrice,
|
||
Amount: it.Amount,
|
||
})
|
||
}
|
||
return &dto.AssetOrderItem{
|
||
OrderNo: o.OrderNo,
|
||
OrderType: o.OrderType,
|
||
PaymentStatus: o.PaymentStatus,
|
||
PaymentStatusText: paymentStatusText(o.PaymentStatus),
|
||
TotalAmount: o.TotalAmount,
|
||
PaymentMethod: o.PaymentMethod,
|
||
PaidAt: o.PaidAt,
|
||
Generation: o.Generation,
|
||
Items: details,
|
||
CreatedAt: o.CreatedAt,
|
||
}
|
||
}
|
||
|
||
func paymentStatusText(status int) string {
|
||
switch status {
|
||
case 1:
|
||
return "待支付"
|
||
case 2:
|
||
return "已支付"
|
||
case 3:
|
||
return "已取消"
|
||
case 4:
|
||
return "已退款"
|
||
default:
|
||
return "未知"
|
||
}
|
||
}
|
||
|
||
// GetEffectiveRealnamePolicy 获取资产的有效实名认证策略
|
||
// 设备卡使用设备策略，单独卡使用卡策略
|
||
func GetEffectiveRealnamePolicy(card *model.IotCard, device *model.Device) string {
|
||
if device != nil {
|
||
return device.RealnamePolicy
|
||
}
|
||
if card != nil {
|
||
return card.RealnamePolicy
|
||
}
|
||
return constants.RealnamePolicyNone
|
||
}
|
||
|
||
// HasValidRechargeOrPaidOrder 检查资产在当前世代是否有有效充值或已支付订单
|
||
// 用于 after_order 策略的生效条件判断
|
||
func (s *Service) HasValidRechargeOrPaidOrder(ctx context.Context, assetType string, assetID uint) (bool, error) {
|
||
generation := s.resolveAssetGeneration(ctx, assetType, assetID)
|
||
|
||
if assetType == "card" {
|
||
var rechargeCount int64
|
||
err := s.db.WithContext(ctx).Model(&model.RechargeOrder{}).
|
||
Where("iot_card_id = ? AND generation = ? AND status = ?", assetID, generation, model.RechargeOrderStatusPaid).
|
||
Count(&rechargeCount).Error
|
||
if err != nil {
|
||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询卡充值订单失败")
|
||
}
|
||
if rechargeCount > 0 {
|
||
return true, nil
|
||
}
|
||
|
||
var orderCount int64
|
||
err = s.db.WithContext(ctx).Model(&model.Order{}).
|
||
Where("iot_card_id = ? AND generation = ? AND payment_status = ?", assetID, generation, model.PaymentStatusPaid).
|
||
Count(&orderCount).Error
|
||
if err != nil {
|
||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询卡订单失败")
|
||
}
|
||
if orderCount > 0 {
|
||
return true, nil
|
||
}
|
||
} else if assetType == "device" {
|
||
var rechargeCount int64
|
||
err := s.db.WithContext(ctx).Model(&model.RechargeOrder{}).
|
||
Where("device_id = ? AND generation = ? AND status = ?", assetID, generation, model.RechargeOrderStatusPaid).
|
||
Count(&rechargeCount).Error
|
||
if err != nil {
|
||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询设备充值订单失败")
|
||
}
|
||
if rechargeCount > 0 {
|
||
return true, nil
|
||
}
|
||
|
||
var orderCount int64
|
||
err = s.db.WithContext(ctx).Model(&model.Order{}).
|
||
Where("device_id = ? AND generation = ? AND payment_status = ?", assetID, generation, model.PaymentStatusPaid).
|
||
Count(&orderCount).Error
|
||
if err != nil {
|
||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询设备订单失败")
|
||
}
|
||
if orderCount > 0 {
|
||
return true, nil
|
||
}
|
||
}
|
||
|
||
return false, nil
|
||
}
|
||
|
||
// 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 "未知"
|
||
}
|
||
}
|