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

Merge branch 'main-v2' into lite-ba

Browse Source
This commit is contained in:
TsMask
2025-08-21 17:00:56 +08:00
parent 152b242671 45e226ce1a
commit 06a6e89eee
191 changed files with 2376 additions and 1793 deletions
Download Patch File Download Diff File Expand all files Collapse all files

249
src/modules/ne_data/controller/all_alarm.go Normal file
View File

@@ -0,0 +1,249 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 AlarmController 结构体
var NewAlarm = &AlarmController{
neInfoService: neService.NewNeInfo,
alarmService: neDataService.NewAlarm,
}
// 告警数据
//
// PATH /alarm
type AlarmController struct {
neInfoService *neService.NeInfo // 网元信息服务
alarmService *neDataService.Alarm // 告警信息服务
}
// 告警列表
//
// GET /list
//
// @Tags ne_data/alarm
// @Accept json
// @Produce json
// @Param neType query string false "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
// @Param neId query string false "NE ID The actual record is the network element RmUid"
// @Param neName query string false "NE Name"
// @Param pvFlag query string false "PV Flag" Enums(PNF,VNF)
// @Param alarmCode query string false "alarm status code"
// @Param alarmType query string false "Alarm type Communication alarms=1, Equipment alarms=2, Processing faults=3, Environmental alarms=4, Quality of service alarms=5" Enums(1,2,3,4,5)
// @Param alarmStatus query string false "Alarm status Clear Active" Enums(0,1)
// @Param origSeverity query string false "Alarm Type 1: Critical, 2: Major, 3: Minor, 4: Warning" Enums(1,2,3,4)
// @Param sortField query string false "Sort fields, fill in result fields" default(event_time)
// @Param sortOrder query string false "Sort by ascending or descending order, asc desc" default(asc)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Alarm List
// @Description Alarm List
// @Router /neData/alarm/list [get]
func (s AlarmController) List(c *gin.Context) {
var query model.AlarmQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询数据
rows, total := s.alarmService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 告警删除
//
// DELETE /:id
func (s AlarmController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.alarmService.DeleteByIds(ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// 告警清除
//
// PUT /clear
func (s AlarmController) Clear(c *gin.Context) {
var body struct {
Ids []int64 `json:"ids" binding:"required"`
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
clearUser := reqctx.LoginUserToUserName(c)
rows, err := s.alarmService.ClearByIds(body.Ids, clearUser, constants.ALARM_CLEAR_TYPE_MANUAL_CLEAR)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(rows))
}
// 告警确认
//
// PUT /ack
func (s AlarmController) Ack(c *gin.Context) {
var body struct {
Ids []int64 `json:"ids" binding:"required"`
AckState bool `json:"ackState" binding:"omitempty"`
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
ackUser := reqctx.LoginUserToUserName(c)
rows, err := s.alarmService.AckByIds(body.Ids, ackUser, constants.ALARM_ACK_STATE_ACK)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(rows))
}
// 告警级别数量
//
// GET /count/severity
func (s AlarmController) CountSeverity(c *gin.Context) {
var query struct {
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"required,oneof=Clear Active"` // 告警状态
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
data := s.alarmService.CountSeverity(query.AlarmStatus)
c.JSON(200, resp.OkData(data))
}
// 告警类别数量
//
// GET /count/type
func (s AlarmController) CountType(c *gin.Context) {
var query struct {
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"required,oneof=Clear Active"` // 告警状态
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
data := s.alarmService.CountType(query.AlarmStatus)
c.JSON(200, resp.OkData(data))
}
// 告警状态前几排名
//
// GET /count/ne
func (s AlarmController) CountNe(c *gin.Context) {
var query struct {
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"required,oneof=Clear Active"` // 告警状态
Top int `json:"top" form:"top" binding:"required"` // 前几
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
data := s.alarmService.CountNe(query.AlarmStatus, query.Top)
c.JSON(200, resp.OkData(data))
}
// 告警列表导出
//
// GET /export
//
// @Tags ne_data/alarm
// @Accept json
// @Produce json
// @Param neType query string false "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
// @Param neId query string false "NE ID The actual record is the network element RmUid"
// @Param neName query string false "NE Name"
// @Param pvFlag query string false "PV Flag" Enums(PNF,VNF)
// @Param alarmCode query string false "alarm status code"
// @Param alarmType query string false "Alarm type Communication alarms=1, Equipment alarms=2, Processing faults=3, Environmental alarms=4, Quality of service alarms=5" Enums(1,2,3,4,5)
// @Param alarmStatus query string false "Alarm status 0:clear, 1:active" Enums(0,1)
// @Param origSeverity query string false "Alarm Type 1: Critical, 2: Major, 3: Minor, 4: Warning" Enums(1,2,3,4)
// @Param sortField query string false "Sort fields, fill in result fields" default(event_time)
// @Param sortOrder query string false "Sort by ascending or descending order, asc desc" default(asc)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Alarm List Export
// @Description Alarm List Export
// @Router /neData/alarm/export [get]
func (s AlarmController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
var query model.AlarmQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 限制导出数据集
if query.PageSize > 10000 {
query.PageSize = 10000
}
// 查询数据
rows, total := s.alarmService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("alarm_export_%d_%s_%d.xlsx", len(rows), query.AlarmStatus, time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.alarmService.ExportXlsx(rows, fileName, language, query.AlarmStatus)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

52
src/modules/ne_data/controller/all_alarm_forward.go Normal file
View File

@@ -0,0 +1,52 @@
package controller
import (
"fmt"
"be.ems/src/framework/resp"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 AlarmForwardController 结构体
var NewAlarmForward = &AlarmForwardController{
alarmForwardLogService: neDataService.NewAlarmForwardLog,
}
// 告警数据
//
// PATH /alarm/forward
type AlarmForwardController struct {
alarmForwardLogService *neDataService.AlarmForwardLog // 告警转发记录服务
}
// 告警转发日志列表
//
// GET /log/list
//
// @Tags ne_data/alarm_forward
// @Accept json
// @Produce json
// @Param neType query string false "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC) Enums(1,2,3,4)
// @Param sortField query string false "Sort fields, fill in result fields" default(event_time)
// @Param sortOrder query string false "Sort by ascending or descending order, asc desc" default(asc)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Alarm Forward Log List
// @Description Alarm Forward Log List
// @Router /neData/alarm/forward/log/list [get]
func (s AlarmForwardController) List(c *gin.Context) {
var query model.AlarmForwardLogQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询数据
rows, total := s.alarmForwardLogService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}

91
src/modules/ne_data/controller/all_alarm_log.go Normal file
View File

@@ -0,0 +1,91 @@
package controller
import (
"fmt"
"be.ems/src/framework/resp"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 AlarmLogController 结构体
var NewAlarmLog = &AlarmLogController{
alarmLogService: neDataService.NewAlarmLog,
alarmEventService: neDataService.NewAlarmEvent,
}
// 告警数据
//
// PATH /alarm/log
type AlarmLogController struct {
alarmLogService *neDataService.AlarmLog // 告警日志信息服务
alarmEventService *neDataService.AlarmEvent // 告警事件信息服务
}
// 告警日志列表
//
// GET /list
//
// @Tags ne_data/alarm_log
// @Accept json
// @Produce json
// @Param neType query string false "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
// @Param neId query string false "NE ID The actual record is the network element RmUid"
// @Param alarmLogType query string false "AlarmLog type Communication AlarmLogs=1, Equipment AlarmLogs=2, Processing faults=3, Environmental AlarmLogs=4, Quality of service AlarmLogs=5" Enums(1,2,3,4,5)
// @Param alarmStatus query string false "Alarm status 0:clear, 1:active" Enums(0,1)
// @Param origSeverity query string false "Alarm Type 1: Critical, 2: Major, 3: Minor, 4: Warning" Enums(1,2,3,4)
// @Param sortField query string false "Sort fields, fill in result fields" default(event_time)
// @Param sortOrder query string false "Sort by ascending or descending order, asc desc" default(asc)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary AlarmLog List
// @Description AlarmLog List
// @Router /neData/alarm/log/list [get]
func (s AlarmLogController) List(c *gin.Context) {
var query model.AlarmLogQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询数据
rows, total := s.alarmLogService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 告警事件日志列表
//
// GET /event
//
// @Tags ne_data/alarm_log
// @Accept json
// @Produce json
// @Param neType query string false "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC)
// @Param neId query string false "NE ID The actual record is the network element RmUid"
// @Param alarmLogType query string false "AlarmLog type Communication AlarmLogs=1, Equipment AlarmLogs=2, Processing faults=3, Environmental AlarmLogs=4, Quality of service AlarmLogs=5" Enums(1,2,3,4,5)
// @Param alarmStatus query string false "Alarm status 0:clear, 1:active" Enums(0,1)
// @Param origSeverity query string false "Alarm Type 1: Critical, 2: Major, 3: Minor, 4: Warning" Enums(1,2,3,4)
// @Param sortField query string false "Sort fields, fill in result fields" default(event_time)
// @Param sortOrder query string false "Sort by ascending or descending order, asc desc" default(asc)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Alarm Event Log List
// @Description Alarm Event Log List
// @Router /neData/alarm/log/event [get]
func (s AlarmLogController) Event(c *gin.Context) {
var query model.AlarmEventQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询数据
rows, total := s.alarmEventService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}

101
src/modules/ne_data/controller/all_backup.go Normal file
View File

@@ -0,0 +1,101 @@
package controller
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 BackupController 结构体
var NewBackup = &BackupController{
backupService: service.NewBackup,
}
// 备份数据
//
// PATH /backup
type BackupController struct {
backupService *service.Backup // 备份相关服务
}
// 备份文件-更新FTP配置
//
// PUT /ftp
func (s BackupController) FTPUpdate(c *gin.Context) {
var body model.BackupDataFTP
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
byteData, err := json.Marshal(body)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
up := s.backupService.FTPConfigUpdate(string(byteData), reqctx.LoginUserToUserName(c))
if up <= 0 {
c.JSON(200, resp.ErrMsg("update failed"))
return
}
c.JSON(200, resp.Ok(nil))
}
// 备份文件-获取FTP配置
//
// GET /ftp
func (s BackupController) FTPInfo(c *gin.Context) {
info := s.backupService.FTPConfigInfo()
c.JSON(200, resp.OkData(info))
}
// 备份文件-文件FTP发送
//
// POST /ftp
func (s BackupController) FTPPush(c *gin.Context) {
var body struct {
Path string `form:"path" binding:"required"` // 路径必须是 BACKUP_DIR 开头的路径
Filename string `form:"fileName" binding:"required"`
Tag string `form:"tag" binding:"required"` // 标签，用于区分不同的备份文件
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 判断路径是否合法
if !strings.HasPrefix(body.Path, s.backupService.BACKUP_DIR) {
c.JSON(200, resp.ErrMsg("operation path is not within the allowed range"))
return
}
// 判断文件是否存在
localFilePath := filepath.Join(body.Path, body.Filename)
if runtime.GOOS == "windows" {
localFilePath = fmt.Sprintf("C:%s", localFilePath)
}
if _, err := os.Stat(localFilePath); os.IsNotExist(err) {
c.JSON(200, resp.ErrMsg("file does not exist"))
return
}
// 发送文件
err := s.backupService.FTPPushFile(localFilePath, body.Tag)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}

176
src/modules/ne_data/controller/all_kpi.go Normal file
View File

@@ -0,0 +1,176 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 KPIController 结构体
var NewKPI = &KPIController{
neInfoService: neService.NewNeInfo,
kpiReportService: neDataService.NewKpiReport,
}
// 性能统计
//
// PATH /kpi
type KPIController struct {
neInfoService *neService.NeInfo // 网元信息服务
kpiReportService *neDataService.KpiReport // 指标统计服务
}
// 获取统计数据
//
// GET /data
//
// @Tags ne_data/kpi
// @Accept json
// @Produce json
// @Param neType query string true "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC) default(AMF)
// @Param neId query string true "NE ID" default(001)
// @Param beginTime query number true "begin time (timestamped milliseconds)" default(1729162507596)
// @Param endTime query number true "end time (timestamped milliseconds)" default(1729164187611)
// @Param interval query number true "interval" Enums(5,10,15,30,60,300,600,900,1800,3600) default(60)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access to statistical data
// @Description Access to statistical data
// @Router /neData/kpi/data [get]
func (s KPIController) KPIData(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var querys model.KPIQuery
if err := c.ShouldBindQuery(&querys); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
querys.RmUID = neInfo.RmUID
// 查询数据
kpiData := s.kpiReportService.FindData(querys)
c.JSON(200, resp.OkData(kpiData))
}
// 获取统计标题
//
// GET /title
//
// @Tags ne_data/kpi
// @Accept json
// @Produce json
// @Param neType query string true "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC) default(AMF)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Get Statistical Headings
// @Description Get Statistical Headings
// @Router /neData/kpi/title [get]
func (s KPIController) KPITitle(c *gin.Context) {
neType := c.Query("neType")
if neType == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neType is empty"))
return
}
kpiTitles := s.kpiReportService.FindTitle(neType)
c.JSON(200, resp.OkData(kpiTitles))
}
// 统计标题列表
//
// GET /title/list
func (s KPIController) ListTitle(c *gin.Context) {
query := reqctx.QueryMap(c)
rows, total := s.kpiReportService.TitleFindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"total": total, "rows": rows}))
}
// 统计标题新增
//
// POST /title
func (s KPIController) AddTitle(c *gin.Context) {
var body model.KpiTitle
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 校验指标是否存在
kpicTitles := s.kpiReportService.TitleFind(model.KpiTitle{
NeType: body.NeType,
KpiId: body.KpiId,
})
if len(kpicTitles) > 0 {
c.JSON(200, resp.ErrMsg("indicator already exist"))
return
}
insertId := s.kpiReportService.TitleInsert(body)
if insertId > 0 {
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, resp.Err(nil))
}
// 统计标题修改
//
// PUT /title
func (s KPIController) EditTitle(c *gin.Context) {
var body model.KpiTitle
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
rows := s.kpiReportService.TitleUpdate(body)
if rows > 0 {
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, resp.Err(nil))
}
// 统计标题删除
//
// DELETE /title?id=1,2,3
func (s KPIController) RemoveTitle(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Query("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.kpiReportService.TitleDeleteByIds(ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}

183
src/modules/ne_data/controller/all_kpi_c.go Normal file
View File

@@ -0,0 +1,183 @@
package controller
import (
"fmt"
"strconv"
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 KPICController 结构体
var NewKPIC = &KPICController{
neInfoService: neService.NewNeInfo,
kpicReportService: neDataService.NewKpiCReport,
}
// 性能统计
//
// PATH /kpic
type KPICController struct {
neInfoService *neService.NeInfo // 网元信息服务
kpicReportService *neDataService.KpiCReport // 指标统计服务
}
// 获取统计数据
//
// GET /data
//
// @Tags ne_data/kpi
// @Accept json
// @Produce json
// @Param neType query string true "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC) default(AMF)
// @Param neId query string true "NE ID" default(001)
// @Param beginTime query number true "begin time (timestamped milliseconds)" default(1729162507596)
// @Param endTime query number true "end time (timestamped milliseconds)" default(1729164187611)
// @Param interval query number true "interval" Enums(5,10,15,30,60,300,600,900,1800,3600) default(60)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access to statistical data
// @Description Access to statistical data
// @Router /neData/kpic/data [get]
func (s KPICController) KPIData(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var querys model.KPICQuery
if err := c.ShouldBindQuery(&querys); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
querys.RmUID = neInfo.RmUID
// 查询数据
kpiData := s.kpicReportService.FindData(querys)
c.JSON(200, resp.OkData(kpiData))
}
// 自定义标题列表
//
// GET /title/list
func (s KPICController) ListTitle(c *gin.Context) {
query := reqctx.QueryMap(c)
if v, ok := query["status"]; ok && v == "" {
query["status"] = "1"
}
rows, total := s.kpicReportService.TitleFindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"total": total, "rows": rows}))
}
// 自定义标题新增
//
// POST /title
func (s KPICController) AddTitle(c *gin.Context) {
var body model.KpiCTitle
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 校验指标是否存在
kpicTitles := s.kpicReportService.TitleFind(model.KpiCTitle{
NeType: body.NeType,
KpiId: body.KpiId,
})
if len(kpicTitles) > 0 {
for _, v := range kpicTitles {
if v.Status == "2" {
c.JSON(200, resp.ErrMsg("custom indicator already exist"))
return
}
}
}
// 生成自定义指标ID
if body.KpiId == "" {
body.KpiId = fmt.Sprintf("%s.C.01", strings.ToUpper(body.NeType))
} else {
// 网元类型最后指标ID
lastKpiId := s.kpicReportService.TitleLastKPIId(body.NeType)
if lastKpiId != "" {
// title like AMF.C.01 截断 .C. 并获取后面的数字部分
parts := strings.Split(lastKpiId, ".C.")
if len(parts) == 2 {
numStr := parts[1]
if num, err := strconv.Atoi(numStr); err == nil {
num++ // 数字加 1
// 转换为前面补零的 2 位字符串
body.KpiId = fmt.Sprintf("%s.C.%02d", strings.ToUpper(body.NeType), num)
}
}
}
}
body.CreatedBy = reqctx.LoginUserToUserName(c)
insertId := s.kpicReportService.TitleInsert(body)
if insertId > 0 {
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, resp.Err(nil))
}
// 自定义标题修改
//
// PUT /title
func (s KPICController) EditTitle(c *gin.Context) {
var body model.KpiCTitle
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
rows := s.kpicReportService.TitleUpdate(body)
if rows > 0 {
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, resp.Err(nil))
}
// 自定义标题删除
//
// DELETE /title
func (s KPICController) RemoveTitle(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Query("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.kpicReportService.TitleDeleteByIds(ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}

123
src/modules/ne_data/controller/all_nb_state.go Normal file
View File

@@ -0,0 +1,123 @@
package controller
import (
"fmt"
"time"
"github.com/gin-gonic/gin"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
)
// 实例化控制层 NBStateController 结构体
var NewNBState = &NBStateController{
neInfoService: neService.NewNeInfo,
nbStateService: neDataService.NewNBState,
}
// 基站状态历史记录 AMF/MME
//
// PATH /nb-state
type NBStateController struct {
neInfoService *neService.NeInfo // 网元信息服务
nbStateService *neDataService.NBState // 基站状态服务
}
// 历史记录列表
//
// GET /list
//
// @Tags ne_data/amf,ne_data/mme
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only AMF/MME" Enums(AMF,MME) default(AMF)
// @Param neId query string true "NE ID" default(001)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Param startTime query number false "Start time (timestamped milliseconds)" default(1729162507596)
// @Param endTime query number false "End time (timestamped milliseconds)" default(1729164187611)
// @Param sortField query string false "Sort fields, fill in result fields" Enums(id,create_time) default(id)
// @Param sortOrder query string false "Sort by ascending or descending order" Enums(asc,desc) default(asc)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Base Station Status List
// @Description Base Station Status List
// @Router /nb-state/list [get]
func (s NBStateController) List(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query model.NBStateQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query.NeType, query.NeID)
if neInfo.NeId != query.NeID || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query.RmUID = neInfo.RmUID
// 查询数据
rows, total := s.nbStateService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 历史记录列表导出
//
// GET /export
//
// @Tags ne_data/amf,ne_data/mme
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Base Station Status List Export
// @Description Base Station Status List Export
// @Router /nb-state/export [get]
func (s NBStateController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
var querys model.NBStateQuery
if err := c.ShouldBindBodyWithJSON(&querys); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 限制导出数据集
if querys.PageSize > 10000 {
querys.PageSize = 10000
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
querys.RmUID = neInfo.RmUID
rows, total := s.nbStateService.FindByPage(querys)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("nb_state_records_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.nbStateService.ExportXlsx(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

59
src/modules/ne_data/controller/all_ne_state.go Normal file
View File

@@ -0,0 +1,59 @@
package controller
import (
"fmt"
"github.com/gin-gonic/gin"
"be.ems/src/framework/resp"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
)
// 实例化控制层 NEStateController 结构体
var NewNEState = &NEStateController{
neInfoService: neService.NewNeInfo,
neStateService: neDataService.NewNEState,
}
// 网元状态记录
//
// PATH /ne-state
type NEStateController struct {
neInfoService *neService.NeInfo // 网元信息服务
neStateService *neDataService.NEState // 网元状态服务
}
// 网元状态记录-内存/CPU/磁盘列表
//
// GET /list
//
// @Tags ne_data
// @Accept json
// @Produce json
// @Param neType query string true "NE Type" Enums(IMS,AMF,AUSF,UDM,SMF,PCF,NSSF,NRF,UPF,MME,CBC,OMC,SGWC,SMSC) default(AMF)
// @Param neId query string true "NE ID" default(001)
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Param startTime query number false "Start time (timestamped milliseconds)" default(1729162507596)
// @Param endTime query number false "End time (timestamped milliseconds)" default(1729164187611)
// @Param sortField query string false "Sort fields, fill in result fields" Enums(id,create_time) default(id)
// @Param sortOrder query string false "Sort by ascending or descending order" Enums(asc,desc) default(asc)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary NE Status Record - Memory/CPU/Disk List
// @Description NE Status Record - Memory/CPU/Disk List
// @Router /ne-state/list [get]
func (s NEStateController) List(c *gin.Context) {
var query model.NEStateQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询数据
rows, total := s.neStateService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}

234
src/modules/ne_data/controller/amf.go Normal file
View File

@@ -0,0 +1,234 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 AMFController 结构体
var NewAMF = &AMFController{
neInfoService: neService.NewNeInfo,
ueEventService: neDataService.NewUEEvent,
}
// 网元AMF
//
// PATH /amf
type AMFController struct {
neInfoService *neService.NeInfo // 网元信息服务
ueEventService *neDataService.UEEvent // UE会话事件服务
}
// UE会话列表
//
// GET /ue/list
//
// @Tags ne_data/amf
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only AMF" Enums(AMF)
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session List
// @Description UE Session List
// @Router /neData/amf/ue/list [get]
func (s *AMFController) UEList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.ueEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UE会话删除
//
// DELETE /ue/:id
//
// @Tags ne_data/amf
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session Deletion
// @Description UE Session Deletion
// @Router /neData/amf/ue/{id} [delete]
func (s *AMFController) UERemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.ueEventService.DeleteByIds("AMF", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// UE会话列表导出
//
// GET /ue/export
//
// @Tags ne_data/amf
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session List Export
// @Description UE Session List Export
// @Router /neData/amf/ue/export [get]
func (s *AMFController) UEExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.ueEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("amf_ue_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.ueEventService.ExportAMF(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}
// 接入基站信息列表
//
// GET /nb/list
//
// @Tags ne_data/amf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param id query string false "Base Station ID"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access Base Station Information List
// @Description Access Base Station Information List
// @Router /neData/amf/nb/list [get]
func (s *AMFController) NbInfoList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
NbId string `form:"id"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("AMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.AMFNbInfoList(neInfo, map[string]string{
"id": query.NbId,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}
// 接入基站状态信息列表
//
// GET /nb/list-cfg
//
// @Tags ne_data/amf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access to the base station status information list
// @Description Access to the base station status information list
// @Router /neData/amf/nb/list-cfg [get]
func (s *AMFController) NbStateList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Query("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("AMF", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.AMFGnbStateList(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}

317
src/modules/ne_data/controller/cbc.go Normal file
View File

@@ -0,0 +1,317 @@
package controller
import (
"encoding/json"
"fmt"
"strconv"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
const (
neType = "CBC" // 网元类型
)
// 实例化控制层 CBCController 结构体
var NewCBC = &CBCController{
neInfoService: neService.NewNeInfo,
neCBCMessageService: neDataService.NewCBCMessage,
}
// 网元CBC
type CBCController struct {
neInfoService *neService.NeInfo // 网元信息服务
neCBCMessageService *neDataService.CBCMessage // CBC消息服务
}
func (m *CBCController) List(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Query("neId")
if neId == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
var query model.CBCMessageQuery
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
query.NeType = neType
query.NeId = neId
data, total, err := neDataService.NewCBCMessage.SelectByPage(query)
if err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
// 转换数据格式，确保 MessageJson 正确序列化
processedData := make([]map[string]interface{}, len(data))
for i, msg := range data {
var messageJson interface{}
if len(msg.MessageJson) > 0 {
// 尝试解析为 JSON 对象
if err := json.Unmarshal(msg.MessageJson, &messageJson); err != nil {
// 如果解析失败，就作为字符串
messageJson = string(msg.MessageJson)
}
}
processedData[i] = map[string]interface{}{
"id": msg.Id,
"neType": msg.NeType,
"neId": msg.NeId,
"messageJson": messageJson, // 这里是解析后的 JSON 对象
"status": msg.Status.Enum(),
"detail": msg.Detail,
"createdAt": msg.CreatedAt,
"updatedAt": msg.UpdatedAt,
}
}
c.JSON(200, resp.Ok(gin.H{
"total": total,
"data": processedData,
}))
}
// Update 更新CB消息
func (m *CBCController) Insert(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 绑定请求体
var msg model.CBCMessage
msg.NeType = neType
msg.NeId = c.Query("neId")
msg.Status = model.CBCEventStatusInactive // 默认状态为 INACTIVE
if msg.NeId == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
now := time.Now().UnixMilli()
msg.CreatedAt = now
msg.UpdatedAt = now
// 使用 ShouldBindBodyWithJSON 读取请求体
var jsonData interface{}
if err := c.ShouldBindBodyWithJSON(&jsonData); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 将绑定的数据转换为 JSON
jsonBytes, err := json.Marshal(jsonData)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
msg.MessageJson = json.RawMessage(jsonBytes)
if err := neDataService.NewCBCMessage.Insert(msg); err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// Update 更新CB消息
func (m *CBCController) Update(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 获取路径参数
messageId := c.Param("id")
if messageId == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
id, err := strconv.ParseInt(messageId, 10, 64)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 直接读取body为json.RawMessage
var jsonData interface{}
if err := c.ShouldBindBodyWithJSON(&jsonData); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 将绑定的数据转换为 JSON
jsonBytes, err := json.Marshal(jsonData)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
messageJson := json.RawMessage(jsonBytes)
if err := neDataService.NewCBCMessage.Update(id, messageJson); err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// UpdateStatus 更新CB消息状态
// 这里的 neId 参数是为了兼容性，实际更新状态时不需要使用它
// 但为了保持与原有接口一致，仍然保留该参数
// 如果需要根据 neId 进行特定的逻辑处理，可以在服务层实现
// 但在当前实现中，neId 仅用于验证请求的有效性
// 实际的状态更新逻辑不依赖于 neId
// 该接口用于更新 CB 消息的状态，状态值通过查询参数传递
// 例如：PUT /:neId/message/status?status=ACTIVE
func (m *CBCController) UpdateStatus(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Query("neId")
status := c.Param("status")
if neId == "" || status == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
messageId := c.Param("id")
if messageId != "" {
id, err := strconv.ParseInt(messageId, 10, 64)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 如果提供了 messageId，则更新特定消息的状态
if err := neDataService.NewCBCMessage.UpdateStatus(id, status); err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
return
}
// 如果没有提供 messageId，则更新所有消息的状态
if err := neDataService.NewCBCMessage.UpdateStatusByNeId(neId, status); err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// Delete 删除CB消息
func (m *CBCController) Delete(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 获取路径参数
messageId := c.Param("id")
if messageId == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
id, err := strconv.ParseInt(messageId, 10, 64)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
if err := neDataService.NewCBCMessage.Delete(id); err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// ListById 根据ID获取CB消息
func (m *CBCController) ListById(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 获取路径参数
idStr := c.Param("id")
if idStr == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
id, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
data, err := neDataService.NewCBCMessage.SelectById(id)
if err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
if data == nil {
c.JSON(404, resp.CodeMsg(404, i18n.TKey(language, "app.common.err404")))
return
}
// 转换数据格式，确保 MessageJson 正确序列化
var messageJson interface{}
if len(data.MessageJson) > 0 {
// 尝试解析为 JSON 对象
if err := json.Unmarshal(data.MessageJson, &messageJson); err != nil {
// 如果解析失败，就作为字符串
messageJson = string(data.MessageJson)
}
}
processedData := map[string]interface{}{
"id": data.Id,
"neType": data.NeType,
"neId": data.NeId,
"messageJson": messageJson, // 这里是解析后的 JSON 对象
"status": data.Status.Enum(),
"detail": data.Detail,
"createdAt": data.CreatedAt,
"updatedAt": data.UpdatedAt,
}
c.JSON(200, resp.Ok(gin.H{
"data": processedData,
}))
}
func (m *CBCController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
var query model.CBCMessageQuery
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 限制导出数据集
if query.PageSize > 10000 {
query.PageSize = 10000
}
// 查询数据
rows, total, err := m.neCBCMessageService.SelectByPage(query)
if err != nil {
c.JSON(500, resp.ErrMsg(err.Error()))
return
}
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("cbc_message_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := m.neCBCMessageService.ExportXlsx(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

238
src/modules/ne_data/controller/ims.go Normal file
View File

@@ -0,0 +1,238 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 IMSController 结构体
var NewIMS = &IMSController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREvent,
}
// 网元IMS
//
// PATH /ims
type IMSController struct {
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREvent // CDR会话事件服务
}
// CDR会话列表
//
// GET /cdr/list
//
// @Tags ne_data/ims
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only IMS" Enums(IMS)
// @Param neId query string true "NE ID" default(001)
// @Param callerParty query string false "callerParty"
// @Param calledParty query string false "calledParty"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List
// @Description CDR Session List
// @Router /neData/ims/cdr/list [get]
func (s *IMSController) CDRList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// CDR会话删除
//
// DELETE /cdr/:id
//
// @Tags ne_data/ims
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session Delete
// @Description CDR Session Delete
// @Router /neData/ims/cdr/{id} [delete]
func (s *IMSController) CDRRemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(442002, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.cdrEventService.DeleteByIds("IMS", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// CDR会话列表导出
//
// GET /cdr/export
//
// @Tags ne_data/ims
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List Export
// @Description CDR Session List Export
// @Router /neData/ims/cdr/export [get]
func (s *IMSController) CDRExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("ims_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.cdrEventService.ExportIMS(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}
// 在线会话用户数量
//
// GET /session/num
//
// @Tags ne_data/ims
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Number of online session users
// @Description Number of online session users
// @Router /neData/ims/session/num [get]
func (s *IMSController) UeSessionNum(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Query("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("IMS", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
num, err := neFetchlink.IMSUeSessionNum(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(num))
}
// 在线会话用户列表信息
//
// GET /session/list
//
// @Tags ne_data/ims
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Param msisdn query string false "msisdn"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Online session user list information
// @Description Online session user list information
// @Router /neData/ims/session/list [get]
func (s *IMSController) UeSessionList(c *gin.Context) {
language := reqctx.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 {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("IMS", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.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, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}

234
src/modules/ne_data/controller/mme.go Normal file
View File

@@ -0,0 +1,234 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 MMEController 结构体
var NewMME = &MMEController{
neInfoService: neService.NewNeInfo,
ueEventService: neDataService.NewUEEvent,
}
// 网元MME
//
// PATH /mme
type MMEController struct {
neInfoService *neService.NeInfo // 网元信息服务
ueEventService *neDataService.UEEvent // UE会话事件服务
}
// UE会话列表
//
// GET /ue/list
//
// @Tags ne_data/mme
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only MME" Enums(MME)
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session List
// @Description UE Session List
// @Router /neData/mme/ue/list [get]
func (s *MMEController) UEList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.ueEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UE会话删除
//
// DELETE /ue/:id
//
// @Tags ne_data/mme
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session Deletion
// @Description UE Session Deletion
// @Router /neData/mme/ue/{id} [delete]
func (s *MMEController) UERemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.ueEventService.DeleteByIds("MME", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// UE会话列表导出
//
// GET /ue/export
//
// @Tags ne_data/mme
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UE Session List Export
// @Description UE Session List Export
// @Router /neData/mme/ue/export [get]
func (s *MMEController) UEExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.ueEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("mme_ue_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.ueEventService.ExportMME(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}
// 接入基站信息列表
//
// GET /nb/list
//
// @Tags ne_data/mme
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param id query string false "Base Station ID"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access Base Station Information List
// @Description Access Base Station Information List
// @Router /neData/mme/nb/list [get]
func (s *MMEController) NbInfoList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
NbId string `form:"id"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("MME", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.MMENbInfoList(neInfo, map[string]string{
"id": query.NbId,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}
// 接入基站状态信息列表
//
// GET /nb/list-cfg
//
// @Tags ne_data/mme
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Access to the base station status information list
// @Description Access to the base station status information list
// @Router /neData/mme/nb/list-cfg [get]
func (s *MMEController) NbStateList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Query("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("MME", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.MMEEnbStateList(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}

70
src/modules/ne_data/controller/n3iwf.go Normal file
View File

@@ -0,0 +1,70 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 N3IWFController 结构体
var NewN3IWF = &N3IWFController{
neInfoService: neService.NewNeInfo,
}
// 网元N3IWF
//
// PATH /n3iwf
type N3IWFController struct {
neInfoService *neService.NeInfo // 网元信息服务
}
// 在线订阅用户列表信息
//
// GET /sub/list
//
// @Tags ne_data/n3iwf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Online session user list information
// @Description Online session user list information
// @Router /neData/n3iwf/sub/list [get]
func (s N3IWFController) SubUserList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
IMSI string `form:"imsi"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("N3IWF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.N3IWFSubInfoList(neInfo, map[string]string{
"imsi": query.IMSI,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}

107
src/modules/ne_data/controller/nssf.go Normal file
View File

@@ -0,0 +1,107 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 NSSFController 结构体
var NewNSSF = &NSSFController{
neInfoService: neService.NewNeInfo,
}
// 网元NSSF
//
// PATH /NSSF
type NSSFController struct {
neInfoService *neService.NeInfo // 网元信息服务
}
// 在线订阅用户列表信息
//
// GET /sub/list
//
// @Tags ne_data/nssf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Online session user list information
// @Description Online session user list information
// @Router /neData/nssf/sub/list [get]
func (s NSSFController) SubUserList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("NSSF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.NSSFSubInfoList(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}
// 可用AMF列表信息
//
// GET /amf/list
//
// @Tags ne_data/nssf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Online session user list information
// @Description Online session user list information
// @Router /neData/nssf/amf/list [get]
func (s NSSFController) AvailableList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("NSSF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.NSSFAvailableAMFList(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}

328
src/modules/ne_data/controller/pcf.go Normal file
View File

@@ -0,0 +1,328 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 PCFController 结构体
var NewPCF = &PCFController{
neInfoService: neService.NewNeInfo,
}
// 网元PCF
//
// PATH /pcf
type PCFController struct {
neInfoService *neService.NeInfo // 网元信息服务
}
// 策略配置列表
//
// GET /rule/list
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "IMSI"
// @Param msisdn query string false "MSISDN"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration List
// @Description Policy Configuration List
// @Router /neData/pcf/rule/list [get]
func (s PCFController) RuleInfoList(c *gin.Context) {
language := reqctx.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 {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.PCFRuleInfo(neInfo, map[string]string{
"imsi": query.IMSI,
"msisdn": query.MSISDN,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(data))
}
// 策略配置添加
//
// POST /rule
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration Additions
// @Description Policy Configuration Additions
// @Router /neData/pcf/rule [post]
func (s PCFController) RuleInfoAdd(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"` // 网元ID
Num int64 `json:"num"` // 批量添加，默认0单条，大于1时imsi/msisdn会累加数值
ParamData map[string]any `json:"paramData" binding:"required"` // 参数数据
// Imsi string `json:"imsi" binding:"required"`
// Msisdn string `json:"msisdn" binding:"required"`
// Sar string `json:"sar"` // 根据PCF参数配置Service Area Restriction -> Name
// PccRules string `json:"pccRules"` // 根据PCF参数配置PCC Rules -> Rule ID
// QosAudio string `json:"qosAudio"` // 根据PCF参数配置QoS Template -> QoS ID
// QosVideo string `json:"qosVideo"` // 根据PCF参数配置QoS Template -> QoS ID
// SessRules string `json:"sessRules"` // 根据PCF参数配置Session Rules -> Rule ID
// HdrEnrich string `json:"hdrEnrich"` // 根据PCF参数配置Header Enrich Template -> Template Name
// UePolicy string `json:"uePolicy"` // UE策略模板(样例: uep_001)
// Rfsp int64 `json:"rfsp"` // 无线频率选择优先级
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
var err error
if body.Num > 0 { // 批量添加
err = neFetchlink.PCFRuleAddBatch(neInfo, body.ParamData, body.Num)
} else { // 单条添加
err = neFetchlink.PCFRuleAdd(neInfo, body.ParamData)
}
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// 策略配置更新
//
// PUT /rule
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration Updates
// @Description Policy Configuration Updates
// @Router /neData/pcf/rule [put]
func (s PCFController) RuleInfoEdit(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"` // 网元ID
Num int64 `json:"num"` // 更新数量
ParamData map[string]any `json:"paramData" binding:"required"` // 参数数据
// Imsi string `json:"imsi" binding:"required"`
// Msisdn string `json:"msisdn" binding:"required"`
// Sar string `json:"sar"` // 根据PCF参数配置Service Area Restriction -> Name
// PccRules string `json:"pccRules"` // 根据PCF参数配置PCC Rules -> Rule ID
// QosAudio string `json:"qosAudio"` // 根据PCF参数配置QoS Template -> QoS ID
// QosVideo string `json:"qosVideo"` // 根据PCF参数配置QoS Template -> QoS ID
// SessRules string `json:"sessRules"` // 根据PCF参数配置Session Rules -> Rule ID
// HdrEnrich string `json:"hdrEnrich"` // 根据PCF参数配置Header Enrich Template -> Template Name
// UePolicy string `json:"uePolicy"` // UE策略模板(样例: uep_001)
// Rfsp int64 `json:"rfsp"` // 无线频率选择优先级
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
var err error
if body.Num > 0 { // 批量更新
err = neFetchlink.PCFRuleUpdateBatch(neInfo, body.ParamData, body.Num)
} else { // 单条更新
err = neFetchlink.PCFRuleUpdate(neInfo, body.ParamData)
}
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// 策略配置删除
//
// DELETE /rule
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string true "IMSi, batch deletion with quantity"
// @Param num query number false "Number of deletions"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration Deletion
// @Description Policy Configuration Deletion
// @Router /neData/pcf/rule [delete]
func (s PCFController) RuleInfoRemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"` // 网元ID
IMSI string `form:"imsi" binding:"required"` // IMSi, 带数量时为批量删除
Num int64 `form:"num"` // 删除数量
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
var err error
if query.Num > 0 { // 批量删除
err = neFetchlink.PCFRuleDeleteBatch(neInfo, query.IMSI, query.Num)
} else { // 单条删除
err = neFetchlink.PCFRuleDelete(neInfo, query.IMSI)
}
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// 策略配置导出
//
// GET /rule/export
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param fileType query string true "File Type" default(txt)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration Export
// @Description Policy Configuration Export
// @Router /neData/pcf/rule/export [get]
func (s PCFController) RuleInfoExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
FileType string `form:"fileType" binding:"required,oneof=txt"` // 文件类型
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.PCFRuleExport(neInfo, map[string]string{
"fileType": query.FileType,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.Writer.Header().Set("Content-Disposition", `attachment; filename="pcf_rule_export.txt"`)
c.Data(200, "application/octet-stream", data)
}
// 策略配置导入
//
// PUT /rule/import
//
// @Tags ne_data/pcf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param fileType query string true "File Type" default(txt)
// @Param filePath query string true "File Path" default(/tmp/pcfuser.txt)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Policy Configuration Import
// @Description Policy Configuration Import
// @Router /neData/pcf/rule/import [put]
func (s PCFController) RuleInfoImport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"`
FileType string `json:"fileType" binding:"required,oneof=txt"` // 文件类型
FilePath string `json:"filePath" binding:"required"` // 网元端文件所在绝对路径
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("PCF", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
output, err := neFetchlink.PCFRuleImport(neInfo, map[string]any{
"type": body.FileType,
"filePath": body.FilePath,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkMsg(output))
}

152
src/modules/ne_data/controller/sgwc.go Normal file
View File

@@ -0,0 +1,152 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SGWCController 结构体
var NewSGWC = &SGWCController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREvent,
UDMExtendService: neDataService.NewUDMExtend,
}
// 网元SGWC
//
// PATH /sgwc
type SGWCController struct {
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREvent // CDR会话事件服务
UDMExtendService *neDataService.UDMExtend // UDM用户信息服务
}
// CDR会话列表
//
// GET /cdr/list
//
// @Tags ne_data/sgwc
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only SGWC" Enums(SGWC)
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Param msisdn query string false "msisdn"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List
// @Description CDR Session List
// @Router /neData/sgwc/cdr/list [get]
func (s *SGWCController) CDRList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// CDR会话删除
//
// DELETE /cdr/:id
//
// @Tags ne_data/sgwc
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session Delete
// @Description CDR Session Delete
// @Router /neData/sgwc/cdr/{id} [delete]
func (s *SGWCController) CDRRemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.cdrEventService.DeleteByIds("SGWC", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// CDR会话列表导出
//
// POST /cdr/export
//
// @Tags ne_data/sgwc
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List Export
// @Description CDR Session List Export
// @Router /neData/sgwc/cdr/export [post]
func (s *SGWCController) CDRExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("sgwc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.cdrEventService.ExportSGWC(rows, fileName)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

269
src/modules/ne_data/controller/smf.go Normal file
View File

@@ -0,0 +1,269 @@
package controller
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SMFController 结构体
var NewSMF = &SMFController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREvent,
UDMExtendService: neDataService.NewUDMExtend,
}
// 网元SMF
//
// PATH /smf
type SMFController struct {
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREvent // CDR会话事件服务
UDMExtendService *neDataService.UDMExtend // UDM用户信息服务
}
// CDR会话列表
//
// GET /cdr/list
//
// @Tags ne_data/smf
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only SMF" Enums(SMF)
// @Param neId query string true "NE ID" default(001)
// @Param subscriberID query string false "subscriberID is IMSI"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List
// @Description CDR Session List
// @Router /neData/smf/cdr/list [get]
func (s *SMFController) CDRList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// CDR会话删除
//
// DELETE /cdr/:id
//
// @Tags ne_data/smf
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session Delete
// @Description CDR Session Delete
// @Router /neData/smf/cdr/{id} [delete]
func (s *SMFController) CDRRemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.cdrEventService.DeleteByIds("SMF", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// CDR会话列表导出
//
// GET /cdr/export
//
// @Tags ne_data/smf
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List Export
// @Description CDR Session List Export
// @Router /neData/smf/cdr/export [get]
func (s *SMFController) CDRExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("smf_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.cdrEventService.ExportSMF(rows, fileName)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}
// 在线订阅用户数量
//
// GET /sub/num
//
// @Tags ne_data/smf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Number of online session users
// @Description Number of online session users
// @Router /neData/smf/sub/num [get]
func (s *SMFController) SubUserNum(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("SMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
num, err := neFetchlink.SMFSubNum(neInfo)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.OkData(num))
}
// 在线订阅用户列表信息
//
// GET /sub/list
//
// @Tags ne_data/smf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "imsi"
// @Param msisdn query string false "msisdn"
// @Param upstate query string false "upstate"
// @Param pageNum query string true "pageNum" default(50)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Online session user list information
// @Description Online session user list information
// @Router /neData/smf/sub/list [get]
func (s *SMFController) SubUserList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
NeId string `form:"neId" binding:"required"`
IMSI string `form:"imsi"`
MSISDN string `form:"msisdn"`
Upstate string `form:"upstate"`
PageNum string `form:"pageNum"`
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元信息
neInfo := s.neInfoService.FindByNeTypeAndNeID("SMF", query.NeId)
if neInfo.NeId != query.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元直连
data, err := neFetchlink.SMFSubInfoList(neInfo, map[string]string{
"imsi": query.IMSI,
"msisdn": query.MSISDN,
"upstate": query.Upstate,
"pageNum": query.PageNum,
})
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 对数据进行处理，去掉前缀，并加入imsi拓展信息
rows := data["rows"].([]any)
if len(rows) > 0 {
arr := &rows
for i := range *arr {
item := (*arr)[i].(map[string]any)
if v, ok := item["imsi"]; ok && v != nil {
imsiStr := v.(string)
imsiStr = strings.TrimPrefix(imsiStr, "imsi-")
item["imsi"] = imsiStr
// 查UDM拓展信息
info := s.UDMExtendService.FindByIMSIAndNeID(imsiStr, "%")
item["remark"] = info.Remark
}
if v, ok := item["msisdn"]; ok && v != nil {
item["msisdn"] = strings.TrimPrefix(v.(string), "msisdn-")
}
}
}
c.JSON(200, resp.OkData(data))
}

151
src/modules/ne_data/controller/smsc.go Normal file
View File

@@ -0,0 +1,151 @@
package controller
import (
"fmt"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SMSCController 结构体
var NewSMSC = &SMSCController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREvent,
}
// 网元SMSC
//
// PATH /smsc
type SMSCController struct {
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREvent // CDR会话事件服务
}
// CDR会话列表
//
// GET /cdr/list
//
// @Tags ne_data/smsc
// @Accept json
// @Produce json
// @Param neType query string true "NE Type only SMSC" Enums(SMSC)
// @Param neId query string true "NE ID" default(001)
// @Param callerParty query string false "callerParty"
// @Param calledParty query string false "calledParty"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List
// @Description CDR Session List
// @Router /neData/smsc/cdr/list [get]
func (s *SMSCController) CDRList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// CDR会话删除
//
// DELETE /cdr/:id
//
// @Tags ne_data/smsc
// @Accept json
// @Produce json
// @Param id path string true "list data id, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session Delete
// @Description CDR Session Delete
// @Router /neData/smsc/cdr/{id} [delete]
func (s *SMSCController) CDRRemove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.cdrEventService.DeleteByIds("SMSC", ids)
if err != nil {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, resp.OkMsg(msg))
}
// CDR会话列表导出
//
// GET /cdr/export
//
// @Tags ne_data/smsc
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary CDR Session List Export
// @Description CDR Session List Export
// @Router /neData/smsc/cdr/export [get]
func (s *SMSCController) CDRExport(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 限制导出数据集
pageSize := parse.Number(query["pageSize"])
if pageSize > 10000 {
query["pageSize"] = "10000"
}
// 查询网元信息 rmUID
neInfo := s.neInfoService.FindByNeTypeAndNeID(query["neType"], query["neId"])
if neInfo.NeType == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
query["rmUID"] = neInfo.RmUID
rows, total := s.cdrEventService.FindByPage(neInfo.NeType, query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 导出文件名称
fileName := fmt.Sprintf("smsc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 导出数据表格
saveFilePath, err := s.cdrEventService.ExportSMSC(rows, fileName, language)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

647
src/modules/ne_data/controller/udm_auth.go Normal file
View File

@@ -0,0 +1,647 @@
package controller
import (
"fmt"
"path/filepath"
"strings"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
neFetchlink "be.ems/src/modules/ne/fetch_link"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 UDMAuthController 结构体
var NewUDMAuth = &UDMAuthController{
udmAuthService: neDataService.NewUDMAuthUser,
neInfoService: neService.NewNeInfo,
}
// UDM鉴权用户
//
// PATH /udm/auth
type UDMAuthController struct {
udmAuthService *neDataService.UDMAuthUser // UDM鉴权信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDM鉴权用户重载数据
//
// PUT /resetData/:neId
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User Data Refresh
// @Description UDM Authenticated User Data List Refresh Synchronization Latest
// @Router /neData/udm/auth/resetData/{neId} [put]
func (s *UDMAuthController) ResetData(c *gin.Context) {
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
data := s.udmAuthService.ResetData(neId)
c.JSON(200, resp.OkData(data))
}
// UDM鉴权用户列表
//
// GET /list
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "IMSI"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User List
// @Description UDM Authentication User List
// @Router /neData/udm/auth/list [get]
func (s *UDMAuthController) List(c *gin.Context) {
query := reqctx.QueryMap(c)
rows, total := s.udmAuthService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UDM鉴权用户信息
//
// GET /:neId/:imsi
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User Information
// @Description UDM Authentication User Information
// @Router /neData/udm/auth/{neId}/{value} [get]
func (s *UDMAuthController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
if neId == "" || imsi == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("dsp authdat:imsi=%s", imsi)
data, err := telnet.ConvertToMap(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
if len(data) == 0 {
c.JSON(200, resp.ErrMsg("No Auth Data"))
return
}
// 解析返回的数据
u := s.udmAuthService.ParseInfo(imsi, neId, data)
s.udmAuthService.Insert(neId, u)
c.JSON(200, resp.OkData(u))
}
// UDM鉴权用户新增
//
// POST /:neId
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User Added
// @Description UDM Authentication User Added
// @Router /neData/udm/auth/{neId} [post]
func (s *UDMAuthController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMAuthUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.IMSI == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("add authdat:imsi=%s,", body.IMSI)
cmd += s.udmAuthService.ParseCommandParams(body)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmAuthService.Insert(neId, body)
}
c.JSON(200, resp.OkData(data))
}
// UDM鉴权用户批量新增
//
// POST /:neId/:num
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path number true "Number of releases, value includes start imsi"
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User Batch Add
// @Description UDM Authentication User Batch Add
// @Router /neData/udm/auth/{neId}/{value} [post]
func (s *UDMAuthController) Adds(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
num := c.Param("num")
if neId == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/num is empty"))
return
}
var body model.UDMAuthUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.IMSI == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("baa authdat:start_imsi=%s,sub_num=%s,", body.IMSI, num)
cmd += s.udmAuthService.ParseCommandParams(body)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmAuthService.LoadData(neId, body.IMSI, num)
}
c.JSON(200, resp.OkData(data))
}
// UDM鉴权用户修改
//
// PUT /:neId
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Modification
// @Description UDM Authenticated User Modification
// @Router /neData/udm/auth/{neId} [put]
func (s *UDMAuthController) Edit(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMAuthUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.IMSI == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("mod authdata:imsi=%s,", body.IMSI)
cmd += s.udmAuthService.ParseCommandParams(body)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmAuthService.Insert(neId, body)
}
c.JSON(200, resp.OkData(data))
}
// UDM鉴权用户删除
//
// DELETE /:neId/:imsi
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Deletion
// @Description UDM Authenticated User Deletion
// @Router /neData/udm/auth/{neId}/{value} [delete]
func (s *UDMAuthController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
if neId == "" || imsi == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi is empty"))
return
}
// 处理字符转id数组后去重
imsiArr := strings.Split(imsi, ",")
uniqueIDs := parse.RemoveDuplicates(imsiArr)
if len(uniqueIDs) <= 0 {
c.JSON(200, resp.Err(nil))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
resultData := map[string]string{}
for _, imsi := range uniqueIDs {
// 发送MML
cmd := fmt.Sprintf("del authdat:imsi=%s", imsi)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
resultData[imsi] = err.Error()
continue
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmAuthService.Delete(imsi, neId)
}
resultData[imsi] = data
}
c.JSON(200, resp.OkData(resultData))
}
// UDM鉴权用户批量删除
//
// DELETE /:neId/:imsi/:num
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param imsi path string true "IMSI"
// @Param num path number true "Number of releases, value includes start imsi"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authentication User Batch Deletion
// @Description UDM Authentication User Batch Deletion
// @Router /neData/udm/auth/{neId}/{imsi}/{num} [delete]
func (s *UDMAuthController) Removes(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
num := c.Param("num")
if neId == "" || imsi == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi/num is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("bde authdat:start_imsi=%s,sub_num=%s", imsi, num)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmAuthService.LoadData(neId, imsi, num)
}
c.JSON(200, resp.OkData(data))
}
// UDM鉴权用户导出
//
// GET /export
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param type query string true "File Type" Enums(csv,txt) default(txt)
// @Param imsi query string false "IMSI"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Export
// @Description UDM Authenticated User Export
// @Router /neData/udm/auth/export [get]
func (s *UDMAuthController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
neId := c.Query("neId")
fileType := c.Query("type")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
if !(fileType == "csv" || fileType == "txt") {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserSubFileFormat")))
return
}
query := reqctx.QueryMap(c)
rows, total := s.udmAuthService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// rows := s.udmAuthService.SelectList(model.UDMAuthUser{NeId: neId})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 文件名
fileName := fmt.Sprintf("udm_auth_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := filepath.Join(file.ParseUploadFileDir(constants.UPLOAD_EXPORT), fileName)
if fileType == "csv" {
// 转换数据
data := [][]string{}
data = append(data, []string{"imsi", "ki", "algo", "amf", "opc"})
for _, v := range rows {
opc := v.Opc
if opc == "-" {
opc = ""
}
data = append(data, []string{v.IMSI, v.Ki, v.AlgoIndex, v.Amf, opc})
}
// 输出到文件
if err := file.WriterFileCSV(data, filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
if fileType == "txt" {
// 转换数据
data := [][]string{}
for _, v := range rows {
opc := v.Opc
if opc == "-" {
opc = ""
}
data = append(data, []string{v.IMSI, v.Ki, v.AlgoIndex, v.Amf, opc})
}
// 输出到文件
if err := file.WriterFileTXTLine(data, ",", filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
c.FileAttachment(filePath, fileName)
}
// UDM鉴权用户导入
//
// POST /import
//
// @Tags ne_data/udm/auth
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Import
// @Description UDM Authenticated User Import
// @Router /neData/udm/auth/import [post]
func (s *UDMAuthController) Import(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"` // 网元ID
UploadPath string `json:"uploadPath" binding:"required"` // 上传文件路径
TypeVal string `json:"typeVal" binding:"required,oneof=default k4"` // default: 默认导入方式, k4: k4类型导入方式
TypeData any `json:"typeData"` // k4类型的数据密钥
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 判断文件名
if !(strings.HasSuffix(body.UploadPath, ".csv") || strings.HasSuffix(body.UploadPath, ".txt")) {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserAuthFileFormat")))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的SSH客户端
// sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sshClient.Close()
// // 网元主机的SSH客户端进行文件传输
// sftpClient, err := sshClient.NewClientSFTP()
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sftpClient.Close()
// 本地文件
localFilePath := file.ParseUploadFileAbsPath(body.UploadPath)
neFilePath := fmt.Sprintf("/tmp/%s", filepath.Base(localFilePath))
// 复制到远程
// if err = sftpClient.CopyFileLocalToRemote(localFilePath, neFilePath); err != nil {
// c.JSON(200, resp.ErrMsg("error uploading file"))
// return
// }
if err := file.CopyFile(localFilePath, neFilePath); err != nil {
c.JSON(200, resp.ErrMsg("error uploading file"))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.NeType, neInfo.NeId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 结果信息
var resultMsg string
var resultErr error
// 默认的情况 发送MML
if body.TypeVal == "default" {
cmd := fmt.Sprintf("import authdat:path=%s", neFilePath)
resultMsg, resultErr = telnet.ConvertToStr(telnetClient, cmd)
}
// K4类型发特定请求
if body.TypeVal == "k4" {
resultMsg, resultErr = neFetchlink.UDMImportAuth(neInfo.IP, map[string]any{
"path": neFilePath, "k4": body.TypeData,
})
}
if resultErr != nil {
c.JSON(200, resp.ErrMsg(resultErr.Error()))
return
}
// 命令ok时
if strings.Contains(resultMsg, "ok") {
if strings.HasSuffix(body.UploadPath, ".csv") {
data := file.ReadFileCSV(localFilePath)
go s.udmAuthService.InsertData(neInfo.NeId, "csv", data)
}
if strings.HasSuffix(body.UploadPath, ".txt") {
data := file.ReadFileTXTLine(",", localFilePath)
go s.udmAuthService.InsertData(neInfo.NeId, "txt", data)
}
}
c.JSON(200, resp.OkMsg(resultMsg))
}

631
src/modules/ne_data/controller/udm_sub.go Normal file
View File

@@ -0,0 +1,631 @@
package controller
import (
"fmt"
"path/filepath"
"strings"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 UDMSubController 结构体
var NewUDMSub = &UDMSubController{
udmSubService: neDataService.NewUDMSubUser,
neInfoService: neService.NewNeInfo,
}
// UDM签约用户
//
// PATH /udm/sub
type UDMSubController struct {
udmSubService *neDataService.UDMSubUser // UDM签约信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDM签约用户重载数据
//
// PUT /resetData/:neId
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Reload Data
// @Description UDM Subscriber User Reload Data
// @Router /neData/udm/sub/resetData/{neId} [put]
func (s *UDMSubController) ResetData(c *gin.Context) {
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
data := s.udmSubService.ResetData(neId)
c.JSON(200, resp.OkData(data))
}
// UDM签约用户列表
//
// GET /list
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "IMSI"
// @Param msisdn query string false "Msisdn"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User List
// @Description UDM Subscriber User List
// @Router /neData/udm/sub/list [get]
func (s *UDMSubController) List(c *gin.Context) {
query := reqctx.QueryMap(c)
rows, total := s.udmSubService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UDM签约用户信息
//
// GET /:neId/:imsi
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Information
// @Description UDM Subscriber User Information
// @Router /neData/udm/sub/{neId}/{value} [get]
func (s *UDMSubController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
if neId == "" || imsi == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("dsp udmuser:imsi=%s", imsi)
data, err := telnet.ConvertToMap(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
if len(data) == 0 {
c.JSON(200, resp.ErrMsg("No Subs Data"))
return
}
// 解析返回的数据
u := s.udmSubService.ParseInfo(imsi, neId, data)
s.udmSubService.Insert(neId, u)
c.JSON(200, resp.OkData(u))
}
// UDM签约用户新增
//
// POST /:neId
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Added
// @Description UDM Subscriber User Added
// @Router /neData/udm/sub/{neId} [post]
func (s *UDMSubController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMSubUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if len(body.IMSI) != 15 {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: IMSI length is not 15 bits"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("add udmuser:imsi=%s,", body.IMSI)
cmd += s.udmSubService.ParseCommandParams(body)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
body.NeId = neId
s.udmSubService.Insert(neId, body)
}
c.JSON(200, resp.OkData(data))
}
// UDM签约用户批量新增
//
// POST /:neId/:num
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path number true "Number of releases, value includes start imsi" default(1)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Batch Add
// @Description UDM Subscriber User Batch Add
// @Router /neData/udm/sub/{neId}/{value} [post]
func (s *UDMSubController) Adds(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
num := c.Param("num")
if neId == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/num is empty"))
return
}
var body model.UDMSubUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if len(body.IMSI) != 15 {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: IMSI length is not 15 bits"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("baa udmuser:start_imsi=%s,start_msisdn=%s,sub_num=%s,", body.IMSI, body.MSISDN, num)
cmd += s.udmSubService.ParseCommandParams(body)
// 去除msisdn参数，避免重复
omemsisdn := fmt.Sprintf(",msisdn=%s,", body.MSISDN)
cmd = strings.Replace(cmd, omemsisdn, ",", 1)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmSubService.LoadData(neId, body.IMSI, num, body.Remark)
}
c.JSON(200, resp.OkData(data))
}
// UDM签约用户修改
//
// PUT /:neId
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Modification
// @Description UDM Subscriber User Modification
// @Router /neData/udm/sub/{neId} [put]
func (s *UDMSubController) Edit(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMSubUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if len(body.IMSI) != 15 {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: IMSI length is not 15 bits"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("mod udmuser:imsi=%s,", body.IMSI)
cmd += s.udmSubService.ParseCommandParams(body)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
body.NeId = neId
s.udmSubService.Insert(neId, body)
}
c.JSON(200, resp.OkData(data))
}
// UDM签约用户删除
//
// DELETE /:neId/:imsi
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Deletion
// @Description UDM Subscriber User Deletion
// @Router /neData/udm/sub/{neId}/{value} [delete]
func (s *UDMSubController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
if neId == "" || len(imsi) < 15 {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi is empty"))
return
}
// 处理字符转id数组后去重
imsiArr := strings.Split(imsi, ",")
uniqueIDs := parse.RemoveDuplicates(imsiArr)
if len(uniqueIDs) <= 0 {
c.JSON(200, resp.Err(nil))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
resultData := map[string]string{}
for _, imsi := range uniqueIDs {
// 发送MML
cmd := fmt.Sprintf("del udmuser:imsi=%s", imsi)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
resultData[imsi] = err.Error()
continue
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmSubService.Delete(neId, imsi)
}
resultData[imsi] = data
}
c.JSON(200, resp.OkData(resultData))
}
// UDM签约用户批量删除
//
// DELETE /:neId/:imsi/:num
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param imsi path string true "IMSI"
// @Param num path number true "Number of releases, value includes start imsi"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Batch Deletion
// @Description UDM Subscriber User Batch Deletion
// @Router /neData/udm/sub/{neId}/{imsi}/{num} [delete]
func (s *UDMSubController) Removes(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
num := c.Param("num")
if neId == "" || len(imsi) < 15 || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi/num is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("bde udmuser:start_imsi=%s,sub_num=%s", imsi, num)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmSubService.LoadData(neId, imsi, num, "-(Deleted)-")
}
c.JSON(200, resp.OkData(data))
}
// UDM签约用户导出
//
// GET /export
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param type query string true "File Type" Enums(csv,txt) default(txt)
// @Param imsi query string false "IMSI"
// @Param msisdn query string false "Msisdn"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Export
// @Description UDM Subscriber User Export
// @Router /neData/udm/sub/export [post]
func (s *UDMSubController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
neId := c.Query("neId")
fileType := c.Query("type")
if neId == "" || fileType == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or type is empty"))
return
}
if !(fileType == "csv" || fileType == "txt") {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserSubFileFormat")))
return
}
query := reqctx.QueryMap(c)
rows, total := s.udmSubService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// rows := s.udmSubService.SelectList(model.UDMSubUser{NeId: neId})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 文件名
fileName := fmt.Sprintf("udm_sub_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := filepath.Join(file.ParseUploadFileDir(constants.UPLOAD_EXPORT), fileName)
if fileType == "csv" {
// 转换数据
data := [][]string{}
data = append(data, []string{"IMSI", "MSISDN", "UeAmbrTpl", "NssaiTpl", "AreaForbiddenTpl", "ServiceAreaRestrictionTpl", "RatRestrictions", "CnTypeRestrictions", "SmfSel", "SmData", "EPSDat"})
for _, v := range rows {
epsDat := fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s", v.EpsFlag, v.EpsOdb, v.HplmnOdb, v.Ard, v.Epstpl, v.ContextId, v.ApnContext, v.StaticIp)
data = append(data, []string{v.IMSI, v.MSISDN, v.UeAmbrTpl, v.NssaiTpl, v.AreaForbiddenTpl, v.ServiceAreaRestrictionTpl, v.RatRestrictions, v.CnTypeRestrictions, v.SmfSel, v.SmData, epsDat})
}
// 输出到文件
if err := file.WriterFileCSV(data, filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
if fileType == "txt" {
// 转换数据
data := [][]string{}
for _, v := range rows {
epsDat := fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s", v.EpsFlag, v.EpsOdb, v.HplmnOdb, v.Ard, v.Epstpl, v.ContextId, v.ApnContext, v.StaticIp)
data = append(data, []string{v.IMSI, v.MSISDN, v.UeAmbrTpl, v.NssaiTpl, v.AreaForbiddenTpl, v.ServiceAreaRestrictionTpl, v.RatRestrictions, v.CnTypeRestrictions, v.SmfSel, v.SmData, epsDat})
}
// 输出到文件
if err := file.WriterFileTXTLine(data, ",", filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
c.FileAttachment(filePath, fileName)
}
// UDM签约用户导入
//
// POST /import
//
// @Tags ne_data/udm/sub
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Subscriber User Import
// @Description UDM Subscriber User Import
// @Router /neData/udm/sub/import [post]
func (s *UDMSubController) Import(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"`
UploadPath string `json:"uploadPath" binding:"required"`
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 判断文件名
if !(strings.HasSuffix(body.UploadPath, ".csv") || strings.HasSuffix(body.UploadPath, ".txt")) {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserSubFileFormat")))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的SSH客户端
// sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sshClient.Close()
// // 网元主机的SSH客户端进行文件传输
// sftpClient, err := sshClient.NewClientSFTP()
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sftpClient.Close()
// 本地文件
localFilePath := file.ParseUploadFileAbsPath(body.UploadPath)
neFilePath := fmt.Sprintf("/tmp/%s", filepath.Base(localFilePath))
// 复制到远程
// if err = sftpClient.CopyFileLocalToRemote(localFilePath, neFilePath); err != nil {
// c.JSON(200, resp.ErrMsg("error uploading file"))
// return
// }
if err := file.CopyFile(localFilePath, neFilePath); err != nil {
c.JSON(200, resp.ErrMsg("error uploading file"))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.NeType, neInfo.NeId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("import udmuser:path=%s", neFilePath)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
if strings.HasSuffix(body.UploadPath, ".csv") {
data := file.ReadFileCSV(localFilePath)
go s.udmSubService.InsertData(neInfo.NeId, "csv", data)
}
if strings.HasSuffix(body.UploadPath, ".txt") {
data := file.ReadFileTXTLine(",", localFilePath)
go s.udmSubService.InsertData(neInfo.NeId, "txt", data)
}
}
c.JSON(200, resp.OkMsg(data))
}

565
src/modules/ne_data/controller/udm_voip.go Normal file
View File

@@ -0,0 +1,565 @@
package controller
import (
"fmt"
"path/filepath"
"strings"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 UDMVOIPController 结构体
var NewUDMVOIP = &UDMVOIPController{
udmVOIPService: neDataService.NewUDMVOIPUser,
neInfoService: neService.NewNeInfo,
}
// UDMVOIP用户
//
// PATH /udm/voip
type UDMVOIPController struct {
udmVOIPService *neDataService.UDMVOIPUser // UDMVOIP信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDMVOIP用户重载数据
//
// PUT /resetData/:neId
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Data Refresh
// @Description UDM VOIP User Data List Refresh Synchronization Latest
// @Router /neData/udm/voip/resetData/{neId} [put]
func (s *UDMVOIPController) ResetData(c *gin.Context) {
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
data := s.udmVOIPService.ResetData(neId)
c.JSON(200, resp.OkData(data))
}
// UDMVOIP用户列表
//
// GET /list
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param username query string false "User Name"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User List
// @Description UDM VOIP User List
// @Router /neData/udm/voip/list [get]
func (s *UDMVOIPController) List(c *gin.Context) {
query := reqctx.QueryMap(c)
rows, total := s.udmVOIPService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UDMVOIP用户信息
//
// GET /:neId/:username
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "User Name"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Information
// @Description UDM VOIP User Information
// @Router /neData/udm/voip/{neId}/{value} [get]
func (s *UDMVOIPController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
username := c.Param("username")
if neId == "" || username == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or username is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("dsp voip:username=%s", username)
data, err := telnet.ConvertToMap(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
if len(data) == 0 {
c.JSON(200, resp.ErrMsg("No VOIP Data"))
return
}
// 解析返回的数据
u := s.udmVOIPService.ParseInfo(neId, data)
if u.ID != "" {
s.udmVOIPService.Insert(neId, u.UserName)
c.JSON(200, resp.OkData(u))
return
}
c.JSON(200, resp.ErrMsg("No VOIP Data"))
}
// UDMVOIP用户新增
//
// POST /:neId
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Added
// @Description UDM VOIP User Added
// @Router /neData/udm/voip/{neId} [post]
func (s *UDMVOIPController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMVOIPUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.UserName == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: username is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("add voip:username=%s,password=%s", body.UserName, body.Password)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVOIPService.Insert(neId, body.UserName)
}
c.JSON(200, resp.OkData(data))
}
// UDMVOIP用户批量新增
//
// POST /:neId/:num
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path number true "Number of releases, value includes start username"
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Batch Add
// @Description UDM VOIP User Batch Add
// @Router /neData/udm/voip/{neId}/{value} [post]
func (s *UDMVOIPController) Adds(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
num := c.Param("num")
if neId == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or num is empty"))
return
}
var body model.UDMVOIPUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.UserName == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: username is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("baa voip:sub_num=%s,start_username=%s,password=%s", num, body.UserName, body.Password)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVOIPService.LoadData(neId, body.UserName, num)
}
c.JSON(200, resp.OkData(data))
}
// UDMVOIP用户删除
//
// DELETE /:neId/:username
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "User Name, multiple separated by a , sign"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Deletion
// @Description UDM VOIP User Deletion
// @Router /neData/udm/voip/{neId}/{value} [delete]
func (s *UDMVOIPController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
username := c.Param("username")
if neId == "" || username == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or username is empty"))
return
}
// 处理字符转id数组后去重
usernameArr := strings.Split(username, ",")
uniqueIDs := parse.RemoveDuplicates(usernameArr)
if len(uniqueIDs) <= 0 {
c.JSON(200, resp.Err(nil))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
resultData := map[string]string{}
for _, v := range uniqueIDs {
// 发送MML
cmd := fmt.Sprintf("del voip:username=%s", v)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
resultData[v] = err.Error()
continue
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVOIPService.Delete(v, neId)
}
resultData[v] = data
}
c.JSON(200, resp.OkData(resultData))
}
// UDMVOIP用户批量删除
//
// DELETE /:neId/:username/:num
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param username path string true "User Name"
// @Param num path number true "Number of releases, value includes start username"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Batch Deletion
// @Description UDM VOIP User Batch Deletion
// @Router /neData/udm/voip/{neId}/{username}/{num} [delete]
func (s *UDMVOIPController) Removes(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
username := c.Param("username")
num := c.Param("num")
if neId == "" || username == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/username/num is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("bde voip:start_username=%s,sub_num=%s", username, num)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVOIPService.LoadData(neId, username, num)
}
c.JSON(200, resp.OkData(data))
}
// UDMVOIP用户导出
//
// GET /export
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param type query string true "File Type" Enums(csv,txt) default(txt)
// @Param username query string false "User Name"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Export
// @Description UDM VOIP User Export
// @Router /neData/udm/voip/export [get]
func (s *UDMVOIPController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
neId := c.Query("neId")
fileType := c.Query("type")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
if !(fileType == "csv" || fileType == "txt") {
c.JSON(200, resp.ErrMsg("file type error, only support csv,txt"))
return
}
query := reqctx.QueryMap(c)
rows, total := s.udmVOIPService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// rows := s.udmVOIPService.SelectList(model.UDMVOIPUser{NeId: neId})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 文件名
fileName := fmt.Sprintf("udm_voip_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := filepath.Join(file.ParseUploadFileDir(constants.UPLOAD_EXPORT), fileName)
if fileType == "csv" {
// 转换数据
data := [][]string{}
data = append(data, []string{"username", "password"})
for _, v := range rows {
data = append(data, []string{v.UserName, v.Password})
}
// 输出到文件
if err := file.WriterFileCSV(data, filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
if fileType == "txt" {
// 转换数据
data := [][]string{}
for _, v := range rows {
data = append(data, []string{v.UserName, v.Password})
}
// 输出到文件
if err := file.WriterFileTXTLine(data, ",", filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
c.FileAttachment(filePath, fileName)
}
// UDMVOIP用户导入
//
// POST /import
//
// @Tags ne_data/udm/voip
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VOIP User Import
// @Description UDM VOIP User Import
// @Router /neData/udm/voip/import [post]
func (s *UDMVOIPController) Import(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"` // 网元ID
UploadPath string `json:"uploadPath" binding:"required"` // 上传文件路径
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 判断文件名
if !(strings.HasSuffix(body.UploadPath, ".csv") || strings.HasSuffix(body.UploadPath, ".txt")) {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserAuthFileFormat")))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的SSH客户端
// sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sshClient.Close()
// // 网元主机的SSH客户端进行文件传输
// sftpClient, err := sshClient.NewClientSFTP()
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sftpClient.Close()
// 本地文件
localFilePath := file.ParseUploadFileAbsPath(body.UploadPath)
neFilePath := fmt.Sprintf("/tmp/%s", filepath.Base(localFilePath))
// 复制到远程
// if err = sftpClient.CopyFileLocalToRemote(localFilePath, neFilePath); err != nil {
// c.JSON(200, resp.ErrMsg("error uploading file"))
// return
// }
if err := file.CopyFile(localFilePath, neFilePath); err != nil {
c.JSON(200, resp.ErrMsg("error uploading file"))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.NeType, neInfo.NeId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 结果信息
var resultMsg string
var resultErr error
// 发送MML
cmd := fmt.Sprintf("import voip:path=%s", neFilePath)
resultMsg, resultErr = telnet.ConvertToStr(telnetClient, cmd)
if resultErr != nil {
c.JSON(200, resp.ErrMsg(resultErr.Error()))
return
}
// 命令ok时
if strings.Contains(resultMsg, "ok") {
if strings.HasSuffix(body.UploadPath, ".csv") {
data := file.ReadFileCSV(localFilePath)
go s.udmVOIPService.InsertData(neInfo.NeId, "csv", data)
}
if strings.HasSuffix(body.UploadPath, ".txt") {
data := file.ReadFileTXTLine(",", localFilePath)
go s.udmVOIPService.InsertData(neInfo.NeId, "txt", data)
}
}
c.JSON(200, resp.OkMsg(resultMsg))
}

609
src/modules/ne_data/controller/udm_volte_ims.go Normal file
View File

@@ -0,0 +1,609 @@
package controller
import (
"fmt"
"path/filepath"
"strings"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/telnet"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 UDMVolteIMSController 结构体
var NewUDMVolteIMS = &UDMVolteIMSController{
udmVolteIMSService: neDataService.NewUDMVolteIMSUser,
neInfoService: neService.NewNeInfo,
}
// UDMVolteIMS用户
//
// PATH /udm/volte-ims
type UDMVolteIMSController struct {
udmVolteIMSService *neDataService.UDMVolteIMSUser // UDMVolteIMS信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDMVolteIMS用户重载数据
//
// PUT /resetData/:neId
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User Data Refresh
// @Description UDM Authenticated User Data List Refresh Synchronization Latest
// @Router /neData/udm/volte-ims/resetData/{neId} [put]
func (s *UDMVolteIMSController) ResetData(c *gin.Context) {
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
data := s.udmVolteIMSService.ResetData(neId)
c.JSON(200, resp.OkData(data))
}
// UDMVolteIMS用户列表
//
// GET /list
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param imsi query string false "IMSI"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User List
// @Description UDM VolteIMS User List
// @Router /neData/udm/volte-ims/list [get]
func (s *UDMVolteIMSController) List(c *gin.Context) {
query := reqctx.QueryMap(c)
rows, total := s.udmVolteIMSService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// UDMVolteIMS用户信息
//
// GET /:neId/:imsi
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI"
// @Param msisdn query string true "MSISDN"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User Information
// @Description UDM VolteIMS User Information
// @Router /neData/udm/volte-ims/{neId}/{value} [get]
func (s *UDMVolteIMSController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi := c.Param("imsi")
msisdn := c.Query("msisdn")
volte := c.Query("volte")
if neId == "" || imsi == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId or imsi is empty"))
return
}
if msisdn == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: msisdn is required"))
return
}
if volte == "" || !(volte == "0" || volte == "1") {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: volte is required"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("dsp imsuser:imsi=%s,msisdn=%s,volte=%s", imsi, msisdn, volte)
data, err := telnet.ConvertToMap(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
if len(data) == 0 {
c.JSON(200, resp.ErrMsg("No Volte IMS Data"))
return
}
// 解析返回的数据
u := s.udmVolteIMSService.ParseInfo(neId, data)
if u.ID != "" {
s.udmVolteIMSService.InsertByIMSI(imsi, neId)
c.JSON(200, resp.OkData(u))
return
}
c.JSON(200, resp.ErrMsg("No Volte IMS Data"))
}
// UDMVolteIMS用户新增
//
// POST /:neId
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User Added
// @Description UDM VolteIMS User Added If VoIP tag=0, then MSISDN and IMSI need to be the same.
// @Router /neData/udm/volte-ims/{neId} [post]
func (s *UDMVolteIMSController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
var body model.UDMVolteIMSUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.IMSI == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 检查同IMSI下msisdn是否存在
hasMsisdns := s.udmVolteIMSService.Find(model.UDMVolteIMSUser{IMSI: body.IMSI, MSISDN: body.MSISDN, NeId: neId})
if len(hasMsisdns) > 0 {
c.JSON(200, resp.ErrMsg("IMSI and MSISDN already exist"))
return
}
// 发送MML
cmd := fmt.Sprintf("add imsuser:imsi=%s,msisdn=%s,volte=%s,vni=%s", body.IMSI, body.MSISDN, body.Tag, body.VNI)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVolteIMSService.InsertByIMSI(body.IMSI, neId)
}
c.JSON(200, resp.OkData(data))
}
// UDMVolteIMS用户批量新增
//
// POST /:neId/:num
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path number true "Number of releases, value includes start imsi"
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User Batch Add
// @Description UDM VolteIMS User Batch Add
// @Router /neData/udm/volte-ims/{neId}/{value} [post]
func (s *UDMVolteIMSController) Adds(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
num := c.Param("num")
if neId == "" || num == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
var body model.UDMVolteIMSUser
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
if body.IMSI == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: imsi is empty"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 发送MML
cmd := fmt.Sprintf("baa imsuser:sub_num=%s,start_imsi=%s,start_msisdn=%s,volte=%s,vni=%s", num, body.IMSI, body.MSISDN, body.Tag, body.VNI)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVolteIMSService.LoadData(neId, body.IMSI, num)
}
c.JSON(200, resp.OkData(data))
}
// UDMVolteIMS用户删除
//
// DELETE /:neId/:imsi
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param value path string true "IMSI, multiple separated by a , sign"
// @Param msisdn query string false "MSISDN"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Deletion
// @Description UDM Authenticated User Deletion
// @Router /neData/udm/volte-ims/{neId}/{value} [delete]
func (s *UDMVolteIMSController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi_msisdn := c.Param("imsi")
volte := c.Query("volte")
if neId == "" || imsi_msisdn == "" {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
if volte == "" || !(volte == "0" || volte == "1") {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: volte is required"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
imsiArr := strings.Split(imsi_msisdn, ",")
// 处理字符转id数组后去重
uniqueIDs := parse.RemoveDuplicates(imsiArr)
if len(uniqueIDs) <= 0 {
c.JSON(200, resp.Err(nil))
return
}
resultData := map[string]string{}
for _, im := range uniqueIDs {
imArr := strings.SplitN(im, "_", 2)
if len(imArr) != 2 {
resultData[im] = "format should be imsi_msisdn"
continue
}
// 发送MML
cmd := fmt.Sprintf("del imsuser:imsi=%s,msisdn=%s,volte=%s", imArr[0], imArr[1], volte)
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
resultData[im] = err.Error()
continue
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVolteIMSService.Delete(imArr[0], neId)
}
resultData[im] = data
}
c.JSON(200, resp.OkData(resultData))
}
// UDMVolteIMS用户批量删除
//
// DELETE /:neId/:imsi/:num
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId path string true "NE ID" default(001)
// @Param imsi path string true "IMSI"
// @Param num path number true "Number of releases, value includes start imsi"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM VolteIMS User Batch Deletion
// @Description UDM VolteIMS User Batch Deletion
// @Router /neData/udm/volte-ims/{neId}/{imsi}/{num} [delete]
func (s *UDMVolteIMSController) Removes(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
neId := c.Param("neId")
imsi_msisdn := c.Param("imsi")
num := c.Param("num")
volte := c.Query("volte")
if neId == "" || imsi_msisdn == "" || num == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId/imsi/num is empty"))
return
}
if volte == "" || !(volte == "0" || volte == "1") {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: volte is required"))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", neId)
if neInfo.NeId != neId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient("UDM", neId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
imArr := strings.SplitN(imsi_msisdn, "_", 2)
if len(imArr) != 2 {
c.JSON(200, resp.ErrMsg("format should be imsi_msisdn"))
return
}
imsi := imArr[0]
msisdn := imArr[1]
// 发送MML
cmd := ""
if volte == "0" {
cmd = fmt.Sprintf("bde imsuser:start_msisdn=%s,sub_num=%s,volte=0", msisdn, num)
}
if volte == "1" {
cmd = fmt.Sprintf("bde imsuser:start_imsi=%s,start_msisdn=%s,sub_num=%s,volte=1", imsi, msisdn, num)
}
data, err := telnet.ConvertToStr(telnetClient, cmd)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 命令ok时
if strings.Contains(data, "ok") {
s.udmVolteIMSService.LoadData(neId, imsi, num)
}
c.JSON(200, resp.OkData(data))
}
// UDMVolteIMS用户导出
//
// GET /export
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param type query string true "File Type" Enums(csv,txt) default(txt)
// @Param imsi query string false "IMSI"
// @Param pageNum query number true "pageNum" default(1)
// @Param pageSize query number true "pageSize" default(10)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Export
// @Description UDM Authenticated User Export
// @Router /neData/udm/volte-ims/export [get]
func (s *UDMVolteIMSController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
neId := c.Query("neId")
fileType := c.Query("type")
if neId == "" {
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_CHEACK, "bind err: neId is empty"))
return
}
if !(fileType == "csv" || fileType == "txt") {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserSubFileFormat")))
return
}
query := reqctx.QueryMap(c)
rows, total := s.udmVolteIMSService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
// 文件名
fileName := fmt.Sprintf("udm_volte_user_export_%s_%d.%s", neId, time.Now().UnixMilli(), fileType)
filePath := filepath.Join(file.ParseUploadFileDir(constants.UPLOAD_EXPORT), fileName)
if fileType == "csv" {
// 转换数据
data := [][]string{}
data = append(data, []string{"IMSI", "MSISDN", "TAG", "VNI"})
for _, v := range rows {
data = append(data, []string{v.IMSI, v.MSISDN, v.Tag, v.VNI})
}
// 输出到文件
if err := file.WriterFileCSV(data, filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
if fileType == "txt" {
// 转换数据
data := [][]string{}
for _, v := range rows {
data = append(data, []string{v.IMSI, v.MSISDN, v.Tag, v.VNI})
}
// 输出到文件
if err := file.WriterFileTXTLine(data, ",", filePath); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
c.FileAttachment(filePath, fileName)
}
// UDMVolteIMS用户导入
//
// POST /import
//
// @Tags ne_data/udm/volte-ims
// @Accept json
// @Produce json
// @Param data body object true "Request Param"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary UDM Authenticated User Import
// @Description UDM Authenticated User Import
// @Router /neData/udm/volte-ims/import [post]
func (s *UDMVolteIMSController) Import(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
NeId string `json:"neId" binding:"required"` // 网元ID
UploadPath string `json:"uploadPath" binding:"required"` // 上传文件路径
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 判断文件名
if !(strings.HasSuffix(body.UploadPath, ".csv") || strings.HasSuffix(body.UploadPath, ".txt")) {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "ne.udm.errImportUserAuthFileFormat")))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UDM", body.NeId)
if neInfo.NeId != body.NeId || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的SSH客户端
// sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sshClient.Close()
// // 网元主机的SSH客户端进行文件传输
// sftpClient, err := sshClient.NewClientSFTP()
// if err != nil {
// c.JSON(200, resp.ErrMsg(err.Error()))
// return
// }
// defer sftpClient.Close()
// 本地文件
localFilePath := file.ParseUploadFileAbsPath(body.UploadPath)
neFilePath := fmt.Sprintf("/tmp/%s", filepath.Base(localFilePath))
// 复制到远程
// if err = sftpClient.CopyFileLocalToRemote(localFilePath, neFilePath); err != nil {
// c.JSON(200, resp.ErrMsg("error uploading file"))
// return
// }
if err := file.CopyFile(localFilePath, neFilePath); err != nil {
c.JSON(200, resp.ErrMsg("error uploading file"))
return
}
// 网元主机的Telnet客户端
telnetClient, err := s.neInfoService.NeRunTelnetClient(neInfo.NeType, neInfo.NeId, 1)
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer telnetClient.Close()
// 结果信息
var resultMsg string
var resultErr error
// 发送MML
cmd := fmt.Sprintf("import imsuser:path=%s", neFilePath)
resultMsg, resultErr = telnet.ConvertToStr(telnetClient, cmd)
if resultErr != nil {
c.JSON(200, resp.ErrMsg(resultErr.Error()))
return
}
// 命令ok时
if strings.Contains(resultMsg, "ok") {
if strings.HasSuffix(body.UploadPath, ".csv") {
data := file.ReadFileCSV(localFilePath)
go s.udmVolteIMSService.InsertData(neInfo.NeId, "csv", data)
}
if strings.HasSuffix(body.UploadPath, ".txt") {
data := file.ReadFileTXTLine(",", localFilePath)
go s.udmVolteIMSService.InsertData(neInfo.NeId, "txt", data)
}
}
c.JSON(200, resp.OkMsg(resultMsg))
}

65
src/modules/ne_data/controller/upf.go Normal file
View File

@@ -0,0 +1,65 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
neService "be.ems/src/modules/ne/service"
neDataService "be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 UPFController 结构体
var NewUPF = &UPFController{
neInfoService: neService.NewNeInfo,
kpiReportService: neDataService.NewKpiReport,
}
// 网元UPF
//
// PATH /upf
type UPFController struct {
neInfoService *neService.NeInfo // 网元信息服务
kpiReportService *neDataService.KpiReport // 统计信息服务
}
// 总流量数 N3上行 N6下行
// 单位 比特(bit)
//
// GET /flow-total
//
// @Tags ne_data/upf
// @Accept json
// @Produce json
// @Param neId query string true "NE ID" default(001)
// @Param day query number true "Statistical time a few days before" Enums(0, 7, 30)
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Total number of flows N3 upstream N6 downstream
// @Description Total number of flows N3 upstream N6 downstream
// @Router /neData/upf/flow-total [get]
func (s UPFController) FlowTotal(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var querys struct {
NeID string `form:"neId" binding:"required"`
Day int `form:"day"`
}
if err := c.ShouldBindQuery(&querys); querys.Day < 0 || err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(resp.CODE_PARAM_PARSER, errMsgs))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.FindByNeTypeAndNeID("UPF", querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
up, down := s.kpiReportService.UPFTodayFlowFind(neInfo.RmUID, querys.Day)
c.JSON(200, resp.OkData(map[string]int64{"up": up, "down": down}))
}

57
src/modules/ne_data/model/alarm.go Normal file
View File

@@ -0,0 +1,57 @@
package model
// Alarm 告警记录
type Alarm struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeId string `json:"neId" gorm:"column:ne_id"` // 网元ID
NeName string `json:"neName" gorm:"column:ne_name"` // 网元名称
Province string `json:"province" gorm:"column:province"` // 网元省份地域
PvFlag string `json:"pvFlag" gorm:"column:pv_flag"` // 网元标识虚拟化标识
AlarmSeq int64 `json:"alarmSeq" gorm:"column:alarm_seq"` // 告警序号 连续递增
AlarmId string `json:"alarmId" gorm:"column:alarm_id"` // 告警ID
AlarmTitle string `json:"alarmTitle" gorm:"column:alarm_title"` // 告警标题
AlarmCode int64 `json:"alarmCode" gorm:"column:alarm_code"` // 告警状态码
EventTime int64 `json:"eventTime" gorm:"column:event_time"` // 事件产生时间
AlarmType string `json:"alarmType" gorm:"column:alarm_type"` // 告警类型
OrigSeverity string `json:"origSeverity" gorm:"column:orig_severity"` // 严重程度
PerceivedSeverity string `json:"perceivedSeverity" gorm:"column:perceived_severity"` // 告警级别
ObjectUid string `json:"objectUid" gorm:"column:object_uid"` // 对象ID
ObjectName string `json:"objectName" gorm:"column:object_name"` // 对象名称
ObjectType string `json:"objectType" gorm:"column:object_type"` // 对象类型
LocationInfo string `json:"locationInfo" gorm:"column:location_info"` // 告警定位信息
AlarmStatus string `json:"alarmStatus" gorm:"column:alarm_status"` // 告警状态
SpecificProblem string `json:"specificProblem" gorm:"column:specific_problem"` // 告警问题原因
SpecificProblemId string `json:"specificProblemId" gorm:"column:specific_problem_id"` // 告警问题原因ID
AddInfo string `json:"addInfo" gorm:"column:add_info"` // 告警辅助信息
AckState string `json:"ackState" gorm:"column:ack_state"` // 确认状态
AckTime int64 `json:"ackTime" gorm:"column:ack_time"` // 确认时间
AckUser string `json:"ackUser" gorm:"column:ack_user"` // 确认用户
ClearType string `json:"clearType" gorm:"column:clear_type"` // 清除状态
ClearTime int64 `json:"clearTime" gorm:"column:clear_time"` // 清除时间
ClearUser string `json:"clearUser" gorm:"column:clear_user"` // 清除用户
Timestamp int64 `json:"timestamp" gorm:"column:timestamp"` // 创建时间
}
// TableName 表名称
func (*Alarm) TableName() string {
return "alarm"
}
// AlarmQuery 告警数据查询参数结构体
type AlarmQuery struct {
NeType string `json:"neType" form:"neType"` // 网元类型
NeID string `json:"neId" form:"neId"` // 网元ID
NeName string `json:"neName" form:"neName"`
PvFlag string `json:"pvFlag" form:"pvFlag"`
AlarmCode string `json:"alarmCode" form:"alarmCode"`
AlarmType string `json:"alarmType" form:"alarmType"`
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"omitempty,oneof=Clear Active"` // 告警状态
OrigSeverity string `json:"origSeverity" form:"origSeverity"` // 告警类型
BeginTime int64 `json:"beginTime" form:"beginTime"` // 开始时间 查event_time
EndTime int64 `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=event_time id"` // 排序字段，填写结果字段
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"`
}

44
src/modules/ne_data/model/alarm_event.go Normal file
View File

@@ -0,0 +1,44 @@
package model
// AlarmEvent 告警_事件记录表
type AlarmEvent struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeId string `json:"neId" gorm:"column:ne_id"` // 网元ID
AlarmSeq int64 `json:"alarmSeq" gorm:"column:alarm_seq"` // 告警序号 同网元类型连续递增
AlarmId string `json:"alarmId" gorm:"column:alarm_id"` // 告警ID
AlarmTitle string `json:"alarmTitle" gorm:"column:alarm_title"` // 告警标题
AlarmCode int64 `json:"alarmCode" gorm:"column:alarm_code"` // 告警状态码
EventTime int64 `json:"eventTime" gorm:"column:event_time"` // 事件产生时间
ObjectUid string `json:"objectUid" gorm:"column:object_uid"` // 对象ID
ObjectName string `json:"objectName" gorm:"column:object_name"` // 对象名称
ObjectType string `json:"objectType" gorm:"column:object_type"` // 对象类型
LocationInfo string `json:"locationInfo" gorm:"column:location_info"` // 告警定位信息
AlarmStatus string `json:"alarmStatus" gorm:"column:alarm_status"` // 告警状态
SpecificProblem string `json:"specificProblem" gorm:"column:specific_problem"` // 告警问题原因
SpecificProblemId string `json:"specificProblemId" gorm:"column:specific_problem_id"` // 告警问题原因ID
AddInfo string `json:"addInfo" gorm:"column:add_info"` // 告警辅助信息
ClearType string `json:"clearType" gorm:"column:clear_type"` // 清除状态
ClearTime int64 `json:"clearTime" gorm:"column:clear_time"` // 清除时间
ClearUser string `json:"clearUser" gorm:"column:clear_user"` // 清除用户
Timestamp int64 `json:"timestamp" gorm:"column:timestamp"` // 创建时间
}
// TableName 表名称
func (*AlarmEvent) TableName() string {
return "alarm_event"
}
// AlarmEventQuery 告警事件数据查询参数结构体
type AlarmEventQuery struct {
NeType string `json:"neType" form:"neType"` // 网元类型
NeID string `json:"neId" form:"neId"` // 网元ID
AlarmCode string `json:"alarmCode" form:"alarmCode"`
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"omitempty,oneof=Clear Active"` // 告警状态
BeginTime int64 `json:"beginTime" form:"beginTime"` // 开始时间 查event_time
EndTime int64 `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=event_time id"` // 排序字段，填写结果字段
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"`
}

37
src/modules/ne_data/model/alarm_forward_log.go Normal file
View File

@@ -0,0 +1,37 @@
package model
// AlarmForwardLog 告警_转发日志记录
type AlarmForwardLog struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"`
NeId string `json:"neId" gorm:"column:ne_id"`
AlarmSeq int64 `json:"alarmSeq" gorm:"column:alarm_seq"` // 告警序号 连续递增
AlarmId string `json:"alarmId" gorm:"column:alarm_id"` // 告警ID
AlarmCode int64 `json:"alarmCode" gorm:"column:alarm_code"` // 告警状态码
AlarmTitle string `json:"alarmTitle" gorm:"column:alarm_title"` // 告警标题
AlarmStatus string `json:"alarmStatus" gorm:"column:alarm_status"` // 告警状态
AlarmType string `json:"alarmType" gorm:"column:alarm_type"` // 告警类型
OrigSeverity string `json:"origSeverity" gorm:"column:orig_severity"` // 严重程度
EventTime int64 `json:"eventTime" gorm:"column:event_time"` // 事件产生时间
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // 创建时间
Type string `json:"type" gorm:"column:type"` // 转发方式 SMS/EMAIL/SMSC
Target string `json:"target" gorm:"column:target"` // 发送目标用户
Result string `json:"result" gorm:"column:result"` // 发送结果
}
// TableName 表名称
func (*AlarmForwardLog) TableName() string {
return "alarm_forward_log"
}
// AlarmForwardLogQuery 告警转发日志数据查询参数结构体
type AlarmForwardLogQuery struct {
NeType string `json:"neType" form:"neType"` // 网元类型
NeID string `json:"neId" form:"neId"` // 网元ID
BeginTime int64 `json:"beginTime" form:"beginTime"` // 开始时间
EndTime int64 `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=event_time id"` // 排序字段，填写结果字段
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"`
}

36
src/modules/ne_data/model/alarm_log.go Normal file
View File

@@ -0,0 +1,36 @@
package model
// AlarmLog 告警_日志记录
type AlarmLog struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"`
NeId string `json:"neId" gorm:"column:ne_id"`
AlarmSeq int64 `json:"alarmSeq" gorm:"column:alarm_seq"` // 告警序号 连续递增
AlarmId string `json:"alarmId" gorm:"column:alarm_id"` // 告警ID
AlarmCode int64 `json:"alarmCode" gorm:"column:alarm_code"` // 告警状态码
AlarmTitle string `json:"alarmTitle" gorm:"column:alarm_title"` // 告警标题
AlarmStatus string `json:"alarmStatus" gorm:"column:alarm_status"` // 告警状态
AlarmType string `json:"alarmType" gorm:"column:alarm_type"` // 告警类型
OrigSeverity string `json:"origSeverity" gorm:"column:orig_severity"` // 严重程度
EventTime int64 `json:"eventTime" gorm:"column:event_time"` // 事件产生时间
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // 创建时间
}
// TableName 表名称
func (*AlarmLog) TableName() string {
return "alarm_log"
}
// AlarmLogQuery 告警日志数据查询参数结构体
type AlarmLogQuery struct {
NeType string `json:"neType" form:"neType"` // 网元类型
NeID string `json:"neId" form:"neId"` // 网元ID
AlarmStatus string `json:"alarmStatus" form:"alarmStatus" binding:"omitempty,oneof=Clear Active"` // 告警状态
OrigSeverity string `json:"origSeverity" form:"origSeverity"` // 告警类型
BeginTime int64 `json:"beginTime" form:"beginTime"` // 开始时间 查event_time
EndTime int64 `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=event_time id"` // 排序字段，填写结果字段
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"`
}

11
src/modules/ne_data/model/backup.go Normal file
View File

@@ -0,0 +1,11 @@
package model
// BackupDataFTP 备份数据FTP服务参数结构体
type BackupDataFTP struct {
Password string `json:"password"` // FTP密码
Username string `json:"username" binding:"required"` // FTP用户名
ToIp string `json:"toIp" binding:"required"` // FTP服务器IP
ToPort int64 `json:"toPort" binding:"required"` // FTP服务器端口
Dir string `json:"dir" binding:"required"` // FTP服务器目录
Enable bool `json:"enable"` // 是否启用
}

112
src/modules/ne_data/model/cbc_message.go Normal file
View File

@@ -0,0 +1,112 @@
package model
import (
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
)
type CBCEventStatus int
// CBCEventStatus CB事件状态枚举
const (
CBCEventStatusNull CBCEventStatus = iota // 未知状态
CBCEventStatusActive
CBCEventStatusInactive
)
func (status CBCEventStatus) Enum() string {
switch status {
case CBCEventStatusNull:
return "NULL"
case CBCEventStatusActive:
return "ACTIVE"
case CBCEventStatusInactive:
return "INACTIVE"
default:
return "UNKNOWN"
}
}
func (status CBCEventStatus) String() string {
return fmt.Sprintf("%d", status)
}
// ParseCBCEventStatus 将字符串转换为 枚举类型
func ParseCBCEventStatus(s string) CBCEventStatus {
if i, err := strconv.Atoi(s); err == nil {
return CBCEventStatus(i)
}
// 如果转换失败，则按名称匹配（忽略大小写）
switch strings.ToUpper(s) {
case "NULL":
return CBCEventStatusNull
case "ACTIVE":
return CBCEventStatusActive
case "INACTIVE":
return CBCEventStatusInactive
case "":
// 如果字符串为空，则返回未知状态
return CBCEventStatusNull
default:
// 默认返回未知状态
return CBCEventStatusNull
}
}
// CBCMessageQuery 查询条件结构体
type CBCMessageQuery struct {
NeType string `form:"neType"` // 网元类型
NeId string `form:"neId"` // 网元ID
EventName string `form:"eventName"` // 事件名称
Status string `form:"status"` // 消息状态
StartTime string `form:"startTime"` // 创建时间范围-起始
EndTime string `form:"endTime"` // 创建时间范围-结束
PageNum int `form:"pageNum" binding:"required"`
PageSize int `form:"pageSize" binding:"required"`
}
// @Description CBCMessage CB消息
type CBCMessage struct {
Id int64 `json:"id" gorm:"column:id"` // CB消息ID
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeId string `json:"neId" gorm:"column:ne_id"` // 网元ID
MessageJson json.RawMessage `json:"messageJson" gorm:"column:message_json"` // 消息内容JSON
Status CBCEventStatus `json:"status" gorm:"column:status"` // 消息状态
Detail string `json:"detail" gorm:"column:detail"` // 详情
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // 创建时间
UpdatedAt int64 `json:"updatedAt" gorm:"column:updated_at"` // 更新时间
}
// TableName 表名称
func (*CBCMessage) TableName() string {
return "cbc_message"
}
// Scan 实现 sql.Scanner 接口，支持从数据库字符串转为 CBCEventStatus
func (s *CBCEventStatus) Scan(value interface{}) error {
switch v := value.(type) {
case string:
*s = ParseCBCEventStatus(v)
return nil
case []byte:
*s = ParseCBCEventStatus(string(v))
return nil
case int64:
*s = CBCEventStatus(v)
return nil
case int:
*s = CBCEventStatus(v)
return nil
default:
return errors.New("unsupported Scan type for CBCEventStatus")
}
}
// Value 实现 driver.Valuer 接口，支持将 CBCEventStatus 存为字符串
func (s CBCEventStatus) Value() (driver.Value, error) {
return s.Enum(), nil
}

17
src/modules/ne_data/model/cdr_event.go Normal file
View File

@@ -0,0 +1,17 @@
package model
// CDREvent CDR会话对象 cdr_event
type CDREvent struct {
ID int64 `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"` // 接收到的timestamp秒级存储毫秒时间戳
CdrJson string `json:"cdrJSON" gorm:"column:cdr_json"` // data JSON String
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // 记录创建存储毫秒
}
// TableName 表名称
func (*CDREvent) TableName() string {
return "cdr_event"
}

52
src/modules/ne_data/model/kpi_c_report.go Normal file
View File

@@ -0,0 +1,52 @@
package model
// KpiCTitle 自定义指标标题信息对象 kpi_title
type KpiCTitle struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"`
KpiId string `json:"kpiId" gorm:"column:kpi_id"`
Title string `json:"title" gorm:"column:title"`
Expression string `json:"expression" gorm:"column:expression"`
Unit string `json:"unit" gorm:"column:unit"`
Status string `json:"status" gorm:"column:status"` // 0-Inactive/1-Active/2-Deleted
Description string `json:"description" gorm:"column:description"`
CreatedBy string `json:"createdBy" gorm:"column:created_by"`
UpdatedAt int64 `json:"updatedAt" gorm:"column:updated_at"`
}
// TableName 表名称
func (*KpiCTitle) TableName() string {
return "kpi_c_title"
}
// KpiCReport 自定义指标报表信息对象
type KpiCReport struct {
ID int64 `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"`
Date string `json:"date" gorm:"column:date"` // Date of the report yyyy-mm-dd hh:mi:ss
StartTime string `json:"startTime" gorm:"column:start_time"` // Start time of the report hh:mi:ss
EndTime string `json:"endTime" gorm:"column:end_time"` // End time of the report hh:mi:ss
Index int64 `json:"index" gorm:"column:index"` // Index of the report
Granularity int64 `json:"granularity" gorm:"column:granularity"` // Time granualarity: 5/10/.../60/300 (second)
KpiValues string `json:"kpiValues" gorm:"column:kpi_values"` // KPI values JSON String
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // Creation time
}
// TableName 表名称
func (*KpiCReport) TableName() string {
return "kpi_c_report"
}
// KPICQuery 指标查询参数结构体
type KPICQuery struct {
NeType string `form:"neType" binding:"required"`
NeID string `form:"neId" binding:"required"`
BeginTime int64 `form:"beginTime" binding:"required"` // 开始时间戳（毫秒）1739361200999
EndTime int64 `form:"endTime" binding:"required"` // 结束时间戳（毫秒）1739361210088
Interval int64 `form:"interval" binding:"required,oneof=5 60 300 900 1800 3600"`
RmUID string `form:"rmUID"`
SortField string `form:"sortField" binding:"omitempty,oneof=timeGroup"`
SortOrder string `form:"sortOrder" binding:"omitempty,oneof=asc desc"`
}

49
src/modules/ne_data/model/kpi_report.go Normal file
View File

@@ -0,0 +1,49 @@
package model
// KpiTitle 指标标题信息对象 kpi_title
type KpiTitle struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
KpiId string `json:"kpiId" gorm:"column:kpi_id"` // KPI标识
TitleJson string `json:"titleJson" gorm:"column:title_json"`
CnTitle string `json:"cnTitle" gorm:"column:cn_title"` // 中文名
EnTitle string `json:"enTitle" gorm:"column:en_title"` // 英文名
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 状态标识 1:启用 0:禁用
}
// TableName 表名称
func (*KpiTitle) TableName() string {
return "kpi_title"
}
// KpiReport 指标报表信息对象
type KpiReport struct {
ID int64 `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"`
Date string `json:"date" gorm:"column:date"` // Date of the report yyyy-mm-dd hh:mi:ss
StartTime string `json:"startTime" gorm:"column:start_time"` // Start time of the report hh:mi:ss
EndTime string `json:"endTime" gorm:"column:end_time"` // End time of the report hh:mi:ss
Index int64 `json:"index" gorm:"column:index"` // Index of the report
Granularity int64 `json:"granularity" gorm:"column:granularity"` // Time granualarity: 5/10/.../60/300 (second)
KpiValues string `json:"kpiValues" gorm:"column:kpi_values"` // KPI values JSON String
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // Creation time 接收到的timestamp秒级存储毫秒时间戳
}
// TableName 表名称
func (*KpiReport) TableName() string {
return "kpi_report"
}
// KPIQuery 指标查询参数结构体
type KPIQuery struct {
NeType string `form:"neType" binding:"required"`
NeID string `form:"neId" binding:"required"`
BeginTime int64 `form:"beginTime" binding:"required"` // 开始时间戳（毫秒）1739361200999
EndTime int64 `form:"endTime" binding:"required"` // 结束时间戳（毫秒）1739361210088
Interval int64 `form:"interval" binding:"required,oneof=5 60 300 900 1800 3600"`
RmUID string `form:"rmUID"`
SortField string `form:"sortField" binding:"omitempty,oneof=timeGroup"`
SortOrder string `form:"sortOrder" binding:"omitempty,oneof=asc desc"`
}

35
src/modules/ne_data/model/nb_state.go Normal file
View File

@@ -0,0 +1,35 @@
package model
// NBState 基站状态记录表 nb_state
type NBState struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型 AMF MME
NeId string `json:"neId" gorm:"column:ne_id"` // 网元ID
RmUid string `json:"rmUid" gorm:"column:rm_uid"` // 资源唯一标识
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
Address string `json:"address" gorm:"column:address"` // 基站IP地址
NbName string `json:"nbName" gorm:"column:nb_name"` // 基站设备名称
Name string `json:"name" gorm:"column:name"` // 基站名称
Position string `json:"position" gorm:"column:position"` // 基站位置
State string `json:"state" gorm:"column:state"` // 基站状态 OFF ON
Time string `json:"time" gorm:"column:time"` // 状态时间
}
// TableName 表名称
func (*NBState) TableName() string {
return "nb_state"
}
// NBStateQuery 查询参数结构体
type NBStateQuery struct {
NeType string `json:"neType" form:"neType" binding:"required"`
NeID string `json:"neId" form:"neId" binding:"required"`
PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"`
PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"`
Status string `json:"status" form:"status"`
StartTime string `json:"startTime" form:"startTime"`
EndTime string `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=id create_time"` // 排序字段，填写结果字段
SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc
RmUID string `json:"rmUID" form:"rmUID"`
}

35
src/modules/ne_data/model/ne_state.go Normal file
View File

@@ -0,0 +1,35 @@
package model
// NEState 网元状态记录表 ne_state
type NEState struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
NeType string `json:"neType" gorm:"column:ne_type"`
NeId string `json:"neId" gorm:"column:ne_id"`
Version string `json:"version" gorm:"column:version"` // 版本
Capability int64 `json:"capability" gorm:"column:capability"` // 用户容量
SerialNum string `json:"serialNum" gorm:"column:serial_num"` // 序列号
ExpiryDate string `json:"expiryDate" gorm:"column:expiry_date"` // 许可证到期日期
SysCpuUsage float64 `json:"sysCpuUsage" gorm:"column:sys_cpu_usage"` // cpu使用率-sys
SysMemUsage float64 `json:"sysMemUsage" gorm:"column:sys_mem_usage"` // 内存使用率-sys
SysDiskUsage float64 `json:"sysDiskUsage" gorm:"column:sys_disk_usage"` // 磁盘使用率-sys
NfCpuUsage float64 `json:"nfCpuUsage" gorm:"column:nf_cpu_usage"` // cpu使用率-nf
NfMemUsed int64 `json:"nfMemUsed" gorm:"column:nf_mem_used"` // 内存使用KB-nf
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
}
// TableName 表名称
func (*NEState) TableName() string {
return "ne_state"
}
// NEStateQuery 查询参数结构体
type NEStateQuery struct {
NeType string `json:"neType" form:"neType" binding:"required"`
NeID string `json:"neId" form:"neId" binding:"required"`
PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"`
PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"`
BeginTime string `json:"beginTime" form:"beginTime"`
EndTime string `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=id create_time"` // 排序字段，填写结果字段
SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc
}

17
src/modules/ne_data/model/udm_auth.go Normal file
View File

@@ -0,0 +1,17 @@
package model
// UDMAuthUser UDM鉴权用户 udm_auth
type UDMAuthUser struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 默认ID
IMSI string `json:"imsi" gorm:"column:imsi"` // SIM卡/USIM卡ID
NeId string `json:"neId" gorm:"column:ne_id"` // UDM网元标识
Amf string `json:"amf" gorm:"column:amf"` // AMF
Ki string `json:"ki" gorm:"column:ki"` // ki
AlgoIndex string `json:"algoIndex" gorm:"column:algo_index"` // algoIndex
Opc string `json:"opc" gorm:"column:opc"` // OPC
}
// TableName 表名称
func (*UDMAuthUser) TableName() string {
return "udm_auth"
}

15
src/modules/ne_data/model/udm_extend.go Normal file
View File

@@ -0,0 +1,15 @@
package model
// UDMExtend UDM用户IMSI扩展信息 udm_extend
type UDMExtend struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 默认ID
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:"column:remark"` // 备注
}
// TableName 表名称
func (*UDMExtend) TableName() string {
return "udm_extend"
}

48
src/modules/ne_data/model/udm_sub.go Normal file
View File

@@ -0,0 +1,48 @@
package model
// UDMSubUser UDM签约用户 udm_sub
type UDMSubUser struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 主键
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网元标识
AmDat string `json:"amDat" gorm:"column:am_dat"` // AmData
UeAmbrTpl string `json:"ambr" gorm:"column:ambr"` // AmData SubUeAMBRTemp
NssaiTpl string `json:"nssai" gorm:"column:nssai"` // AmData SubSNSSAITemp
RatRestrictions string `json:"rat" gorm:"column:rat"` // AmData RAT 0x00:VIRTUAL 0x01:WLAN 0x02:EUTRA 0x03:NR
AreaForbiddenTpl string `json:"arfb" gorm:"column:arfb"` // AmData AreaForbidden
ServiceAreaRestrictionTpl string `json:"sar" gorm:"column:sar"` // AmData serviceAreaRestrictTemp
CnTypeRestrictions string `json:"cnType" gorm:"column:cn_type"` // AmData CNType 0x00:EPC和5GC 0x01:5GC 0x02:EPC 0x03:EPC+5GC
RfspIndex string `json:"rfspIndex" gorm:"column:rfsp_index"` // AmData RfspIndex
SubsRegTime string `json:"regTimer" gorm:"column:reg_timer"` // AmData RegTimer
UeUsageType string `json:"ueUsageType" gorm:"column:ue_usage_type"` // AmData UEUsageType
ActiveTime string `json:"activeTime" gorm:"column:active_time"` // AmData ActiveTime
MicoAllowed string `json:"mico" gorm:"column:mico"` // AmData MICO
OdbPs string `json:"odbPs" gorm:"column:odb_ps"` // AmData ODB_PS 0-all,1-hplmn,2-vplmn
GroupId string `json:"groupId" gorm:"column:group_id"` // AmData GroupId
EpsDat string `json:"epsDat" gorm:"column:eps_dat"` // EpsDat
EpsFlag string `json:"epsFlag" gorm:"column:eps_flag"` // EpsDat epsFlag
EpsOdb string `json:"epsOdb" gorm:"column:eps_odb"` // EpsDat epsOdb
HplmnOdb string `json:"hplmnOdb" gorm:"column:hplmn_odb"` // EpsDat hplmnOdb
Ard string `json:"ard" gorm:"column:ard"` // EpsDat Ard
Epstpl string `json:"epstpl" gorm:"column:epstpl"` // EpsDat Epstpl
ContextId string `json:"contextId" gorm:"column:context_id"` // EpsDat ContextId
ApnNum string `json:"apnNum" gorm:"column:apn_mum"` // EpsDat apnNum
ApnContext string `json:"apnContext" gorm:"column:apn_context"` // EpsDat apnContext
StaticIp string `json:"staticIp" gorm:"column:static_ip"` // EpsDat staticIp 指给4G UE分配的静态IP，没有可不带此字段名
SmData string `json:"smData" gorm:"column:sm_data"` // smData
SmfSel string `json:"smfSel" gorm:"column:smf_sel"` // smfSel
Cag string `json:"cag" gorm:"column:cag"` // CAG
// ====== 非数据库字段属性 ======
Remark string `json:"remark,omitempty" gorm:"-"` // 备注
}
// TableName 表名称
func (*UDMSubUser) TableName() string {
return "udm_sub"
}

15
src/modules/ne_data/model/udm_voip.go Normal file
View File

@@ -0,0 +1,15 @@
package model
// UDMVOIPUser UDMVOIP用户 udm_voip
type UDMVOIPUser struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 主键
NeId string `json:"neId" gorm:"column:ne_id"` // UDM网元标识
UserName string `json:"username" gorm:"column:username"` // 用户名
Password string `json:"password" gorm:"column:password"` // 密码
}
// TableName 表名称
func (*UDMVOIPUser) TableName() string {
return "udm_voip"
}

17
src/modules/ne_data/model/udm_volte_ims.go Normal file
View File

@@ -0,0 +1,17 @@
package model
// UDMVolteIMSUser UDMVolteIMS用户 udm_volte_ims
type UDMVolteIMSUser struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 主键
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网元标识
Tag string `json:"tag" gorm:"column:tag"` // 0=VoIP, 1=VoLTE
VNI string `json:"vni" gorm:"column:vni"` // VNI
}
// TableName 表名称
func (*UDMVolteIMSUser) TableName() string {
return "udm_volte_ims"
}

18
src/modules/ne_data/model/ue_event.go Normal file
View File

@@ -0,0 +1,18 @@
package model
// UEEvent UE会话对象 ue_event
type UEEvent struct {
ID int64 `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"` // 接收到时间
EventType string `json:"eventType" gorm:"column:event_type"` // 事件类型
EventJSONStr string `json:"eventJSON" gorm:"column:event_json"` // data JSON String
CreatedAt int64 `json:"createdAt" gorm:"column:created_at"` // 记录创建存储毫秒
}
// TableName 表名称
func (*UEEvent) TableName() string {
return "ue_event"
}

642
src/modules/ne_data/ne_data.go Normal file
View File

@@ -0,0 +1,642 @@
package ne_data
import (
"be.ems/src/framework/logger"
"be.ems/src/framework/middleware"
"be.ems/src/framework/middleware/collectlogs"
"be.ems/src/framework/middleware/repeat"
"be.ems/src/modules/ne_data/controller"
"be.ems/src/modules/ne_data/service"
"github.com/gin-gonic/gin"
)
// 模块路由注册
func Setup(router *gin.Engine) {
logger.Infof("开始加载 ====> ne_data 模块路由")
// 启动时需要的初始参数
InitLoad()
neDataGroup := router.Group("/neData")
// 性能统计信息
kpiGroup := neDataGroup.Group("/kpi")
{
kpiGroup.GET("/title",
middleware.AuthorizeUser(nil),
controller.NewKPI.KPITitle,
)
kpiGroup.GET("/title/list",
middleware.AuthorizeUser(nil),
controller.NewKPI.ListTitle,
)
kpiGroup.POST("/title",
middleware.AuthorizeUser(nil),
controller.NewKPI.AddTitle,
)
kpiGroup.PUT("/title",
middleware.AuthorizeUser(nil),
controller.NewKPI.EditTitle,
)
kpiGroup.DELETE("/title",
middleware.AuthorizeUser(nil),
controller.NewKPI.RemoveTitle,
)
kpiGroup.GET("/data",
middleware.AuthorizeUser(nil),
controller.NewKPI.KPIData,
)
}
// 性能自定义统计信息
kpicGroup := neDataGroup.Group("/kpic")
{
kpicGroup.GET("/data",
middleware.AuthorizeUser(nil),
controller.NewKPIC.KPIData,
)
kpicGroup.GET("/title/list",
middleware.AuthorizeUser(nil),
controller.NewKPIC.ListTitle,
)
kpicGroup.POST("/title",
middleware.AuthorizeUser(nil),
controller.NewKPIC.AddTitle,
)
kpicGroup.PUT("/title",
middleware.AuthorizeUser(nil),
controller.NewKPIC.EditTitle,
)
kpicGroup.DELETE("/title",
middleware.AuthorizeUser(nil),
controller.NewKPIC.RemoveTitle,
)
}
// 告警数据信息
alarmGroup := neDataGroup.Group("/alarm")
{
alarmGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewAlarm.List,
)
alarmGroup.DELETE("/:id",
middleware.AuthorizeUser(nil),
controller.NewAlarm.Remove,
)
alarmGroup.PUT("/clear",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.alarm", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewAlarm.Clear,
)
alarmGroup.PUT("/ack",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.alarm", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewAlarm.Ack,
)
alarmGroup.GET("/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.alarm", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewAlarm.Export,
)
alarmGroup.GET("/count/type",
middleware.AuthorizeUser(nil),
controller.NewAlarm.CountType,
)
alarmGroup.GET("/count/severity",
middleware.AuthorizeUser(nil),
controller.NewAlarm.CountSeverity,
)
alarmGroup.GET("/count/ne",
middleware.AuthorizeUser(nil),
controller.NewAlarm.CountNe,
)
}
// 告警日志数据信息
alarmLogGroup := neDataGroup.Group("/alarm/log")
{
alarmLogGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewAlarmLog.List,
)
alarmLogGroup.GET("/event",
middleware.AuthorizeUser(nil),
controller.NewAlarmLog.Event,
)
}
// 告警转发数据信息
alarmForwardGroup := neDataGroup.Group("/alarm/forward")
{
alarmForwardGroup.GET("/log/list",
middleware.AuthorizeUser(nil),
controller.NewAlarmForward.List,
)
}
// 网元状态记录信息
neStateGroup := neDataGroup.Group("/ne-state")
{
neStateGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewNEState.List,
)
}
// 基站状态历史记录信息 含AMF/MME
nbStateGroup := neDataGroup.Group("/nb-state")
{
nbStateGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewNBState.List,
)
nbStateGroup.GET("/export",
middleware.AuthorizeUser(nil),
controller.NewNBState.Export,
)
}
// 网元IMS
imsGroup := neDataGroup.Group("/ims")
{
imsGroup.GET("/cdr/list",
middleware.AuthorizeUser(nil),
controller.NewIMS.CDRList,
)
imsGroup.DELETE("/cdr/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.imsCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewIMS.CDRRemove,
)
imsGroup.GET("/cdr/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.imsCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewIMS.CDRExport,
)
imsGroup.GET("/session/num",
middleware.AuthorizeUser(nil),
controller.NewIMS.UeSessionNum,
)
imsGroup.GET("/session/list",
middleware.AuthorizeUser(nil),
controller.NewIMS.UeSessionList,
)
}
// 网元SMSC
smscGroup := neDataGroup.Group("/smsc")
{
smscGroup.GET("/cdr/list",
middleware.AuthorizeUser(nil),
controller.NewSMSC.CDRList,
)
smscGroup.DELETE("/cdr/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smscCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSMSC.CDRRemove,
)
smscGroup.GET("/cdr/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smscCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSMSC.CDRExport,
)
}
// 网元SMF
smfGroup := neDataGroup.Group("/smf")
{
smfGroup.GET("/cdr/list",
middleware.AuthorizeUser(nil),
controller.NewSMF.CDRList,
)
smfGroup.DELETE("/cdr/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smfCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSMF.CDRRemove,
)
smfGroup.GET("/cdr/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smfCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSMF.CDRExport,
)
smfGroup.GET("/sub/num",
middleware.AuthorizeUser(nil),
controller.NewSMF.SubUserNum,
)
smfGroup.GET("/sub/list",
middleware.AuthorizeUser(nil),
controller.NewSMF.SubUserList,
)
}
// 网元AMF
amfGroup := neDataGroup.Group("/amf")
{
amfGroup.GET("/ue/list",
middleware.AuthorizeUser(nil),
controller.NewAMF.UEList,
)
amfGroup.DELETE("/ue/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.amfUE", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewAMF.UERemove,
)
amfGroup.GET("/ue/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.amfUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewAMF.UEExport,
)
amfGroup.GET("/nb/list",
middleware.AuthorizeUser(nil),
controller.NewAMF.NbInfoList,
)
amfGroup.GET("/nb/list-cfg",
middleware.AuthorizeUser(nil),
controller.NewAMF.NbStateList,
)
}
// 网元UPF
upfGroup := neDataGroup.Group("/upf")
{
upfGroup.GET("/flow-total",
middleware.AuthorizeUser(nil),
controller.NewUPF.FlowTotal,
)
}
// 网元N3IWF
n3iwfGroup := neDataGroup.Group("/n3iwf")
{
n3iwfGroup.GET("/sub/list",
middleware.AuthorizeUser(nil),
controller.NewN3IWF.SubUserList,
)
}
// 网元N3IWF
nssf := controller.NewNSSF
nssfGroup := neDataGroup.Group("/nssf")
{
nssfGroup.GET("/sub/list",
middleware.AuthorizeUser(nil),
nssf.SubUserList,
)
nssfGroup.GET("/amf/list",
middleware.AuthorizeUser(nil),
nssf.AvailableList,
)
}
// 备份数据
backupGroup := neDataGroup.Group("/backup")
{
backupGroup.GET("/ftp",
middleware.AuthorizeUser(nil),
controller.NewBackup.FTPInfo,
)
backupGroup.PUT("/ftp",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.backup", collectlogs.BUSINESS_TYPE_OTHER)),
controller.NewBackup.FTPUpdate,
)
backupGroup.POST("/ftp",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.backup", collectlogs.BUSINESS_TYPE_OTHER)),
controller.NewBackup.FTPPush,
)
}
// 网元UDM 鉴权用户信息
udmAuthGroup := neDataGroup.Group("/udm/auth")
{
udmAuthGroup.PUT("/resetData/:neId",
repeat.RepeatSubmit(5),
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewUDMAuth.ResetData,
)
udmAuthGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewUDMAuth.List,
)
udmAuthGroup.GET("/:neId/:imsi",
middleware.AuthorizeUser(nil),
controller.NewUDMAuth.Info,
)
udmAuthGroup.POST("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMAuth.Add,
)
udmAuthGroup.POST("/:neId/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMAuth.Adds,
)
udmAuthGroup.PUT("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewUDMAuth.Edit,
)
udmAuthGroup.DELETE("/:neId/:imsi",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMAuth.Remove,
)
udmAuthGroup.DELETE("/:neId/:imsi/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMAuth.Removes,
)
udmAuthGroup.GET("/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewUDMAuth.Export,
)
udmAuthGroup.POST("/import",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmAuth", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewUDMAuth.Import,
)
}
// 网元UDM 签约用户信息
udmSubGroup := neDataGroup.Group("/udm/sub")
{
udmSubGroup.PUT("/resetData/:neId",
repeat.RepeatSubmit(5),
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewUDMSub.ResetData,
)
udmSubGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewUDMSub.List,
)
udmSubGroup.GET("/:neId/:imsi",
middleware.AuthorizeUser(nil),
controller.NewUDMSub.Info,
)
udmSubGroup.POST("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMSub.Add,
)
udmSubGroup.POST("/:neId/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMSub.Adds,
)
udmSubGroup.PUT("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewUDMSub.Edit,
)
udmSubGroup.DELETE("/:neId/:imsi",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMSub.Remove,
)
udmSubGroup.DELETE("/:neId/:imsi/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMSub.Removes,
)
udmSubGroup.GET("/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewUDMSub.Export,
)
udmSubGroup.POST("/import",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmSub", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewUDMSub.Import,
)
}
// 网元UDM VOIP用户信息
udmVOIPGroup := neDataGroup.Group("/udm/voip")
{
udmVOIPGroup.PUT("/resetData/:neId",
repeat.RepeatSubmit(5),
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewUDMVOIP.ResetData,
)
udmVOIPGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewUDMVOIP.List,
)
udmVOIPGroup.GET("/:neId/:username",
middleware.AuthorizeUser(nil),
controller.NewUDMVOIP.Info,
)
udmVOIPGroup.POST("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMVOIP.Add,
)
udmVOIPGroup.POST("/:neId/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMVOIP.Adds,
)
udmVOIPGroup.DELETE("/:neId/:username",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMVOIP.Remove,
)
udmVOIPGroup.DELETE("/:neId/:username/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMVOIP.Removes,
)
udmVOIPGroup.GET("/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewUDMVOIP.Export,
)
udmVOIPGroup.POST("/import",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVOIP", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewUDMVOIP.Import,
)
}
// 网元UDM VolteIMS用户信息
udmVolteIMSGroup := neDataGroup.Group("/udm/volte-ims")
{
udmVolteIMSGroup.PUT("/resetData/:neId",
repeat.RepeatSubmit(5),
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewUDMVolteIMS.ResetData,
)
udmVolteIMSGroup.GET("/list",
middleware.AuthorizeUser(nil),
controller.NewUDMVolteIMS.List,
)
udmVolteIMSGroup.GET("/:neId/:imsi",
middleware.AuthorizeUser(nil),
controller.NewUDMVolteIMS.Info,
)
udmVolteIMSGroup.POST("/:neId",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMVolteIMS.Add,
)
udmVolteIMSGroup.POST("/:neId/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewUDMVolteIMS.Adds,
)
udmVolteIMSGroup.DELETE("/:neId/:imsi",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMVolteIMS.Remove,
)
udmVolteIMSGroup.DELETE("/:neId/:imsi/:num",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewUDMVolteIMS.Removes,
)
udmVolteIMSGroup.GET("/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewUDMVolteIMS.Export,
)
udmVolteIMSGroup.POST("/import",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.udmVolteIMS", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewUDMVolteIMS.Import,
)
}
// 网元MME
mmeGroup := neDataGroup.Group("/mme")
{
mmeGroup.GET("/ue/list",
middleware.AuthorizeUser(nil),
controller.NewMME.UEList,
)
mmeGroup.DELETE("/ue/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.mmeUE", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewMME.UERemove,
)
mmeGroup.GET("/ue/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.mmeUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewMME.UEExport,
)
mmeGroup.GET("/nb/list",
middleware.AuthorizeUser(nil),
controller.NewMME.NbInfoList,
)
mmeGroup.GET("/nb/list-cfg",
middleware.AuthorizeUser(nil),
controller.NewMME.NbStateList,
)
}
// 网元SGWC
sgwcGroup := neDataGroup.Group("/sgwc")
{
sgwcGroup.GET("/cdr/list",
middleware.AuthorizeUser(nil),
controller.NewSGWC.CDRList,
)
sgwcGroup.DELETE("/cdr/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sgwcCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSGWC.CDRRemove,
)
sgwcGroup.POST("/cdr/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sgwcCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSGWC.CDRExport,
)
}
// 网元PCF
pcfGroup := neDataGroup.Group("/pcf")
{
pcfGroup.GET("/rule/list",
middleware.AuthorizeUser(nil),
controller.NewPCF.RuleInfoList,
)
pcfGroup.POST("/rule",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.pcfRule", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewPCF.RuleInfoAdd,
)
pcfGroup.PUT("/rule",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.pcfRule", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewPCF.RuleInfoEdit,
)
pcfGroup.DELETE("/rule",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.pcfRule", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewPCF.RuleInfoRemove,
)
pcfGroup.GET("/rule/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.pcfRule", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewPCF.RuleInfoExport,
)
pcfGroup.PUT("/rule/import",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.pcfRule", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewPCF.RuleInfoImport,
)
}
// 网元CBC
cbcGroup := neDataGroup.Group("/cbc")
{
cbcGroup.GET("/message/list",
middleware.AuthorizeUser(nil),
controller.NewCBC.List,
)
cbcGroup.GET("/message/:id",
middleware.AuthorizeUser(nil),
controller.NewCBC.ListById,
)
cbcGroup.POST("/message",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.cbcMessage", collectlogs.BUSINESS_TYPE_IMPORT)),
controller.NewCBC.Insert,
)
cbcGroup.PUT("/message/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.cbcMessage", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewCBC.Update,
)
cbcGroup.PUT("/message/:id/:status",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.cbcMessage", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewCBC.UpdateStatus,
)
cbcGroup.DELETE("/message/:id",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.cbcMessage", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewCBC.Delete,
)
cbcGroup.GET("/message/export",
middleware.AuthorizeUser(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.cbcMessage", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewCBC.Export,
)
}
}
// InitLoad 初始参数
func InitLoad() {
// 启动时，加载UPF上下行流量
go service.NewKpiReport.UPFTodayFlowLoad(30)
}

213
src/modules/ne_data/repository/alarm.go Normal file
View File

@@ -0,0 +1,213 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 Alarm 结构体
var NewAlarm = &Alarm{}
// Alarm 告警 数据层处理
type Alarm struct{}
// SelectByPage 分页查询集合
func (r Alarm) SelectByPage(query model.AlarmQuery) ([]model.Alarm, int64) {
tx := db.DB("").Model(&model.Alarm{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.NeName != "" {
tx = tx.Where("ne_name = ?", query.NeName)
}
if query.PvFlag != "" {
tx = tx.Where("pv_flag = ?", query.PvFlag)
}
if query.AlarmCode != "" {
tx = tx.Where("alarm_code like ?", fmt.Sprintf("%%%s%%", query.AlarmCode))
}
if query.AlarmType != "" {
tx = tx.Where("alarm_type in (?)", strings.Split(query.AlarmType, ","))
}
if query.AlarmStatus != "" {
tx = tx.Where("alarm_status = ?", query.AlarmStatus)
}
if query.OrigSeverity != "" {
tx = tx.Where("orig_severity in (?)", strings.Split(query.OrigSeverity, ","))
}
if query.BeginTime != 0 {
tx = tx.Where("event_time >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("event_time <= ?", query.EndTime)
}
// 查询结果
var total int64 = 0
rows := []model.Alarm{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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
}
// Select 查询集合
func (r Alarm) Select(param model.Alarm) []model.Alarm {
tx := db.DB("").Model(&model.Alarm{})
// 查询条件拼接
if param.NeType != "" {
tx = tx.Where("ne_type = ?", param.NeType)
}
if param.NeId != "" {
tx = tx.Where("ne_id = ?", param.NeId)
}
if param.NeName != "" {
tx = tx.Where("ne_name = ?", param.NeName)
}
if param.AlarmCode > 0 {
tx = tx.Where("alarm_code = ?", param.AlarmCode)
}
if param.AlarmType != "" {
tx = tx.Where("alarm_type = ?", param.AlarmType)
}
if param.AlarmId != "" {
tx = tx.Where("alarm_id = ?", param.AlarmId)
}
if param.OrigSeverity != "" {
eventTypes := strings.Split(param.OrigSeverity, ",")
tx = tx.Where("orig_severity in (%s)", eventTypes)
}
if param.PvFlag != "" {
tx = tx.Where("pv_flag = ?", param.PvFlag)
}
// 查询数据
rows := []model.Alarm{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询
func (r Alarm) SelectByIds(ids []int64) []model.Alarm {
rows := []model.Alarm{}
if len(ids) <= 0 {
return rows
}
tx := db.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
}
// Insert 新增信息 返回新增数据ID
func (r Alarm) Insert(param model.Alarm) int64 {
if param.Timestamp == 0 {
param.Timestamp = time.Now().UnixMilli()
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}
// Update 修改信息 返回受影响的行数
func (r Alarm) Update(param model.Alarm) int64 {
if param.ID <= 0 {
return 0
}
tx := db.DB("").Model(&model.Alarm{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "timestamp")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息
func (r Alarm) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.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
}
// SelectAlarmSeqLast 查询网元告警最后一条序号
func (r Alarm) SelectAlarmSeqLast(neType, neId string) int64 {
tx := db.DB("").Model(&model.Alarm{})
tx = tx.Where("ne_type=? and ne_id=?", neType, neId)
tx = tx.Select("alarm_seq").Order("alarm_seq DESC")
// 查询数据
var alarmSeq int64 = 0
if err := tx.Limit(1).Find(&alarmSeq).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return alarmSeq
}
return alarmSeq
}
// GroupTotal 分组统计
func (r Alarm) GroupTotal(alarmStatus string, group string, limit int) []map[string]any {
tx := db.DB("").Model(&model.Alarm{})
tx = tx.Select("count(*) as total", group)
tx = tx.Where("alarm_status=?", alarmStatus)
tx = tx.Group(group).Order("total DESC")
// 查询数据
var rows []map[string]any = make([]map[string]any, 0)
if limit > 0 {
tx = tx.Limit(limit)
}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}

169
src/modules/ne_data/repository/alarm_event.go Normal file
View File

@@ -0,0 +1,169 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 AlarmEvent 结构体
var NewAlarmEvent = &AlarmEvent{}
// AlarmEvent 告警 数据层处理
type AlarmEvent struct{}
// SelectByPage 分页查询集合
func (r AlarmEvent) SelectByPage(query model.AlarmEventQuery) ([]model.AlarmEvent, int64) {
tx := db.DB("").Model(&model.AlarmEvent{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.AlarmCode != "" {
tx = tx.Where("alarm_code = ?", query.AlarmCode)
}
if query.AlarmStatus != "" {
tx = tx.Where("alarm_status = ?", query.AlarmStatus)
}
if query.BeginTime != 0 {
tx = tx.Where("event_time >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("event_time <= ?", query.EndTime)
}
// 查询结果
var total int64 = 0
rows := []model.AlarmEvent{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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
}
// Select 查询集合
func (r AlarmEvent) Select(param model.AlarmEvent) []model.AlarmEvent {
tx := db.DB("").Model(&model.AlarmEvent{})
// 查询条件拼接
if param.NeType != "" {
tx = tx.Where("ne_type = ?", param.NeType)
}
if param.NeId != "" {
tx = tx.Where("ne_id = ?", param.NeId)
}
if param.AlarmId != "" {
tx = tx.Where("alarm_id = ?", param.AlarmId)
}
if param.AlarmCode != 0 {
tx = tx.Where("alarm_code = ?", param.AlarmCode)
}
if param.AlarmStatus != "" {
tx = tx.Where("alarm_status = ?", param.AlarmStatus)
}
// 查询数据
rows := []model.AlarmEvent{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询
func (r AlarmEvent) SelectByIds(ids []int64) []model.AlarmEvent {
rows := []model.AlarmEvent{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.AlarmEvent{})
// 构建查询条件
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 新增信息 返回新增数据ID
func (r AlarmEvent) Insert(param model.AlarmEvent) int64 {
if param.Timestamp == 0 {
param.Timestamp = time.Now().UnixMilli()
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}
// Update 修改信息 返回受影响的行数
func (r AlarmEvent) Update(param model.AlarmEvent) int64 {
if param.ID <= 0 {
return 0
}
tx := db.DB("").Model(&model.AlarmEvent{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "timestamp")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息
func (r AlarmEvent) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.AlarmEvent{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// SelectAlarmEventSeqLast 查询网元告警最后一条序号
func (r AlarmEvent) SelectAlarmEventSeqLast(neType, neId string) int64 {
tx := db.DB("").Model(&model.AlarmEvent{})
tx = tx.Where("ne_type=? and ne_id=?", neType, neId)
tx = tx.Select("alarm_seq").Order("alarm_seq DESC")
// 查询数据
var AlarmEventSeq int64 = 0
if err := tx.Limit(1).Find(&AlarmEventSeq).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return AlarmEventSeq
}
return AlarmEventSeq
}

104
src/modules/ne_data/repository/alarm_forward_log.go Normal file
View File

@@ -0,0 +1,104 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 AlarmForwardLog 结构体
var NewAlarmForwardLog = &AlarmForwardLog{}
// AlarmForwardLog 告警转发记录表 数据层处理
type AlarmForwardLog struct{}
// SelectByPage 分页查询集合
func (r AlarmForwardLog) SelectByPage(query model.AlarmForwardLogQuery) ([]model.AlarmForwardLog, int64) {
tx := db.DB("").Model(&model.AlarmForwardLog{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.BeginTime != 0 {
tx = tx.Where("created_at >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("created_at <= ?", query.EndTime)
}
// 查询结果
var total int64 = 0
rows := []model.AlarmForwardLog{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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 AlarmForwardLog) SelectByIds(ids []int64) []model.AlarmForwardLog {
rows := []model.AlarmForwardLog{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.AlarmForwardLog{})
// 构建查询条件
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 AlarmForwardLog) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.AlarmForwardLog{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息
func (r AlarmForwardLog) Insert(param model.AlarmForwardLog) int64 {
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

107
src/modules/ne_data/repository/alarm_log.go Normal file
View File

@@ -0,0 +1,107 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 AlarmLog 结构体
var NewAlarmLog = &AlarmLog{}
// AlarmLog 基站状态记录表 数据层处理
type AlarmLog struct{}
// SelectByPage 分页查询集合
func (r AlarmLog) SelectByPage(query model.AlarmLogQuery) ([]model.AlarmLog, int64) {
tx := db.DB("").Model(&model.AlarmLog{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.AlarmStatus != "" {
tx = tx.Where("alarm_status = ?", query.AlarmStatus)
}
if query.BeginTime != 0 {
tx = tx.Where("created_at >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("created_at <= ?", query.EndTime)
}
// 查询结果
var total int64 = 0
rows := []model.AlarmLog{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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 AlarmLog) SelectByIds(ids []int64) []model.AlarmLog {
rows := []model.AlarmLog{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.AlarmLog{})
// 构建查询条件
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 AlarmLog) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.AlarmLog{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息
func (r AlarmLog) Insert(param model.AlarmLog) int64 {
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

273
src/modules/ne_data/repository/cbc_message.go Normal file
View File

@@ -0,0 +1,273 @@
package repository
import (
"encoding/json"
"fmt"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/modules/ne_data/model"
"gorm.io/gorm"
)
// 实例化数据层 UEEvent 结构体
var NewCBCMessage = &CBCMessage{}
// UEEvent UE会话事件 数据层处理
type CBCMessage struct{}
// SelectCBCMessage 根据条件分页查询CB消息
func (s *CBCMessage) SelectByPage(query model.CBCMessageQuery) ([]model.CBCMessage, int, error) {
var msg []model.CBCMessage
var total int64
tx := db.DB("").Table("cbc_message")
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeId != "" {
tx = tx.Where("ne_id = ?", query.NeId)
}
if query.EventName != "" {
tx = tx.Where("JSON_EXTRACT(message_json, '$.eventName') = ?", query.EventName)
}
if query.Status != "" {
tx = tx.Where("status = ?", query.Status)
}
var startMicro, endMicro int64
var err error
if query.StartTime != "" {
startMicro, err = parseTimeToMilli(query.StartTime)
if err != nil {
return nil, 0, fmt.Errorf("invalid start time: %w", err)
}
}
if query.EndTime != "" {
endMicro, err = parseTimeToMilli(query.EndTime)
if err != nil {
return nil, 0, fmt.Errorf("invalid end time: %w", err)
}
}
if startMicro > 0 && endMicro > 0 {
tx = tx.Where("created_at BETWEEN ? AND ?", startMicro, endMicro)
} else if startMicro > 0 {
tx = tx.Where("created_at >= ?", startMicro)
} else if endMicro > 0 {
tx = tx.Where("created_at <= ?", endMicro)
}
// 统计总数
if err := tx.Count(&total).Error; err != nil {
return nil, 0, fmt.Errorf("failed to count CBC message: %w", err)
}
// 分页查询
offset := (query.PageNum - 1) * query.PageSize
if err := tx.Limit(query.PageSize).Offset(offset).Order("created_at desc").Find(&msg).Error; err != nil {
return nil, 0, fmt.Errorf("failed to select CBC message: %w", err)
}
return msg, int(total), nil
}
// SelectCBCMessageByPage 分页查询CB消息
// @Description 分页查询CB消息
// @param page 页码
// @param pageSize 每页大小
// @return []model.CBCMessage CB消息列表
// @return int 总记录数
// @return error 错误信息
// @example
// SelectByPage(1, 10)
// func (s *CBCMessage) SelectByPage(pageNum int, pageSize int) ([]model.CBCMessage, int, error) {
// var tickets []model.CBCMessage
// var total int64
// // 统计总数
// if err := db.DB("").Table("cbc_message").Count(&total).Error; err != nil {
// return nil, 0, fmt.Errorf("failed to count CBC message: %w", err)
// }
// // 分页查询
// offset := (pageNum - 1) * pageSize
// if err := db.DB("").Table("cbc_message").
// Limit(pageSize).
// Offset(offset).
// Find(&tickets).Error; err != nil {
// return nil, 0, fmt.Errorf("failed to select CBC message: %w", err)
// }
// return tickets, int(total), nil
// }
// InsertCBCMessage 插入CB消息
// @Description 插入CB消息
// @param msg CB消息对象
// @return error 错误信息
// @example
// CBCMessage.InsertCBCMessage(msg)
func (s *CBCMessage) Insert(msg model.CBCMessage) error {
msg.CreatedAt = time.Now().UnixMilli()
// 这里可以使用ORM或其他方式将ticket插入到数据库中
if err := db.DB("").Table("cbc_message").Create(&msg).Error; err != nil {
return fmt.Errorf("failed to insert CBC message: %w", err)
}
return nil
}
// SelectCBCMessageById 根据工单ID查询CB消息
// @Description 根据工单ID查询CB消息
// @param id 工单ID
// @return *model.CBCMessage CB消息对象
// @return error 错误信息
// @example
// CBCMessage.SelectCBCMessageById(12345)
func (s *CBCMessage) SelectById(id int64) (*model.CBCMessage, error) {
var msg model.CBCMessage
if err := db.DB("").Table("cbc_message").
Where("id = ?", id).
First(&msg).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, nil
}
return nil, fmt.Errorf("failed to select CBC message: %w", err)
}
return &msg, nil
}
// SelectByEventName 根据事件名称查询CB消息
func (s *CBCMessage) SelectByEventName(eventName string) (*model.CBCMessage, error) {
var msg model.CBCMessage
if err := db.DB("").Table("cbc_message").
Where("JSON_EXTRACT(message_json, '$.eventName') = ?", eventName).
First(&msg).Error; err != nil {
if err == gorm.ErrRecordNotFound {
return nil, nil
}
return nil, err
}
return &msg, nil
}
// UpdateCBCMessage 更新CB消息
// @Description 更新CB消息
// @param msg CB消息对象
// @return error 错误信息
// @example
// mfCBCMessageService.UpdateCBCMessage(msg)
func (s *CBCMessage) Update(id int64, messageJson json.RawMessage) (*model.CBCMessage, error) {
var msg model.CBCMessage
now := time.Now().UnixMilli()
err := db.DB("").Transaction(func(tx *gorm.DB) error {
// 在事务中更新
if err := tx.Table("cbc_message").
Where("id = ?", id).
Updates(map[string]any{
"message_json": messageJson,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("failed to update CBC message: %w", err)
}
// 在事务中查询更新后的记录
if err := tx.Table("cbc_message").
Where("id = ?", id).
First(&msg).Error; err != nil {
return fmt.Errorf("failed to fetch updated CBC message: %w", err)
}
return nil
})
if err != nil {
return nil, err
}
return &msg, nil
}
// UpdateCBCMessage 更新CB消息
// @Description 更新CB消息
// @param msg CB消息对象
// @return error 错误信息
// @example
// UpdateCBCMessageDetail(msg)
func (s *CBCMessage) UpdateDetail(eventName, detail string) error {
now := time.Now().UnixMilli()
if err := db.DB("").Table("cbc_message").
Where("JSON_EXTRACT(message_json, '$.eventName') = ?", eventName).
Updates(map[string]any{
"detail": detail,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("failed to update CBC message: %w", err)
}
return nil
}
// DeleteCBCMessage 删除CB消息
// @Description 删除CB消息
// @param id 工单ID
// @return error 错误信息
// @example
// DeleteCBCMessage(12345)
func (s *CBCMessage) Delete(id int64) error {
// 执行删除操作
if err := db.DB("").Table("cbc_message").
Where("id = ?", id).
Delete(&model.CBCMessage{}).Error; err != nil {
return fmt.Errorf("failed to delete CBC message: %w", err)
}
return nil
}
// UpdateCBCMessageStatus 更新CB消息状态
// @Description 更新CB消息状态，并根据状态变化发送相应的HTTP请求
// @param status 新状态
// @return error 错误信息
func (s *CBCMessage) UpdateStatus(id int64, status model.CBCEventStatus) error {
// 更新数据库状态
now := time.Now().UnixMilli()
if err := db.DB("").Table("cbc_message").
Where("id = ?", id).
Updates(map[string]interface{}{
"status": status,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("failed to update CBC message status: %w", err)
}
return nil
}
// Select 查询所有CB消息
func (s *CBCMessage) Select(msgs *[]model.CBCMessage) error {
if err := db.DB("").Table("cbc_message").Find(&msgs).Error; err != nil {
return fmt.Errorf("failed to query CB messages: %w", err)
}
return nil
}
// SelectByNeId 根据网元ID查询CB消息
func (s *CBCMessage) SelectByNeId(neId string, msgs *[]model.CBCMessage) error {
if err := db.DB("").Table("cbc_message").Where("ne_id = ?", neId).Find(&msgs).Error; err != nil {
return fmt.Errorf("failed to query CB messages: %w", err)
}
return nil
}
// 假设 query.StartTime 和 query.EndTime 是 "2006-01-02 15:04:05" 格式字符串
func parseTimeToMilli(ts string) (int64, error) {
if ts == "" {
return 0, nil
}
t, err := time.ParseInLocation("2006-01-02 15:04:05", ts, time.Local)
if err != nil {
return 0, err
}
return t.UnixMilli(), nil
}

167
src/modules/ne_data/repository/cdr_event.go Normal file
View File

@@ -0,0 +1,167 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 CDREvent 结构体
var NewCDREvent = &CDREvent{}
// CDREvent CDR会话事件 数据层处理
type CDREvent struct{}
// SelectByPage 分页查询集合
func (r CDREvent) SelectByPage(neType string, query map[string]string) ([]model.CDREvent, int64) {
// 表名
tableName := fmt.Sprintf("cdr_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Model(&model.CDREvent{})
// 查询条件拼接
if v, ok := query["rmUID"]; ok && v != "" {
tx = tx.Where("rm_uid = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = v + "000"
}
tx = tx.Where("created_at >= ?", v)
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = v + "000"
}
tx = tx.Where("created_at <= ?", v)
}
// 各个网元特殊查询条件
switch neType {
case "SMSC":
if v, ok := query["callerParty"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["calledParty"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["recordType"]; ok && v != "" {
recordTypes := strings.Split(v, ",")
var querytrArr []string
for _, recordType := range recordTypes {
querytrArr = append(querytrArr, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') = '%s'", recordType))
}
tx = tx.Where(fmt.Sprintf("( %s )", strings.Join(querytrArr, " OR ")))
}
case "SMF":
if v, ok := query["recordType"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.recordType') = ?", v)
}
if v, ok := query["subscriberID"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["dnn"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.pDUSessionChargingInformation.dNNID') = ?", v)
}
case "SGWC":
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedIMSI') like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["msisdn"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedMSISDN') like ?", fmt.Sprintf("%%%s%%", v))
}
case "IMS":
if v, ok := query["callerParty"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["calledParty"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') like ?", fmt.Sprintf("%%%s%%", v))
}
}
var total int64 = 0
rows := []model.CDREvent{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectByIds 通过ID查询
func (r CDREvent) SelectByIds(neType string, ids []int64) []model.CDREvent {
rows := []model.CDREvent{}
if len(ids) <= 0 {
return rows
}
// 表名
tableName := fmt.Sprintf("cdr_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Model(&model.CDREvent{})
// 构建查询条件
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 CDREvent) DeleteByIds(neType string, ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
// 表名
tableName := fmt.Sprintf("cdr_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Where("id in ?", ids)
if err := tx.Delete(&model.CDREvent{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息 返回新增数据ID
func (r CDREvent) Insert(param model.CDREvent) int64 {
if param.NeType == "" {
return 0
}
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 表名
tableName := fmt.Sprintf("cdr_event_%s", strings.ToLower(param.NeType))
// 执行插入
if err := db.DB("").Table(tableName).Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

218
src/modules/ne_data/repository/kpi_c_report.go Normal file
View File

@@ -0,0 +1,218 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 KpiCReport 结构体
var NewKpiCReport = &KpiCReport{}
// KpiCReport 性能统计 数据层处理
type KpiCReport struct{}
// SelectGoldKPI 通过网元指标数据信息
func (r KpiCReport) SelectKPI(query model.KPICQuery) []model.KpiCReport {
rows := []model.KpiCReport{}
if query.NeType == "" {
return rows
}
tx := db.DB("").Model(&model.KpiCReport{})
// 表名
tableName := fmt.Sprintf("kpi_c_report_%s", strings.ToLower(query.NeType))
tx.Table(tableName)
// 构建查询条件
if query.RmUID != "" {
tx = tx.Where("rm_uid = ?", query.RmUID)
}
if query.BeginTime != 0 {
tx = tx.Where("created_at >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("created_at <= ?", query.EndTime)
}
// 排序
if query.SortField == "" || query.SortField == "timeGroup" {
query.SortField = "created_at"
}
if query.SortOrder == "" {
query.SortOrder = "desc"
}
tx = tx.Order(fmt.Sprintf("%s %s", query.SortField, query.SortOrder))
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r KpiCReport) Insert(param model.KpiCReport) int64 {
if param.NeType == "" {
return 0
}
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 表名
tableName := fmt.Sprintf("kpi_c_report_%s", strings.ToLower(param.NeType))
// 执行插入
if err := db.DB("").Table(tableName).Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}
// SelectKPITitle 网元对应的指标名称
func (r KpiCReport) SelectKPITitle(neType string) []model.KpiCTitle {
rows := []model.KpiCTitle{}
if neType == "" {
return rows
}
tx := db.DB("").Model(&model.KpiCTitle{})
// 构建查询条件
tx = tx.Where("ne_type =?", neType)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// TitleLastKPIId 查询指标标题最后kpiid
func (r KpiCReport) TitleLastKPIId(neType string) string {
tx := db.DB("").Model(&model.KpiCTitle{})
tx = tx.Where("ne_type=?", neType)
tx = tx.Select("kpi_id").Order("kpi_id DESC")
// 查询数据
var kpiId string = ""
if err := tx.Limit(1).Find(&kpiId).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return kpiId
}
return kpiId
}
// SelectByPageTitle 分页查询集合
func (r KpiCReport) TitleSelectByPage(query map[string]string) ([]model.KpiCTitle, int64) {
tx := db.DB("").Model(&model.KpiCTitle{})
// 查询条件拼接
if v, ok := query["neType"]; ok && v != "" {
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["status"]; ok && v != "" {
tx = tx.Where("status = ?", v)
} else {
tx = tx.Where("status != ?", "2")
}
// 查询结果
var total int64 = 0
rows := []model.KpiCTitle{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// TitleSelect 网元对应的指标名称
func (r KpiCReport) TitleSelect(param model.KpiCTitle) []model.KpiCTitle {
tx := db.DB("").Model(&model.KpiCTitle{})
// 构建查询条件
if param.NeType != "" {
tx = tx.Where("ne_type =?", param.NeType)
}
if param.Title != "" {
tx = tx.Where("title = ?", param.Title)
}
if param.Status != "" {
tx = tx.Where("status = ?", param.Status)
}
// 查询数据
rows := []model.KpiCTitle{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// TitleInsert 新增信息
func (r KpiCReport) TitleInsert(param model.KpiCTitle) int64 {
if param.CreatedBy != "" {
param.UpdatedAt = time.Now().UnixMilli()
}
param.Status = "1"
tx := db.DB("").Create(&param)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return param.ID
}
// TitleUpdate 修改信息
func (r KpiCReport) TitleUpdate(param model.KpiCTitle) int64 {
if param.ID <= 0 {
return 0
}
param.UpdatedAt = time.Now().UnixMilli()
tx := db.DB("").Model(&model.KpiCTitle{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "created_by")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// TitleDeleteByIds 批量删除信息
func (r KpiCReport) TitleDeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Model(&model.KpiCTitle{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
if err := tx.Update("status", 2).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

218
src/modules/ne_data/repository/kpi_report.go Normal file
View File

@@ -0,0 +1,218 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 KpiReport 结构体
var NewKpiReport = &KpiReport{}
// KpiReport 性能统计 数据层处理
type KpiReport struct{}
// SelectGoldKPI 通过网元指标数据信息
func (r KpiReport) SelectKPI(query model.KPIQuery) []model.KpiReport {
rows := []model.KpiReport{}
if query.NeType == "" {
return rows
}
tx := db.DB("").Model(&model.KpiReport{})
// 表名
tableName := fmt.Sprintf("kpi_report_%s", strings.ToLower(query.NeType))
tx = tx.Table(tableName)
// 构建查询条件
if query.RmUID != "" {
tx = tx.Where("rm_uid = ?", query.RmUID)
}
if query.BeginTime != 0 {
tx = tx.Where("created_at >= ?", query.BeginTime)
}
if query.EndTime != 0 {
tx = tx.Where("created_at <= ?", query.EndTime)
}
// 排序
if query.SortField == "" || query.SortField == "timeGroup" {
query.SortField = "created_at"
}
if query.SortOrder == "" {
query.SortOrder = "desc"
}
tx = tx.Order(fmt.Sprintf("%s %s", query.SortField, query.SortOrder))
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r KpiReport) Insert(param model.KpiReport) int64 {
if param.NeType == "" {
return 0
}
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 表名
tableName := fmt.Sprintf("kpi_report_%s", strings.ToLower(param.NeType))
// 执行插入
if err := db.DB("").Table(tableName).Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}
// SelectUPF 查询UPF数据 N3上行,N6下行
func (r KpiReport) SelectUPF(rmUID string, beginTime, endTime int64) []model.KpiReport {
tx := db.DB("").Model(&model.KpiReport{})
// 表名
tx = tx.Table("kpi_report_upf")
tx = tx.Where("rm_uid = ?", rmUID)
tx = tx.Where("created_at >= ?", beginTime)
tx = tx.Where("created_at <= ?", endTime)
// 查询数据
rows := []model.KpiReport{}
if err := tx.Select("kpi_values").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectKPITitle 网元对应的指标名称
func (r KpiReport) SelectKPITitle(neType string) []model.KpiTitle {
rows := []model.KpiTitle{}
if neType == "" {
return rows
}
tx := db.DB("").Model(&model.KpiTitle{})
// 构建查询条件
tx = tx.Where("ne_type = ? and status_flag = ?", neType, "1")
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByPageTitle 分页查询集合
func (r KpiReport) TitleSelectByPage(query map[string]string) ([]model.KpiTitle, int64) {
tx := db.DB("").Model(&model.KpiTitle{})
// 查询条件拼接
if v, ok := query["neType"]; ok && v != "" {
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["kpiId"]; ok && v != "" {
tx = tx.Where("kpi_id like ?", fmt.Sprintf("%s%%", v))
}
if v, ok := query["title"]; ok && v != "" {
tx = tx.Where("cn_title like ? or en_title like ?", fmt.Sprintf("%%%s%%", v), fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
// 查询结果
var total int64 = 0
rows := []model.KpiTitle{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// TitleSelect 网元对应的指标名称
func (r KpiReport) TitleSelect(param model.KpiTitle) []model.KpiTitle {
tx := db.DB("").Model(&model.KpiTitle{})
// 构建查询条件
if param.NeType != "" {
tx = tx.Where("ne_type =?", param.NeType)
}
if param.KpiId != "" {
tx = tx.Where("kpi_id = ?", param.KpiId)
}
if param.StatusFlag != "" {
tx = tx.Where("status_flag = ?", param.StatusFlag)
}
// 查询数据
rows := []model.KpiTitle{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// TitleInsert 新增信息
func (r KpiReport) TitleInsert(param model.KpiTitle) int64 {
tx := db.DB("").Create(&param)
if err := tx.Error; err != nil {
logger.Errorf("Create err => %v", err)
}
return param.ID
}
// TitleUpdate 修改信息
func (r KpiReport) TitleUpdate(param model.KpiTitle) int64 {
if param.ID <= 0 {
return 0
}
tx := db.DB("").Model(&model.KpiTitle{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "title_json")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// TitleDeleteByIds 批量删除信息
func (r KpiReport) TitleDeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.KpiTitle{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

116
src/modules/ne_data/repository/nb_state.go Normal file
View File

@@ -0,0 +1,116 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 NBState 结构体
var NewNBState = &NBState{}
// NBState 基站状态记录表 数据层处理
type NBState struct{}
// SelectByPage 分页查询集合
func (r NBState) SelectByPage(query model.NBStateQuery) ([]model.NBState, int64) {
tx := db.DB("").Model(&model.NBState{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.RmUID != "" {
tx = tx.Where("rm_uid = ?", query.RmUID)
}
if query.Status != "" {
tx = tx.Where("state = ?", query.Status)
}
if query.StartTime != "" {
startTime := query.StartTime
if len(startTime) == 10 {
startTime = startTime + "000"
}
tx = tx.Where("create_time >= ?", startTime)
}
if query.EndTime != "" {
endTime := query.EndTime
if len(endTime) == 10 {
endTime = endTime + "999"
}
tx = tx.Where("create_time <= ?", endTime)
}
// 查询结果
var total int64 = 0
rows := []model.NBState{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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 NBState) SelectByIds(ids []string) []model.NBState {
rows := []model.NBState{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.NBState{})
// 构建查询条件
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 NBState) DeleteByIds(ids []string) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.NBState{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息
func (r NBState) Insert(param model.NBState) int64 {
param.CreateTime = time.Now().UnixMilli()
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

110
src/modules/ne_data/repository/ne_state.go Normal file
View File

@@ -0,0 +1,110 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 NEState 结构体
var NewNEState = &NEState{}
// NEState 网元状态记录表 数据层处理
type NEState struct{}
// SelectByPage 分页查询集合
func (r NEState) SelectByPage(query model.NEStateQuery) ([]model.NEState, int64) {
tx := db.DB("").Model(&model.NEState{})
// 查询条件拼接
if query.NeType != "" {
tx = tx.Where("ne_type = ?", query.NeType)
}
if query.NeID != "" {
tx = tx.Where("ne_id = ?", query.NeID)
}
if query.BeginTime != "" {
startTime := query.BeginTime
if len(startTime) == 10 {
startTime = startTime + "000"
}
tx = tx.Where("create_time >= ?", startTime)
}
if query.EndTime != "" {
endTime := query.EndTime
if len(endTime) == 10 {
endTime = endTime + "999"
}
tx = tx.Where("create_time <= ?", endTime)
}
// 查询结果
var total int64 = 0
rows := []model.NEState{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if query.SortField != "" {
sortField := query.SortField
if query.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.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 NEState) SelectByIds(ids []string) []model.NEState {
rows := []model.NEState{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.NEState{})
// 构建查询条件
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
}
// DeleteByTime 删除信息
func (r NEState) DeleteByTime(ltTime int64) int64 {
if ltTime <= 0 {
return 0
}
tx := db.DB("").Where("create_time < ?", ltTime)
if err := tx.Delete(&model.NEState{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息
func (r NEState) Insert(param model.NEState) int64 {
param.CreateTime = time.Now().UnixMilli()
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

136
src/modules/ne_data/repository/udm_auth.go Normal file
View File

@@ -0,0 +1,136 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UDMAuthUser 结构体
var NewUDMAuthUser = &UDMAuthUser{}
// UDMAuthUser UDM鉴权信息表 数据层处理
type UDMAuthUser struct{}
// ClearAndInsert 清空ne_id后新增实体
func (r *UDMAuthUser) ClearAndInsert(neId string, uArr []model.UDMAuthUser) int64 {
// 不指定neID时，用 TRUNCATE 清空表快
// _, err := datasource.ExecDB("", "TRUNCATE TABLE udm_auth", nil)
result := db.DB("").Where("ne_id = ?", neId).Unscoped().Delete(&model.UDMAuthUser{})
if result.Error != nil {
logger.Errorf("Delete err => %v", result.Error)
}
return r.Inserts(uArr)
}
// SelectPage 根据条件分页查询
func (r *UDMAuthUser) SelectPage(query map[string]string) ([]model.UDMAuthUser, int64) {
tx := db.DB("").Model(&model.UDMAuthUser{})
// 查询条件拼接
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
if v, ok := query["imsis"]; ok && v != "" {
arr := strings.Split(v, ",")
tx = tx.Where("imsi in ?", arr)
// 勾选时，pageSize为勾选的数量
query["pageSize"] = fmt.Sprint(len(arr))
}
var total int64 = 0
rows := []model.UDMAuthUser{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectList 根据实体查询
func (r *UDMAuthUser) SelectList(u model.UDMAuthUser) []model.UDMAuthUser {
tx := db.DB("").Model(&model.UDMAuthUser{})
// 查询条件拼接
if u.IMSI != "" {
tx = tx.Where("imsi = ?", u.IMSI)
}
if u.NeId != "" {
tx = tx.Where("ne_id = ?", u.NeId)
}
// 查询数据
arr := []model.UDMAuthUser{}
if err := tx.Order("imsi asc").Find(&arr).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return arr
}
// SelectByIMSIAndNeID 通过imsi和ne_id查询
func (r *UDMAuthUser) SelectByIMSIAndNeID(imsi, neId string) model.UDMAuthUser {
tx := db.DB("").Model(&model.UDMAuthUser{})
item := model.UDMAuthUser{}
// 查询条件拼接
tx = tx.Where("imsi = ? and ne_id = ?", imsi, neId)
// 查询数据
if err := tx.Order("imsi asc").Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return item
}
// Insert 批量添加
func (r *UDMAuthUser) Inserts(uArr []model.UDMAuthUser) int64 {
tx := db.DB("").CreateInBatches(uArr, 500)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return tx.RowsAffected
}
// Delete 删除实体
func (r *UDMAuthUser) Delete(imsi, neId string) int64 {
tx := db.DB("").Where("imsi = ? and ne_id = ?", imsi, neId).Delete(&model.UDMAuthUser{})
if err := tx.Error; err != nil {
logger.Errorf("Delete err => %v", err)
}
return tx.RowsAffected
}
// DeletePrefixByIMSI 删除前缀匹配的实体
func (r *UDMAuthUser) DeletePrefixByIMSI(imsi, neId string) int64 {
tx := db.DB("").Where("imsi like ? and ne_id = ?", fmt.Sprintf("%s%%", imsi), neId).Delete(&model.UDMAuthUser{})
if err := tx.Error; err != nil {
logger.Errorf("DeletePrefixByIMSI err => %v", err)
}
return tx.RowsAffected
}

119
src/modules/ne_data/repository/udm_extend.go Normal file
View File

@@ -0,0 +1,119 @@
package repository
import (
"fmt"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UDMExtend 结构体
var NewUDMExtend = &UDMExtend{}
// UDMExtend UDM鉴权信息表 数据层处理
type UDMExtend struct{}
// SelectByPage 分页查询集合
func (r UDMExtend) SelectByPage(query map[string]string) ([]model.UDMExtend, int64) {
tx := db.DB("").Model(&model.UDMExtend{})
// 查询条件拼接
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
// 查询结果
var total int64 = 0
rows := []model.UDMExtend{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortField := v
if o, ok := query["sortOrder"]; ok && o != "" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["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
}
// SelectList 根据实体查询
func (r *UDMExtend) SelectList(u model.UDMExtend) []model.UDMExtend {
tx := db.DB("").Model(&model.UDMExtend{})
// 构建查询条件
if u.IMSI != "" {
tx = tx.Where("imsi = ?", u.IMSI)
}
if u.NeId != "" {
tx = tx.Where("ne_id = ?", u.NeId)
}
tx = tx.Order("imsi asc")
// 查询数据
rows := []model.UDMExtend{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIMSIAndNeID 通过imsi和ne_id查询 neId为%时模糊imsi查询
func (r *UDMExtend) SelectByIMSIAndNeID(imsi, neId string) model.UDMExtend {
tx := db.DB("").Model(&model.UDMExtend{})
// 构建查询条件
if neId == "%" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%s%%", imsi))
} else {
tx = tx.Where(" imsi = ? and ne_id = ?", imsi, neId)
}
// 查询数据
rows := []model.UDMExtend{}
if err := tx.Limit(1).Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
}
if len(rows) > 0 {
return rows[0]
}
return model.UDMExtend{}
}
// Insert 批量添加
func (r *UDMExtend) Inserts(uArr []model.UDMExtend) int64 {
tx := db.DB("").CreateInBatches(uArr, 500)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return tx.RowsAffected
}
// Delete 删除实体 neId为%时模糊imsi前缀
func (r *UDMExtend) Delete(imsi, neId string) int64 {
tx := db.DB("")
if neId == "%" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%s%%", imsi))
} else {
tx = tx.Where(" imsi = ? and ne_id = ?", imsi, neId)
}
tx = tx.Delete(&model.UDMExtend{})
if err := tx.Error; err != nil {
logger.Errorf("Delete err => %v", err)
}
return tx.RowsAffected
}

139
src/modules/ne_data/repository/udm_sub.go Normal file
View File

@@ -0,0 +1,139 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UDMSubUser 结构体
var NewUDMSub = &UDMSubUser{}
// UDMSubUser UDM签约信息表 数据层处理
type UDMSubUser struct{}
// ClearAndInsert 清空ne_id后新增实体
func (r *UDMSubUser) ClearAndInsert(neId string, u []model.UDMSubUser) int64 {
// 不指定neID时，用 TRUNCATE 清空表快
// _, err := datasource.ExecDB("", "TRUNCATE TABLE udm_sub", nil)
result := db.DB("").Where("ne_id = ?", neId).Unscoped().Delete(&model.UDMSubUser{})
if result.Error != nil {
logger.Errorf("Delete err => %v", result.Error)
}
return r.Inserts(u)
}
// SelectPage 根据条件分页查询字典类型
func (r *UDMSubUser) SelectPage(query map[string]string) ([]model.UDMSubUser, int64) {
tx := db.DB("").Model(&model.UDMSubUser{})
// 查询条件拼接
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["msisdn"]; ok && v != "" {
tx = tx.Where("msisdn like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id =?", v)
}
if v, ok := query["imsis"]; ok && v != "" {
arr := strings.Split(v, ",")
tx = tx.Where("imsi in ?", arr)
// 勾选时，pageSize为勾选的数量
query["pageSize"] = fmt.Sprint(len(arr))
}
var total int64 = 0
rows := []model.UDMSubUser{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectList 根据实体查询
func (r *UDMSubUser) SelectList(u model.UDMSubUser) []model.UDMSubUser {
tx := db.DB("").Model(&model.UDMSubUser{})
// 查询条件拼接
if u.IMSI != "" {
tx = tx.Where("imsi = ?", u.IMSI)
}
if u.NeId != "" {
tx = tx.Where("ne_id = ?", u.NeId)
}
// 查询数据
arr := []model.UDMSubUser{}
if err := tx.Order("imsi asc").Find(&arr).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return arr
}
// SelectByIMSIAndNeID 通过imsi和ne_id查询
func (r *UDMSubUser) SelectByIMSIAndNeID(imsi, neId string) model.UDMSubUser {
tx := db.DB("").Model(&model.UDMSubUser{})
item := model.UDMSubUser{}
// 查询条件拼接
tx = tx.Where("imsi = ? and ne_id = ?", imsi, neId)
// 查询数据
if err := tx.Order("imsi asc").Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return item
}
// Insert 批量添加
func (r *UDMSubUser) Inserts(uArr []model.UDMSubUser) int64 {
tx := db.DB("").CreateInBatches(uArr, 500)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return tx.RowsAffected
}
// Delete 删除实体
func (r *UDMSubUser) Delete(imsi, neId string) int64 {
tx := db.DB("").Where("imsi = ? and ne_id = ?", imsi, neId).Delete(&model.UDMSubUser{})
if err := tx.Error; err != nil {
logger.Errorf("Delete err => %v", err)
}
return tx.RowsAffected
}
// DeletePrefixByIMSI 删除前缀匹配的实体
func (r *UDMSubUser) DeletePrefixByIMSI(imsiPrefix, neId string) int64 {
tx := db.DB("").Where("imsi like ? and ne_id = ?", fmt.Sprintf("%s%%", imsiPrefix), neId).Delete(&model.UDMSubUser{})
if err := tx.Error; err != nil {
logger.Errorf("DeletePrefixByIMSI err => %v", err)
}
return tx.RowsAffected
}

138
src/modules/ne_data/repository/udm_voip.go Normal file
View File

@@ -0,0 +1,138 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UDMVOIPUser 结构体
var NewUDMVOIPUser = &UDMVOIPUser{}
// UDMVOIPUser UDMVOIP用户信息表 数据层处理
type UDMVOIPUser struct{}
// ClearAndInsert 清空ne_id后新增实体
func (r UDMVOIPUser) ClearAndInsert(neId string, uArr []model.UDMVOIPUser) int64 {
// 不指定neID时，用 TRUNCATE 清空表快
// _, err := datasource.ExecDB("", "TRUNCATE TABLE udm_voip", nil)
result := db.DB("").Where("ne_id = ?", neId).Unscoped().Delete(&model.UDMVOIPUser{})
if result.Error != nil {
logger.Errorf("Delete err => %v", result.Error)
}
return r.Inserts(uArr)
}
// SelectPage 根据条件分页查询
func (r UDMVOIPUser) SelectPage(query map[string]string) ([]model.UDMVOIPUser, int64) {
tx := db.DB("").Model(&model.UDMVOIPUser{})
// 查询条件拼接
if v, ok := query["username"]; ok && v != "" {
tx = tx.Where("username like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
if v, ok := query["usernames"]; ok && v != "" {
arr := strings.Split(v, ",")
tx = tx.Where("username in ?", arr)
// 勾选时，pageSize为勾选的数量
query["pageSize"] = fmt.Sprint(len(arr))
}
var total int64 = 0
rows := []model.UDMVOIPUser{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
} else {
tx = tx.Order("username asc")
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectList 根据实体查询
func (r UDMVOIPUser) SelectList(u model.UDMVOIPUser) []model.UDMVOIPUser {
tx := db.DB("").Model(&model.UDMVOIPUser{})
// 查询条件拼接
if u.UserName != "" {
tx = tx.Where("username = ?", u.UserName)
}
if u.NeId != "" {
tx = tx.Where("ne_id = ?", u.NeId)
}
// 查询数据
arr := []model.UDMVOIPUser{}
if err := tx.Order("username asc").Find(&arr).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return arr
}
// SelectByUserNameAndNeID 通过username和ne_id查询
func (r UDMVOIPUser) SelectByUserNameAndNeID(username, neId string) model.UDMVOIPUser {
tx := db.DB("").Model(&model.UDMVOIPUser{})
item := model.UDMVOIPUser{}
// 查询条件拼接
tx = tx.Where("username = ? and ne_id = ?", username, neId)
// 查询数据
if err := tx.Order("username asc").Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return item
}
// Insert 批量添加
func (r UDMVOIPUser) Inserts(uArr []model.UDMVOIPUser) int64 {
tx := db.DB("").CreateInBatches(uArr, 500)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return tx.RowsAffected
}
// Delete 删除实体
func (r UDMVOIPUser) Delete(username, neId string) int64 {
tx := db.DB("").Where("username = ? and ne_id = ?", username, neId).Delete(&model.UDMVOIPUser{})
if err := tx.Error; err != nil {
logger.Errorf("Delete err => %v", err)
}
return tx.RowsAffected
}
// DeletePrefixByUserName 删除前缀匹配的实体
func (r UDMVOIPUser) DeletePrefixByUserName(username, neId string) int64 {
tx := db.DB("").Where("username like ? and ne_id = ?", fmt.Sprintf("%s%%", username), neId).Delete(&model.UDMVOIPUser{})
if err := tx.Error; err != nil {
logger.Errorf("DeletePrefixByUserName err => %v", err)
}
return tx.RowsAffected
}

150
src/modules/ne_data/repository/udm_volte_ims.go Normal file
View File

@@ -0,0 +1,150 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UDMVolteIMSUser 结构体
var NewUDMVolteIMSUser = &UDMVolteIMSUser{}
// UDMVolteIMSUser UDMVOIP用户信息表 数据层处理
type UDMVolteIMSUser struct{}
// ClearAndInsert 清空ne_id后新增实体
func (r UDMVolteIMSUser) ClearAndInsert(neId string, uArr []model.UDMVolteIMSUser) int64 {
// 不指定neID时，用 TRUNCATE 清空表快
// _, err := datasource.ExecDB("", "TRUNCATE TABLE udm_volte_ims", nil)
result := db.DB("").Where("ne_id = ?", neId).Unscoped().Delete(&model.UDMVolteIMSUser{})
if result.Error != nil {
logger.Errorf("Delete err => %v", result.Error)
}
return r.Inserts(uArr)
}
// SelectPage 根据条件分页查询
func (r UDMVolteIMSUser) SelectPage(query map[string]string) ([]model.UDMVolteIMSUser, int64) {
tx := db.DB("").Model(&model.UDMVolteIMSUser{})
// 查询条件拼接
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("imsi like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["msisdn"]; ok && v != "" {
tx = tx.Where("msisdn like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
if v, ok := query["tag"]; ok && v != "" {
tx = tx.Where("tag = ?", v)
}
if v, ok := query["vni"]; ok && v != "" {
tx = tx.Where("vni like ?", fmt.Sprintf("%%%s%%", v))
}
if v, ok := query["imsis"]; ok && v != "" {
arr := strings.Split(v, ",")
tx = tx.Where("imsi in ?", arr)
// 勾选时，pageSize为勾选的数量
query["pageSize"] = fmt.Sprint(len(arr))
}
var total int64 = 0
rows := []model.UDMVolteIMSUser{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
} else {
tx = tx.Order("imsi asc")
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectList 根据实体查询
func (r UDMVolteIMSUser) SelectList(u model.UDMVolteIMSUser) []model.UDMVolteIMSUser {
tx := db.DB("").Model(&model.UDMVolteIMSUser{})
// 查询条件拼接
if u.IMSI != "" {
tx = tx.Where("imsi = ?", u.IMSI)
}
if u.NeId != "" {
tx = tx.Where("ne_id = ?", u.NeId)
}
if u.Tag != "" {
tx = tx.Where("tag = ?", u.Tag)
}
// 查询数据
arr := []model.UDMVolteIMSUser{}
if err := tx.Order("imsi asc").Find(&arr).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return arr
}
// SelectByIMSIAndMSISDNAndNeID 通过imsi,msisdn,ne_id查询
func (r UDMVolteIMSUser) SelectByIMSIAndMSISDNAndNeID(imsi, msisdn, neId string) model.UDMVolteIMSUser {
tx := db.DB("").Model(&model.UDMVolteIMSUser{})
item := model.UDMVolteIMSUser{}
// 查询条件拼接
tx = tx.Where("imsi = ? and msisdn = ? and ne_id = ?", imsi, msisdn, neId)
// 查询数据
if err := tx.Order("imsi asc").Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return item
}
// Insert 批量添加
func (r UDMVolteIMSUser) Inserts(uArr []model.UDMVolteIMSUser) int64 {
tx := db.DB("").CreateInBatches(uArr, 500)
if err := tx.Error; err != nil {
logger.Errorf("CreateInBatches err => %v", err)
}
return tx.RowsAffected
}
// Delete 删除实体
func (r UDMVolteIMSUser) Delete(imsi, neId string) int64 {
tx := db.DB("").Where("imsi = ? and ne_id = ?", imsi, neId).Delete(&model.UDMVolteIMSUser{})
if err := tx.Error; err != nil {
logger.Errorf("Delete err => %v", err)
}
return tx.RowsAffected
}
// DeletePrefixByIMSI 删除前缀匹配的实体
func (r UDMVolteIMSUser) DeletePrefixByIMSI(imsi, neId string) int64 {
tx := db.DB("").Where("imsi like ? and ne_id = ?", fmt.Sprintf("%s%%", imsi), neId).Delete(&model.UDMVolteIMSUser{})
if err := tx.Error; err != nil {
logger.Errorf("DeletePrefixByIMSI err => %v", err)
}
return tx.RowsAffected
}

132
src/modules/ne_data/repository/ue_event.go Normal file
View File

@@ -0,0 +1,132 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/ne_data/model"
)
// 实例化数据层 UEEvent 结构体
var NewUEEvent = &UEEvent{}
// UEEvent UE会话事件 数据层处理
type UEEvent struct{}
// SelectByPage 分页查询集合
func (r UEEvent) SelectByPage(neType string, query map[string]string) ([]model.UEEvent, int64) {
// 表名
tableName := fmt.Sprintf("ue_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Model(&model.CDREvent{})
// 查询条件拼接
if v, ok := query["rmUID"]; ok && v != "" {
tx = tx.Where("rm_uid = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = v + "000"
}
tx = tx.Where("created_at >= ?", v)
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = v + "000"
}
tx = tx.Where("created_at <= ?", v)
}
if v, ok := query["eventType"]; ok && v != "" {
eventTypes := strings.Split(v, ",")
tx = tx.Where("event_type in ?", eventTypes)
}
if v, ok := query["imsi"]; ok && v != "" {
tx = tx.Where("JSON_EXTRACT(event_json, '$.imsi') like ?", fmt.Sprintf("%%%s%%", v))
}
// 查询结果
var total int64 = 0
rows := []model.UEEvent{}
// 查询数量 长度为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Offset(int(pageNum * pageSize)).Limit(int(pageSize))
// 排序
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v
if o, ok := query["sortOrder"]; ok && o != "" {
if o == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
tx = tx.Order(sortSql)
}
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query err => %v", err)
}
return rows, total
}
// SelectByIds 通过ID查询
func (r UEEvent) SelectByIds(neType string, ids []int64) []model.UEEvent {
rows := []model.UEEvent{}
if len(ids) <= 0 {
return rows
}
// 表名
tableName := fmt.Sprintf("ue_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Model(&model.UEEvent{})
// 构建查询条件
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 UEEvent) DeleteByIds(neType string, ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
// 表名
tableName := fmt.Sprintf("ue_event_%s", strings.ToLower(neType))
tx := db.DB("").Table(tableName).Where("id in ?", ids)
if err := tx.Delete(&model.UEEvent{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Insert 新增信息 返回新增数据ID
func (r UEEvent) Insert(param model.UEEvent) int64 {
if param.NeType == "" {
return 0
}
if param.CreatedAt == 0 {
param.CreatedAt = time.Now().UnixMilli()
}
// 表名
tableName := fmt.Sprintf("ue_event_%s", strings.ToLower(param.NeType))
// 执行插入
if err := db.DB("").Table(tableName).Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}

269
src/modules/ne_data/service/alarm.go Normal file
View File

@@ -0,0 +1,269 @@
package service
import (
"fmt"
"strconv"
"time"
"github.com/tsmask/go-oam"
"github.com/tsmask/go-oam/framework/utils/parse"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
sysService "be.ems/src/modules/system/service"
)
// 实例化数据层 Alarm 结构体
var NewAlarm = &Alarm{
alarmRepository: repository.NewAlarm,
}
// Alarm 告警 服务层处理
type Alarm struct {
alarmRepository *repository.Alarm // 告警数据信息
}
// FindByPage 根据条件分页查询
func (r Alarm) FindByPage(query model.AlarmQuery) ([]model.Alarm, int64) {
return r.alarmRepository.SelectByPage(query)
}
// Find 查询
func (r Alarm) Find(param model.Alarm) []model.Alarm {
return r.alarmRepository.Select(param)
}
// Insert 新增信息
func (s Alarm) Insert(param model.Alarm) int64 {
return s.alarmRepository.Insert(param)
}
// Update 修改信息
func (s Alarm) Update(param model.Alarm) int64 {
return s.alarmRepository.Update(param)
}
// DeleteByIds 批量删除信息
func (r Alarm) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
data := r.alarmRepository.SelectByIds(ids)
if len(data) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(data) == len(ids) {
rows := r.alarmRepository.DeleteByIds(ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// FindAlarmSeqLast 查询网元告警最后一条序号
func (s Alarm) FindAlarmSeqLast(neType, neId string) int64 {
return s.alarmRepository.SelectAlarmSeqLast(neType, neId)
}
// ClearByIds 批量清除告警信息
func (r Alarm) ClearByIds(ids []int64, clearUser, clearType string) (int64, error) {
// 检查是否存在
arr := r.alarmRepository.SelectByIds(ids)
if len(arr) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(arr) == len(ids) {
var rows int64 = 0
for _, v := range arr {
// 状态检查AlarmCode变更告警ID
if v.AlarmCode == constants.ALARM_STATE_CHECK || v.AlarmCode == constants.ALARM_CMD_CHECK || v.AlarmCode == constants.ALARM_LICENSE_CHECK {
v.AlarmId = fmt.Sprintf("%d%d", v.AlarmCode, v.EventTime)
}
v.AlarmStatus = oam.ALARM_STATUS_CLEAR
// 告警清除
v.ClearType = clearType
v.ClearUser = clearUser
v.ClearTime = time.Now().UnixMilli()
rows += r.alarmRepository.Update(v)
}
return rows, nil
}
return 0, fmt.Errorf("clear fail")
}
// AckByIds 批量确认清除告警信息
func (r Alarm) AckByIds(ids []int64, ackUser, ackState string) (int64, error) {
// 检查是否存在
arr := r.alarmRepository.SelectByIds(ids)
if len(arr) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(arr) == len(ids) {
var rows int64 = 0
for _, v := range arr {
v.AckState = ackState
v.AckTime = time.Now().UnixMilli()
v.AckUser = ackUser
rows += r.alarmRepository.Update(v)
}
return rows, nil
}
return 0, fmt.Errorf("ack fail")
}
// CountType 告警类别数量
func (s Alarm) CountType(alarmStatus string) []map[string]any {
data := []map[string]any{}
alarmTypeArr := []string{
oam.ALARM_TYPE_COMMUNICATION_ALARM,
oam.ALARM_TYPE_EQUIPMENT_ALARM,
oam.ALARM_TYPE_PROCESSING_FAILURE,
oam.ALARM_TYPE_ENVIRONMENTAL_ALARM,
oam.ALARM_TYPE_QUALITY_OF_SERVICE_ALARM,
}
for _, v := range alarmTypeArr {
data = append(data, map[string]any{
"alarmType": v,
"total": 0,
})
}
// 告警类别数量
rows := s.alarmRepository.GroupTotal(alarmStatus, "alarm_type", -1)
for _, item := range data {
for _, v := range rows {
str := fmt.Sprint(v["alarm_type"])
if str == item["alarmType"] {
item["alarmType"] = str
item["total"] = parse.Number(v["total"])
}
}
}
return data
}
// CountSeverity 告警级别数量
func (s Alarm) CountSeverity(alarmStatus string) []map[string]any {
data := []map[string]any{}
alarmTypeArr := []string{
oam.ALARM_SEVERITY_CRITICAL,
oam.ALARM_SEVERITY_MAJOR,
oam.ALARM_SEVERITY_MINOR,
oam.ALARM_SEVERITY_WARNING,
}
for _, v := range alarmTypeArr {
data = append(data, map[string]any{
"severity": v,
"total": 0,
})
}
// 数量
rows := s.alarmRepository.GroupTotal(alarmStatus, "perceived_severity", -1)
for _, item := range data {
for _, v := range rows {
str := fmt.Sprint(v["perceived_severity"])
if str == item["severity"] {
item["severity"] = str
item["total"] = parse.Number(v["total"])
}
}
}
return data
}
// CountNe 告警状态前几排名
func (s Alarm) CountNe(alarmStatus string, top int) []map[string]any {
data := s.alarmRepository.GroupTotal(alarmStatus, "ne_type", top)
for _, v := range data {
v["neType"] = fmt.Sprint(v["ne_type"])
v["total"] = parse.Number(v["total"])
delete(v, "ne_type")
}
return data
}
// ExportXlsx 导出数据到 xlsx 文件
func (r Alarm) ExportXlsx(rows []model.Alarm, fileName, language, alarmStatus string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": i18n.TKey(language, "alarm.export.alarmType"),
"B1": i18n.TKey(language, "alarm.export.origSeverity"),
"C1": i18n.TKey(language, "alarm.export.alarmTitle"),
"D1": i18n.TKey(language, "alarm.export.eventTime"),
"E1": i18n.TKey(language, "alarm.export.alarmId"),
"F1": i18n.TKey(language, "alarm.export.alarmCode"),
"G1": i18n.TKey(language, "ne.common.neType"),
"H1": i18n.TKey(language, "ne.common.neName"),
"I1": i18n.TKey(language, "ne.common.neId"),
}
if alarmStatus == "0" {
headerCells["J1"] = i18n.TKey(language, "alarm.export.clearUser")
headerCells["K1"] = i18n.TKey(language, "alarm.export.clearTime")
headerCells["L1"] = i18n.TKey(language, "alarm.export.clearType")
}
// 读取字典数据 告警原始严重程度
dictActiveAlarmType := sysService.NewSysDictData.FindByType("active_alarm_type")
// 读取字典数据 告警类型
dictActiveClearType := sysService.NewSysDictData.FindByType("active_clear_type")
// 读取字典数据 告警确认类型
dictActiveAlarmSeverity := sysService.NewSysDictData.FindByType("active_alarm_severity")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 原始严重程度
origSeverity := "-"
for _, v := range dictActiveAlarmSeverity {
if row.OrigSeverity == v.DataValue {
origSeverity = i18n.TKey(language, v.DataLabel)
break
}
}
// 活动告警类型
alarmType := "-"
for _, v := range dictActiveAlarmType {
if row.AlarmType == v.DataValue {
alarmType = i18n.TKey(language, v.DataLabel)
break
}
}
// 告警清除类型
clearType := "-"
for _, v := range dictActiveClearType {
if fmt.Sprint(row.ClearType) == v.DataValue {
clearType = i18n.TKey(language, v.DataLabel)
break
}
}
eventTimeStr := date.ParseDateToStr(row.EventTime, date.YYYY_MM_DDTHH_MM_SSZ)
cells := map[string]any{
"A" + idx: alarmType,
"B" + idx: origSeverity,
"C" + idx: row.AlarmTitle,
"D" + idx: eventTimeStr,
"E" + idx: row.AlarmId,
"F" + idx: row.AlarmCode,
"G" + idx: row.NeType,
"H" + idx: row.NeName,
"I" + idx: row.NeId,
}
if alarmStatus == "0" {
clearTimeStr := date.ParseDateToStr(row.ClearTime, date.YYYY_MM_DDTHH_MM_SSZ)
cells["J"+idx] = row.ClearUser
cells["K"+idx] = clearType
cells["L"+idx] = clearTimeStr
}
dataCells = append(dataCells, cells)
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

85
src/modules/ne_data/service/alarm_event.go Normal file
View File

@@ -0,0 +1,85 @@
package service
import (
"fmt"
"time"
"github.com/tsmask/go-oam"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 AlarmEvent 结构体
var NewAlarmEvent = &AlarmEvent{
alarmEventRepository: repository.NewAlarmEvent,
}
// AlarmEvent 告警 服务层处理
type AlarmEvent struct {
alarmEventRepository *repository.AlarmEvent // 告警数据信息
}
// FindByPage 根据条件分页查询
func (r AlarmEvent) FindByPage(query model.AlarmEventQuery) ([]model.AlarmEvent, int64) {
return r.alarmEventRepository.SelectByPage(query)
}
// Find 查询
func (r AlarmEvent) Find(param model.AlarmEvent) []model.AlarmEvent {
return r.alarmEventRepository.Select(param)
}
// Insert 新增信息
func (s AlarmEvent) Insert(param model.AlarmEvent) int64 {
return s.alarmEventRepository.Insert(param)
}
// Update 修改信息
func (s AlarmEvent) Update(param model.AlarmEvent) int64 {
return s.alarmEventRepository.Update(param)
}
// DeleteByIds 批量删除信息
func (r AlarmEvent) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
data := r.alarmEventRepository.SelectByIds(ids)
if len(data) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(data) == len(ids) {
rows := r.alarmEventRepository.DeleteByIds(ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// FindAlarmEventSeqLast 查询网元告警最后一条序号
func (s AlarmEvent) FindAlarmEventSeqLast(neType, neId string) int64 {
return s.alarmEventRepository.SelectAlarmEventSeqLast(neType, neId)
}
// ClearByIds 批量清除告警信息
func (r AlarmEvent) ClearByIds(ids []int64, clearUser, clearType string) (int64, error) {
// 检查是否存在
arr := r.alarmEventRepository.SelectByIds(ids)
if len(arr) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(arr) == len(ids) {
var rows int64 = 0
for _, v := range arr {
v.AlarmStatus = oam.ALARM_STATUS_CLEAR
// 告警清除
v.ClearType = clearType
v.ClearUser = clearUser
v.ClearTime = time.Now().UnixMilli()
rows += r.alarmEventRepository.Update(v)
}
return rows, nil
}
return 0, fmt.Errorf("clear fail")
}

26
src/modules/ne_data/service/alarm_forward_log.go Normal file
View File

@@ -0,0 +1,26 @@
package service
import (
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 AlarmForwardLog 结构体
var NewAlarmForwardLog = &AlarmForwardLog{
alarmForwardLogRepository: repository.NewAlarmForwardLog,
}
// AlarmForwardLog 告警转发记录表 服务层处理
type AlarmForwardLog struct {
alarmForwardLogRepository *repository.AlarmForwardLog // 告警转发记录信息
}
// FindByPage 根据条件分页查询
func (r AlarmForwardLog) FindByPage(query model.AlarmForwardLogQuery) ([]model.AlarmForwardLog, int64) {
return r.alarmForwardLogRepository.SelectByPage(query)
}
// Insert 插入数据
func (r AlarmForwardLog) Insert(item model.AlarmForwardLog) int64 {
return r.alarmForwardLogRepository.Insert(item)
}

26
src/modules/ne_data/service/alarm_log.go Normal file
View File

@@ -0,0 +1,26 @@
package service
import (
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 AlarmLog 结构体
var NewAlarmLog = &AlarmLog{
alarmLogRepository: repository.NewAlarmLog,
}
// AlarmLog 基站状态记录表 服务层处理
type AlarmLog struct {
alarmLogRepository *repository.AlarmLog // 基站状态记录信息
}
// FindByPage 根据条件分页查询
func (r AlarmLog) FindByPage(query model.AlarmLogQuery) ([]model.AlarmLog, int64) {
return r.alarmLogRepository.SelectByPage(query)
}
// Insert 插入数据
func (r AlarmLog) Insert(item model.AlarmLog) int64 {
return r.alarmLogRepository.Insert(item)
}

86
src/modules/ne_data/service/backup.go Normal file
View File

@@ -0,0 +1,86 @@
package service
import (
"encoding/json"
"fmt"
"path/filepath"
"strings"
"be.ems/src/framework/ssh"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
systemService "be.ems/src/modules/system/service"
)
// 实例化数据层 Backup 结构体
var NewBackup = &Backup{
BACKUP_DIR: "/usr/local/omc/backup",
neInfoService: neService.NewNeInfo,
sysConfigService: systemService.NewSysConfig,
}
// Backup 备份相关 服务层处理
type Backup struct {
BACKUP_DIR string // 备份目录
neInfoService *neService.NeInfo // 网元信息服务
sysConfigService *systemService.SysConfig // 参数配置服务
}
// FTPConfigUpdate 更新FTP配置信息
func (r Backup) FTPConfigUpdate(value, updateBy string) int64 {
cfg := r.sysConfigService.FindByKey("neData.backupDataFTP")
if cfg.ConfigId == 0 {
return 0
}
cfg.ConfigValue = value
cfg.UpdateBy = updateBy
return r.sysConfigService.UpdateEncryptValue(cfg)
}
// FTPConfigInfo 获取FTP配置信息
func (r Backup) FTPConfigInfo() model.BackupDataFTP {
info := model.BackupDataFTP{}
// 获取配置
cfg := r.sysConfigService.FindByKeyDecryptValue("neData.backupDataFTP")
if cfg.ConfigId > 0 && cfg.ConfigValue != "" {
if err := json.Unmarshal([]byte(cfg.ConfigValue), &info); err != nil {
return info
}
}
return info
}
// FTPPushFile 推送文件到FTP
func (r Backup) FTPPushFile(localFilePath, tag string) error {
cfgData := r.FTPConfigInfo()
if !cfgData.Enable {
return fmt.Errorf("setting remote backup ftp is disabled")
}
connSSH := ssh.ConnSSH{
User: cfgData.Username,
Password: cfgData.Password,
Addr: cfgData.ToIp,
Port: cfgData.ToPort,
AuthMode: "0",
}
sshClient, err := connSSH.NewClient()
if err != nil {
return err
}
defer sshClient.Close()
// 网元主机的SSH客户端进行文件传输
sftpClient, err := sshClient.NewClientSFTP()
if err != nil {
return err
}
defer sftpClient.Close()
remotePath := strings.Replace(localFilePath, r.BACKUP_DIR, tag, 1)
remotePath = filepath.Join(cfgData.Dir, remotePath)
// 复制到远程
if err = sftpClient.CopyFileLocalToRemote(localFilePath, remotePath); err != nil {
return fmt.Errorf("error uploading file")
}
return nil
}

453
src/modules/ne_data/service/cbc_message.go Normal file
View File

@@ -0,0 +1,453 @@
package service
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/file"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
"gorm.io/gorm"
)
// 实例化数据层 CBCMessage 结构体
var NewCBCMessage = &CBCMessage{
cbcMessageRepository: repository.NewCBCMessage,
}
// CBCMessage CB消息 服务层处理
type CBCMessage struct {
cbcMessageRepository *repository.CBCMessage // UE会话事件数据信息
}
// SelectByPage 根据条件分页查询CB消息
func (s *CBCMessage) SelectByPage(query model.CBCMessageQuery) ([]model.CBCMessage, int, error) {
return s.cbcMessageRepository.SelectByPage(query)
}
// SelectCBCMessageById 根据工单ID查询CB消息
// @Description 根据工单ID查询CB消息
// @param id 工单ID
// @return *model.CBCMessage CB消息对象
// @return error 错误信息
// @example
// CBCMessage.SelectCBCMessageById(12345)
func (s *CBCMessage) SelectById(id int64) (*model.CBCMessage, error) {
return s.cbcMessageRepository.SelectById(id)
}
func (s *CBCMessage) Insert(msg model.CBCMessage) error {
// 解析messageJson获取eventName
var messageData map[string]interface{}
if err := json.Unmarshal(msg.MessageJson, &messageData); err != nil {
return fmt.Errorf("failed to parse message_json: %w", err)
}
// 提取eventName
eventName, ok := messageData["eventName"].(string)
if !ok || eventName == "" {
return fmt.Errorf("eventName is required in message_json")
}
// 检查是否已存在相同的eventName
var err error
var existingMsg *model.CBCMessage
if existingMsg, err = s.cbcMessageRepository.SelectByEventName(eventName); err != nil {
return fmt.Errorf("failed to check existing CBC message: %w", err)
}
if existingMsg != nil {
return fmt.Errorf("CBC message with eventName '%s' already exists for neType '%s' and neId '%s'",
eventName, existingMsg.NeType, existingMsg.NeId)
}
return s.cbcMessageRepository.Insert(msg)
}
// UpdateCBCMessage 更新CB消息
// @Description 更新CB消息
// @param msg CB消息对象
// @return error 错误信息
// @example
// mfCBCMessageService.UpdateCBCMessage(msg)
func (s *CBCMessage) Update(id int64, messageJson json.RawMessage) error {
// 解析messageJson获取eventName
var messageData map[string]interface{}
if err := json.Unmarshal(messageJson, &messageData); err != nil {
return fmt.Errorf("failed to parse message_json: %w", err)
}
// 提取eventName
eventName, ok := messageData["eventName"].(string)
if !ok || eventName == "" {
return fmt.Errorf("eventName is required in message_json")
}
// 检查是否已存在相同的eventName
var err error
if _, err = s.cbcMessageRepository.SelectByEventName(eventName); err != nil {
if err == gorm.ErrRecordNotFound {
return fmt.Errorf("no existing CBC message found with eventName: %s", eventName)
}
return fmt.Errorf("failed to query existing CBC message: %w", err)
}
// 如果存在，更新记录
var msg *model.CBCMessage
if msg, err = s.cbcMessageRepository.Update(id, messageJson); err != nil {
return fmt.Errorf("failed to update CBC message: %w", err)
}
// 如果状态是ACTIVE，发送更新请求
if msg.Status == model.CBCEventStatusActive {
if err := s.sendUpdateRequest(*msg); err != nil {
return fmt.Errorf("failed to send update request: %w", err)
}
}
return nil
}
// UpdateCBCMessage 更新CB消息
// @Description 更新CB消息
// @param msg CB消息对象
// @return error 错误信息
// @example
// UpdateCBCMessageDetail(msg)
func (s *CBCMessage) UpdateDetail(eventName, detail string) error {
if err := s.cbcMessageRepository.UpdateDetail(eventName, detail); err != nil {
return fmt.Errorf("failed to update CBC message detail: %w", err)
}
return nil
}
// DeleteCBCMessage 删除CB消息
// @Description 删除CB消息
// @param id 工单ID
// @return error 错误信息
// @example
// mfCBCMessageService.DeleteCBCMessage(12345)
func (s *CBCMessage) Delete(id int64) error {
// 先查询记录状态
var err error
var msg *model.CBCMessage
if msg, err = s.cbcMessageRepository.SelectById(id); err != nil {
if err == gorm.ErrRecordNotFound {
return fmt.Errorf("CBC message with ID %d not found", id)
}
return fmt.Errorf("failed to query CBC message: %w", err)
}
// 检查状态是否为ACTIVE
if msg.Status == model.CBCEventStatusActive {
return fmt.Errorf("cannot delete an active CBC message (ID: %d)", id)
}
// 执行删除操作
if err := s.cbcMessageRepository.Delete(id); err != nil {
return fmt.Errorf("failed to delete CBC message: %w", err)
}
return nil
}
// UpdateCBCMessageStatus 更新CB消息状态
// @Description 更新CB消息状态，并根据状态变化发送相应的HTTP请求
// @param status 新状态
// @return error 错误信息
func (s *CBCMessage) UpdateStatus(id int64, status string) error {
newStatus := model.ParseCBCEventStatus(status)
// 查询所有需要更新的记录
var err error
var msg *model.CBCMessage
if msg, err = s.cbcMessageRepository.SelectById(id); err != nil {
if err == gorm.ErrRecordNotFound {
return fmt.Errorf("CBC message with ID %d not found", id)
}
return fmt.Errorf("failed to query CBC message: %w", err)
}
oldStatus := msg.Status
// 检查状态是否发生变化
if oldStatus == newStatus {
return fmt.Errorf("CBC message status is already %s", newStatus.Enum())
}
// 更新数据库状态
if err := s.cbcMessageRepository.UpdateStatus(id, newStatus); err != nil {
return fmt.Errorf("failed to update CBC message status: %w", err)
}
// 根据状态变化发送HTTP请求
if err := s.handleStatusChange(*msg, oldStatus, newStatus); err != nil {
// 记录错误但不中断处理其他消息
fmt.Printf("Failed to handle status change for message %d: %v\n", msg.Id, err)
}
return nil
}
// UpdateCBCMessageStatus 更新CB消息状态
// @Description 更新CB消息状态，并根据状态变化发送相应的HTTP请求
// @param status 新状态
// @return error 错误信息
func (s *CBCMessage) UpdateStatusByNeId(neId string, status string) error {
newStatus := model.ParseCBCEventStatus(status)
// 查询所有需要更新的记录
msgs := make([]model.CBCMessage, 0)
if err := s.cbcMessageRepository.SelectByNeId(neId, &msgs); err != nil {
return fmt.Errorf("failed to query CB messages: %w", err)
}
for _, msg := range msgs {
oldStatus := msg.Status
// 检查状态是否发生变化
if oldStatus == newStatus {
continue // 状态没有变化，跳过
}
// 更新数据库状态
if err := s.cbcMessageRepository.UpdateStatus(msg.Id, newStatus); err != nil {
return fmt.Errorf("failed to update CBC message status: %w", err)
}
// 根据状态变化发送HTTP请求
if err := s.handleStatusChange(msg, oldStatus, newStatus); err != nil {
// 记录错误但不中断处理其他消息
fmt.Printf("Failed to handle status change for message %d: %v\n", msg.Id, err)
}
}
return nil
}
// UpdateCBCMessageStatus 更新CB消息状态
// @Description 更新CB消息状态，并根据状态变化发送相应的HTTP请求
// @param status 新状态
// @return error 错误信息
func (s *CBCMessage) UpdateAllStatus(status string) error {
newStatus := model.ParseCBCEventStatus(status)
// 查询所有需要更新的记录
msgs := make([]model.CBCMessage, 0)
if err := s.cbcMessageRepository.Select(&msgs); err != nil {
return fmt.Errorf("failed to query CB messages: %w", err)
}
for _, msg := range msgs {
oldStatus := msg.Status
// 检查状态是否发生变化
if oldStatus == newStatus {
continue // 状态没有变化，跳过
}
// 更新数据库状态
if err := s.cbcMessageRepository.UpdateStatus(msg.Id, newStatus); err != nil {
return fmt.Errorf("failed to update CBC message status: %w", err)
}
// 根据状态变化发送HTTP请求
if err := s.handleStatusChange(msg, oldStatus, newStatus); err != nil {
// 记录错误但不中断处理其他消息
fmt.Printf("Failed to handle status change for message %d: %v\n", msg.Id, err)
}
}
return nil
}
// ExportXlsx 导出数据到 xlsx 文件
func (r CBCMessage) ExportXlsx(rows []model.CBCMessage, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": i18n.TKey(language, "alarm.export.alarmType"),
"B1": i18n.TKey(language, "alarm.export.origSeverity"),
"C1": i18n.TKey(language, "alarm.export.alarmTitle"),
"D1": i18n.TKey(language, "alarm.export.eventTime"),
"E1": i18n.TKey(language, "alarm.export.alarmId"),
"F1": i18n.TKey(language, "alarm.export.alarmCode"),
"G1": i18n.TKey(language, "ne.common.neType"),
"H1": i18n.TKey(language, "ne.common.neName"),
"I1": i18n.TKey(language, "ne.common.neId"),
}
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
cells := map[string]any{
"A" + idx: row.NeType,
"B" + idx: row.NeId,
"C" + idx: row.MessageJson, // 这里假设 MessageJson 已经是字符串格式
"D" + idx: row.Status.Enum(),
"E" + idx: row.Detail,
"F" + idx: time.UnixMilli(row.CreatedAt).Format(time.RFC3339),
"G" + idx: time.UnixMilli(row.UpdatedAt).Format(time.RFC3339),
}
dataCells = append(dataCells, cells)
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}
// handleStatusChange 处理状态变化时的HTTP请求
func (s *CBCMessage) handleStatusChange(msg model.CBCMessage, oldStatus, newStatus model.CBCEventStatus) error {
// 从NULL/INACTIVE状态修改为ACTIVE
if (oldStatus == model.CBCEventStatusNull || oldStatus == model.CBCEventStatusInactive) &&
newStatus == model.CBCEventStatusActive {
return s.sendActivateRequest(msg)
}
// 从ACTIVE更改为INACTIVE状态
if oldStatus == model.CBCEventStatusActive && newStatus == model.CBCEventStatusInactive {
return s.sendDeactivateRequest(msg)
}
return nil
}
// getCBCNetworkElement 获取CBC网元的IP和端口信息
// 这个方法需要根据你的实际网元管理系统来实现
func (s *CBCMessage) getCBCNetworkElement(neId string) (string, int64, error) {
// 查询网元信息
neInfo := neService.NewNeInfo.FindByNeTypeAndNeID("CBC", neId)
if neInfo.IP == "" {
return "", 0, fmt.Errorf("CBC network element not found for neId: %s", neId)
}
return neInfo.IP, neInfo.Port, nil
}
// CBCHTTPClient CBC网元HTTP客户端
type CBCHTTPClient struct {
client *http.Client
baseURL string
}
// NewCBCHTTPClient 创建CBC HTTP客户端
func NewCBCHTTPClient(baseURL string) *CBCHTTPClient {
return &CBCHTTPClient{
client: &http.Client{
Timeout: 10 * time.Second,
},
baseURL: baseURL,
}
}
// PostMessage 发送POST请求创建消息
func (c *CBCHTTPClient) PostMessage(messageData []byte) error {
url := fmt.Sprintf("%s/api/v1/cbe/message", c.baseURL)
return c.sendRequest("POST", url, messageData)
}
// PutMessage 发送PUT请求更新消息
func (c *CBCHTTPClient) PutMessage(messageData []byte) error {
url := fmt.Sprintf("%s/api/v1/cbe/message", c.baseURL)
return c.sendRequest("PUT", url, messageData)
}
// DeleteMessage 发送DELETE请求删除消息
func (c *CBCHTTPClient) DeleteMessage(eventName string, deletePayload []byte) error {
url := fmt.Sprintf("%s/api/v1/cbe/message/%s", c.baseURL, eventName)
return c.sendRequest("DELETE", url, deletePayload)
}
// sendRequest 发送HTTP请求
func (c *CBCHTTPClient) sendRequest(method, url string, body []byte) error {
req, err := http.NewRequest(method, url, bytes.NewReader(body))
if err != nil {
return fmt.Errorf("failed to create %s request: %w", method, err)
}
req.Header.Set("Content-Type", "application/json")
resp, err := c.client.Do(req)
if err != nil {
return fmt.Errorf("failed to send %s request: %w", method, err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
body, _ := io.ReadAll(resp.Body)
return fmt.Errorf("%s request failed with status: %d, body: %s",
method, resp.StatusCode, string(body))
}
return nil
}
// 在CBCMessageService中添加方法
func (s *CBCMessage) getCBCHTTPClient(neId string) (*CBCHTTPClient, error) {
cbcIP, cbcPort, err := s.getCBCNetworkElement(neId)
if err != nil {
return nil, fmt.Errorf("failed to get CBC network element info: %w", err)
}
baseURL := fmt.Sprintf("http://%s:%d", cbcIP, cbcPort)
return NewCBCHTTPClient(baseURL), nil
}
// 重构后的激活请求
func (s *CBCMessage) sendActivateRequest(msg model.CBCMessage) error {
client, err := s.getCBCHTTPClient(msg.NeId)
if err != nil {
return err
}
// 直接使用 MessageJson 发送POST请求
return client.PostMessage(msg.MessageJson)
}
// 重构后的更新请求
func (s *CBCMessage) sendUpdateRequest(msg model.CBCMessage) error {
client, err := s.getCBCHTTPClient(msg.NeId)
if err != nil {
return err
}
// 直接使用 MessageJson 发送POST请求
return client.PostMessage(msg.MessageJson)
}
// 重构后的停用请求
func (s *CBCMessage) sendDeactivateRequest(msg model.CBCMessage) error {
client, err := s.getCBCHTTPClient(msg.NeId)
if err != nil {
return err
}
// 解析和构造删除载荷的逻辑保持不变
var messageData map[string]interface{}
if err := json.Unmarshal(msg.MessageJson, &messageData); err != nil {
return fmt.Errorf("failed to parse message_json: %w", err)
}
eventName, ok := messageData["eventName"].(string)
if !ok || eventName == "" {
return fmt.Errorf("eventName not found in message_json")
}
deletePayload := make(map[string]interface{})
if messageIdProfile, exists := messageData["messageIdProfile"]; exists {
deletePayload["messageIdProfile"] = messageIdProfile
}
if warningAreaList, exists := messageData["warningAreaList"]; exists {
deletePayload["warningAreaList"] = warningAreaList
}
payloadBytes, err := json.Marshal(deletePayload)
if err != nil {
return fmt.Errorf("failed to marshal delete payload: %w", err)
}
return client.DeleteMessage(eventName, payloadBytes)
}

645
src/modules/ne_data/service/cdr_event.go Normal file
View File

@@ -0,0 +1,645 @@
package service
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
sysService "be.ems/src/modules/system/service"
)
// 实例化数据层 CDREvent 结构体
var NewCDREvent = &CDREvent{
cdrEventRepository: repository.NewCDREvent,
}
// CDREvent CDR会话事件 服务层处理
type CDREvent struct {
cdrEventRepository *repository.CDREvent // CDR会话事件数据信息
}
// FindByPage 根据条件分页查询
func (r CDREvent) FindByPage(neType string, query map[string]string) ([]model.CDREvent, int64) {
return r.cdrEventRepository.SelectByPage(neType, query)
}
// DeleteByIds 批量删除信息
func (r CDREvent) DeleteByIds(neType string, ids []int64) (int64, error) {
// 检查是否存在
rows := r.cdrEventRepository.SelectByIds(neType, ids)
if len(rows) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(rows) == len(ids) {
rows := r.cdrEventRepository.DeleteByIds(neType, ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// Insert 新增信息
func (s CDREvent) Insert(param model.CDREvent) int64 {
return s.cdrEventRepository.Insert(param)
}
// ExportSMSC 导出数据到 xlsx 文件
func (r CDREvent) ExportSMSC(rows []model.CDREvent, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "NE Name",
"C1": "Record Behavior",
"D1": "Service Type",
"E1": "Caller",
"F1": "Called",
"G1": "Result",
"H1": "Time",
}
// 读取字典数据 CDR 原因码
dictCDRCauseCode := sysService.NewSysDictData.FindByType("cdr_cause_code")
// 从第二行开始的数据
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.CdrJson), &cdrJSON)
if err != nil {
logger.Warnf("CDRExport Error parsing JSON: %s", err.Error())
continue
}
// 记录类型
recordType := ""
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string)
}
// 服务类型
serviceType := ""
if v, ok := cdrJSON["serviceType"]; ok && v != nil {
serviceType = 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)
}
// 呼叫结果 0失败，1成功
callResult := "Fail"
if v, ok := cdrJSON["result"]; ok && v != nil {
resultVal := parse.Number(v)
if resultVal == 1 {
callResult = "Success"
}
}
// 结果原因
if v, ok := cdrJSON["cause"]; ok && v != nil && callResult == "Fail" {
cause := fmt.Sprint(v)
for _, v := range dictCDRCauseCode {
if cause == v.DataValue {
callResult = fmt.Sprintf("%s, %s", callResult, i18n.TKey(language, v.DataLabel))
break
}
}
}
// 取时间
timeStr := ""
if v, ok := cdrJSON["updateTime"]; ok && v != nil {
if releaseTime := parse.Number(v); releaseTime > 0 {
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
timeStr = v.(string)
}
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.NeName,
"C" + idx: recordType,
"D" + idx: serviceType,
"E" + idx: caller,
"F" + idx: called,
"G" + idx: callResult,
"H" + idx: timeStr,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}
// ExportSMF 导出数据到 xlsx 文件
func (r CDREvent) ExportSMF(rows []model.CDREvent, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "Charging ID",
"C1": "NE Name",
"D1": "Resource Unique ID",
"E1": "Subscriber ID Data",
"F1": "Subscriber ID Type",
"G1": "Data Volume Uplink",
"H1": "Data Volume Downlink",
"I1": "Data Total Volume",
"J1": "Duration",
"K1": "Invocation Time",
"L1": "User Identifier",
"M1": "SSC Mode",
"N1": "DNN ID",
"O1": "PDU Type",
"P1": "RAT Type",
"Q1": "PDU IPv4 Address",
"R1": "Network Function IPv4",
"S1": "PDU IPv6 Address Swith Prefix",
"T1": "Record Network Function ID",
"U1": "Record Type",
"V1": "Record Opening Time",
}
// 从第二行开始的数据
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.CdrJson), &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))
}
// 订阅 ID 类型
subscriptionIDType := "-"
// 订阅 ID 数据
subscriptionIDData := "-"
if v, ok := cdrJSON["subscriberIdentifier"]; ok && v != nil {
if sub, subOk := v.(map[string]any); subOk && sub != nil {
subscriptionIDType = sub["subscriptionIDType"].(string)
subscriptionIDData = sub["subscriptionIDData"].(string)
}
}
// 网络功能 IPv4 地址
networkFunctionIPv4Address := ""
if v, ok := cdrJSON["nFunctionConsumerInformation"]; ok && v != nil {
if conInfo, conInfoOk := v.(map[string]any); conInfoOk && conInfo != nil {
networkFunctionIPv4Address = conInfo["networkFunctionIPv4Address"].(string)
}
}
// 数据量上行链路
var dataVolumeUplink int64 = 0
// 数据量下行链路
var dataVolumeDownlink int64 = 0
// 数据总量
var dataTotalVolume int64 = 0
if v, ok := cdrJSON["listOfMultipleUnitUsage"]; ok && v != nil {
usageList := v.([]any)
if len(usageList) > 0 {
for _, used := range usageList {
usedUnit := used.(map[string]any)
usedUnitList := usedUnit["usedUnitContainer"].([]any)
if len(usedUnitList) > 0 {
for _, data := range usedUnitList {
udata := data.(map[string]any)
if dup, dupOk := udata["dataVolumeUplink"]; dupOk {
dataVolumeUplink += parse.Number(dup)
}
if ddown, ddownOk := udata["dataVolumeDownlink"]; ddownOk {
dataVolumeDownlink += parse.Number(ddown)
}
if dt, dtOk := udata["dataTotalVolume"]; dtOk {
dataTotalVolume += parse.Number(dt)
}
}
}
}
}
}
// 时长
duration := "-"
if v, ok := cdrJSON["duration"]; ok && v != nil {
duration = fmt.Sprint(parse.Number(v))
}
// 调用时间
invocationTimestamp := ""
if v, ok := cdrJSON["invocationTimestamp"]; ok && v != nil {
invocationTimestamp = v.(string)
}
// 记录打开时间
User_Identifier := ""
SSC_Mode := ""
RAT_Type := ""
DNN_ID := ""
PDU_Type := ""
PDU_IPv4 := ""
PDU_IPv6 := ""
if v, ok := cdrJSON["pDUSessionChargingInformation"]; ok && v != nil {
pduInfo := v.(map[string]any)
if v, ok := pduInfo["userIdentifier"]; ok && v != nil {
User_Identifier = v.(string)
}
if v, ok := pduInfo["sSCMode"]; ok && v != nil {
SSC_Mode = v.(string)
}
if v, ok := pduInfo["rATType"]; ok && v != nil {
RAT_Type = v.(string)
}
if v, ok := pduInfo["dNNID"]; ok && v != nil {
DNN_ID = v.(string)
}
if v, ok := pduInfo["pDUType"]; ok && v != nil {
PDU_Type = v.(string)
}
if v, ok := pduInfo["pDUAddress"]; ok && v != nil {
pDUAddress := v.(map[string]any)
if addr, ok := pDUAddress["pDUIPv4Address"]; ok && addr != nil {
PDU_IPv4 = addr.(string)
}
if addr, ok := pDUAddress["pDUIPv6AddresswithPrefix"]; ok && addr != nil {
PDU_IPv6 = addr.(string)
}
}
}
// 记录网络参数ID
recordNFID := ""
if v, ok := cdrJSON["recordingNetworkFunctionID"]; ok && v != nil {
recordNFID = v.(string)
}
//记录开始时间
recordOpeningTime := ""
if v, ok := cdrJSON["recordOpeningTime"]; ok && v != nil {
recordOpeningTime = v.(string)
}
//记录类型
recordType := ""
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string)
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: chargingID,
"C" + idx: row.NeName,
"D" + idx: row.RmUid,
"E" + idx: subscriptionIDData,
"F" + idx: subscriptionIDType,
"G" + idx: dataVolumeUplink,
"H" + idx: dataVolumeDownlink,
"I" + idx: dataTotalVolume,
"J" + idx: duration,
"K" + idx: invocationTimestamp,
"L" + idx: User_Identifier,
"M" + idx: SSC_Mode,
"N" + idx: DNN_ID,
"O" + idx: PDU_Type,
"P" + idx: RAT_Type,
"Q" + idx: PDU_IPv4,
"R" + idx: networkFunctionIPv4Address,
"S" + idx: PDU_IPv6,
"T" + idx: recordNFID,
"U" + idx: recordType,
"V" + idx: recordOpeningTime,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}
// ExportSGWC 导出数据到 xlsx 文件
func (r CDREvent) ExportSGWC(rows []model.CDREvent, fileName string) (string, error) {
// 第一行表头标题
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",
"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",
"V1": "Record Type",
"W1": "Record Opening Time",
}
// 从第二行开始的数据
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.CdrJson), &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)
headerCells["K1"] = "PGW Address"
}
if v, ok := cdrJSON["GGSNAddress"]; ok && v != nil {
pGWAddressUsed = fmt.Sprint(v)
headerCells["K1"] = "GGSN Address"
}
// sGWAddress
sGWAddress := ""
if v, ok := cdrJSON["sGWAddress"]; ok && v != nil {
sGWAddress = fmt.Sprint(v)
headerCells["L1"] = "SGW Address"
}
if v, ok := cdrJSON["SGSNAddress"]; ok && v != nil {
sGWAddress = fmt.Sprint(v)
headerCells["L1"] = "SGSN Address"
}
// recordType
recordType := ""
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = 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)
}
// 数据量上行链路
var dataVolumeGPRSUplink int64 = 0
// 数据量下行链路
var dataVolumeGPRSDownlink int64 = 0
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 = parse.Number(dup)
}
if ddown, ddownOk := usedUnit["dataVolumeGPRSDownlink"]; ddownOk {
dataVolumeGPRSDownlink = 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: dataVolumeGPRSUplink,
"H" + idx: 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,
"V" + idx: recordType,
"W" + idx: invocationTimestamp,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}
// ExportIMS 导出数据到 xlsx 文件
func (r CDREvent) ExportIMS(rows []model.CDREvent, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "NE Name",
"C1": "Record Behavior",
"D1": "Type",
"E1": "Caller",
"F1": "Called",
"G1": "Duration",
"H1": "Result Code",
"I1": "Result Cause",
"J1": "Call Start Time",
"K1": "Hangup Time",
}
// 读取字典数据 CDR SIP响应代码类别类型
dictCDRSipCode := sysService.NewSysDictData.FindByType("cdr_sip_code")
// 读取字典数据 CDR SIP响应代码类别类型原因
dictCDRSipCodeCause := sysService.NewSysDictData.FindByType("cdr_sip_code_cause")
// 读取字典数据 CDR 呼叫类型
dictCDRCallType := sysService.NewSysDictData.FindByType("cdr_call_type")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 解析 JSON 字符串为 map
var cdrJSON map[string]any
err := json.Unmarshal([]byte(row.CdrJson), &cdrJSON)
if err != nil {
logger.Warnf("CDRExport Error parsing JSON: %s", err.Error())
continue
}
// 记录类型
recordType := ""
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string)
}
// 呼叫类型
callType := "sms"
callTypeLable := "SMS"
if v, ok := cdrJSON["callType"]; ok && v != nil {
callType = v.(string)
for _, v := range dictCDRCallType {
if callType == v.DataValue {
callTypeLable = i18n.TKey(language, v.DataLabel)
break
}
}
}
// 被叫
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" {
duration = fmt.Sprintf("%ds", parse.Number(v))
}
// 呼叫结果 非短信都有code作为结果 sms短信都ok
callResult := "Other"
callCause := "Call failure for other reason"
if callType == "sms" {
callResult = "Success"
callCause = "Normal Send"
} else {
if v, ok := cdrJSON["cause"]; ok && v != nil {
cause := fmt.Sprint(v)
for _, v := range dictCDRSipCode {
if cause == v.DataValue {
callResult = i18n.TKey(language, v.DataLabel)
break
}
}
for _, v := range dictCDRSipCodeCause {
if cause == v.DataValue {
callCause = i18n.TKey(language, v.DataLabel)
break
}
}
}
}
// 呼叫时间
seizureTimeStr := ""
if v, ok := cdrJSON["seizureTime"]; ok && v != nil {
if seizureTime := parse.Number(v); seizureTime > 0 {
seizureTimeStr = date.ParseDateToStr(seizureTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
seizureTimeStr = v.(string)
}
}
// 挂断时间
releaseTimeStr := ""
if v, ok := cdrJSON["releaseTime"]; ok && v != nil {
if releaseTime := parse.Number(v); releaseTime > 0 {
releaseTimeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
releaseTimeStr = v.(string)
}
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.NeName,
"C" + idx: recordType,
"D" + idx: callTypeLable,
"E" + idx: caller,
"F" + idx: called,
"G" + idx: duration,
"H" + idx: callResult,
"I" + idx: callCause,
"J" + idx: seizureTimeStr,
"K" + idx: releaseTimeStr,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

186
src/modules/ne_data/service/kpi_c_report.go Normal file
View File

@@ -0,0 +1,186 @@
package service
import (
"encoding/json"
"fmt"
"sort"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 KpiCReport 结构体
var NewKpiCReport = &KpiCReport{
kpiCReportRepository: repository.NewKpiCReport,
}
// KpiCReport 自定义性能统计 服务层处理
type KpiCReport struct {
kpiCReportRepository *repository.KpiCReport // 自定义KPI数据信息
}
// FindKPI 通过网元指标数据信息
func (s KpiCReport) FindData(query model.KPICQuery) []map[string]any {
// 标题单位映射
kpicTitles := s.kpiCReportRepository.SelectKPITitle(query.NeType)
kpicTitleUnitMap := map[string]string{}
for _, v := range kpicTitles {
kpicTitleUnitMap[v.KpiId] = v.Unit
}
// 原始数据
rows := s.kpiCReportRepository.SelectKPI(query)
if len(rows) <= 0 {
return []map[string]any{}
}
kpiIdsHas := false
kpiIds := []string{}
// 处理数据
arr := []map[string]any{}
for _, row := range rows {
// 解析 JSON 字符串为 map
var kpiValues []map[string]any
err := json.Unmarshal([]byte(row.KpiValues), &kpiValues)
if err != nil {
continue
}
item := map[string]any{
"neType": row.NeType,
"neName": row.NeName,
"rmUID": row.RmUid,
"startIndex": row.Index,
"timeGroup": row.CreatedAt,
}
// 遍历 kpiValues 数组
for _, v := range kpiValues {
kpiId := "-"
if k, ok := v["kpiId"]; ok {
kpiId = fmt.Sprint(k)
}
item[kpiId] = v["value"]
}
arr = append(arr, item)
// 添加指标ID
if !kpiIdsHas {
for _, v := range kpiValues {
kpiId := "-"
if k, ok := v["kpiId"]; ok {
kpiId = fmt.Sprint(k)
}
kpiIds = append(kpiIds, kpiId)
}
kpiIdsHas = true
}
}
// 时间密度分钟 数值单位秒 5分钟的传入300秒
timeInterval := query.Interval
// 创建一个map来存储按时间段合并后的数据
timeGroup := make(map[int64][]map[string]any)
// 遍历每个数据项
for _, v := range arr {
itemTime := parse.Number(v["timeGroup"])
// 计算时间戳的x分钟时间段（使用秒并除以x分钟）
timeMinute := itemTime / 1000 / timeInterval * timeInterval
// 合并到对应的时间段
timeGroup[timeMinute] = append(timeGroup[timeMinute], v)
}
// 时间组合输出
data := []map[string]any{}
for _, records := range timeGroup {
if len(records) <= 0 {
continue
}
// 转换为具体时间显示（根据需要可以格式化显示）
// timeStr := time.Unix(k, 0).Format("2006-01-02 15:04:05")
// fmt.Printf("Time Group: %s records: %d\n", timeStr, len(records))
startItem := records[len(records)-1] // 取最后一条数据也是最开始startIndex
if len(records) >= 2 { // 最后一条数据不参与计算
for _, record := range records[:len(records)-1] {
// fmt.Printf(" - startIndex: %v, Value: %v\n", record["startIndex"], record["timeGroup"])
// 遍历kpiIds数组对lastRecord赋值
for _, kpiId := range kpiIds {
if v, ok := record[kpiId]; ok {
value := v.(float64) + startItem[kpiId].(float64)
startItem[kpiId] = value
// value := parse.Number(startItem[kpiId])
// startItem[kpiId] = value + parse.Number(v)
}
}
}
// 处理单位
for _, kpiId := range kpiIds {
unit, ok := kpicTitleUnitMap[kpiId]
if !ok {
continue
}
// "Mbps" "%"
if unit == "%" {
startItem[kpiId] = startItem[kpiId].(float64) / float64(len(records))
}
}
}
data = append(data, startItem)
}
// 按时间排序
sort.SliceStable(data, func(i, j int) bool {
vi := parse.Number(data[i]["timeGroup"])
vj := parse.Number(data[j]["timeGroup"])
if query.SortOrder == "asc" {
return vi < vj // asc
}
return vi > vj // desc
})
return data
}
// Insert 新增信息
func (s KpiCReport) Insert(param model.KpiCReport) int64 {
return s.kpiCReportRepository.Insert(param)
}
// FindKPITitle 网元对应的指标名称
func (r KpiCReport) FindTitle(neType string) []model.KpiCTitle {
return r.kpiCReportRepository.SelectKPITitle(neType)
}
// TitleLastKPIId 指标标题最后kpiid
func (r KpiCReport) TitleLastKPIId(neType string) string {
return r.kpiCReportRepository.TitleLastKPIId(neType)
}
// FindByPage 根据条件分页查询
func (r KpiCReport) TitleFindByPage(query map[string]string) ([]model.KpiCTitle, int64) {
return r.kpiCReportRepository.TitleSelectByPage(query)
}
// TitleFind 查询信息
func (r KpiCReport) TitleFind(param model.KpiCTitle) []model.KpiCTitle {
return r.kpiCReportRepository.TitleSelect(param)
}
// TitleUpdate 更新信息
func (r KpiCReport) TitleUpdate(param model.KpiCTitle) int64 {
return r.kpiCReportRepository.TitleUpdate(param)
}
// TitleDeleteByIds 批量删除信息
func (r KpiCReport) TitleDeleteByIds(ids []int64) (int64, error) {
rows := r.kpiCReportRepository.TitleDeleteByIds(ids)
if rows > 0 {
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// TitleInsert 新增信息
func (r KpiCReport) TitleInsert(param model.KpiCTitle) int64 {
return r.kpiCReportRepository.TitleInsert(param)
}

282
src/modules/ne_data/service/kpi_report.go Normal file
View File

@@ -0,0 +1,282 @@
package service
import (
"encoding/json"
"fmt"
"sort"
"time"
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/framework/utils/parse"
neModel "be.ems/src/modules/ne/model"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 KpiReport 结构体
var NewKpiReport = &KpiReport{
kpiReportRepository: repository.NewKpiReport,
}
// KpiReport 指标统计 服务层处理
type KpiReport struct {
kpiReportRepository *repository.KpiReport // 指标数据信息
}
// FindData 通过网元指标数据信息
func (s KpiReport) FindData(query model.KPIQuery) []map[string]any {
// 原始数据
rows := s.kpiReportRepository.SelectKPI(query)
if len(rows) <= 0 {
return []map[string]any{}
}
kpiIdsHas := false
kpiIds := []string{}
// 处理数据
arr := []map[string]any{}
for _, row := range rows {
// 解析 JSON 字符串为 map
var kpiValues []map[string]any
err := json.Unmarshal([]byte(row.KpiValues), &kpiValues)
if err != nil {
continue
}
item := map[string]any{
"neType": row.NeType,
"neName": row.NeName,
"rmUID": row.RmUid,
"startIndex": row.Index,
"timeGroup": row.CreatedAt,
}
// 遍历 kpiValues 数组
for _, v := range kpiValues {
kpiId := "-"
if k, ok := v["kpiId"]; ok {
kpiId = fmt.Sprint(k)
}
item[kpiId] = v["value"]
}
arr = append(arr, item)
// 添加指标ID
if !kpiIdsHas {
for _, v := range kpiValues {
kpiId := "-"
if k, ok := v["kpiId"]; ok {
kpiId = fmt.Sprint(k)
}
kpiIds = append(kpiIds, kpiId)
}
kpiIdsHas = true
}
}
// 时间密度分钟 数值单位秒 5分钟的传入300秒
timeInterval := query.Interval
// 创建一个map来存储按时间段合并后的数据
timeGroup := make(map[int64][]map[string]any)
// 遍历每个数据项
for _, v := range arr {
itemTime := parse.Number(v["timeGroup"])
// 计算时间戳的x分钟时间段（使用秒并除以x分钟）
timeMinute := itemTime / 1000 / timeInterval * timeInterval
// 合并到对应的时间段
timeGroup[timeMinute] = append(timeGroup[timeMinute], v)
}
// 时间组合输出
data := []map[string]any{}
for _, records := range timeGroup {
if len(records) <= 0 {
continue
}
// 转换为具体时间显示（根据需要可以格式化显示）
// timeStr := time.Unix(k, 0).Format("2006-01-02 15:04:05")
// fmt.Printf("Time Group: %s records: %d\n", timeStr, len(records))
startItem := records[len(records)-1] // 取最后一条数据也是最开始startIndex
if len(records) >= 2 { // 最后一条数据不参与计算
for _, record := range records[:len(records)-1] {
// fmt.Printf(" - startIndex: %v, Value: %v\n", record["startIndex"], record["timeGroup"])
// 遍历kpiIds数组对lastRecord赋值
for _, kpiId := range kpiIds {
if v, ok := record[kpiId]; ok {
// 特殊字段，只取一次收到的非0值
if kpiId == "AMF.01" || kpiId == "UDM.01" || kpiId == "UDM.02" || kpiId == "UDM.03" || kpiId == "SMF.01" {
// startItem[kpiId] = parse.Number(v)
continue // startIndex的值不累加不取最后
} else {
value := parse.Number(startItem[kpiId])
startItem[kpiId] = value + parse.Number(v)
}
}
}
}
}
data = append(data, startItem)
}
// 按时间排序
sort.SliceStable(data, func(i, j int) bool {
vi := parse.Number(data[i]["timeGroup"])
vj := parse.Number(data[j]["timeGroup"])
if query.SortOrder == "asc" {
return vi < vj // asc
}
return vi > vj // desc
})
return data
}
// Insert 新增信息
func (s KpiReport) Insert(param model.KpiReport) int64 {
return s.kpiReportRepository.Insert(param)
}
// FindTitle 网元对应的指标名称
func (r KpiReport) FindTitle(neType string) []model.KpiTitle {
return r.kpiReportRepository.SelectKPITitle(neType)
}
// FindByPage 根据条件分页查询
func (r KpiReport) TitleFindByPage(query map[string]string) ([]model.KpiTitle, int64) {
return r.kpiReportRepository.TitleSelectByPage(query)
}
// TitleFind 查询信息
func (r KpiReport) TitleFind(param model.KpiTitle) []model.KpiTitle {
return r.kpiReportRepository.TitleSelect(param)
}
// TitleUpdate 更新信息
func (r KpiReport) TitleUpdate(param model.KpiTitle) int64 {
return r.kpiReportRepository.TitleUpdate(param)
}
// TitleDeleteByIds 批量删除信息
func (r KpiReport) TitleDeleteByIds(ids []int64) (int64, error) {
rows := r.kpiReportRepository.TitleDeleteByIds(ids)
if rows > 0 {
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// TitleInsert 新增信息
func (r KpiReport) TitleInsert(param model.KpiTitle) int64 {
return r.kpiReportRepository.TitleInsert(param)
}
// UPFTodayFlowFind 查询UPF总流量 N3上行 N6下行
// day 统计天数
// down * 8 / 1000 / 1000 单位M
func (r KpiReport) UPFTodayFlowFind(rmUID string, day int) (int64, int64) {
// 获取当前日期
now := time.Now()
var upTotal, downTotal int64
// 查询最近day天的数据
for i := 0; i <= day; i++ {
dateKey := now.AddDate(0, 0, -i).Format("2006-01-02")
key := fmt.Sprintf("%s:UPF_FLOW:%s:%s", constants.CACHE_NE_DATA, rmUID, dateKey)
// 读取缓存数据
up, err := redis.GetHash("", key, "up")
if err != nil || up == "" {
up = "0"
}
down, err := redis.GetHash("", key, "down")
if err != nil || down == "" {
down = "0"
}
upTotal += parse.Number(up)
downTotal += parse.Number(down)
}
return upTotal, downTotal
}
// UPFTodayFlow UPF流量今日统计
func (r KpiReport) UPFTodayFlowUpdate(rmUID string, upValue, downValue int64) error {
// 按日期存储统计数据
dateKey := time.Now().Format("2006-01-02")
key := fmt.Sprintf("%s:UPF_FLOW:%s:%s", constants.CACHE_NE_DATA, rmUID, dateKey)
// 使用HIncrBy实时累加统计值
if err := redis.IncrBy("", key, "up", upValue); err != nil {
return err
}
if err := redis.IncrBy("", key, "down", downValue); err != nil {
return err
}
return nil
}
// UPFTodayFlowLoad UPF上下行数据到redis
// day 统计天数
func (r KpiReport) UPFTodayFlowLoad(day int) {
cacheKeys, _ := redis.GetKeys("", constants.CACHE_NE_INFO+":UPF:*")
if len(cacheKeys) == 0 {
return
}
now := time.Now()
for _, key := range cacheKeys {
var v neModel.NeInfo
jsonStr, _ := redis.Get("", key)
if len(jsonStr) > 7 {
json.Unmarshal([]byte(jsonStr), &v)
}
if v.NeType == "UPF" && v.RmUID != "" {
// 查询最近day天的数据
for i := 0; i <= day; i++ {
dateKey := now.AddDate(0, 0, -i).Format("2006-01-02")
key := fmt.Sprintf("%s:UPF_FLOW:%s:%s", constants.CACHE_NE_DATA, v.RmUID, dateKey)
// 根据传入天数计算时间范围
beginTime := now.AddDate(0, 0, -i).Truncate(24 * time.Hour).UnixMilli()
endTime := beginTime + 24*60*60*1000 - 1
// 查询历史数据
rows := r.kpiReportRepository.SelectUPF(v.RmUID, beginTime, endTime)
var upTotal, downTotal int64
// 处理历史数据
for _, row := range rows {
var kpiValues []map[string]any
if err := json.Unmarshal([]byte(row.KpiValues), &kpiValues); err != nil {
continue
}
for _, v := range kpiValues {
if k, ok := v["kpiId"]; ok {
if k == "UPF.03" {
upTotal += parse.Number(v["value"])
}
if k == "UPF.06" {
downTotal += parse.Number(v["value"])
}
}
}
}
err := redis.SetHash("", key, map[string]any{
"up": upTotal,
"down": downTotal,
})
if err != nil {
continue
}
// 设置key的过期时间为30天，自动清理旧数据
daySub := (30 - i) * 24
err = redis.Expire("", key, time.Duration(daySub)*time.Hour)
if err != nil {
continue
}
}
}
}
}

84
src/modules/ne_data/service/nb_state.go Normal file
View File

@@ -0,0 +1,84 @@
package service
import (
"fmt"
"strconv"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 NBState 结构体
var NewNBState = &NBState{
nbStateRepository: repository.NewNBState,
}
// NBState 基站状态记录表 服务层处理
type NBState struct {
nbStateRepository *repository.NBState // 基站状态记录信息
}
// FindByPage 根据条件分页查询
func (r NBState) FindByPage(query model.NBStateQuery) ([]model.NBState, int64) {
return r.nbStateRepository.SelectByPage(query)
}
// Insert 插入数据
func (r NBState) Insert(item model.NBState) int64 {
return r.nbStateRepository.Insert(item)
}
// DeleteByIds 批量删除信息
func (r NBState) DeleteByIds(ids []string) (int64, error) {
// 检查是否存在
arr := r.nbStateRepository.SelectByIds(ids)
if len(arr) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(arr) == len(ids) {
rows := r.nbStateRepository.DeleteByIds(ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// ExportXlsx 导出数据到 xlsx 文件
func (r NBState) ExportXlsx(rows []model.NBState, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": i18n.TKey(language, "nbState.export.id"),
"B1": i18n.TKey(language, "nbState.export.name"),
"C1": i18n.TKey(language, "nbState.export.position"),
"D1": i18n.TKey(language, "nbState.export.address"),
"E1": i18n.TKey(language, "nbState.export.nbName"),
"F1": i18n.TKey(language, "nbState.export.state"),
"G1": i18n.TKey(language, "nbState.export.time"),
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 角色状态
statusValue := i18n.TKey(language, "dictData.offline")
if row.State == "ON" {
statusValue = i18n.TKey(language, "dictData.online")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.Name,
"C" + idx: row.Position,
"D" + idx: row.Address,
"E" + idx: row.NbName,
"F" + idx: statusValue,
"G" + idx: row.Time,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "Sheet1")
}

31
src/modules/ne_data/service/ne_state.go Normal file
View File

@@ -0,0 +1,31 @@
package service
import (
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化数据层 NEState 结构体
var NewNEState = &NEState{
neStateRepository: repository.NewNEState,
}
// NEState 网元状态记录表 服务层处理
type NEState struct {
neStateRepository *repository.NEState // 网元状态记录信息
}
// FindByPage 根据条件分页查询
func (r NEState) FindByPage(query model.NEStateQuery) ([]model.NEState, int64) {
return r.neStateRepository.SelectByPage(query)
}
// Insert 插入数据
func (r NEState) Insert(item model.NEState) int64 {
return r.neStateRepository.Insert(item)
}
// DeleteByTime 删除数据
func (r NEState) DeleteByTime(ltTime int64) int64 {
return r.neStateRepository.DeleteByTime(ltTime)
}

202
src/modules/ne_data/service/udm_auth.go Normal file
View File

@@ -0,0 +1,202 @@
package service
import (
"fmt"
"strconv"
"strings"
"be.ems/src/framework/database/redis"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化服务层 UDMAuthUser 结构体
var NewUDMAuthUser = &UDMAuthUser{
udmAuthRepository: repository.NewUDMAuthUser,
}
// UDM鉴权信息 服务层处理
type UDMAuthUser struct {
// UDM鉴权信息数据信息
udmAuthRepository *repository.UDMAuthUser
}
// dataByRedis UDM鉴权用户 db:0 中 ausf:*
func (r *UDMAuthUser) dataByRedis(imsi, neId string) []model.UDMAuthUser {
arr := []model.UDMAuthUser{}
key := fmt.Sprintf("ausf:%s", imsi)
source := fmt.Sprintf("UDM_%s", neId)
// 网元主机的Redis客户端
redisClient, err := neService.NewNeInfo.NeRunRedisClient("UDM", neId)
if err != nil {
return arr
}
defer func() {
redisClient.Close()
redis.ConnectPush(source, nil)
}()
redis.ConnectPush(source, redisClient.Client)
ausfArr, err := redis.GetKeys(source, key)
if err != nil {
return arr
}
mkv, err := redis.GetHashBatch(source, ausfArr)
if err != nil {
return arr
}
for k, m := range mkv {
if len(k) != 20 {
continue
}
// 跳过-号数据 ausf:360000100000130
imsi, hasPrefix := strings.CutPrefix(k, "ausf:")
if strings.Contains(imsi, "-") || !hasPrefix {
continue
}
amf := ""
if v, ok := m["amf"]; ok {
amf = strings.Replace(v, "\r\n", "", 1)
}
a := model.UDMAuthUser{
IMSI: imsi,
Amf: amf,
Ki: m["ki"],
AlgoIndex: m["algo"],
Opc: m["opc"],
NeId: neId,
}
arr = append(arr, a)
}
return arr
}
// ResetData 重置鉴权用户数据，清空数据库重新同步Redis数据
func (r *UDMAuthUser) ResetData(neId string) int64 {
authArr := r.dataByRedis("*", neId)
// 数据清空后添加
go r.udmAuthRepository.ClearAndInsert(neId, authArr)
return int64(len(authArr))
}
// ParseInfo 解析单个用户imsi鉴权信息 data从命令MML得到的结果
func (r *UDMAuthUser) ParseInfo(imsi, neId string, data map[string]string) model.UDMAuthUser {
u := r.udmAuthRepository.SelectByIMSIAndNeID(imsi, neId)
// 用于更新
u.IMSI = imsi
u.NeId = neId
u.Amf = data["amf"]
u.Ki = data["ki"]
u.AlgoIndex = data["algo"]
u.Opc = data["opc"]
return u
}
// FindByPage 分页查询数据库
func (r *UDMAuthUser) FindByPage(query map[string]string) ([]model.UDMAuthUser, int64) {
return r.udmAuthRepository.SelectPage(query)
}
// Find 查询数据库
func (r *UDMAuthUser) Find(u model.UDMAuthUser) []model.UDMAuthUser {
return r.udmAuthRepository.SelectList(u)
}
// Insert 从数据中读取后删除imsi再存入数据库
// imsi长度15，ki长度32，opc长度0或者32
func (r *UDMAuthUser) Insert(neId string, u model.UDMAuthUser) int64 {
uArr := r.dataByRedis(u.IMSI, neId)
if len(uArr) > 0 {
r.udmAuthRepository.Delete(u.IMSI, neId)
return r.udmAuthRepository.Inserts(uArr)
}
return 0
}
// InsertData 导入文件数据 dataType目前两种：txt/csv
func (r *UDMAuthUser) InsertData(neId, dataType string, data any) int64 {
// imsi截取前缀,重新获取部分数据
prefixes := make(map[string]struct{})
if dataType == "csv" {
for _, v := range data.([]map[string]string) {
imsi := v["imsi"]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
if dataType == "txt" {
for _, v := range data.([][]string) {
imsi := v[0]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
// 根据前缀重新加载插入
var num int64 = 0
for prefix := range prefixes {
// 直接删除前缀的记录
r.udmAuthRepository.DeletePrefixByIMSI(prefix, neId)
// keys ausf:4600001000004*
arr := r.dataByRedis(prefix+"*", neId)
if len(arr) > 0 {
num += r.udmAuthRepository.Inserts(arr)
}
}
return num
}
// Delete 删除单个不重新加载
func (r *UDMAuthUser) Delete(imsi, neId string) int64 {
return r.udmAuthRepository.Delete(imsi, neId)
}
// LoadData 重新加载从imsi开始num的数据
func (r *UDMAuthUser) LoadData(neId, imsi, num string) {
startIMSI, _ := strconv.ParseInt(imsi, 10, 64)
subNum, _ := strconv.ParseInt(num, 10, 64)
var i int64
for i = 0; i < subNum; i++ {
keyIMSI := fmt.Sprintf("%015d", startIMSI+i)
// 删除原数据
r.udmAuthRepository.Delete(keyIMSI, neId)
// 加载数据
arr := r.dataByRedis(keyIMSI, neId)
if len(arr) < 1 {
continue
}
r.udmAuthRepository.Inserts(arr)
}
}
// ParseCommandParams 解析数据组成命令参数 ki=xx,xx=xx,...
func (r *UDMAuthUser) ParseCommandParams(item model.UDMAuthUser) string {
var conditions []string
if item.Ki != "" {
conditions = append(conditions, fmt.Sprintf("ki=%s", item.Ki))
}
if item.Amf != "" {
conditions = append(conditions, fmt.Sprintf("amf=%s", item.Amf))
}
if item.AlgoIndex != "" {
conditions = append(conditions, fmt.Sprintf("algo=%s", item.AlgoIndex))
}
if item.Opc != "" {
conditions = append(conditions, fmt.Sprintf("opc=%s", item.Opc))
}
return strings.Join(conditions, ",")
}

33
src/modules/ne_data/service/udm_extend.go Normal file
View File

@@ -0,0 +1,33 @@
package service
import (
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化服务层 UDMExtend 结构体
var NewUDMExtend = &UDMExtend{
UDMExtendRepository: repository.NewUDMExtend,
}
// UDM用户IMSI拓展信息 服务层处理
type UDMExtend struct {
// UDM用户IMSI信息数据信息
UDMExtendRepository *repository.UDMExtend
}
// FindByIMSIAndNeID 通过IMSI和网元标识查询信息 neId为%时模糊imsi查询
func (r UDMExtend) FindByIMSIAndNeID(imsi, neId string) model.UDMExtend {
return r.UDMExtendRepository.SelectByIMSIAndNeID(imsi, neId)
}
// Save 新增或修改信息
func (r UDMExtend) Save(u model.UDMExtend) bool {
r.UDMExtendRepository.Delete(u.IMSI, u.NeId)
return r.UDMExtendRepository.Inserts([]model.UDMExtend{u}) > 0
}
// Delete 删除信息 neId为%时模糊imsi查询
func (r UDMExtend) Delete(imsi, neId string) int64 {
return r.UDMExtendRepository.Delete(imsi, neId)
}

371
src/modules/ne_data/service/udm_sub.go Normal file
View File

@@ -0,0 +1,371 @@
package service
import (
"fmt"
"strconv"
"strings"
"be.ems/src/framework/database/redis"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化服务层 UDMSubUser 结构体
var NewUDMSubUser = &UDMSubUser{
udmSubRepository: repository.NewUDMSub,
UDMExtendRepository: repository.NewUDMExtend,
}
// UDM签约信息 服务层处理
type UDMSubUser struct {
udmSubRepository *repository.UDMSubUser // UDM签约信息数据信息
UDMExtendRepository *repository.UDMExtend // UDM用户IMSI信息数据信息
}
// dataByRedis UDM签约用户 db:0 中 udm-sd:*
func (r *UDMSubUser) dataByRedis(imsi, neId string) []model.UDMSubUser {
arr := []model.UDMSubUser{}
key := fmt.Sprintf("udm-sd:%s", imsi)
source := fmt.Sprintf("UDM_%s", neId)
// 网元主机的Redis客户端
redisClient, err := neService.NewNeInfo.NeRunRedisClient("UDM", neId)
if err != nil {
return arr
}
defer func() {
redisClient.Close()
redis.ConnectPush(source, nil)
}()
redis.ConnectPush(source, redisClient.Client)
udmsdArr, err := redis.GetKeys(source, key)
if err != nil {
return arr
}
mkv, err := redis.GetHashBatch(source, udmsdArr)
if err != nil {
return arr
}
for k, m := range mkv {
if len(k) != 22 {
continue
}
// 跳过-号数据 udm-sd:360000100000130
imsi, hasPrefix := strings.CutPrefix(k, "udm-sd:")
if strings.Contains(imsi, "-") || !hasPrefix {
continue
}
a := model.UDMSubUser{
IMSI: imsi, // udm-sd:360000100000130
MSISDN: m["gpsi"], // 8612300000130
NeId: neId,
SmfSel: m["smf-sel"], // def_snssai
SmData: m["sm-dat"], // 1-000001&cmnet&ims&3gnet
Cag: m["cag"], // def_cag
}
// def_ambr,def_nssai,0,def_arfb,def_sar,3,1,12000,1,1000,0,1,-
if v, ok := m["am-dat"]; ok {
arr := strings.Split(v, ",")
a.AmDat = v
a.UeAmbrTpl = arr[0]
a.NssaiTpl = arr[1]
a.RatRestrictions = arr[2]
a.AreaForbiddenTpl = arr[3]
a.ServiceAreaRestrictionTpl = arr[4]
a.CnTypeRestrictions = arr[5]
a.RfspIndex = arr[6]
a.SubsRegTime = arr[7]
a.UeUsageType = arr[8]
a.ActiveTime = arr[9]
a.MicoAllowed = "0" // arr[10]
a.OdbPs = "1" // arr[11]
a.GroupId = "-" // arr[12]
if len(arr) > 10 {
a.MicoAllowed = arr[10]
}
if len(arr) > 11 {
a.OdbPs = arr[11]
}
if len(arr) > 12 && arr[12] != "-" {
a.GroupId = arr[12]
}
}
// 1,64,24,65,def_eps,1,2,010200000000,-
if v, ok := m["eps-dat"]; ok {
arr := strings.Split(v, ",")
// 跳过非常规数据
if len(arr) > 9 {
continue
}
a.EpsDat = v
a.EpsFlag = arr[0]
a.EpsOdb = arr[1]
a.HplmnOdb = arr[2]
a.Ard = arr[3]
a.Epstpl = arr[4]
a.ContextId = arr[5]
a.ApnNum = arr[6] // 导入和导出不用
a.ApnContext = arr[7]
if len(arr) >= 9 {
a.StaticIp = arr[8]
}
}
arr = append(arr, a)
}
return arr
}
// ResetData 重置鉴权用户数据，清空数据库重新同步Redis数据
func (r *UDMSubUser) ResetData(neId string) int64 {
subArr := r.dataByRedis("*", neId)
// 数据清空后添加
go r.udmSubRepository.ClearAndInsert(neId, subArr)
return int64(len(subArr))
}
// ParseInfo 解析单个用户imsi签约信息 data从命令MML得到的结果
func (r *UDMSubUser) ParseInfo(imsi, neId string, data map[string]string) model.UDMSubUser {
u := r.udmSubRepository.SelectByIMSIAndNeID(imsi, neId)
cnType, _ := strconv.ParseInt(data["CNType"][:4], 0, 64) // 0x03(EPC|5GC)
rat, _ := strconv.ParseInt(data["RAT"][:4], 0, 64) // 0x00(VIRTUAL|WLAN|EUTRA|NR)
msisdn := data["MSISDN"]
if imsMsisdnLen := strings.Index(msisdn, ","); imsMsisdnLen != -1 {
msisdn = msisdn[:imsMsisdnLen]
}
// 用于更新
u.IMSI = imsi
u.MSISDN = msisdn
u.NeId = neId
u.UeAmbrTpl = data["AMBR"]
u.NssaiTpl = data["NSSAI"]
u.AreaForbiddenTpl = data["AreaForbidden"]
u.ServiceAreaRestrictionTpl = data["ServiceAreaRestriction"]
u.CnTypeRestrictions = fmt.Sprint(cnType)
u.RatRestrictions = fmt.Sprint(rat)
u.MicoAllowed = data["MICO"]
u.SmData = data["SM-Data(snssai+dnn[1..n])"]
u.SmfSel = data["Smf-Selection"]
u.Cag = data["cag"]
// 1,64,24,65,def_eps,1,2,010200000000,-
if v, ok := data["EPS-Data"]; ok {
u.EpsDat = v
arr := strings.Split(v, ",")
u.EpsFlag = arr[0]
u.EpsOdb = arr[1]
u.HplmnOdb = arr[2]
u.Ard = arr[3]
u.Epstpl = arr[4]
u.ContextId = arr[5]
u.ApnNum = arr[6] // 导入和导出不用
u.ApnContext = arr[7]
u.StaticIp = arr[8]
}
// 补充用户拓展信息
info := r.UDMExtendRepository.SelectByIMSIAndNeID(imsi, neId)
if info.IMSI == imsi {
u.Remark = info.Remark
}
return u
}
// FindByPage 分页查询数据库
func (r *UDMSubUser) FindByPage(query map[string]string) ([]model.UDMSubUser, int64) {
return r.udmSubRepository.SelectPage(query)
}
// Find 查询数据库
func (r *UDMSubUser) Find(u model.UDMSubUser) []model.UDMSubUser {
return r.udmSubRepository.SelectList(u)
}
// Insert 从数据中读取后删除imsi再存入数据库
// imsi长度15，ki长度32，opc长度0或者32
func (r *UDMSubUser) Insert(neId string, u model.UDMSubUser) int64 {
uArr := r.dataByRedis(u.IMSI, neId)
if len(uArr) > 0 {
r.udmSubRepository.Delete(u.IMSI, neId)
// 新增到拓展信息
if u.Remark != "" {
r.UDMExtendRepository.Delete(u.IMSI, "%")
r.UDMExtendRepository.Inserts([]model.UDMExtend{{
IMSI: u.IMSI,
MSISDN: u.MSISDN,
NeId: u.NeId,
Remark: u.Remark,
}})
}
return r.udmSubRepository.Inserts(uArr)
}
return 0
}
// InsertData 导入文件数据 dataType目前两种：txt/csv
func (r *UDMSubUser) InsertData(neId, dataType string, data any) int64 {
// imsi截取前缀,重新获取部分数据
prefixes := make(map[string]struct{})
if dataType == "csv" {
for _, v := range data.([]map[string]string) {
imsi := v["imsi"]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
if dataType == "txt" {
for _, v := range data.([][]string) {
imsi := v[0]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
// 根据前缀重新加载插入
var num int64 = 0
for prefix := range prefixes {
// keys udm-sd:4600001000004*
arr := r.dataByRedis(prefix+"*", neId)
if len(arr) > 0 {
r.udmSubRepository.DeletePrefixByIMSI(prefix, neId)
num += r.udmSubRepository.Inserts(arr)
}
}
return num
}
// Delete 删除单个不重新加载
func (r *UDMSubUser) Delete(neId, imsi string) int64 {
// 删除拓展信息
r.UDMExtendRepository.Delete(imsi, neId)
return r.udmSubRepository.Delete(imsi, neId)
}
// LoadData 重新加载从imsi开始num的数据
// remark不为空，则新增到拓展信息，删除标记为-(Deleted)-
func (r *UDMSubUser) LoadData(neId, imsi, num, remark string) {
startIMSI, _ := strconv.ParseInt(imsi, 10, 64)
subNum, _ := strconv.ParseInt(num, 10, 64)
var i int64
for i = 0; i < subNum; i++ {
keyIMSI := fmt.Sprintf("%015d", startIMSI+i)
// 删除原数据
r.udmSubRepository.Delete(keyIMSI, neId)
if remark == "-(Deleted)-" {
r.UDMExtendRepository.Delete(keyIMSI, "%")
}
// 加载数据，删除标记为-(Deleted)-加载为空不插入
arr := r.dataByRedis(keyIMSI, neId)
if len(arr) < 1 {
continue
}
r.udmSubRepository.Inserts(arr)
// 拓展信息
if remark != "" {
uarr := make([]model.UDMExtend, 0, len(arr))
for _, v := range arr {
uarr = append(uarr, model.UDMExtend{
IMSI: v.IMSI,
MSISDN: v.MSISDN,
NeId: v.NeId,
Remark: remark,
})
}
r.UDMExtendRepository.Delete(keyIMSI, neId)
r.UDMExtendRepository.Inserts(uarr)
}
}
}
// ParseCommandParams 解析数据组成命令参数 msisdn=xx,xx=xx,...
func (r *UDMSubUser) ParseCommandParams(item model.UDMSubUser) string {
var conditions []string
if item.MSISDN != "" {
conditions = append(conditions, fmt.Sprintf("msisdn=%s", item.MSISDN))
}
// AmData
if item.UeAmbrTpl != "" {
conditions = append(conditions, fmt.Sprintf("ambr=%s", item.UeAmbrTpl))
}
if item.NssaiTpl != "" {
conditions = append(conditions, fmt.Sprintf("nssai=%s", item.NssaiTpl))
}
if item.AreaForbiddenTpl != "" {
conditions = append(conditions, fmt.Sprintf("arfb=%s", item.AreaForbiddenTpl))
}
if item.ServiceAreaRestrictionTpl != "" {
conditions = append(conditions, fmt.Sprintf("sar=%s", item.ServiceAreaRestrictionTpl))
}
if item.RatRestrictions != "" {
conditions = append(conditions, fmt.Sprintf("rat=%s", item.RatRestrictions))
}
if item.CnTypeRestrictions != "" {
conditions = append(conditions, fmt.Sprintf("cn=%s", item.CnTypeRestrictions))
}
if item.RfspIndex != "" {
conditions = append(conditions, fmt.Sprintf("rfsp=%s", item.RfspIndex))
}
if item.UeUsageType != "" {
conditions = append(conditions, fmt.Sprintf("usagetype=%s", item.UeUsageType))
}
if item.MicoAllowed != "" {
conditions = append(conditions, fmt.Sprintf("mico=%s", item.MicoAllowed))
}
// EpsDat
// if item.EpsDat != "" {
// conditions = append(conditions, fmt.Sprintf("eps_dat=%s", item.EpsDat))
// }
if item.EpsFlag != "" {
conditions = append(conditions, fmt.Sprintf("eps_flag=%s", item.EpsFlag))
}
if item.EpsOdb != "" {
conditions = append(conditions, fmt.Sprintf("eps_odb=%s", item.EpsOdb))
}
if item.HplmnOdb != "" {
conditions = append(conditions, fmt.Sprintf("hplmn_odb=%s", item.HplmnOdb))
}
if item.Epstpl != "" {
conditions = append(conditions, fmt.Sprintf("epstpl=%s", item.Epstpl))
}
if item.Ard != "" {
conditions = append(conditions, fmt.Sprintf("ard=%s", item.Ard))
}
if item.ContextId != "" {
conditions = append(conditions, fmt.Sprintf("context_id=%s", item.ContextId))
}
if item.ApnContext != "" {
conditions = append(conditions, fmt.Sprintf("apn_context=%s", item.ApnContext))
}
// static_ip指给4G UE分配的静态IP，没有可不带此字段名，批量添加IP会自动递增
if item.StaticIp != "" {
conditions = append(conditions, fmt.Sprintf("static_ip=%s", item.StaticIp))
}
// 其他
if item.SmfSel != "" {
conditions = append(conditions, fmt.Sprintf("smf_sel=%s", item.SmfSel))
}
if item.SmData != "" {
conditions = append(conditions, fmt.Sprintf("sm_data=%s", item.SmData))
}
conditions = append(conditions, fmt.Sprintf("cag=%s", item.Cag))
return strings.Join(conditions, ",")
}

172
src/modules/ne_data/service/udm_voip.go Normal file
View File

@@ -0,0 +1,172 @@
package service
import (
"fmt"
"strconv"
"strings"
"be.ems/src/framework/database/redis"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化服务层 UDMVOIPUser 结构体
var NewUDMVOIPUser = &UDMVOIPUser{
udmVOIPRepository: repository.NewUDMVOIPUser,
}
// UDMVOIP信息 服务层处理
type UDMVOIPUser struct {
// UDMVOIP信息数据信息
udmVOIPRepository *repository.UDMVOIPUser
}
// dataByRedis UDMVOIP用户 db:0 中 voip:*
func (r UDMVOIPUser) dataByRedis(username, neId string) []model.UDMVOIPUser {
arr := []model.UDMVOIPUser{}
key := fmt.Sprintf("voip:%s", username)
source := fmt.Sprintf("UDM_%s", neId)
// 网元主机的Redis客户端
redisClient, err := neService.NewNeInfo.NeRunRedisClient("UDM", neId)
if err != nil {
return arr
}
defer func() {
redisClient.Close()
redis.ConnectPush(source, nil)
}()
redis.ConnectPush(source, redisClient.Client)
voipArr, err := redis.GetKeys(source, key)
if err != nil {
return arr
}
mkv, err := redis.GetHashBatch(source, voipArr)
if err != nil {
return arr
}
for k, m := range mkv {
// 跳过-号数据 voip:360000100000130
username, hasPrefix := strings.CutPrefix(k, "voip:")
if strings.Contains(username, "-") || !hasPrefix {
continue
}
a := model.UDMVOIPUser{
NeId: neId,
UserName: username,
Password: m["password"],
}
arr = append(arr, a)
}
return arr
}
// ResetData 重置VOIP用户数据，清空数据库重新同步Redis数据
func (r UDMVOIPUser) ResetData(neId string) int64 {
arr := r.dataByRedis("*", neId)
// 数据清空后添加
go r.udmVOIPRepository.ClearAndInsert(neId, arr)
return int64(len(arr))
}
// ParseInfo 解析单个用户userName信息 data从命令MML得到的结果
func (r UDMVOIPUser) ParseInfo(neId string, data map[string]string) model.UDMVOIPUser {
u := model.UDMVOIPUser{
NeId: neId,
UserName: data["username"],
Password: data["password"],
}
// 赋予ID
item := r.udmVOIPRepository.SelectByUserNameAndNeID(u.UserName, neId)
if item.ID != "" {
u.ID = item.ID
}
return u
}
// FindByPage 分页查询数据库
func (r UDMVOIPUser) FindByPage(query map[string]string) ([]model.UDMVOIPUser, int64) {
return r.udmVOIPRepository.SelectPage(query)
}
// Find 查询数据库
func (r UDMVOIPUser) Find(u model.UDMVOIPUser) []model.UDMVOIPUser {
return r.udmVOIPRepository.SelectList(u)
}
// Insert 从数据中读取后删除username再存入数据库
func (r UDMVOIPUser) Insert(neId string, username string) int64 {
uArr := r.dataByRedis(username, neId)
if len(uArr) > 0 {
r.udmVOIPRepository.Delete(username, neId)
return r.udmVOIPRepository.Inserts(uArr)
}
return 0
}
// InsertData 导入文件数据 dataType目前两种：txt/csv
func (r UDMVOIPUser) InsertData(neId, dataType string, data any) int64 {
// imsi截取前缀,重新获取部分数据
prefixes := make(map[string]struct{})
if dataType == "csv" {
for _, v := range data.([]map[string]string) {
username := v["username"]
if len(username) < 4 {
continue
}
prefix := username[:len(username)-3]
prefixes[prefix] = struct{}{}
}
}
if dataType == "txt" {
for _, v := range data.([][]string) {
username := v[0]
if len(username) < 4 {
continue
}
prefix := username[:len(username)-3]
prefixes[prefix] = struct{}{}
}
}
// 根据前缀重新加载插入
var num int64 = 0
for prefix := range prefixes {
// 直接删除前缀的记录
r.udmVOIPRepository.DeletePrefixByUserName(prefix, neId)
// keys voip:4600001000004*
arr := r.dataByRedis(prefix+"*", neId)
if len(arr) > 0 {
num += r.udmVOIPRepository.Inserts(arr)
}
}
return num
}
// Delete 删除单个不重新加载
func (r UDMVOIPUser) Delete(username, neId string) int64 {
return r.udmVOIPRepository.Delete(username, neId)
}
// LoadData 重新加载从username开始num的数据
func (r UDMVOIPUser) LoadData(neId, username, num string) {
startUserName, _ := strconv.ParseInt(username, 10, 64)
subNum, _ := strconv.ParseInt(num, 10, 64)
var i int64
for i = 0; i < subNum; i++ {
keyUserName := fmt.Sprintf("%d", startUserName+i)
// 删除原数据
r.udmVOIPRepository.Delete(keyUserName, neId)
// 加载数据
arr := r.dataByRedis(keyUserName, neId)
if len(arr) < 1 {
continue
}
r.udmVOIPRepository.Inserts(arr)
}
}

197
src/modules/ne_data/service/udm_volte_ims.go Normal file
View File

@@ -0,0 +1,197 @@
package service
import (
"fmt"
"strconv"
"strings"
"be.ems/src/framework/database/redis"
neService "be.ems/src/modules/ne/service"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
)
// 实例化服务层 UDMVolteIMSUser 结构体
var NewUDMVolteIMSUser = &UDMVolteIMSUser{
udmVolteIMSRepository: repository.NewUDMVolteIMSUser,
}
// UDMVolteIMS信息 服务层处理
type UDMVolteIMSUser struct {
// UDMVolteIMS信息数据信息
udmVolteIMSRepository *repository.UDMVolteIMSUser
}
// dataByRedis UDMVolteIMS用户 db:0 中 volte:*
func (r UDMVolteIMSUser) dataByRedis(imsi, neId string) []model.UDMVolteIMSUser {
arr := []model.UDMVolteIMSUser{}
key := fmt.Sprintf("volte:%s", imsi)
source := fmt.Sprintf("UDM_%s", neId)
// 网元主机的Redis客户端
redisClient, err := neService.NewNeInfo.NeRunRedisClient("UDM", neId)
if err != nil {
return arr
}
defer func() {
redisClient.Close()
redis.ConnectPush(source, nil)
}()
redis.ConnectPush(source, redisClient.Client)
volteArr, err := redis.GetKeys(source, key)
if err != nil {
return arr
}
mkv, err := redis.GetHashBatch(source, volteArr)
if err != nil {
return arr
}
for k, m := range mkv {
// volte:360000100000130:8612300000130
keys := strings.Split(k, ":")
if len(keys) != 3 {
continue
}
// "110011200004217@ims.mnc001.mcc110.3gppnetwork.org"
vni := ""
impiParts := strings.Split(m["impi"], "@")
if len(impiParts) > 1 {
vni = impiParts[1]
}
a := model.UDMVolteIMSUser{
NeId: neId,
IMSI: keys[1],
MSISDN: keys[2],
Tag: m["tag"], // volte = tag
VNI: vni,
}
arr = append(arr, a)
}
return arr
}
// ResetData 重置VolteIMS用户数据，清空数据库重新同步Redis数据
func (r UDMVolteIMSUser) ResetData(neId string) int64 {
authArr := r.dataByRedis("*", neId)
// 数据清空后添加
go r.udmVolteIMSRepository.ClearAndInsert(neId, authArr)
return int64(len(authArr))
}
// ParseInfo 解析单个用户imsi信息 data从命令MML得到的结果
func (r UDMVolteIMSUser) ParseInfo(neId string, data map[string]string) model.UDMVolteIMSUser {
// "110011200004217@ims.mnc001.mcc110.3gppnetwork.org"
vni := ""
impiParts := strings.Split(data["impi"], "@")
if len(impiParts) > 1 {
vni = impiParts[1]
}
if vni == "" {
return model.UDMVolteIMSUser{}
}
u := model.UDMVolteIMSUser{
NeId: neId,
IMSI: data["imsi"],
MSISDN: data["msisdn"],
Tag: data["volte_tag"],
VNI: vni,
}
// 赋予ID
item := r.udmVolteIMSRepository.SelectByIMSIAndMSISDNAndNeID(u.IMSI, u.MSISDN, neId)
if item.ID != "" {
u.ID = item.ID
}
return u
}
// FindByPage 分页查询数据库
func (r UDMVolteIMSUser) FindByPage(query map[string]string) ([]model.UDMVolteIMSUser, int64) {
return r.udmVolteIMSRepository.SelectPage(query)
}
// Find 查询数据库
func (r UDMVolteIMSUser) Find(u model.UDMVolteIMSUser) []model.UDMVolteIMSUser {
return r.udmVolteIMSRepository.SelectList(u)
}
// InsertByIMSI 从数据中读取后删除imsi再存入数据库
// imsi长度15
func (r UDMVolteIMSUser) InsertByIMSI(imsi, neId string) int64 {
uArr := r.dataByRedis(imsi+":*", neId)
if len(uArr) > 0 {
r.udmVolteIMSRepository.Delete(imsi, neId)
return r.udmVolteIMSRepository.Inserts(uArr)
}
return 0
}
// InsertData 导入文件数据 dataType目前两种：txt/csv
func (r UDMVolteIMSUser) InsertData(neId, dataType string, data any) int64 {
// imsi截取前缀,重新获取部分数据
prefixes := make(map[string]struct{})
if dataType == "csv" {
for _, v := range data.([]map[string]string) {
imsi := v["imsi"]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
if dataType == "txt" {
for _, v := range data.([][]string) {
imsi := v[0]
if len(imsi) < 6 {
continue
}
prefix := imsi[:len(imsi)-4]
prefixes[prefix] = struct{}{}
}
}
// 根据前缀重新加载插入
var num int64 = 0
for prefix := range prefixes {
// 直接删除前缀的记录
r.udmVolteIMSRepository.DeletePrefixByIMSI(prefix, neId)
// keys voip:4600001000004*
arr := r.dataByRedis(prefix+"*", neId)
if len(arr) > 0 {
num += r.udmVolteIMSRepository.Inserts(arr)
}
}
return num
}
// Delete 删除单个不重新加载
func (r UDMVolteIMSUser) Delete(imsi, neId string) int64 {
return r.udmVolteIMSRepository.Delete(imsi, neId)
}
// LoadData 重新加载从imsi开始num的数据
func (r UDMVolteIMSUser) LoadData(neId, imsiOrMsisdn, num string) {
startIMSIOrMsisdn, _ := strconv.ParseInt(imsiOrMsisdn, 10, 64)
subNum, _ := strconv.ParseInt(num, 10, 64)
var i int64
for i = 0; i < subNum; i++ {
keyIMSI := fmt.Sprintf("%015d", startIMSIOrMsisdn+i)
if !strings.HasPrefix(imsiOrMsisdn, "0") {
keyIMSI = fmt.Sprintf("%d", startIMSIOrMsisdn+i)
}
// 删除原数据
r.udmVolteIMSRepository.Delete(keyIMSI, neId)
// 加载数据
arr := r.dataByRedis(keyIMSI+":*", neId)
if len(arr) < 1 {
continue
}
r.udmVolteIMSRepository.Inserts(arr)
}
}

229
src/modules/ne_data/service/ue_event.go Normal file
View File

@@ -0,0 +1,229 @@
package service
import (
"encoding/json"
"fmt"
"strconv"
"be.ems/src/framework/i18n"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/ne_data/model"
"be.ems/src/modules/ne_data/repository"
sysService "be.ems/src/modules/system/service"
"github.com/tsmask/go-oam"
)
// 实例化数据层 UEEvent 结构体
var NewUEEvent = &UEEvent{
ueEventRepository: repository.NewUEEvent,
}
// UEEvent UE会话事件 服务层处理
type UEEvent struct {
ueEventRepository *repository.UEEvent // UE会话事件数据信息
}
// FindByPage 根据条件分页查询
func (r UEEvent) FindByPage(neType string, query map[string]string) ([]model.UEEvent, int64) {
return r.ueEventRepository.SelectByPage(neType, query)
}
// DeleteByIds 批量删除信息
func (r UEEvent) DeleteByIds(neType string, ids []int64) (int64, error) {
// 检查是否存在
rows := r.ueEventRepository.SelectByIds(neType, ids)
if len(rows) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(rows) == len(ids) {
rows := r.ueEventRepository.DeleteByIds(neType, ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// Insert 新增信息
func (r UEEvent) Insert(param model.UEEvent) int64 {
return r.ueEventRepository.Insert(param)
}
// ExportAMF 导出数据到 xlsx 文件
func (r UEEvent) ExportAMF(rows []model.UEEvent, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "IMSI",
"C1": "Event Type",
"D1": "Result",
"E1": "Time",
}
// 读取字典数据 UE 事件类型
dictUEEventType := sysService.NewSysDictData.FindByType("ue_event_type")
// 读取字典数据 UE 事件认证代码类型
dictUEAauthCode := sysService.NewSysDictData.FindByType("ue_auth_code")
// 读取字典数据 UE 事件CM状态
dictUEEventCmState := sysService.NewSysDictData.FindByType("ue_event_cm_state")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 解析 JSON 字符串为 map
var eventJSON map[string]interface{}
err := json.Unmarshal([]byte(row.EventJSONStr), &eventJSON)
if err != nil {
logger.Warnf("UEExport Error parsing JSON: %s", err.Error())
continue
}
// 取IMSI
imsi := ""
if v, ok := eventJSON["imsi"]; ok && v != nil {
imsi = v.(string)
}
// 取类型
eventType := ""
for _, v := range dictUEEventType {
if row.EventType == v.DataValue {
eventType = i18n.TKey(language, v.DataLabel)
break
}
}
// 取结果
eventResult := ""
// 取时间
timeStr := ""
if row.EventType == oam.UENB_TYPE_AUTH {
if v, ok := eventJSON["authTime"]; ok && v != nil {
timeStr = v.(string)
}
if v, ok := eventJSON["authCode"]; ok && v != nil {
eventResult = v.(string)
for _, v := range dictUEAauthCode {
if eventResult == v.DataValue {
eventResult = i18n.TKey(language, v.DataLabel)
break
}
}
}
}
if row.EventType == oam.UENB_TYPE_DETACH {
if v, ok := eventJSON["detachTime"]; ok && v != nil {
timeStr = v.(string)
}
eventResult = "Success"
}
if row.EventType == oam.UENB_TYPE_CM {
if v, ok := eventJSON["changeTime"]; ok && v != nil {
timeStr = v.(string)
}
if v, ok := eventJSON["status"]; ok && v != nil {
eventResult = fmt.Sprint(v)
for _, v := range dictUEEventCmState {
if eventResult == v.DataValue {
eventResult = i18n.TKey(language, v.DataLabel)
break
}
}
}
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: imsi,
"C" + idx: eventType,
"D" + idx: eventResult,
"E" + idx: timeStr,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}
// ExportMME 导出数据到 xlsx 文件
func (r UEEvent) ExportMME(rows []model.UEEvent, fileName, language string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "ID",
"B1": "IMSI",
"C1": "Event Type",
"D1": "Result",
"E1": "Time",
}
// 读取字典数据 UE 事件类型
dictUEEventType := sysService.NewSysDictData.FindByType("ue_event_type")
// 读取字典数据 UE 事件认证代码类型
dictUEAauthCode := sysService.NewSysDictData.FindByType("ue_auth_code")
// 读取字典数据 UE 事件CM状态
dictUEEventCmState := sysService.NewSysDictData.FindByType("ue_event_cm_state")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 解析 JSON 字符串为 map
var eventJSON map[string]interface{}
err := json.Unmarshal([]byte(row.EventJSONStr), &eventJSON)
if err != nil {
logger.Warnf("UEExport Error parsing JSON: %s", err.Error())
continue
}
// 取IMSI
imsi := ""
if v, ok := eventJSON["imsi"]; ok && v != nil {
imsi = v.(string)
}
// 取类型
eventType := row.EventType
for _, v := range dictUEEventType {
if row.EventType == v.DataValue {
eventType = i18n.TKey(language, v.DataLabel)
break
}
}
// 取结果
eventResult := ""
if v, ok := eventJSON["result"]; ok && v != nil {
eventResult = v.(string)
if row.EventType == oam.UENB_TYPE_AUTH {
for _, v := range dictUEAauthCode {
if eventResult == v.DataValue {
eventResult = i18n.TKey(language, v.DataLabel)
break
}
}
}
if row.EventType == oam.UENB_TYPE_CM {
for _, v := range dictUEEventCmState {
if eventResult == v.DataValue {
eventResult = i18n.TKey(language, v.DataLabel)
break
}
}
}
}
// 取时间
timeStr := ""
if v, ok := eventJSON["timestamp"]; ok && v != nil {
rowTime := parse.Number(v)
timeStr = date.ParseDateToStr(rowTime, date.YYYY_MM_DDTHH_MM_SSZ)
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: imsi,
"C" + idx: eventType,
"D" + idx: eventResult,
"E" + idx: timeStr,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

54
src/modules/ne_data/udm_auth_k4_test.go Normal file
View File

@@ -0,0 +1,54 @@
package ne_data
import (
"crypto/des"
"errors"
"testing"
)
// UDM K4加密
func encrypt(origData, key []byte) ([]byte, error) {
if len(origData) < 1 || len(key) < 1 {
return nil, errors.New("wrong data or key")
}
block, err := des.NewCipher(key)
if err != nil {
return nil, err
}
bs := block.BlockSize()
if len(origData)%bs != 0 {
return nil, errors.New("wrong padding")
}
out := make([]byte, len(origData))
dst := out
for len(origData) > 0 {
block.Encrypt(dst, origData[:bs])
origData = origData[bs:]
dst = dst[bs:]
}
return out, nil
}
func TestEncrypt(t *testing.T) {
// key := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}
// 0123456789abcdef
// ki := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}
// 0123456789abcdef0123456789abcdef
// k4 password
key := []byte{0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34}
// 1234123412341234
// k4 crypt ki
ki := []byte{0x80, 0x5D, 0xAD, 0xC6, 0xE8, 0xA5, 0x4A, 0x0D, 0x59, 0xD6, 0x22, 0xC7, 0xA0, 0x4D, 0x08, 0xE0}
// 805DADC6E8A54A0D59D622C7A04D08E0
kis, err := encrypt(ki, key)
// 加密后的，放导入导入文件里ki
t.Errorf("kis: %x\n", kis)
// 3e479135bb16f45dc874a18831b54d71
t.Errorf("err: %v\n", err)
}