OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

Merge remote-tracking branch 'origin/main' into multi-tenant

Browse Source
This commit is contained in:
TsMask
2024-12-24 17:24:24 +08:00
parent 73c40d95d6 30bd6c85a2
commit 10d198cb87
119 changed files with 3113 additions and 1328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/modules/common/controller/common.go
View File

@@ -10,15 +10,14 @@ import (
// 实例化控制层 CommontController 结构体
var NewCommont = &CommontController{
commontService: commonService.NewCommontImpl,
commontService: commonService.NewCommont,
}
// 通用请求
//
// PATH /
type CommontController struct {
// 通用请求服务
commontService commonService.ICommont
commontService *commonService.Commont // 通用请求服务
}
// 哈希加密
@@ -36,17 +35,12 @@ func (s *CommontController) I18n(c *gin.Context) {
i18nLang := i18n.TKey(language, "i18n")
hello := i18n.TKey(language, "hello")
ivs := i18n.TTemplate(language, "errorFields", nil)
errorFields := i18n.TTemplate(language, "errorFields", map[string]any{
"num": 1000,
"hello": "你好",
"h2o2": false,
"fileName": " ====",
errorFields := i18n.TTemplate(language, "dictData.errLabelExists", map[string]any{
"name": " ====",
})
c.JSON(200, map[string]any{
"lang": language,
"i18nLang": i18nLang,
"ivs": ivs,
"hello": hello,
"errorFields": errorFields,
})

4
src/modules/common/controller/file.go
View File

@@ -95,7 +95,7 @@ func (s *FileController) Upload(c *gin.Context) {
newFileName := upFilePath[strings.LastIndex(upFilePath, "/")+1:]
c.JSON(200, result.OkData(map[string]string{
"url": "http://" + c.Request.Host + upFilePath,
"url": "//" + c.Request.Host + upFilePath,
"fileName": upFilePath,
"newFileName": newFileName,
"originalFileName": formFile.Filename,
@@ -160,7 +160,7 @@ func (s *FileController) ChunkMerge(c *gin.Context) {
newFileName := mergeFilePath[strings.LastIndex(mergeFilePath, "/")+1:]
c.JSON(200, result.OkData(map[string]string{
"url": "http://" + c.Request.Host + mergeFilePath,
"url": "//" + c.Request.Host + mergeFilePath,
"fileName": mergeFilePath,
"newFileName": newFileName,
"originalFileName": body.FileName,

6
src/modules/common/controller/index.go
View File

@@ -3,7 +3,7 @@ package controller
import (
"fmt"
"be.ems/src/framework/config"
libGlobal "be.ems/lib/global"
"be.ems/src/framework/vo/result"
"github.com/gin-gonic/gin"
@@ -21,8 +21,8 @@ type IndexController struct{}
//
// GET /
func (s *IndexController) Handler(c *gin.Context) {
name := config.Get("framework.name").(string)
version := config.Get("framework.version").(string)
name := "OMC"
version := libGlobal.Version
// str := "欢迎使用%s核心网管理平台，当前版本：%s，请通过前台地址访问。"
str := "Welcome to the %s Core Network Management Platform, current version: %s, please access via the frontend address."
c.JSON(200, result.OkMsg(fmt.Sprintf(str, name, version)))

82
src/modules/common/service/commont.go
View File

@@ -1,7 +1,81 @@
package service
// 通用请求 服务层接口
type ICommont interface {
// SystemConfigInfo 系统配置信息
SystemConfigInfo() map[string]string
import (
"fmt"
"be.ems/lib/global"
"be.ems/src/framework/config"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/utils/machine"
systemService "be.ems/src/modules/system/service"
)
// 实例化服务层 Commont 结构体
var NewCommont = &Commont{
sysUserService: systemService.NewSysUserImpl,
sysConfigService: systemService.NewSysConfigImpl,
}
// 通用请求 服务层处理
type Commont struct {
// 用户信息服务
sysUserService systemService.ISysUser
// 参数配置服务
sysConfigService systemService.ISysConfig
}
// SystemConfigInfo 系统配置信息
func (s *Commont) SystemConfigInfo() map[string]string {
infoMap := map[string]string{}
// 获取打包注入的全局变量信息
infoMap["version"] = global.Version
infoMap["buildTime"] = global.BuildTime
// 系统首次使用标记
launchInfo := machine.LaunchInfo
if launchInfo != nil {
if v, ok := launchInfo[common.LAUNCH_BOOTLOADER]; ok {
infoMap[common.LAUNCH_BOOTLOADER] = fmt.Sprint(v)
} else {
infoMap[common.LAUNCH_BOOTLOADER] = "true"
}
} else {
infoMap[common.LAUNCH_BOOTLOADER] = "true"
}
// 用户登录认证
infoMap["loginAuth"] = fmt.Sprint(config.Get("user.loginAuth"))
// 序列号
infoMap["serialNum"] = fmt.Sprint(config.Get("omc.sn"))
// 获取LOGO类型
logoType := s.sysConfigService.SelectConfigValueByKey("sys.logo.type")
infoMap["logoType"] = logoType
// 获取LOGO文件
filePathIcon := s.sysConfigService.SelectConfigValueByKey("sys.logo.filePathIcon")
infoMap["filePathIcon"] = filePathIcon
filePathBrand := s.sysConfigService.SelectConfigValueByKey("sys.logo.filePathBrand")
infoMap["filePathBrand"] = filePathBrand
// 获取系统名称
title := s.sysConfigService.SelectConfigValueByKey("sys.title")
infoMap["title"] = title
// 获取版权声明
copyright := s.sysConfigService.SelectConfigValueByKey("sys.copyright")
infoMap["copyright"] = copyright
// 获取是否开启用户注册功能
registerUser := s.sysConfigService.SelectConfigValueByKey("sys.account.registerUser")
infoMap["registerUser"] = registerUser
// 获取登录界面背景
loginBackground := s.sysConfigService.SelectConfigValueByKey("sys.loginBackground")
infoMap["loginBackground"] = loginBackground
// 系统设置-官网网址
officialUrl := s.sysConfigService.SelectConfigValueByKey("sys.officialUrl")
infoMap["officialUrl"] = officialUrl
// 系统设置-系统使用文档
helpDoc := s.sysConfigService.SelectConfigValueByKey("sys.helpDoc")
infoMap["helpDoc"] = helpDoc
// 国际化切换
i18nOpen := s.sysConfigService.SelectConfigValueByKey("sys.i18n.open")
infoMap["i18nOpen"] = i18nOpen
// 国际化默认语言
i18nDefault := s.sysConfigService.SelectConfigValueByKey("sys.i18n.default")
infoMap["i18nDefault"] = i18nDefault
return infoMap
}

80
src/modules/common/service/commont.impl.go
View File

@@ -1,80 +0,0 @@
package service
import (
"fmt"
"be.ems/lib/global"
"be.ems/src/framework/config"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/utils/machine"
systemService "be.ems/src/modules/system/service"
)
// 实例化服务层 CommontImpl 结构体
var NewCommontImpl = &CommontImpl{
sysUserService: systemService.NewSysUserImpl,
sysConfigService: systemService.NewSysConfigImpl,
}
// 通用请求 服务层处理
type CommontImpl struct {
// 用户信息服务
sysUserService systemService.ISysUser
// 参数配置服务
sysConfigService systemService.ISysConfig
}
// SystemConfigInfo 系统配置信息
func (s *CommontImpl) SystemConfigInfo() map[string]string {
infoMap := map[string]string{}
// 获取打包注入的全局变量信息
infoMap["version"] = global.Version
infoMap["buildTime"] = global.BuildTime
infoMap["goVer"] = global.GoVer
// 系统首次使用标记
launchInfo := machine.LaunchInfo
if launchInfo != nil {
if v, ok := launchInfo[common.LAUNCH_BOOTLOADER]; ok {
infoMap[common.LAUNCH_BOOTLOADER] = fmt.Sprint(v)
} else {
infoMap[common.LAUNCH_BOOTLOADER] = "true"
}
} else {
infoMap[common.LAUNCH_BOOTLOADER] = "true"
}
// 序列号
infoMap["serialNum"] = fmt.Sprint(config.Get("omc.sn"))
// 获取LOGO类型
logoType := s.sysConfigService.SelectConfigValueByKey("sys.logo.type")
infoMap["logoType"] = logoType
// 获取LOGO文件
filePathIcon := s.sysConfigService.SelectConfigValueByKey("sys.logo.filePathIcon")
infoMap["filePathIcon"] = filePathIcon
filePathBrand := s.sysConfigService.SelectConfigValueByKey("sys.logo.filePathBrand")
infoMap["filePathBrand"] = filePathBrand
// 获取系统名称
title := s.sysConfigService.SelectConfigValueByKey("sys.title")
infoMap["title"] = title
// 获取版权声明
copyright := s.sysConfigService.SelectConfigValueByKey("sys.copyright")
infoMap["copyright"] = copyright
// 获取是否开启用户注册功能
registerUser := s.sysConfigService.SelectConfigValueByKey("sys.account.registerUser")
infoMap["registerUser"] = registerUser
// 获取登录界面背景
loginBackground := s.sysConfigService.SelectConfigValueByKey("sys.loginBackground")
infoMap["loginBackground"] = loginBackground
// 系统设置-官网网址
officialUrl := s.sysConfigService.SelectConfigValueByKey("sys.officialUrl")
infoMap["officialUrl"] = officialUrl
// 系统设置-系统使用文档
helpDoc := s.sysConfigService.SelectConfigValueByKey("sys.helpDoc")
infoMap["helpDoc"] = helpDoc
// 国际化切换
i18nOpen := s.sysConfigService.SelectConfigValueByKey("sys.i18n.open")
infoMap["i18nOpen"] = i18nOpen
// 国际化默认语言
i18nDefault := s.sysConfigService.SelectConfigValueByKey("sys.i18n.default")
infoMap["i18nDefault"] = i18nDefault
return infoMap
}

45
src/modules/crontask/processor/ne_data_udm/ne_data_udm.go Normal file
View File

@@ -0,0 +1,45 @@
package ne_data_udm
import (
"fmt"
"be.ems/src/framework/cron"
"be.ems/src/framework/logger"
neDataService "be.ems/src/modules/network_data/service"
neModel "be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
)
var NewProcessor = &NeDataUDM{
udmAuthService: neDataService.NewUDMAuthUser,
udmSubService: neDataService.NewUDMSubUser,
neInfoService: neService.NewNeInfo,
count: 0,
}
// NeDataUDM 网元配置文件定期备份
type NeDataUDM struct {
udmAuthService *neDataService.UDMAuthUser // UDM鉴权信息
udmSubService *neDataService.UDMSubUser // UDM签约信息
neInfoService *neService.NeInfo // 网元信息服务
count int // 执行次数
}
func (s *NeDataUDM) Execute(data any) (any, error) {
s.count++ // 执行次数加一
options := data.(cron.JobData)
sysJob := options.SysJob
logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
// 返回结果，用于记录执行结果
result := map[string]any{
"count": s.count,
}
neList := s.neInfoService.SelectList(neModel.NeInfo{NeType: "UDM"}, false, false)
for _, neInfo := range neList {
result[fmt.Sprintf("AuthNumber_%s", neInfo.NeId)] = s.udmAuthService.ResetData(neInfo.NeId)
result[fmt.Sprintf("SubNumber_%s", neInfo.NeId)] = s.udmSubService.ResetData(neInfo.NeId)
}
return result, nil
}

3
src/modules/crontask/processor/processor.go
View File

@@ -10,6 +10,7 @@ import (
"be.ems/src/modules/crontask/processor/getStateFromNE"
processorMonitorSysResource "be.ems/src/modules/crontask/processor/monitor_sys_resource"
processorNeConfigBackup "be.ems/src/modules/crontask/processor/ne_config_backup"
processorNeDataUDM "be.ems/src/modules/crontask/processor/ne_data_udm"
"be.ems/src/modules/crontask/processor/removeFile"
)
@@ -19,6 +20,8 @@ func InitCronQueue() {
cron.CreateQueue("monitor_sys_resource", processorMonitorSysResource.NewProcessor)
// 网元-网元配置文件定期备份
cron.CreateQueue("ne_config_backup", processorNeConfigBackup.NewProcessor)
// 网元数据-UDM数据刷新同步
cron.CreateQueue("ne_data_udm", processorNeDataUDM.NewProcessor)
// delete expired NE backup file
cron.CreateQueue("delExpiredNeBackup", delExpiredNeBackup.NewProcessor)
cron.CreateQueue("deleteExpiredRecord", deleteExpiredRecord.NewProcessor)

4
src/modules/network_data/controller/all_alarm.go
View File

@@ -48,8 +48,8 @@ func (s *AlarmController) List(c *gin.Context) {
querys.RmUID = neInfo.RmUID
// 查询数据
data := s.alarmService.SelectPage(querys)
c.JSON(200, result.Ok(data))
rows, total := s.alarmService.SelectPage(querys)
c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
}
// 告警删除

38
src/modules/network_data/controller/amf.go
View File

@@ -15,6 +15,7 @@ import (
"be.ems/src/framework/vo/result"
"be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
neService "be.ems/src/modules/network_element/service"
sysService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
@@ -57,7 +58,7 @@ func (s *AMFController) UEList(c *gin.Context) {
// for multi-tenancy
querys.UserName = ctx.LoginUserToUserName(c)
// 查询数据
data := s.ueEventService.SelectPage(querys)
data := s.ueEventService.SelectPageMT(querys)
c.JSON(200, result.Ok(data))
}
@@ -105,7 +106,7 @@ func (s *AMFController) UEExport(c *gin.Context) {
if querys.PageSize > 10000 {
querys.PageSize = 10000
}
data := s.ueEventService.SelectPage(querys)
data := s.ueEventService.SelectPageMT(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
@@ -215,3 +216,36 @@ func (s *AMFController) UEExport(c *gin.Context) {
c.FileAttachment(saveFilePath, fileName)
}
// 接入基站信息列表
//
// GET /nb/list
func (s *AMFController) NbInfoList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
NbId string `form:"nbId"`
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("AMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.AMFNbInfoList(neInfo, map[string]string{
"nbId": query.NbId,
})
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(data))
}

97
src/modules/network_data/controller/ims.go
View File

@@ -16,6 +16,7 @@ import (
"be.ems/src/framework/vo/result"
"be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
neService "be.ems/src/modules/network_element/service"
sysService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
@@ -58,7 +59,7 @@ func (s *IMSController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID
// 查询数据
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
c.JSON(200, result.Ok(data))
}
@@ -113,7 +114,7 @@ func (s *IMSController) CDRExport(c *gin.Context) {
return
}
querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
@@ -155,16 +156,6 @@ func (s *IMSController) CDRExport(c *gin.Context) {
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string)
}
// 被叫
called := ""
if v, ok := cdrJSON["calledParty"]; ok && v != nil {
called = v.(string)
}
// 主叫
caller := ""
if v, ok := cdrJSON["callerParty"]; ok && v != nil {
caller = v.(string)
}
// 呼叫类型
callType := "sms"
callTypeLable := "SMS"
@@ -177,6 +168,16 @@ func (s *IMSController) CDRExport(c *gin.Context) {
}
}
}
// 被叫
called := ""
if v, ok := cdrJSON["calledParty"]; ok && v != nil {
called = v.(string)
}
// 主叫
caller := ""
if v, ok := cdrJSON["callerParty"]; ok && v != nil {
caller = v.(string)
}
// 时长
duration := "-"
if v, ok := cdrJSON["callDuration"]; ok && v != nil && callType != "sms" {
@@ -196,8 +197,11 @@ func (s *IMSController) CDRExport(c *gin.Context) {
// 取时间
timeStr := ""
if v, ok := cdrJSON["releaseTime"]; ok && v != nil {
releaseTime := parse.Number(v)
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
if releaseTime := parse.Number(v); releaseTime > 0 {
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
timeStr = v.(string)
}
}
// for multi-tenant, get tenant name
tenantName := row.TenantName
@@ -224,3 +228,68 @@ func (s *IMSController) CDRExport(c *gin.Context) {
c.FileAttachment(saveFilePath, fileName)
}
// 在线会话用户数量
//
// GET /session/num
func (s *IMSController) UeSessionNum(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("IMS", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
num, err := neFetchlink.IMSUeSessionNum(neInfo)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(num))
}
// 在线会话用户列表信息
//
// GET /session/list
func (s *IMSController) UeSessionList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
IMSI string `form:"imsi"`
MSISDN string `form:"msisdn"`
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("IMS", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.IMSUeSessionList(neInfo, map[string]string{
"imsi": query.IMSI,
"msisdn": query.MSISDN,
})
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(data))
}

38
src/modules/network_data/controller/mme.go
View File

@@ -16,6 +16,7 @@ import (
"be.ems/src/framework/vo/result"
"be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
neService "be.ems/src/modules/network_element/service"
sysService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
@@ -58,7 +59,7 @@ func (s *MMEController) UEList(c *gin.Context) {
// for multi-tenancy
querys.UserName = ctx.LoginUserToUserName(c)
// 查询数据
data := s.ueEventService.SelectPage(querys)
data := s.ueEventService.SelectPageMT(querys)
c.JSON(200, result.Ok(data))
}
@@ -106,7 +107,7 @@ func (s *MMEController) UEExport(c *gin.Context) {
if querys.PageSize > 10000 {
querys.PageSize = 10000
}
data := s.ueEventService.SelectPage(querys)
data := s.ueEventService.SelectPageMT(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
@@ -205,3 +206,36 @@ func (s *MMEController) UEExport(c *gin.Context) {
c.FileAttachment(saveFilePath, fileName)
}
// 接入基站信息列表
//
// GET /nb/list
func (s *MMEController) NbInfoList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
NbId string `form:"nbId"`
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("MME", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.MMENbInfoList(neInfo, map[string]string{
"nbId": query.NbId,
})
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(data))
}

292
src/modules/network_data/controller/sgwc.go Normal file
View File

@@ -0,0 +1,292 @@
package controller
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service"
neService "be.ems/src/modules/network_element/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SGWCController 结构体
var NewSGWC = &SGWCController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREventSGWC,
udmUserInfoService: neDataService.NewUDMUserInfo,
}
// 网元SGWC
//
// PATH /SGWC
type SGWCController struct {
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREventSGWC // CDR会话事件服务
udmUserInfoService *neDataService.UDMUserInfo // UDM用户信息服务
}
// CDR会话列表
//
// GET /cdr/list
func (s *SGWCController) CDRList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys model.CDREventSGWCQuery
if err := c.ShouldBindQuery(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
querys.RmUID = neInfo.RmUID
// 查询数据
rows, total := s.cdrEventService.SelectPage(querys)
c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
}
// CDR会话删除
//
// DELETE /cdr/:cdrIds
func (s *SGWCController) CDRRemove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
cdrIds := c.Param("cdrIds")
if cdrIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 处理字符转id数组后去重
ids := strings.Split(cdrIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.cdrEventService.DeleteByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
}
// CDR会话列表导出
//
// POST /cdr/export
func (s *SGWCController) CDRExport(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
var querys model.CDREventSGWCQuery
if err := c.ShouldBindBodyWithJSON(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 限制导出数据集
if querys.PageSize > 10000 {
querys.PageSize = 10000
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
querys.RmUID = neInfo.RmUID
rows, total := s.cdrEventService.SelectPage(querys)
if total == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("sgwc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "NE Name",
"C1": "Resource Unique ID",
"D1": "Charging ID",
"E1": "IMSI",
"F1": "MSISDN",
"G1": "GPRS Uplink",
"H1": "GPRS Downlink",
"I1": "Duration",
"J1": "Invocation Time",
"K1": "PGW Address Used",
"L1": "SGW Address",
"M1": "RAT Type",
"N1": "PDPPDN Type",
"O1": "PDPPDN Address",
"P1": "Node Address",
"Q1": "Node Type",
"R1": "Record Access Point Name NI",
"S1": "Record Cause For Rec Closing",
"T1": "Record Sequence Number",
"U1": "Local Record Sequence Number",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 解析 JSON 字符串为 map
var cdrJSON map[string]interface{}
err := json.Unmarshal([]byte(row.CDRJSONStr), &cdrJSON)
if err != nil {
logger.Warnf("CDRExport Error parsing JSON: %s", err.Error())
continue
}
// 计费ID
chargingID := ""
if v, ok := cdrJSON["chargingID"]; ok && v != nil {
chargingID = fmt.Sprint(parse.Number(v))
}
// IMSI
servedIMSI := ""
if v, ok := cdrJSON["servedIMSI"]; ok && v != nil {
servedIMSI = fmt.Sprint(v)
}
// MSISDN
servedMSISDN := ""
if v, ok := cdrJSON["servedMSISDN"]; ok && v != nil {
servedMSISDN = fmt.Sprint(v)
}
// pGWAddressUsed
pGWAddressUsed := ""
if v, ok := cdrJSON["pGWAddressUsed"]; ok && v != nil {
pGWAddressUsed = fmt.Sprint(v)
}
// sGWAddress
sGWAddress := ""
if v, ok := cdrJSON["sGWAddress"]; ok && v != nil {
sGWAddress = fmt.Sprint(v)
}
// rATType
rATType := ""
if v, ok := cdrJSON["rATType"]; ok && v != nil {
rATType = fmt.Sprint(v)
}
// pdpPDNType
pdpPDNType := ""
if v, ok := cdrJSON["pdpPDNType"]; ok && v != nil {
pdpPDNType = fmt.Sprint(v)
}
// servedPDPPDNAddress
servedPDPPDNAddress := ""
if v, ok := cdrJSON["servedPDPPDNAddress"]; ok && v != nil {
servedPDPPDNAddress = fmt.Sprint(v)
}
// servedPDPPDNAddress
servingNodeAddress := []string{}
if v, ok := cdrJSON["servingNodeAddress"]; ok && v != nil {
for _, v := range v.([]any) {
servingNodeAddress = append(servingNodeAddress, fmt.Sprint(v))
}
}
// servingNodeType
servingNodeType := []string{}
if v, ok := cdrJSON["servingNodeType"]; ok && v != nil {
for _, v := range v.([]any) {
if v, ok := v.(map[string]any)["servingNodeType"]; ok && v != nil {
servingNodeType = append(servingNodeType, fmt.Sprint(v))
}
}
}
// accessPointNameNI
accessPointNameNI := ""
if v, ok := cdrJSON["accessPointNameNI"]; ok && v != nil {
accessPointNameNI = fmt.Sprint(v)
}
// causeForRecClosing
causeForRecClosing := ""
if v, ok := cdrJSON["causeForRecClosing"]; ok && v != nil {
causeForRecClosing = fmt.Sprint(v)
}
// recordSequenceNumber
recordSequenceNumber := ""
if v, ok := cdrJSON["recordSequenceNumber"]; ok && v != nil {
recordSequenceNumber = fmt.Sprint(v)
}
// localRecordSequenceNumber
localRecordSequenceNumber := ""
if v, ok := cdrJSON["localRecordSequenceNumber"]; ok && v != nil {
localRecordSequenceNumber = fmt.Sprint(v)
}
// 数据量上行链路
dataVolumeGPRSUplink := []string{}
// 数据量下行链路
dataVolumeGPRSDownlink := []string{}
if v, ok := cdrJSON["listOfTrafficVolumes"]; ok && v != nil {
usageList := v.([]any)
if len(usageList) > 0 {
for _, used := range usageList {
usedUnit := used.(map[string]any)
if dup, dupOk := usedUnit["dataVolumeGPRSUplink"]; dupOk {
dataVolumeGPRSUplink = append(dataVolumeGPRSUplink, fmt.Sprint(parse.Number(dup)))
}
if ddown, ddownOk := usedUnit["dataVolumeGPRSDownlink"]; ddownOk {
dataVolumeGPRSDownlink = append(dataVolumeGPRSDownlink, fmt.Sprint(parse.Number(ddown)))
}
}
}
}
// 时长
duration := "-"
if v, ok := cdrJSON["duration"]; ok && v != nil {
duration = fmt.Sprint(parse.Number(v))
}
// 调用时间
invocationTimestamp := ""
if v, ok := cdrJSON["recordOpeningTime"]; ok && v != nil {
invocationTimestamp = v.(string)
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.NeName,
"C" + idx: row.RmUID,
"D" + idx: chargingID,
"E" + idx: servedIMSI,
"F" + idx: servedMSISDN,
"G" + idx: strings.Join(dataVolumeGPRSUplink, ","),
"H" + idx: strings.Join(dataVolumeGPRSDownlink, ","),
"I" + idx: duration,
"J" + idx: invocationTimestamp,
"K" + idx: pGWAddressUsed,
"L" + idx: sGWAddress,
"M" + idx: rATType,
"N" + idx: pdpPDNType,
"O" + idx: servedPDPPDNAddress,
"P" + idx: strings.Join(servingNodeAddress, ","),
"Q" + idx: strings.Join(servingNodeType, ","),
"R" + idx: accessPointNameNI,
"S" + idx: causeForRecClosing,
"T" + idx: recordSequenceNumber,
"U" + idx: localRecordSequenceNumber,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

38
src/modules/network_data/controller/smf.go
View File

@@ -59,7 +59,7 @@ func (s *SMFController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID
// 查询数据
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
c.JSON(200, result.Ok(data))
}
@@ -114,7 +114,7 @@ func (s *SMFController) CDRExport(c *gin.Context) {
return
}
querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
@@ -326,9 +326,39 @@ func (s *SMFController) CDRExport(c *gin.Context) {
c.FileAttachment(saveFilePath, fileName)
}
// 在线订阅用户数量
//
// GET /sub/num
func (s *SMFController) SubUserNum(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("SMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
num, err := neFetchlink.SMFSubNum(neInfo)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(num))
}
// 在线订阅用户列表信息
//
// GET /subscribers
// GET /sub/list
func (s *SMFController) SubUserList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
@@ -343,7 +373,7 @@ func (s *SMFController) SubUserList(c *gin.Context) {
return
}
// 查询网元信息 rmUID
// 查询网元信息
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID("SMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))

24
src/modules/network_data/controller/smsc.go
View File

@@ -17,6 +17,7 @@ import (
"be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service"
neService "be.ems/src/modules/network_element/service"
sysService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
@@ -57,7 +58,7 @@ func (s *SMSCController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID
// 查询数据
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
c.JSON(200, result.Ok(data))
}
@@ -112,7 +113,7 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
return
}
querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys)
data := s.cdrEventService.SelectPageMT(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
@@ -133,6 +134,8 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
"G1": "Time",
"H1": "Tenant Name", // for multi-tenancy
}
// 读取字典数据 CDR 原因码
dictCDRCauseCode := sysService.NewSysDictData.SelectDictDataByType("cdr_cause_code")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
@@ -172,11 +175,24 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
callResult = "Success"
}
}
// 结果原因
if v, ok := cdrJSON["cause"]; ok && v != nil && callResult == "Fail" {
cause := fmt.Sprint(v)
for _, v := range dictCDRCauseCode {
if cause == v.DictValue {
callResult = fmt.Sprintf("%s, %s", callResult, i18n.TKey(language, v.DictLabel))
break
}
}
}
// 取时间
timeStr := ""
if v, ok := cdrJSON["updateTime"]; ok && v != nil {
releaseTime := parse.Number(v)
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
if releaseTime := parse.Number(v); releaseTime > 0 {
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
timeStr = v.(string)
}
}
// for multi-tenant, get tenant name
tenantName := row.TenantName

2
src/modules/network_data/controller/udm_auth.go
View File

@@ -381,7 +381,7 @@ func (s *UDMAuthController) Export(c *gin.Context) {
// 文件名
fileName := fmt.Sprintf("udm_auth_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := fmt.Sprintf("%s/%s", file.ParseUploadFileDir(uploadsubpath.EXPORT), fileName)
filePath := filepath.Join(file.ParseUploadFileDir(uploadsubpath.EXPORT), fileName)
if fileType == "csv" {
// 转换数据

4
src/modules/network_data/controller/udm_sub.go
View File

@@ -22,7 +22,7 @@ import (
// 实例化控制层 UDMSubController 结构体
var NewUDMSub = &UDMSubController{
udmSubService: neDataService.NewUDMSub,
udmSubService: neDataService.NewUDMSubUser,
neInfoService: neService.NewNeInfo,
}
@@ -407,7 +407,7 @@ func (s *UDMSubController) Export(c *gin.Context) {
// 文件名
fileName := fmt.Sprintf("udm_sub_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := fmt.Sprintf("%s/%s", file.ParseUploadFileDir(uploadsubpath.EXPORT), fileName)
filePath := filepath.Join(file.ParseUploadFileDir(uploadsubpath.EXPORT), fileName)
if fileType == "csv" {
// 转换数据

62
src/modules/network_data/model/alarm.go
View File

@@ -4,37 +4,37 @@ import "time"
// Alarm 告警数据对象 alarm
type Alarm struct {
ID string `json:"id" gorm:"id"`
AlarmSeq string `json:"alarmSeq" gorm:"alarm_seq"`
AlarmId string `json:"alarmId" gorm:"alarm_id"`
AlarmTitle string `json:"alarmTitle" gorm:"alarm_title"`
NeType string `json:"neType" gorm:"ne_type"`
NeId string `json:"neId" gorm:"ne_id"`
AlarmCode string `json:"alarmCode" gorm:"alarm_code"`
EventTime time.Time `json:"eventTime" gorm:"event_time"`
AlarmType string `json:"alarmType" gorm:"alarm_type"`
OrigSeverity string `json:"origSeverity" gorm:"orig_severity"` // 1: Critical, 2: Major, 3: Minor, 4: Warning, 5: Event(Only VNF)
PerceivedSeverity string `json:"perceivedSeverity" gorm:"perceived_severity"` // 1: Critical, 2: Major, 3: Minor, 4: Warning, 5: Event(Only VNF)
PvFlag string `json:"pvFlag" gorm:"pv_flag"`
NeName string `json:"neName" gorm:"ne_name"`
ObjectUid string `json:"objectUid" gorm:"object_uid"`
ObjectName string `json:"objectName" gorm:"object_name"`
ObjectType string `json:"objectType" gorm:"object_type"`
LocationInfo string `json:"locationInfo" gorm:"location_info"`
Province string `json:"province" gorm:"province"`
AlarmStatus string `json:"alarmStatus" gorm:"alarm_status"` // 0:clear, 1:active
SpecificProblem string `json:"specificProblem" gorm:"specific_problem"`
SpecificProblemId string `json:"specificProblemId" gorm:"specific_problem_id"`
AddInfo string `json:"addInfo" gorm:"add_info"`
Counter string `json:"counter" gorm:"counter"`
LatestEventTime time.Time `json:"latestEventTime" gorm:"latest_event_time"`
AckState string `json:"ackState" gorm:"ack_state"` // 0: Unacked, 1: Acked
AckTime time.Time `json:"ackTime" gorm:"ack_time"`
AckUser string `json:"ackUser" gorm:"ack_user"`
ClearType string `json:"clearType" gorm:"clear_type"` // 0: Unclear, 1: AutoClear, 2: ManualClear
ClearTime time.Time `json:"clearTime" gorm:"clear_time"`
ClearUser string `json:"clearUser" gorm:"clear_user"`
Timestamp time.Time `json:"timestamp" gorm:"timestamp"`
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
AlarmSeq string `json:"alarmSeq" gorm:"column:alarm_seq"`
AlarmId string `json:"alarmId" gorm:"column:alarm_id"`
AlarmTitle string `json:"alarmTitle" gorm:"column:alarm_title"`
NeType string `json:"neType" gorm:"column:ne_type"`
NeId string `json:"neId" gorm:"column:ne_id"`
AlarmCode string `json:"alarmCode" gorm:"column:alarm_code"`
EventTime time.Time `json:"eventTime" gorm:"column:event_time"`
AlarmType string `json:"alarmType" gorm:"column:alarm_type"`
OrigSeverity string `json:"origSeverity" gorm:"column:orig_severity"` // 1: Critical, 2: Major, 3: Minor, 4: Warning, 5: Event(Only VNF)
PerceivedSeverity string `json:"perceivedSeverity" gorm:"column:perceived_severity"` // 1: Critical, 2: Major, 3: Minor, 4: Warning, 5: Event(Only VNF)
PvFlag string `json:"pvFlag" gorm:"column:pv_flag"`
NeName string `json:"neName" gorm:"column:ne_name"`
ObjectUid string `json:"objectUid" gorm:"column:object_uid"`
ObjectName string `json:"objectName" gorm:"column:object_name"`
ObjectType string `json:"objectType" gorm:"column:object_type"`
LocationInfo string `json:"locationInfo" gorm:"column:location_info"`
Province string `json:"province" gorm:"column:province"`
AlarmStatus string `json:"alarmStatus" gorm:"column:alarm_status"` // 0:clear, 1:active
SpecificProblem string `json:"specificProblem" gorm:"column:specific_problem"`
SpecificProblemId string `json:"specificProblemId" gorm:"column:specific_problem_id"`
AddInfo string `json:"addInfo" gorm:"column:add_info"`
Counter string `json:"counter" gorm:"column:counter"`
LatestEventTime time.Time `json:"latestEventTime" gorm:"column:latest_event_time"`
AckState string `json:"ackState" gorm:"column:ack_state"` // 0: Unacked, 1: Acked
AckTime time.Time `json:"ackTime" gorm:"column:ack_time"`
AckUser string `json:"ackUser" gorm:"column:ack_user"`
ClearType string `json:"clearType" gorm:"column:clear_type"` // 0: Unclear, 1: AutoClear, 2: ManualClear
ClearTime time.Time `json:"clearTime" gorm:"column:clear_time"`
ClearUser string `json:"clearUser" gorm:"column:clear_user"`
Timestamp time.Time `json:"timestamp" gorm:"column:timestamp"`
}
// TableName 表名称

36
src/modules/network_data/model/cdr_event_sgwc.go Normal file
View File

@@ -0,0 +1,36 @@
package model
import "time"
// CDREventSGWC CDR会话对象SGWC cdr_event_sgwc
type CDREventSGWC struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"`
NeName string `json:"neName" gorm:"column:ne_name"`
RmUID string `json:"rmUID" gorm:"column:rm_uid"`
Timestamp int64 `json:"timestamp" gorm:"column:timestamp"`
CDRJSONStr string `json:"cdrJSON" gorm:"column:cdr_json"`
CreatedAt time.Time `json:"createdAt" gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
// ====== 非数据库字段属性 ======
}
// TableName 表名称
func (*CDREventSGWC) TableName() string {
return "cdr_event_sgwc"
}
// CDREventSGWCQuery CDR会话对象SGWC查询参数结构体
type CDREventSGWCQuery struct {
NeType string `json:"neType" form:"neType" binding:"required,oneof=SGWC"` // SGWC
NeID string `json:"neId" form:"neId" binding:"required"`
RmUID string `json:"rmUID" form:"rmUID"`
IMSI string `json:"imsi" form:"imsi"`
MSISDN string `json:"msisdn" form:"msisdn"`
StartTime string `json:"startTime" form:"startTime"`
EndTime string `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=timestamp"` // 排序字段，填写结果字段
SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc
PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"`
PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"`
}

2
src/modules/network_data/model/udm_user_info.go
View File

@@ -6,7 +6,7 @@ type UDMUserInfo struct {
IMSI string `json:"imsi" gorm:"column:imsi"` // SIM卡/USIM卡ID
MSISDN string `json:"msisdn" gorm:"column:msisdn"` // 用户电话号码
NeId string `json:"neId" gorm:"column:ne_id"` // UDM网元标识-子系统
Remark string `json:"remark" gorm:"remark"` // 备注
Remark string `json:"remark" gorm:"column:remark"` // 备注
}
// TableName 表名称

41
src/modules/network_data/network_data.go
View File

@@ -59,6 +59,14 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.imsCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewIMS.CDRExport,
)
imsGroup.GET("/session/num",
middleware.PreAuthorize(nil),
controller.NewIMS.UeSessionNum,
)
imsGroup.GET("/session/list",
middleware.PreAuthorize(nil),
controller.NewIMS.UeSessionList,
)
}
// 网元SMSC
@@ -97,7 +105,11 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smfCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSMF.CDRExport,
)
smfGroup.GET("/subscribers",
smfGroup.GET("/sub/num",
middleware.PreAuthorize(nil),
controller.NewSMF.SubUserNum,
)
smfGroup.GET("/sub/list",
middleware.PreAuthorize(nil),
controller.NewSMF.SubUserList,
)
@@ -120,6 +132,10 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.amfUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewAMF.UEExport,
)
amfGroup.GET("/nb/list",
middleware.PreAuthorize(nil),
controller.NewAMF.NbInfoList,
)
}
// 网元UPF
@@ -256,5 +272,28 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.mmeUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewMME.UEExport,
)
mmeGroup.GET("/nb/list",
middleware.PreAuthorize(nil),
controller.NewMME.NbInfoList,
)
}
// 网元SGWC
sgwcGroup := neDataGroup.Group("/sgwc")
{
sgwcGroup.GET("/cdr/list",
middleware.PreAuthorize(nil),
controller.NewSGWC.CDRList,
)
sgwcGroup.DELETE("/cdr/:cdrIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sgwcCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSGWC.CDRRemove,
)
sgwcGroup.POST("/cdr/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sgwcCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSGWC.CDRExport,
)
}
}

199
src/modules/network_data/repository/alarm.go
View File

@@ -1,194 +1,103 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 Alarm 结构体
var NewAlarm = &Alarm{
selectSql: `select
id, alarm_seq, alarm_id, alarm_title, ne_type, ne_id, alarm_code, event_time,
alarm_type, orig_severity, perceived_severity, pv_flag, ne_name, object_uid, object_name,
object_type, location_info, province, alarm_status, specific_problem, specific_problem_id,
add_info, counter, latest_event_time, ack_state, ack_time, ack_user, clear_type,
clear_time, clear_user, timestamp
from alarm`,
resultMap: map[string]string{
"id": "ID",
"alarm_seq": "AlarmSeq",
"alarm_id": "AlarmId",
"alarm_title": "AlarmTitle",
"ne_type": "NeType",
"ne_id": "NeId",
"alarm_code": "AlarmCode",
"event_time": "EventTime",
"alarm_type": "AlarmType",
"orig_severity": "OrigSeverity",
"perceived_severity": "PerceivedSeverity",
"pv_flag": "PvFlag",
"ne_name": "NeName",
"object_uid": "ObjectUid",
"object_name": "ObjectName",
"object_type": "ObjectType",
"location_info": "LocationInfo",
"province": "Province",
"alarm_status": "AlarmStatus",
"specific_problem": "SpecificProblem",
"specific_problem_id": "SpecificProblemId",
"add_info": "AddInfo",
"counter": "Counter",
"latest_event_time": "LatestEventTime",
"ack_state": "AckState",
"ack_time": "AckTime",
"ack_user": "AckUser",
"clear_type": "ClearType",
"clear_time": "ClearTime",
"clear_user": "ClearUser",
"timestamp": "Timestamp",
},
}
var NewAlarm = &Alarm{}
// Alarm 告警 数据层处理
type Alarm struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type Alarm struct{}
// convertResultRows 将结果记录转实体结果组
func (r *Alarm) convertResultRows(rows []map[string]any) []model.Alarm {
arr := make([]model.Alarm, 0)
for _, row := range rows {
item := model.Alarm{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *Alarm) SelectPage(querys model.AlarmQuery) map[string]any {
// SelectByPage 分页查询集合
func (r Alarm) SelectByPage(querys model.AlarmQuery) ([]model.Alarm, int64) {
tx := datasource.DB("").Model(&model.Alarm{})
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
tx = tx.Where("ne_type = ?", querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "object_uid = ?")
params = append(params, querys.RmUID)
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
params = append(params, querys.StartTime)
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
params = append(params, querys.EndTime)
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.OrigSeverity != "" {
eventTypes := strings.Split(querys.OrigSeverity, ",")
placeholder := repo.KeyPlaceholderByQuery(len(eventTypes))
conditions = append(conditions, fmt.Sprintf("orig_severity in (%s)", placeholder))
for _, eventType := range eventTypes {
params = append(params, eventType)
}
tx = tx.Where("orig_severity in (%s)", eventTypes)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
var total int64 = 0
rows := []model.Alarm{}
result := map[string]any{
"total": 0,
"rows": []model.Alarm{},
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from alarm"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
orderSql = fmt.Sprintf(" order by %s ", sortSql)
tx = tx.Order(sortField)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query err => %v", err)
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
return rows, total
}
// SelectByIds 通过ID查询
func (r *Alarm) SelectByIds(ids []string) []model.Alarm {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.Alarm{}
rows := []model.Alarm{}
if len(ids) <= 0 {
return rows
}
// 转换实体
return r.convertResultRows(results)
tx := datasource.DB("").Model(&model.Alarm{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *Alarm) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
sql := "delete from alarm where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.Alarm{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

110
src/modules/network_data/repository/cdr_event_ims.go
View File

@@ -194,29 +194,101 @@ func (r *CDREventIMS) SelectPage(querys model.CDREventIMSQuery) map[string]any {
return result
}
// SelectByIds 通过ID查询
func (r *CDREventIMS) SelectByIds(cdrIds []string) []model.CDREventIMS {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventIMS{}
// SelectByPage 分页查询集合
func (r CDREventIMS) SelectByPage(querys model.CDREventIMSQuery) ([]model.CDREventIMS, int64) {
tx := datasource.DB("").Model(&model.CDREventIMS{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
// 转换实体
return r.convertResultRows(results)
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.CallerParty != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') = ?", querys.CallerParty)
}
if querys.CalledParty != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') = ?", querys.CalledParty)
}
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') = '%s'", recordType))
}
tx = tx.Where(fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 查询结果
var total int64 = 0
rows := []model.CDREventIMS{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r *CDREventIMS) SelectByIds(ids []string) []model.CDREventIMS {
rows := []model.CDREventIMS{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.CDREventIMS{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *CDREventIMS) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_ims where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
func (r *CDREventIMS) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventIMS{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

103
src/modules/network_data/repository/cdr_event_sgwc.go Normal file
View File

@@ -0,0 +1,103 @@
package repository
import (
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 CDREventSGWC 结构体
var NewCDREventSGWC = &CDREventSGWC{}
// CDREventSGWC CDR会话事件 数据层处理
type CDREventSGWC struct{}
// SelectByPage 分页查询集合
func (r CDREventSGWC) SelectByPage(querys model.CDREventSGWCQuery) ([]model.CDREventSGWC, int64) {
tx := datasource.DB("").Model(&model.CDREventSGWC{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.IMSI != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedIMSI') = ?", querys.IMSI)
}
if querys.MSISDN != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedMSISDN') = ?", querys.MSISDN)
}
// 查询结果
var total int64 = 0
rows := []model.CDREventSGWC{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r *CDREventSGWC) SelectByIds(ids []string) []model.CDREventSGWC {
rows := []model.CDREventSGWC{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.CDREventSGWC{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *CDREventSGWC) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventSGWC{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

101
src/modules/network_data/repository/cdr_event_smf.go
View File

@@ -176,29 +176,92 @@ func (r *CDREventSMF) SelectPage(querys model.CDREventSMFQuery) map[string]any {
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMF) SelectByIds(cdrIds []string) []model.CDREventSMF {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMF{}
// SelectByPage 分页查询集合
func (r CDREventSMF) SelectByPage(querys model.CDREventSMFQuery) ([]model.CDREventSMF, int64) {
tx := datasource.DB("").Model(&model.CDREventSMF{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
// 转换实体
return r.convertResultRows(results)
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.RecordType != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.recordType') = ?", querys.RecordType)
}
if querys.SubscriberID != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?", querys.SubscriberID)
}
// 查询结果
var total int64 = 0
rows := []model.CDREventSMF{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r *CDREventSMF) SelectByIds(ids []string) []model.CDREventSMF {
rows := []model.CDREventSMF{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.CDREventSMF{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *CDREventSMF) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
func (r *CDREventSMF) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventSMF{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

110
src/modules/network_data/repository/cdr_event_smsc.go
View File

@@ -195,29 +195,101 @@ func (r *CDREventSMSC) SelectPage(querys model.CDREventSMSCQuery) map[string]any
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMSC) SelectByIds(cdrIds []string) []model.CDREventSMSC {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMSC{}
// SelectByPage 分页查询集合
func (r CDREventSMSC) SelectByPage(querys model.CDREventSMSCQuery) ([]model.CDREventSMSC, int64) {
tx := datasource.DB("").Model(&model.CDREventSMSC{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
// 转换实体
return r.convertResultRows(results)
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.CallerParty != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') = ?", querys.CallerParty)
}
if querys.CalledParty != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') = ?", querys.CalledParty)
}
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') = '%s'", recordType))
}
tx = tx.Where(fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 查询结果
var total int64 = 0
rows := []model.CDREventSMSC{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r *CDREventSMSC) SelectByIds(ids []string) []model.CDREventSMSC {
rows := []model.CDREventSMSC{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.CDREventSMSC{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *CDREventSMSC) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smsc where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
func (r *CDREventSMSC) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventSMSC{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

159
src/modules/network_data/repository/udm_user_info.go
View File

@@ -1,164 +1,87 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 UDMUserInfo 结构体
var NewUDMUserInfo = &UDMUserInfo{
selectSql: `select id, imsi, msisdn, ne_id, remark from u_user_info`,
resultMap: map[string]string{
"id": "ID",
"imsi": "IMSI",
"msisdn": "MSISDN",
"ne_id": "NeId",
"remark": "Remark",
},
}
var NewUDMUserInfo = &UDMUserInfo{}
// UDMUserInfo UDM鉴权信息表 数据层处理
type UDMUserInfo struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type UDMUserInfo struct{}
// convertResultRows 将结果记录转实体结果组
func (r *UDMUserInfo) convertResultRows(rows []map[string]any) []model.UDMUserInfo {
arr := make([]model.UDMUserInfo, 0)
for _, row := range rows {
item := model.UDMUserInfo{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *UDMUserInfo) SelectPage(query map[string]any) map[string]any {
// SelectByPage 分页查询集合
func (r UDMUserInfo) SelectByPage(query map[string]string) ([]model.UDMUserInfo, int64) {
tx := datasource.DB("").Model(&model.UDMUserInfo{})
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["imsi"]; ok && v != "" {
conditions = append(conditions, "imsi like concat(concat('%', ?), '%')")
params = append(params, strings.Trim(v.(string), " "))
tx = tx.Where("imsi like concat(concat('%', ?), '%')", v)
}
if v, ok := query["neId"]; ok && v != "" {
conditions = append(conditions, "ne_id = ?")
params = append(params, v)
tx = tx.Where("ne_id = ?", v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
var total int64 = 0
rows := []model.UDMUserInfo{}
result := map[string]any{
"total": 0,
"rows": []model.UDMUserInfo{},
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from u_user_info"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v.(string)
if o, ok := query["sortOrder"]; ok && o != nil && v != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
sortField := v
if o, ok := query["sortOrder"]; ok && o != "" {
sortField = sortField + " desc"
}
orderSql = fmt.Sprintf(" order by %s ", sortSql)
tx = tx.Order(sortField)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query err => %v", err)
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
return rows, total
}
// SelectList 根据实体查询
func (r *UDMUserInfo) SelectList(u model.UDMUserInfo) []model.UDMUserInfo {
// 查询条件拼接
var conditions []string
var params []any
tx := datasource.DB("").Model(&model.UDMUserInfo{})
// 构建查询条件
if u.IMSI != "" {
conditions = append(conditions, "imsi = ?")
params = append(params, u.IMSI)
tx = tx.Where("imsi = ?", u.IMSI)
}
if u.NeId != "" {
conditions = append(conditions, "ne_id = ?")
params = append(params, u.NeId)
tx = tx.Where("ne_id = ?", u.NeId)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
tx = tx.Order("imsi asc")
// 查询数据
querySql := r.selectSql + whereSql + " order by imsi asc "
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
rows := []model.UDMUserInfo{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
// 转换实体
return r.convertResultRows(results)
return rows
}
// SelectByIMSIAndNeID 通过imsi和ne_id查询
func (r *UDMUserInfo) SelectByIMSIAndNeID(imsi, neId string) model.UDMUserInfo {
querySql := r.selectSql + " where imsi = ? and ne_id = ?"
results, err := datasource.RawDB("", querySql, []any{imsi, neId})
if err != nil {
logger.Errorf("query err => %v", err)
return model.UDMUserInfo{}
tx := datasource.DB("").Model(&model.UDMUserInfo{})
// 构建查询条件
tx = tx.Where(" imsi = ? and ne_id = ?", imsi, neId)
// 查询数据
rows := []model.UDMUserInfo{}
if err := tx.Limit(1).Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}

102
src/modules/network_data/repository/ue_event_amf.go
View File

@@ -181,29 +181,93 @@ func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) map[string]any {
return result
}
// SelectByIds 通过ID查询
func (r *UEEventAMF) SelectByIds(ueIds []string) []model.UEEventAMF {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventAMF{}
// SelectByPage 分页查询集合
func (r UEEventAMF) SelectByPage(querys model.UEEventAMFQuery) ([]model.UEEventAMF, int64) {
tx := datasource.DB("").Model(&model.UEEventAMF{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
// 转换实体
return r.convertResultRows(results)
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
tx = tx.Where("event_type in ?", eventTypes)
}
if querys.IMSI != "" {
tx = tx.Where("JSON_EXTRACT(event_json, '$.imsi') = ?", querys.IMSI)
}
// 查询结果
var total int64 = 0
rows := []model.UEEventAMF{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r UEEventAMF) SelectByIds(ids []string) []model.UEEventAMF {
rows := []model.UEEventAMF{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.UEEventAMF{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *UEEventAMF) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_amf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
func (r UEEventAMF) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.UEEventAMF{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

102
src/modules/network_data/repository/ue_event_mme.go
View File

@@ -181,29 +181,93 @@ func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) map[string]any {
return result
}
// SelectByIds 通过ID查询
func (r *UEEventMME) SelectByIds(ueIds []string) []model.UEEventMME {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventMME{}
// SelectByPage 分页查询集合
func (r UEEventMME) SelectByPage(querys model.UEEventMMEQuery) ([]model.UEEventMME, int64) {
tx := datasource.DB("").Model(&model.UEEventMME{})
// 查询条件拼接
if querys.NeType != "" {
tx = tx.Where("ne_type = ?", querys.NeType)
}
// 转换实体
return r.convertResultRows(results)
if querys.RmUID != "" {
tx = tx.Where("rm_uid = ?", querys.RmUID)
}
if querys.StartTime != "" {
startTime := querys.StartTime
if len(startTime) == 13 {
startTime = startTime[:10]
}
tx = tx.Where("timestamp >= ?", startTime)
}
if querys.EndTime != "" {
endTime := querys.EndTime
if len(endTime) == 13 {
endTime = endTime[:10]
}
tx = tx.Where("timestamp <= ?", endTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
tx = tx.Where("event_type in ?", eventTypes)
}
if querys.IMSI != "" {
tx = tx.Where("JSON_EXTRACT(event_json, '$.imsi') = ?", querys.IMSI)
}
// 查询结果
var total int64 = 0
rows := []model.UEEventMME{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询
func (r UEEventMME) SelectByIds(ids []string) []model.UEEventMME {
rows := []model.UEEventMME{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.UEEventMME{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *UEEventMME) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_mme where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
func (r UEEventMME) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
return results
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.UEEventMME{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

4
src/modules/network_data/service/alarm.go
View File

@@ -18,8 +18,8 @@ type Alarm struct {
}
// SelectPage 根据条件分页查询
func (r *Alarm) SelectPage(querys model.AlarmQuery) map[string]any {
return r.alarmRepository.SelectPage(querys)
func (r *Alarm) SelectPage(querys model.AlarmQuery) ([]model.Alarm, int64) {
return r.alarmRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息

7
src/modules/network_data/service/cdr_event_ims.go
View File

@@ -18,10 +18,15 @@ type CDREventIMS struct {
}
// SelectPage 根据条件分页查询
func (r *CDREventIMS) SelectPage(querys model.CDREventIMSQuery) map[string]any {
func (r *CDREventIMS) SelectPageMT(querys model.CDREventIMSQuery) map[string]any {
return r.cdrEventIMSRepository.SelectPage(querys)
}
// SelectPage 根据条件分页查询
func (r *CDREventIMS) SelectPage(querys model.CDREventIMSQuery) ([]model.CDREventIMS, int64) {
return r.cdrEventIMSRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventIMS) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在

39
src/modules/network_data/service/cdr_event_sgwc.go Normal file
View File

@@ -0,0 +1,39 @@
package service
import (
"fmt"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// 实例化数据层 CDREventSGWC 结构体
var NewCDREventSGWC = &CDREventSGWC{
cdrEventRepository: repository.NewCDREventSGWC,
}
// CDREventSGWC CDR会话事件SGWC 服务层处理
type CDREventSGWC struct {
cdrEventRepository *repository.CDREventSGWC // CDR会话事件数据信息
}
// SelectPage 根据条件分页查询
func (r *CDREventSGWC) SelectPage(querys model.CDREventSGWCQuery) ([]model.CDREventSGWC, int64) {
return r.cdrEventRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventSGWC) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在
ids := r.cdrEventRepository.SelectByIds(cdrIds)
if len(ids) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(ids) == len(cdrIds) {
rows := r.cdrEventRepository.DeleteByIds(cdrIds)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}

7
src/modules/network_data/service/cdr_event_smf.go
View File

@@ -18,10 +18,15 @@ type CDREventSMF struct {
}
// SelectPage 根据条件分页查询
func (r *CDREventSMF) SelectPage(querys model.CDREventSMFQuery) map[string]any {
func (r *CDREventSMF) SelectPageMT(querys model.CDREventSMFQuery) map[string]any {
return r.cdrEventRepository.SelectPage(querys)
}
// SelectPage 根据条件分页查询
func (r *CDREventSMF) SelectPage(querys model.CDREventSMFQuery) ([]model.CDREventSMF, int64) {
return r.cdrEventRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMF) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在

7
src/modules/network_data/service/cdr_event_smsc.go
View File

@@ -18,10 +18,15 @@ type CDREventSMSC struct {
}
// SelectPage 根据条件分页查询
func (r *CDREventSMSC) SelectPage(querys model.CDREventSMSCQuery) map[string]any {
func (r *CDREventSMSC) SelectPageMT(querys model.CDREventSMSCQuery) map[string]any {
return r.cdrEventRepository.SelectPage(querys)
}
// SelectPage 根据条件分页查询
func (r *CDREventSMSC) SelectPage(querys model.CDREventSMSCQuery) ([]model.CDREventSMSC, int64) {
return r.cdrEventRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMSC) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在

2
src/modules/network_data/service/udm_sub.go
View File

@@ -12,7 +12,7 @@ import (
)
// 实例化服务层 UDMSubUser 结构体
var NewUDMSub = &UDMSubUser{
var NewUDMSubUser = &UDMSubUser{
udmSubRepository: repository.NewUDMSub,
udmUserInfoRepository: repository.NewUDMUserInfo,
}

7
src/modules/network_data/service/ue_event_amf.go
View File

@@ -19,10 +19,15 @@ type UEEventAMF struct {
}
// SelectPage 根据条件分页查询
func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) map[string]any {
func (r *UEEventAMF) SelectPageMT(querys model.UEEventAMFQuery) map[string]any {
return r.ueEventRepository.SelectPage(querys)
}
// SelectPage 根据条件分页查询
func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) ([]model.UEEventAMF, int64) {
return r.ueEventRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *UEEventAMF) DeleteByIds(ueIds []string) (int64, error) {
// 检查是否存在

7
src/modules/network_data/service/ue_event_mme.go
View File

@@ -18,10 +18,15 @@ type UEEventMME struct {
}
// SelectPage 根据条件分页查询
func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) map[string]any {
func (r *UEEventMME) SelectPageMT(querys model.UEEventMMEQuery) map[string]any {
return r.ueEventRepository.SelectPage(querys)
}
// SelectPage 根据条件分页查询
func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) ([]model.UEEventMME, int64) {
return r.ueEventRepository.SelectByPage(querys)
}
// DeleteByIds 批量删除信息
func (r *UEEventMME) DeleteByIds(ueIds []string) (int64, error) {
// 检查是否存在

41
src/modules/network_element/controller/ne_config.go
View File

@@ -34,10 +34,9 @@ type NeConfigController struct {
//
// GET /list
func (s *NeConfigController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.neConfigService.SelectPage(querys)
c.JSON(200, result.Ok(data))
querys := ctx.QueryMapString(c)
rows, total := s.neConfigService.SelectPage(querys)
c.JSON(200, result.Ok(map[string]any{"total": total, "rows": rows}))
}
// 网元参数配置可用属性值信息
@@ -199,16 +198,16 @@ func (s *NeConfigController) DataInfo(c *gin.Context) {
}
c.JSON(200, result.OkData(resData))
return
} else {
// 网元直连
resData, err := neFetchlink.NeConfigInfo(neInfo, query.ParamName)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.Ok(resData))
}
// 网元直连
resData, err := neFetchlink.NeConfigInfo(neInfo, query.ParamName)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.Ok(resData))
}
// 网元参数配置数据修改
@@ -242,15 +241,15 @@ func (s *NeConfigController) DataEdit(c *gin.Context) {
}
c.JSON(200, result.OkData(resData))
return
} else {
// 网元直连
resData, err := neFetchlink.NeConfigUpdate(neInfo, body.ParamName, body.Loc, body.ParamData)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(resData))
}
// 网元直连
resData, err := neFetchlink.NeConfigUpdate(neInfo, body.ParamName, body.Loc, body.ParamData)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(resData))
}
// 网元参数配置数据新增（array）

7
src/modules/network_element/controller/ne_host.go
View File

@@ -79,6 +79,13 @@ func (s *NeHostController) Add(c *gin.Context) {
return
}
if body.GroupID == "1" {
// 主机信息操作【%s】失败，禁止操作网元
msg := i18n.TKey(language, "neHost.banNE")
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查属性值唯一
uniqueHost := s.neHostService.CheckUniqueHostTitle(body.GroupID, body.Title, body.HostType, "")
if !uniqueHost {

50
src/modules/network_element/fetch_link/amf.go Normal file
View File

@@ -0,0 +1,50 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// AMFNbInfoList AMF基站信息
//
// 查询参数 {"nbId":"7"}
//
// 返回结果 []
func AMFNbInfoList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/amf/objectType/nbInfo", neInfo.IP, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["nbId"]; ok && v != "" {
query = append(query, fmt.Sprintf("nbId=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
var resData map[string]any
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("AMFNbInfoList Get \"%s\"", neUrl)
logger.Errorf("AMFNbInfoList %s", errStr)
return nil, fmt.Errorf("NeService AMF API Error")
}
// 序列化结果 {"data":[{"id":"7","name":"NR-SA-GNB","address":"192.168.5.100:60110","ueNum":0}]}
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("AMFNbInfoList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
return v.([]map[string]any), nil
}
return []map[string]any{}, nil
}

4
src/modules/network_element/fetch_link/hlr.go
View File

@@ -37,7 +37,7 @@ func HLRTraceStart(neInfo model.NeInfo, data map[string]any) (string, error) {
if v, ok := resData["code"]; ok && v == "0" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf(resData["message"])
return "", fmt.Errorf("%s", resData["message"])
}
// HLRTraceStop HLR跟踪任务停止
@@ -64,5 +64,5 @@ func HLRTraceStop(neInfo model.NeInfo, data map[string]any) (string, error) {
if v, ok := resData["code"]; ok && v == "0" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf(resData["message"])
return "", fmt.Errorf("%s", resData["message"])
}

94
src/modules/network_element/fetch_link/ims.go Normal file
View File

@@ -0,0 +1,94 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/network_element/model"
)
// IMSUeSessionNum IMS会话数量
//
// 返回结果 0
func IMSUeSessionNum(neInfo model.NeInfo) (int64, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/ims/objectType/ueNum", neInfo.IP, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("IMSUeSessionNum Get \"%s\"", neUrl)
logger.Errorf("IMSUeSessionNum %s", errStr)
return 0, fmt.Errorf("NeService IMS API Error")
}
// 序列化结果 {"data":{"ueNum":0}}
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSessionNum Unmarshal %s", err.Error())
return 0, err
}
// 固定返回字段，方便前端解析
var ueNum int64 = 0
if v, ok := resData["data"]; ok && v != nil {
if num := v.(map[string]any)["ueNum"]; num != nil {
ueNum = parse.Number(num)
}
}
return ueNum, nil
}
// IMSUeSessionList IMS会话列表
//
// 查询参数 {"imsi":"460001230000002","msisdn":"12307551232"}
//
// 返回结果 []
func IMSUeSessionList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/ims/objectType/ueInfo", neInfo.IP, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["imsi"]; ok && v != "" {
query = append(query, fmt.Sprintf("imsi=%s", v))
}
if v, ok := data["msisdn"]; ok && v != "" {
query = append(query, fmt.Sprintf("msisdn=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("IMSUeSessionList Get \"%s\"", neUrl)
logger.Errorf("IMSUeSessionList %s", errStr)
return nil, fmt.Errorf("NeService IMS API Error")
}
// 序列化结果
// { "data":[
// {
// "activeTime": "2023-11-29 17:04:54",
// "barring": 0,
// "impu": "sip:12307551232@ims.mnc000.mcc460.3gppnetwork.org",
// "imsi": "460001230000002",
// "msisdn": "12307551232",
// "regState": 1
// }
// ] }
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSessionList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
return v.([]map[string]any), nil
}
return []map[string]any{}, nil
}

50
src/modules/network_element/fetch_link/mme.go Normal file
View File

@@ -0,0 +1,50 @@
package fetchlink
import (
"encoding/json"
"fmt"
"strings"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/modules/network_element/model"
)
// MMENbInfoList AMF基站信息
//
// 查询参数 {"nbId":"7"}
//
// 返回结果 []
func MMENbInfoList(neInfo model.NeInfo, data map[string]string) ([]map[string]any, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/mme/objectType/nbInfo", neInfo.IP, neInfo.Port)
// 查询参数拼接
query := []string{}
if v, ok := data["nbId"]; ok && v != "" {
query = append(query, fmt.Sprintf("nbId=%s", v))
}
if len(query) > 0 {
neUrl = fmt.Sprintf("%s?%s", neUrl, strings.Join(query, "&"))
}
var resData map[string]any
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("MMENbInfoList Get \"%s\"", neUrl)
logger.Errorf("MMENbInfoList %s", errStr)
return nil, fmt.Errorf("NeService AMF API Error")
}
// 序列化结果 {"data":[{"id":"7","name":"NR-SA-GNB","address":"192.168.5.100:60110","ueNum":0}]}
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("MMENbInfoList Unmarshal %s", err.Error())
return nil, err
}
// 固定返回字段，方便前端解析
if v, ok := resData["data"]; ok && v != nil {
return v.([]map[string]any), nil
}
return []map[string]any{}, nil
}

31
src/modules/network_element/fetch_link/smf.go
View File

@@ -7,9 +7,40 @@ import (
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/fetch"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/network_element/model"
)
// SMFSubNum SMF在线订阅用户数量 只含5G用户数据
//
// 返回结果 0
func SMFSubNum(neInfo model.NeInfo) (int64, error) {
neUrl := fmt.Sprintf("http://%s:%d/api/rest/ueManagement/v1/elementType/smf/objectType/ueNum", neInfo.IP, neInfo.Port)
resBytes, err := fetch.Get(neUrl, nil, 60_000)
if err != nil {
errStr := err.Error()
logger.Warnf("SMFSubNum Get \"%s\"", neUrl)
logger.Errorf("SMFSubNum %s", errStr)
return 0, fmt.Errorf("NeService SMF API Error")
}
// 序列化结果 {"data":{"ueNum":0}}
var resData map[string]any
err = json.Unmarshal(resBytes, &resData)
if err != nil {
logger.Errorf("IMSUeSession Unmarshal %s", err.Error())
return 0, err
}
// 固定返回字段，方便前端解析
var ueNum int64 = 0
if v, ok := resData["data"]; ok && v != nil {
if num := v.(map[string]any)["ueNum"]; num != nil {
ueNum = parse.Number(num)
}
}
return ueNum, nil
}
// SMFSubInfoList SMF在线订阅用户列表信息
//
// 查询参数 {"imsi":"360000100000130","msisdn":"8612300000130","upstate":"Inactive","pageNum":"1"}

2
src/modules/network_element/fetch_link/udm.go
View File

@@ -35,5 +35,5 @@ func UDMImportAuth(udmIP string, data map[string]any) (string, error) {
if v, ok := resData["code"]; ok && v == "00000" {
return strings.TrimSpace(strings.ToLower(resData["message"])), nil
}
return "", fmt.Errorf(resData["message"])
return "", fmt.Errorf("%s", resData["message"])
}

17
src/modules/network_element/model/ne_config.go
View File

@@ -3,14 +3,15 @@ package model
// NeConfig 网元_参数配置可用属性值
type NeConfig struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" binding:"required" gorm:"ne_type"` // 网元类型
ParamName string `json:"paramName" binding:"required" gorm:"param_name"` // 参数名
ParamDisplay string `json:"paramDisplay" binding:"required" gorm:"param_display"` // 参数显示名
ParamType string `json:"paramType" gorm:"param_type"` // 参数类型 list列表单层 array数组多层
ParamJson string `json:"-" gorm:"param_json"` // accesss属性控制：只读read-only/read/ro 读写read-write
ParamSort int64 `json:"paramSort" gorm:"param_sort"` // 参数排序
ParamPerms string `json:"paramPerms" gorm:"param_perms"` // 操作权限 get只读 put可编辑 delete可删除 post可新增
UpdateTime int64 `json:"updateTime" gorm:"update_time"` // 更新时间
NeType string `json:"neType" binding:"required" gorm:"column:ne_type"` // 网元类型
ParamName string `json:"paramName" binding:"required" gorm:"column:param_name"` // 参数名
ParamDisplay string `json:"paramDisplay" binding:"required" gorm:"column:param_display"` // 参数显示名
ParamType string `json:"paramType" gorm:"column:param_type"` // 参数类型 list列表单层 array数组多层
ParamJson string `json:"-" gorm:"column:param_json"` // accesss属性控制：只读read-only/read/ro 读写read-write
ParamSort int64 `json:"paramSort" gorm:"column:param_sort"` // 参数排序
ParamPerms string `json:"paramPerms" gorm:"column:param_perms"` // 操作权限 get只读 put可编辑 delete可删除 post可新增
Visible string `json:"visible" gorm:"column:visible"` // 可见性 默认public 单独网元self
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
// ====== 非数据库字段属性 ======

10
src/modules/network_element/ne_config_test.go
View File

@@ -92,6 +92,7 @@ func saveData(params []map[string]string) {
})
// 遍历插入
for _, v := range params {
// 排序
paramSort := v["paramSort"]
if len(paramSort) == 0 || paramSort == "" {
paramSort = "0"
@@ -101,6 +102,12 @@ func saveData(params []map[string]string) {
sort = 0
}
// 可见性 默认public
visible := v["visible"]
if len(visible) == 0 || visible == "" {
visible = "public"
}
neConfig := model.NeConfig{
NeType: v["neType"],
ParamName: v["paramName"],
@@ -108,6 +115,7 @@ func saveData(params []map[string]string) {
ParamType: v["paramType"],
ParamJson: v["paramJson"],
ParamPerms: v["paramPerms"],
Visible: visible,
ParamSort: sort,
}
neConfig.ID = saveDB(neConfig)
@@ -215,6 +223,8 @@ func parseParamConfig(data map[string]any) ([]map[string]string, error) {
itemMap["paramDisplay"] = iiv.(string)
case "sort":
itemMap["paramSort"] = fmt.Sprint(iiv)
case "visible":
itemMap["visible"] = fmt.Sprint(iiv)
case "perms", "method":
itemMap["paramPerms"] = iiv.(string)
case "list", "array": // 参数类型为数组

300
src/modules/network_element/repository/ne_config.go
View File

@@ -1,259 +1,125 @@
package repository
import (
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_element/model"
)
// 实例化数据层 NeConfig 结构体
var NewNeConfig = &NeConfig{
selectSql: `select id, ne_type, param_name, param_display, param_type, param_json, param_sort, param_perms, update_time from ne_config`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"param_name": "ParamName",
"param_display": "ParamDisplay",
"param_type": "ParamType",
"param_json": "ParamJson",
"param_sort": "ParamSort",
"param_perms": "ParamPerms",
"update_time": "UpdateTime",
},
}
var NewNeConfig = &NeConfig{}
// NeConfig 网元参数配置可用属性值 数据层处理
type NeConfig struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type NeConfig struct{}
// convertResultRows 将结果记录转实体结果组
func (r *NeConfig) convertResultRows(rows []map[string]any) []model.NeConfig {
arr := make([]model.NeConfig, 0)
for _, row := range rows {
item := model.NeConfig{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询字典类型
func (r *NeConfig) SelectPage(query map[string]any) map[string]any {
// SelectByPage 分页查询集合
func (r NeConfig) SelectByPage(query map[string]string) ([]model.NeConfig, int64) {
tx := datasource.DB("").Model(&model.NeConfig{})
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["neType"]; ok && v != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, v)
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["paramName"]; ok && v != "" {
conditions = append(conditions, "param_name = ?")
params = append(params, v)
tx = tx.Where("param_name = ?", v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
// 查询结果
var total int64 = 0
rows := []model.NeConfig{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
result := map[string]any{
"total": 0,
"rows": []model.NeHost{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(id) as 'total' from ne_config"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("total err => %v", err)
return result
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
return rows, total
}
// SelectList 根据实体查询
func (r *NeConfig) SelectList(param model.NeConfig) []model.NeConfig {
tx := datasource.DB("").Model(&model.NeConfig{})
// 查询条件拼接
var conditions []string
var params []any
if param.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, param.NeType)
tx = tx.Where("ne_type = ?", param.NeType)
}
if param.ParamName != "" {
conditions = append(conditions, "param_name = ?")
params = append(params, param.ParamName)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
tx = tx.Where("param_name = ?", param.ParamName)
}
// 查询数据
querySql := r.selectSql + whereSql + " order by param_sort asc "
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
return r.convertResultRows(results)
}
// SelectByIds 通过ID查询
func (r *NeConfig) SelectByIds(ids []string) []model.NeConfig {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.NeConfig{}
}
// 转换实体
return r.convertResultRows(results)
}
// Insert 新增信息
func (r *NeConfig) Insert(param model.NeConfig) string {
// 参数拼接
params := make(map[string]any)
if param.NeType != "" {
params["ne_type"] = param.NeType
}
if param.ParamName != "" {
params["param_name"] = param.ParamName
}
if param.ParamDisplay != "" {
params["param_display"] = param.ParamDisplay
}
if param.ParamType != "" {
params["param_type"] = param.ParamType
}
if param.ParamJson != "" {
params["param_json"] = param.ParamJson
}
params["param_sort"] = param.ParamSort
if param.ParamPerms != "" {
params["param_perms"] = param.ParamPerms
}
params["update_time"] = time.Now().UnixMilli()
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into ne_config (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// Update 修改信息
func (r *NeConfig) Update(param model.NeConfig) int64 {
// 参数拼接
params := make(map[string]any)
if param.NeType != "" {
params["ne_type"] = param.NeType
}
if param.ParamName != "" {
params["param_name"] = param.ParamName
}
if param.ParamDisplay != "" {
params["param_display"] = param.ParamDisplay
}
if param.ParamType != "" {
params["param_type"] = param.ParamType
}
if param.ParamJson != "" {
params["param_json"] = param.ParamJson
}
params["param_sort"] = param.ParamSort
if param.ParamPerms != "" {
params["param_perms"] = param.ParamPerms
}
params["update_time"] = time.Now().UnixMilli()
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update ne_config set " + strings.Join(keys, ",") + " where id = ?"
// 执行更新
values = append(values, param.ID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
rows := []model.NeConfig{}
if err := tx.Order("param_sort asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *NeConfig) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
sql := "delete from ne_config where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
// SelectByIds 通过ID查询
func (r *NeConfig) SelectByIds(ids []string) []model.NeConfig {
rows := []model.NeConfig{}
if len(ids) <= 0 {
return rows
}
tx := datasource.DB("").Model(&model.NeConfig{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息
func (r *NeConfig) Insert(param model.NeConfig) string {
param.UpdateTime = time.Now().UnixMilli()
// 执行插入
if err := datasource.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return ""
}
return param.ID
}
// Update 修改信息
func (r *NeConfig) Update(param model.NeConfig) int64 {
if param.ID == "" {
return 0
}
return results
param.UpdateTime = time.Now().UnixMilli()
tx := datasource.DB("").Model(&model.NeConfig{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息
func (r *NeConfig) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.NeConfig{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

22
src/modules/network_element/repository/ne_host.go
View File

@@ -111,8 +111,28 @@ func (r *NeHost) SelectPage(query map[string]any) map[string]any {
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if sv, ok := query["sortField"]; ok && sv != "" {
sortSql := fmt.Sprint(sv)
if sortSql == "updateTime" {
sortSql = "update_time"
}
if sortSql == "createTime" {
sortSql = "create_time"
}
if ov, ok := query["sortOrder"]; ok && ov != "" {
if fmt.Sprint(ov) == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + pageSql
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)

3
src/modules/network_element/repository/ne_info.go
View File

@@ -18,6 +18,7 @@ var neListSort = []string{
"IMS",
"AMF",
"AUSF",
"UDR",
"UDM",
"SMF",
"PCF",
@@ -33,6 +34,8 @@ var neListSort = []string{
"SMSF",
"CBC",
"CHF",
"HLR",
"SGWC",
}
// 实例化数据层 NeInfo 结构体

4
src/modules/network_element/service/ne_config.go
View File

@@ -115,8 +115,8 @@ func (r *NeConfig) SelectNeConfigByNeTypeAndParamName(neType, paramName string)
}
// SelectNeHostPage 分页查询列表数据
func (r *NeConfig) SelectPage(query map[string]any) map[string]any {
return r.neConfigRepository.SelectPage(query)
func (r *NeConfig) SelectPage(query map[string]string) ([]model.NeConfig, int64) {
return r.neConfigRepository.SelectByPage(query)
}
// SelectConfigList 查询列表

7
src/modules/network_element/service/ne_host.go
View File

@@ -149,6 +149,13 @@ func (r *NeHost) DeleteByIds(hostIds []string) (int64, error) {
return 0, fmt.Errorf("neHost.noData")
}
for _, v := range ids {
if v.GroupID == "1" {
// 主机信息操作【%s】失败，禁止操作网元
return 0, fmt.Errorf("neHost.banNE")
}
}
if len(ids) == len(hostIds) {
rows := r.neHostRepository.DeleteByIds(hostIds)
return rows, nil

14
src/modules/tool/controller/iperf.go
View File

@@ -37,15 +37,16 @@ type IPerfController struct {
func (s *IPerfController) Version(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
NeType string `form:"neType" binding:"required"` // 网元类型
NeID string `form:"neId" binding:"required"` // 网元ID
NeType string `form:"neType" binding:"required"` // 网元类型
NeId string `form:"neId" binding:"required"` // 网元ID
Version string `form:"version" binding:"required,oneof=V2 V3"` // 版本
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
output, err := s.iperfService.Version(query.NeType, query.NeID)
output, err := s.iperfService.Version(query.NeType, query.NeId, query.Version)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
return
@@ -60,15 +61,16 @@ func (s *IPerfController) Version(c *gin.Context) {
func (s *IPerfController) Install(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var body struct {
NeType string `json:"neType" binding:"required"` // 网元类型
NeID string `json:"neId" binding:"required"` // 网元ID
NeType string `json:"neType" binding:"required"` // 网元类型
NeId string `json:"neId" binding:"required"` // 网元ID
Version string `form:"version" binding:"required,oneof=V2 V3"` // 版本
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
if err := s.iperfService.Install(body.NeType, body.NeID); err != nil {
if err := s.iperfService.Install(body.NeType, body.NeId, body.Version); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
return
}

101
src/modules/tool/service/iperf.go
View File

@@ -22,17 +22,39 @@ var NewIPerf = &IPerf{}
type IPerf struct{}
// Version 查询版本信息
func (s *IPerf) Version(meType, neId string) (string, error) {
// 检查是否安装iperf3
output, err := neService.NewNeInfo.NeRunSSHCmd(meType, neId, "iperf3 --version")
func (s *IPerf) Version(meType, neId, version string) (string, error) {
if version != "V2" && version != "V3" {
return "", fmt.Errorf("iperf version is required V2 or V3")
}
cmd := "iperf3 --version"
if version == "V2" {
cmd = "iperf -v"
}
// 网元主机的SSH客户端
sshClient, err := neService.NewNeInfo.NeRunSSHClient(meType, neId)
if err != nil {
return "", fmt.Errorf("iperf3 not installed")
return "", err
}
defer sshClient.Close()
// 检查是否安装iperf
output, err := sshClient.RunCMD(cmd)
if err != nil {
if version == "V2" && strings.HasSuffix(err.Error(), "status 1") { // V2 版本
return strings.TrimSpace(output), nil
}
return "", fmt.Errorf("iperf %s not installed", version)
}
return strings.TrimSpace(output), err
}
// Install 安装iperf3
func (s *IPerf) Install(meType, neId string) error {
func (s *IPerf) Install(meType, neId, version string) error {
if version != "V2" && version != "V3" {
return fmt.Errorf("iperf version is required V2 or V3")
}
// 网元主机的SSH客户端
sshClient, err := neService.NewNeInfo.NeRunSSHClient(meType, neId)
if err != nil {
@@ -56,9 +78,16 @@ func (s *IPerf) Install(meType, neId string) error {
depDir = "assets/dependency/iperf3/deb"
// sudo apt remove iperf3 libiperf0 libsctp1 libsctp-dev lksctp-tools
} else if _, err := sshClient.RunCMD("sudo yum --version"); err == nil {
depPkg = "sudo rpm -Uvh --force"
depPkg = "sudo rpm -Uvh --nosignature --reinstall --force"
depDir = "assets/dependency/iperf3/rpm"
// yum remove iperf3 iperf3-help.noarch
} else {
return fmt.Errorf("iperf %s not supported install", version)
}
// V2版本和V3版本的安装包路径不同
if version == "V2" {
depDir = strings.Replace(depDir, "iperf3", "iperf", 1)
}
// 从 embed.FS 中读取默认配置文件内容
@@ -72,19 +101,19 @@ func (s *IPerf) Install(meType, neId string) error {
// 打开本地文件
localFile, err := assetsDir.Open(fmt.Sprintf("%s/%s", depDir, d.Name()))
if err != nil {
return fmt.Errorf("iperf3 file local error")
return fmt.Errorf("iperf %s file local error", version)
}
defer localFile.Close()
// 创建远程文件
remotePath := fmt.Sprintf("%s/%s", nePath, d.Name())
remoteFile, err := sftpClient.Client.Create(remotePath)
if err != nil {
return fmt.Errorf("iperf3 file remote error")
return fmt.Errorf("iperf %s file remote error", version)
}
defer remoteFile.Close()
// 使用 io.Copy 将嵌入的文件内容复制到目标文件
if _, err := io.Copy(remoteFile, localFile); err != nil {
return fmt.Errorf("iperf3 file copy error")
return fmt.Errorf("iperf %s file copy error", version)
}
neFilePaths = append(neFilePaths, remotePath)
}
@@ -98,7 +127,7 @@ func (s *IPerf) Install(meType, neId string) error {
// 安装软件包
pkgInstall := fmt.Sprintf("%s %s", depPkg, strings.Join(neFilePaths, " "))
if _, err := sshClient.RunCMD(pkgInstall); err != nil {
return fmt.Errorf("iperf3 install error")
return fmt.Errorf("iperf %s install error", version)
}
return err
}
@@ -108,7 +137,7 @@ func (s *IPerf) Run(client *wsModel.WSClient, reqMsg wsModel.WSRequest) {
// 必传requestId确认消息
if reqMsg.RequestID == "" {
msg := "message requestId is required"
logger.Infof("ws IPerf3 Run UID %s err: %s", client.BindUid, msg)
logger.Infof("ws IPerf Run UID %s err: %s", client.BindUid, msg)
msgByte, _ := json.Marshal(result.ErrMsg(msg))
client.MsgChan <- msgByte
return
@@ -126,7 +155,7 @@ func (s *IPerf) Run(client *wsModel.WSClient, reqMsg wsModel.WSRequest) {
time.Sleep(1 * time.Second)
client.StopChan <- struct{}{}
return
case "iperf3":
case "iperf":
// SSH会话消息接收写入会话
var command string
command, err = s.parseOptions(reqMsg.Data)
@@ -155,7 +184,7 @@ func (s *IPerf) Run(client *wsModel.WSClient, reqMsg wsModel.WSRequest) {
}
if err != nil {
logger.Warnf("ws IPerf3 Run UID %s err: %s", client.BindUid, err.Error())
logger.Warnf("ws IPerf Run UID %s err: %s", client.BindUid, err.Error())
msgByte, _ := json.Marshal(result.ErrMsg(err.Error()))
client.MsgChan <- msgByte
if err == io.EOF {
@@ -175,7 +204,8 @@ func (s *IPerf) parseOptions(reqData any) (string, error) {
msgByte, _ := json.Marshal(reqData)
var data struct {
Command string `json:"command"` // 命令字符串
Client bool `json:"client"` // 服务端或客户端，默认服务端
Version string `json:"version"` // 服务版本，默认V3
Mode string `json:"mode"` // 服务端或客户端，默认客户端client
Host string `json:"host"` // 客户端连接到的服务端IP地址
// Server or Client
Port int `json:"port"` // 服务端口
@@ -183,17 +213,25 @@ func (s *IPerf) parseOptions(reqData any) (string, error) {
// Server
OneOff bool `json:"oneOff"` // 只进行一次连接
// Client
UDP bool `json:"udp"` // use UDP rather than TCP
Time int `json:"time"` // 以秒为单位的传输时间（默认为 10 秒）
Reverse bool `json:"reverse"` // 以反向模式运行（服务器发送，客户端接收）
Window string `json:"window"` // 设置窗口大小/套接字缓冲区大小
UDP bool `json:"udp"` // use UDP rather than TCP
Time int `json:"time"` // 以秒为单位的传输时间（默认为 10 秒）
Reverse bool `json:"reverse"` // 以反向模式运行（服务器发送，客户端接收）
Window string `json:"window"` // 设置窗口大小/套接字缓冲区大小
Parallel int `json:"parallel"` // 运行的并行客户端流数量
Bitrate int `json:"bitrate"` // 以比特/秒为单位（0 表示无限制）
}
if err := json.Unmarshal(msgByte, &data); err != nil {
logger.Warnf("ws processor parseClient err: %s", err.Error())
return "", fmt.Errorf("query data structure error")
}
if data.Version != "V3" && data.Version != "V2" {
return "", fmt.Errorf("query data version support V3 or V2")
}
command := []string{"iperf3"}
if data.Version == "V2" {
command = []string{"iperf"}
}
// 命令字符串高优先级
if data.Command != "" {
command = append(command, data.Command)
@@ -201,16 +239,14 @@ func (s *IPerf) parseOptions(reqData any) (string, error) {
return strings.Join(command, " "), nil
}
if data.Client && data.Host == "" {
if data.Mode != "client" && data.Mode != "server" {
return "", fmt.Errorf("query data mode support client or server")
}
if data.Mode == "client" && data.Host == "" {
return "", fmt.Errorf("query data client host empty")
}
if !data.Client {
command = append(command, "-s")
// Server
if data.OneOff {
command = append(command, "-1")
}
} else {
if data.Mode == "client" {
command = append(command, "-c")
command = append(command, data.Host)
// Client
@@ -220,6 +256,12 @@ func (s *IPerf) parseOptions(reqData any) (string, error) {
if data.Time > 0 {
command = append(command, fmt.Sprintf("-t %d", data.Time))
}
if data.Bitrate > 0 {
command = append(command, fmt.Sprintf("-b %d", data.Bitrate))
}
if data.Parallel > 0 {
command = append(command, fmt.Sprintf("-P %d", data.Parallel))
}
if data.Reverse {
command = append(command, "-R")
}
@@ -227,6 +269,13 @@ func (s *IPerf) parseOptions(reqData any) (string, error) {
command = append(command, fmt.Sprintf("-w %s", data.Window))
}
}
if data.Mode == "server" {
command = append(command, "-s")
// Server
if data.OneOff {
command = append(command, "-1")
}
}
// Server or Client
if data.Port > 0 {

8
src/modules/trace/service/trace_task_hlr.go
View File

@@ -60,7 +60,7 @@ func (r *TraceTaskHlr) DeleteByIds(ids []string) (int64, error) {
if len(rows) == len(ids) {
// 停止任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "UDM"}, false, false)
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, r := range rows {
if r.Status == "0" {
continue
@@ -98,7 +98,7 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
}
// 发送创建任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "UDM"}, false, false)
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, neInfo := range neInfos {
hlrItem := map[string]any{
"neType": neInfo.NeType,
@@ -129,7 +129,7 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
func (r *TraceTaskHlr) Stop(task model.TraceTaskHlr) error {
hlrList := []map[string]any{}
// 发送停止任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "UDM"}, false, false)
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, neInfo := range neInfos {
hlrItem := map[string]any{
"neType": neInfo.NeType,
@@ -161,7 +161,7 @@ func (r *TraceTaskHlr) Stop(task model.TraceTaskHlr) error {
func (r *TraceTaskHlr) File(traceId, dirPath string) ([]map[string]any, error) {
hlrList := []map[string]any{}
// 查询所有匹配的网元类型
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "UDM"}, false, false)
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
if len(neInfos) == 0 {
return nil, fmt.Errorf("not found network element")
}

69
src/modules/ws/controller/ws_redis.go Normal file
View File

@@ -0,0 +1,69 @@
package controller
import (
"be.ems/src/framework/i18n"
"be.ems/src/framework/logger"
"be.ems/src/framework/redis"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo/result"
neService "be.ems/src/modules/network_element/service"
"github.com/gin-gonic/gin"
)
// Redis 终端
//
// GET /redis?hostId=1
func (s *WSController) Redis(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var query struct {
HostId string `form:"hostId" binding:"required"` // 连接主机ID
}
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, i18n.TKey(language, err.Error())))
return
}
neHost := neService.NewNeHost.SelectById(query.HostId)
if neHost.HostID != query.HostId || neHost.HostType != "redis" {
// 没有可访问主机信息数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "neHost.noData")))
return
}
// 创建链接Redis客户端
var connRedis redis.ConnRedis
neHost.CopyTo(&connRedis)
client, err := connRedis.NewClient()
if err != nil {
// 连接主机失败，请检查连接参数后重试
c.JSON(200, result.ErrMsg(i18n.TKey(language, "neHost.errByHostInfo")))
return
}
defer client.Close()
// 将 HTTP 连接升级为 WebSocket 连接
wsConn := s.wsService.UpgraderWs(c.Writer, c.Request)
if wsConn == nil {
return
}
defer wsConn.Close()
wsClient := s.wsService.ClientCreate(loginUser.UserID, nil, wsConn, client)
go s.wsService.ClientWriteListen(wsClient)
go s.wsService.ClientReadListen(wsClient, s.wsReceiveService.Redis)
// 等待停止信号
for value := range wsClient.StopChan {
s.wsService.ClientClose(wsClient.ID)
logger.Infof("ws Stop Client UID %s %s", wsClient.BindUid, value)
return
}
}

12
src/modules/ws/processor/cdr_connect.go
View File

@@ -28,10 +28,10 @@ func GetCDRConnectByIMS(requestID string, data any) ([]byte, error) {
}
query.RmUID = neInfo.RmUID
dataMap := neDataService.NewCDREventIMS.SelectPage(query)
rows, total := neDataService.NewCDREventIMS.SelectPage(query)
resultByte, err := json.Marshal(result.Ok(map[string]any{
"requestId": requestID,
"data": dataMap,
"data": map[string]any{"rows": rows, "total": total},
}))
return resultByte, err
}
@@ -53,10 +53,10 @@ func GetCDRConnectBySMF(requestID string, data any) ([]byte, error) {
}
query.RmUID = neInfo.RmUID
dataMap := neDataService.NewCDREventSMF.SelectPage(query)
rows, total := neDataService.NewCDREventSMF.SelectPage(query)
resultByte, err := json.Marshal(result.Ok(map[string]any{
"requestId": requestID,
"data": dataMap,
"data": map[string]any{"rows": rows, "total": total},
}))
return resultByte, err
}
@@ -78,10 +78,10 @@ func GetCDRConnectBySMSC(requestID string, data any) ([]byte, error) {
}
query.RmUID = neInfo.RmUID
dataMap := neDataService.NewCDREventSMSC.SelectPage(query)
rows, total := neDataService.NewCDREventSMSC.SelectPage(query)
resultByte, err := json.Marshal(result.Ok(map[string]any{
"requestId": requestID,
"data": dataMap,
"data": map[string]any{"rows": rows, "total": total},
}))
return resultByte, err
}

8
src/modules/ws/processor/ue_connect.go
View File

@@ -20,10 +20,10 @@ func GetUEConnectByAMF(requestID string, data any) ([]byte, error) {
return nil, fmt.Errorf("query data structure error")
}
dataMap := neDataService.NewUEEventAMF.SelectPage(query)
rows, total := neDataService.NewUEEventAMF.SelectPage(query)
resultByte, err := json.Marshal(result.Ok(map[string]any{
"requestId": requestID,
"data": dataMap,
"data": map[string]any{"rows": rows, "total": total},
}))
return resultByte, err
}
@@ -38,10 +38,10 @@ func GetUEConnectByMME(requestID string, data any) ([]byte, error) {
return nil, fmt.Errorf("query data structure error")
}
dataMap := neDataService.NewUEEventMME.SelectPage(query)
rows, total := neDataService.NewUEEventMME.SelectPage(query)
resultByte, err := json.Marshal(result.Ok(map[string]any{
"requestId": requestID,
"data": dataMap,
"data": map[string]any{"rows": rows, "total": total},
}))
return resultByte, err
}

80
src/modules/ws/service/ws_receive.go
View File

@@ -4,9 +4,12 @@ import (
"encoding/json"
"fmt"
"io"
"reflect"
"strings"
"time"
"be.ems/src/framework/logger"
"be.ems/src/framework/redis"
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/ssh"
"be.ems/src/framework/vo/result"
@@ -104,7 +107,7 @@ func (s *WSReceive) Shell(client *model.WSClient, reqMsg model.WSRequest) {
command := reqMsg.Data.(string)
sshClientSession := client.ChildConn.(*ssh.SSHClientSession)
_, err = sshClientSession.Write(command)
case "ssh_resize":
case "resize":
// SSH会话窗口重置
msgByte, _ := json.Marshal(reqMsg.Data)
var data struct {
@@ -225,7 +228,7 @@ func (s *WSReceive) Telnet(client *model.WSClient, reqMsg model.WSRequest) {
command := reqMsg.Data.(string)
telnetClientSession := client.ChildConn.(*telnet.TelnetClientSession)
_, err = telnetClientSession.Write(command)
case "telnet_resize":
case "resize":
// Telnet会话窗口重置
msgByte, _ := json.Marshal(reqMsg.Data)
var data struct {
@@ -256,3 +259,76 @@ func (s *WSReceive) Telnet(client *model.WSClient, reqMsg model.WSRequest) {
client.MsgChan <- resByte
}
}
// Redis 接收终端交互业务处理
func (s *WSReceive) Redis(client *model.WSClient, reqMsg model.WSRequest) {
// 必传requestId确认消息
if reqMsg.RequestID == "" {
msg := "message requestId is required"
logger.Infof("ws Shell UID %s err: %s", client.BindUid, msg)
msgByte, _ := json.Marshal(result.ErrMsg(msg))
client.MsgChan <- msgByte
return
}
var resByte []byte
var err error
switch reqMsg.Type {
case "close":
s.close(client)
return
case "redis":
// Redis会话消息接收写入会话
command := fmt.Sprint(reqMsg.Data)
redisClientSession := client.ChildConn.(*redis.ConnRedis)
output, err := redisClientSession.RunCMD(command)
dataStr := ""
if err != nil {
dataStr = fmt.Sprintf("%s \r\n", err.Error())
} else {
// 获取结果的反射类型
resultType := reflect.TypeOf(output)
switch resultType.Kind() {
case reflect.Slice:
// 如果是切片类型需要进一步判断是否是 []string 或 []interface{}
if resultType.Elem().Kind() == reflect.String {
dataStr = fmt.Sprintf("%s \r\n", strings.Join(output.([]string), "\r\n"))
} else if resultType.Elem().Kind() == reflect.Interface {
arr := []string{}
for _, v := range output.([]any) {
arr = append(arr, fmt.Sprintf("%s", v))
}
dataStr = fmt.Sprintf("%s \r\n", strings.Join(arr, "\r\n"))
}
case reflect.Ptr:
dataStr = "\r\n"
case reflect.String, reflect.Int64:
dataStr = fmt.Sprintf("%s \r\n", output)
default:
dataStr = fmt.Sprintf("%s \r\n", output)
}
}
resByte, _ = json.Marshal(result.Ok(map[string]any{
"requestId": reqMsg.RequestID,
"data": dataStr,
}))
default:
err = fmt.Errorf("message type %s not supported", reqMsg.Type)
}
if err != nil {
logger.Warnf("ws Shell UID %s err: %s", client.BindUid, err.Error())
msgByte, _ := json.Marshal(result.ErrMsg(err.Error()))
client.MsgChan <- msgByte
if err == io.EOF {
// 等待1s后关闭连接
time.Sleep(1 * time.Second)
client.StopChan <- struct{}{}
}
return
}
if len(resByte) > 0 {
client.MsgChan <- resByte
}
}

2
src/modules/ws/service/ws_send.go
View File

@@ -28,6 +28,8 @@ const (
GROUP_SMF_CDR = "1006_"
// 组号-SMSC_CDR会话事件 1007_neId
GROUP_SMSC_CDR = "1007_"
// 组号-SGWC_CDR会话事件 1008_neId
GROUP_SGWC_CDR = "1008_"
// 组号-AMF_UE会话事件
GROUP_AMF_UE = "1010"
// 组号-MME_UE会话事件 1011_neId

5
src/modules/ws/ws.go
View File

@@ -35,6 +35,11 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.ws", collectlogs.BUSINESS_TYPE_OTHER)),
controller.NewWSController.Telnet,
)
wsGroup.GET("/redis",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.ws", collectlogs.BUSINESS_TYPE_OTHER)),
controller.NewWSController.Redis,
)
wsGroup.GET("/view",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.ws", collectlogs.BUSINESS_TYPE_OTHER)),