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

style: 去除Impl接口声明层聚焦服务函数

Browse Source
This commit is contained in:
TsMask
2024-10-12 19:06:12 +08:00
parent 94bba0c910
commit 1f0c932be8
102 changed files with 5624 additions and 6320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -15,19 +15,17 @@ import (
)
// 实例化控制层 AlarmController 结构体
var NewAlarmController = &AlarmController{
neInfoService: neService.NewNeInfoImpl,
alarmService: neDataService.NewAlarmImpl,
var NewAlarm = &AlarmController{
neInfoService: neService.NewNeInfo,
alarmService: neDataService.NewAlarm,
}
// 告警数据
//
// PATH /alarm
type AlarmController struct {
// 网元信息服务
neInfoService neService.INeInfo
// 告警信息服务
alarmService neDataService.IAlarm
neInfoService *neService.NeInfo // 网元信息服务
alarmService *neDataService.Alarm // 告警信息服务
}
// 告警列表

12
src/modules/network_data/controller/all_kpi.go
View File

@@ -11,19 +11,17 @@ import (
)
// 实例化控制层 PerfKPIController 结构体
var NewPerfKPIController = &PerfKPIController{
neInfoService: neService.NewNeInfoImpl,
perfKPIService: neDataService.NewPerfKPIImpl,
var NewPerfKPI = &PerfKPIController{
neInfoService: neService.NewNeInfo,
perfKPIService: neDataService.NewPerfKPI,
}
// 性能统计
//
// PATH /kpi
type PerfKPIController struct {
// 网元信息服务
neInfoService neService.INeInfo
// 统计信息服务
perfKPIService neDataService.IPerfKPI
neInfoService *neService.NeInfo // 网元信息服务
perfKPIService *neDataService.PerfKPI // 统计信息服务
}
// 获取统计数据

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

@@ -22,19 +22,17 @@ import (
)
// 实例化控制层 AMFController 结构体
var NewAMFController = &AMFController{
neInfoService: neService.NewNeInfoImpl,
ueEventService: neDataService.NewUEEventAMFImpl,
var NewAMF = &AMFController{
neInfoService: neService.NewNeInfo,
ueEventService: neDataService.NewUEEventAMF,
}
// 网元AMF
//
// PATH /amf
type AMFController struct {
// 网元信息服务
neInfoService neService.INeInfo
// UE会话事件服务
ueEventService neDataService.IUEEventAMF
neInfoService *neService.NeInfo // 网元信息服务
ueEventService *neDataService.UEEventAMF // UE会话事件服务
}
// UE会话列表

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

@@ -23,19 +23,17 @@ import (
)
// 实例化控制层 IMSController 结构体
var NewIMSController = &IMSController{
neInfoService: neService.NewNeInfoImpl,
cdrEventService: neDataService.NewCDREventIMSImpl,
var NewIMS = &IMSController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREventIMS,
}
// 网元IMS
//
// PATH /ims
type IMSController struct {
// 网元信息服务
neInfoService neService.INeInfo
// CDR会话事件服务
cdrEventService neDataService.ICDREventIMS
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREventIMS // CDR会话事件服务
}
// CDR会话列表

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

@@ -23,19 +23,17 @@ import (
)
// 实例化控制层 MMEController 结构体
var NewMMEController = &MMEController{
neInfoService: neService.NewNeInfoImpl,
ueEventService: neDataService.NewUEEventMMEImpl,
var NewMME = &MMEController{
neInfoService: neService.NewNeInfo,
ueEventService: neDataService.NewUEEventMME,
}
// 网元MME
//
// PATH /mme
type MMEController struct {
// 网元信息服务
neInfoService neService.INeInfo
// UE会话事件服务
ueEventService neDataService.IUEEventMME
neInfoService *neService.NeInfo // 网元信息服务
ueEventService *neDataService.UEEventMME // UE会话事件服务
}
// UE会话列表

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

@@ -22,22 +22,19 @@ import (
)
// 实例化控制层 SMFController 结构体
var NewSMFController = &SMFController{
neInfoService: neService.NewNeInfoImpl,
cdrEventService: neDataService.NewCDREventSMFImpl,
udmUserInfoService: *neDataService.NewUDMUserInfo,
var NewSMF = &SMFController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREventSMF,
udmUserInfoService: neDataService.NewUDMUserInfo,
}
// 网元SMF
//
// PATH /smf
type SMFController struct {
// 网元信息服务
neInfoService neService.INeInfo
// CDR会话事件服务
cdrEventService neDataService.ICDREventSMF
// UDM用户信息服务
udmUserInfoService neDataService.UDMUserInfo
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREventSMF // CDR会话事件服务
udmUserInfoService *neDataService.UDMUserInfo // UDM用户信息服务
}
// CDR会话列表

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

@@ -22,19 +22,17 @@ import (
)
// 实例化控制层 SMSCController 结构体
var NewSMSCController = &SMSCController{
neInfoService: neService.NewNeInfoImpl,
cdrEventService: neDataService.NewCDREventSMSCImpl,
var NewSMSC = &SMSCController{
neInfoService: neService.NewNeInfo,
cdrEventService: neDataService.NewCDREventSMSC,
}
// 网元SMSC
//
// PATH /smsc
type SMSCController struct {
// 网元信息服务
neInfoService neService.INeInfo
// CDR会话事件服务
cdrEventService neDataService.ICDREventSMSC
neInfoService *neService.NeInfo // 网元信息服务
cdrEventService *neDataService.CDREventSMSC // CDR会话事件服务
}
// CDR会话列表

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

@@ -24,17 +24,15 @@ import (
// 实例化控制层 UDMAuthController 结构体
var NewUDMAuth = &UDMAuthController{
udmAuthService: neDataService.NewUDMAuthUser,
neInfoService: neService.NewNeInfoImpl,
neInfoService: neService.NewNeInfo,
}
// UDM鉴权用户
//
// PATH /udm/auth
type UDMAuthController struct {
// UDM鉴权信息服务
udmAuthService *neDataService.UDMAuthUser
// 网元信息服务
neInfoService neService.INeInfo
udmAuthService *neDataService.UDMAuthUser // UDM鉴权信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDM鉴权用户重载数据

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

@@ -23,17 +23,15 @@ import (
// 实例化控制层 UDMSubController 结构体
var NewUDMSub = &UDMSubController{
udmSubService: neDataService.NewUDMSub,
neInfoService: neService.NewNeInfoImpl,
neInfoService: neService.NewNeInfo,
}
// UDM签约用户
//
// PATH /udm/sub
type UDMSubController struct {
// UDM签约信息服务
udmSubService *neDataService.UDMSubUser
// 网元信息服务
neInfoService neService.INeInfo
udmSubService *neDataService.UDMSubUser // UDM签约信息服务
neInfoService *neService.NeInfo // 网元信息服务
}
// UDM签约用户重载数据

12
src/modules/network_data/controller/upf.go
View File

@@ -10,19 +10,17 @@ import (
)
// 实例化控制层 UPFController 结构体
var NewUPFController = &UPFController{
neInfoService: neService.NewNeInfoImpl,
perfKPIService: neDataService.NewPerfKPIImpl,
var NewUPF = &UPFController{
neInfoService: neService.NewNeInfo,
perfKPIService: neDataService.NewPerfKPI,
}
// 网元UPF
//
// PATH /upf
type UPFController struct {
// 网元信息服务
neInfoService neService.INeInfo
// 统计信息服务
perfKPIService neDataService.IPerfKPI
neInfoService *neService.NeInfo // 网元信息服务
perfKPIService *neDataService.PerfKPI // 统计信息服务
}
// 总流量数 N3上行 N6下行

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

@@ -21,11 +21,11 @@ func Setup(router *gin.Engine) {
{
kpiGroup.GET("/title",
middleware.PreAuthorize(nil),
controller.NewPerfKPIController.Title,
controller.NewPerfKPI.Title,
)
kpiGroup.GET("/data",
middleware.PreAuthorize(nil),
controller.NewPerfKPIController.GoldKPI,
controller.NewPerfKPI.GoldKPI,
)
}
@@ -34,11 +34,11 @@ func Setup(router *gin.Engine) {
{
alarmGroup.GET("/list",
middleware.PreAuthorize(nil),
controller.NewAlarmController.List,
controller.NewAlarm.List,
)
alarmGroup.DELETE("/:alarmIds",
middleware.PreAuthorize(nil),
controller.NewAlarmController.Remove,
controller.NewAlarm.Remove,
)
}
@@ -47,17 +47,17 @@ func Setup(router *gin.Engine) {
{
imsGroup.GET("/cdr/list",
middleware.PreAuthorize(nil),
controller.NewIMSController.CDRList,
controller.NewIMS.CDRList,
)
imsGroup.DELETE("/cdr/:cdrIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.imsCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewIMSController.CDRRemove,
controller.NewIMS.CDRRemove,
)
imsGroup.POST("/cdr/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.imsCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewIMSController.CDRExport,
controller.NewIMS.CDRExport,
)
}
@@ -66,17 +66,17 @@ func Setup(router *gin.Engine) {
{
smscGroup.GET("/cdr/list",
middleware.PreAuthorize(nil),
controller.NewSMSCController.CDRList,
controller.NewSMSC.CDRList,
)
smscGroup.DELETE("/cdr/:cdrIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smscCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSMSCController.CDRRemove,
controller.NewSMSC.CDRRemove,
)
smscGroup.POST("/cdr/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smscCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSMSCController.CDRExport,
controller.NewSMSC.CDRExport,
)
}
@@ -85,21 +85,21 @@ func Setup(router *gin.Engine) {
{
smfGroup.GET("/cdr/list",
middleware.PreAuthorize(nil),
controller.NewSMFController.CDRList,
controller.NewSMF.CDRList,
)
smfGroup.DELETE("/cdr/:cdrIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smfCDR", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSMFController.CDRRemove,
controller.NewSMF.CDRRemove,
)
smfGroup.POST("/cdr/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.smfCDR", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSMFController.CDRExport,
controller.NewSMF.CDRExport,
)
smfGroup.GET("/subscribers",
middleware.PreAuthorize(nil),
controller.NewSMFController.SubUserList,
controller.NewSMF.SubUserList,
)
}
@@ -108,17 +108,17 @@ func Setup(router *gin.Engine) {
{
amfGroup.GET("/ue/list",
middleware.PreAuthorize(nil),
controller.NewAMFController.UEList,
controller.NewAMF.UEList,
)
amfGroup.DELETE("/ue/:ueIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.amfUE", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewAMFController.UERemove,
controller.NewAMF.UERemove,
)
amfGroup.POST("/ue/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.amfUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewAMFController.UEExport,
controller.NewAMF.UEExport,
)
}
@@ -127,7 +127,7 @@ func Setup(router *gin.Engine) {
{
upfGroup.GET("/totalFlow",
middleware.PreAuthorize(nil),
controller.NewUPFController.TotalFlow,
controller.NewUPF.TotalFlow,
)
}
@@ -244,17 +244,17 @@ func Setup(router *gin.Engine) {
{
mmeGroup.GET("/ue/list",
middleware.PreAuthorize(nil),
controller.NewMMEController.UEList,
controller.NewMME.UEList,
)
mmeGroup.DELETE("/ue/:ueIds",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.mmeUE", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewMMEController.UERemove,
controller.NewMME.UERemove,
)
mmeGroup.POST("/ue/export",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.mmeUE", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewMMEController.UEExport,
controller.NewMME.UEExport,
)
}
}

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

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

194
src/modules/network_data/repository/alarm.impl.go
View File

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

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

@@ -1,15 +1,189 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// CDR会话事件IMS 数据层接口
type ICDREventIMS interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.CDREventIMSQuery) map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// SelectByIds 通过ID查询
SelectByIds(cdrIds []string) []model.CDREventIMS
// 实例化数据层 CDREventIMS 结构体
var NewCDREventIMS = &CDREventIMS{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_ims`,
// DeleteByIds 批量删除信息
DeleteByIds(cdrIds []string) int64
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventIMS CDR会话事件IMS 数据层处理
type CDREventIMS struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventIMS) convertResultRows(rows []map[string]any) []model.CDREventIMS {
arr := make([]model.CDREventIMS, 0)
for _, row := range rows {
item := model.CDREventIMS{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventIMS) SelectPage(querys model.CDREventIMSQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.CallerParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.callerParty') = ?")
params = append(params, querys.CallerParty)
}
if querys.CalledParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.calledParty') = ?")
params = append(params, querys.CalledParty)
}
// MySQL8支持的
// if querys.RecordType != "" {
// recordTypes := strings.Split(querys.RecordType, ",")
// placeholder := repo.KeyPlaceholderByQuery(len(recordTypes))
// conditions = append(conditions, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') in (%s)", placeholder))
// for _, recordType := range recordTypes {
// params = append(params, recordType)
// }
// }
// Mariadb不支持json in查询改or
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, recordType)
}
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventIMS{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_ims"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventIMS) SelectByIds(cdrIds []string) []model.CDREventIMS {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventIMS{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventIMS) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_ims where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

189
src/modules/network_data/repository/cdr_event_ims.impl.go
View File

@@ -1,189 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 CDREventImpl 结构体
var NewCDREventIMSImpl = &CDREventIMSImpl{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_ims`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventIMSImpl CDR会话事件IMS 数据层处理
type CDREventIMSImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventIMSImpl) convertResultRows(rows []map[string]any) []model.CDREventIMS {
arr := make([]model.CDREventIMS, 0)
for _, row := range rows {
item := model.CDREventIMS{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventIMSImpl) SelectPage(querys model.CDREventIMSQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.CallerParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.callerParty') = ?")
params = append(params, querys.CallerParty)
}
if querys.CalledParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.calledParty') = ?")
params = append(params, querys.CalledParty)
}
// MySQL8支持的
// if querys.RecordType != "" {
// recordTypes := strings.Split(querys.RecordType, ",")
// placeholder := repo.KeyPlaceholderByQuery(len(recordTypes))
// conditions = append(conditions, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') in (%s)", placeholder))
// for _, recordType := range recordTypes {
// params = append(params, recordType)
// }
// }
// Mariadb不支持json in查询改or
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, recordType)
}
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventIMS{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_ims"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventIMSImpl) SelectByIds(cdrIds []string) []model.CDREventIMS {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventIMS{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventIMSImpl) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_ims where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

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

@@ -1,15 +1,170 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// CDR会话事件SMF 数据层接口
type ICDREventSMF interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.CDREventSMFQuery) map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// SelectByIds 通过ID查询
SelectByIds(cdrIds []string) []model.CDREventSMF
// 实例化数据层 CDREventSMF 结构体
var NewCDREventSMF = &CDREventSMF{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_smf`,
// DeleteByIds 批量删除信息
DeleteByIds(cdrIds []string) int64
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventSMF CDR会话事件 数据层处理
type CDREventSMF struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventSMF) convertResultRows(rows []map[string]any) []model.CDREventSMF {
arr := make([]model.CDREventSMF, 0)
for _, row := range rows {
item := model.CDREventSMF{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventSMF) SelectPage(querys model.CDREventSMFQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.RecordType != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, querys.RecordType)
}
if querys.SubscriberID != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?")
params = append(params, querys.SubscriberID)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventSMF{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_smf"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMF) SelectByIds(cdrIds []string) []model.CDREventSMF {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMF{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMF) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

170
src/modules/network_data/repository/cdr_event_smf.impl.go
View File

@@ -1,170 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 CDREventSMFImpl 结构体
var NewCDREventSMFImpl = &CDREventSMFImpl{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_smf`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventSMFImpl CDR会话事件 数据层处理
type CDREventSMFImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventSMFImpl) convertResultRows(rows []map[string]any) []model.CDREventSMF {
arr := make([]model.CDREventSMF, 0)
for _, row := range rows {
item := model.CDREventSMF{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventSMFImpl) SelectPage(querys model.CDREventSMFQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.RecordType != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, querys.RecordType)
}
if querys.SubscriberID != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?")
params = append(params, querys.SubscriberID)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventSMF{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_smf"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMFImpl) SelectByIds(cdrIds []string) []model.CDREventSMF {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMF{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMFImpl) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

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

@@ -1,15 +1,181 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// CDR会话事件SMSC 数据层接口
type ICDREventSMSC interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.CDREventSMSCQuery) map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// SelectByIds 通过ID查询
SelectByIds(cdrIds []string) []model.CDREventSMSC
// 实例化数据层 CDREventSMSC 结构体
var NewCDREventSMSC = &CDREventSMSC{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_smsc`,
// DeleteByIds 批量删除信息
DeleteByIds(cdrIds []string) int64
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventSMSC CDR会话事件 数据层处理
type CDREventSMSC struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventSMSC) convertResultRows(rows []map[string]any) []model.CDREventSMSC {
arr := make([]model.CDREventSMSC, 0)
for _, row := range rows {
item := model.CDREventSMSC{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventSMSC) SelectPage(querys model.CDREventSMSCQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
// MySQL8支持的
// if querys.RecordType != "" {
// recordTypes := strings.Split(querys.RecordType, ",")
// placeholder := repo.KeyPlaceholderByQuery(len(recordTypes))
// conditions = append(conditions, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') in (%s)", placeholder))
// for _, recordType := range recordTypes {
// params = append(params, recordType)
// }
// }
// Mariadb不支持json in查询改or
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, recordType)
}
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventSMSC{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_smsc"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMSC) SelectByIds(cdrIds []string) []model.CDREventSMSC {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMSC{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMSC) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smsc where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

181
src/modules/network_data/repository/cdr_event_smsc.impl.go
View File

@@ -1,181 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 CDREventSMSCImpl 结构体
var NewCDREventSMSCImpl = &CDREventSMSCImpl{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_smsc`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventSMSCImpl CDR会话事件 数据层处理
type CDREventSMSCImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *CDREventSMSCImpl) convertResultRows(rows []map[string]any) []model.CDREventSMSC {
arr := make([]model.CDREventSMSC, 0)
for _, row := range rows {
item := model.CDREventSMSC{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *CDREventSMSCImpl) SelectPage(querys model.CDREventSMSCQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
// MySQL8支持的
// if querys.RecordType != "" {
// recordTypes := strings.Split(querys.RecordType, ",")
// placeholder := repo.KeyPlaceholderByQuery(len(recordTypes))
// conditions = append(conditions, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') in (%s)", placeholder))
// for _, recordType := range recordTypes {
// params = append(params, recordType)
// }
// }
// Mariadb不支持json in查询改or
if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string
for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?")
params = append(params, recordType)
}
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.CDREventSMSC{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from cdr_event_smsc"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *CDREventSMSCImpl) SelectByIds(cdrIds []string) []model.CDREventSMSC {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMSC{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMSCImpl) DeleteByIds(cdrIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds))
sql := "delete from cdr_event_smsc where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(cdrIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

134
src/modules/network_data/repository/perf_kpi.go
View File

@@ -1,15 +1,131 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// 性能统计 数据层接口
type IPerfKPI interface {
// SelectGoldKPI 通过网元指标数据信息
SelectGoldKPI(query model.GoldKPIQuery, kpiIds []string) []map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/modules/network_data/model"
)
// SelectGoldKPITitle 网元对应的指标名称
SelectGoldKPITitle(neType string) []model.GoldKPITitle
// 实例化数据层 PerfKPI 结构体
var NewPerfKPI = &PerfKPI{}
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
SelectUPFTotalFlow(neType, rmUID, startDate, endDate string) map[string]any
// PerfKPI 性能统计 数据层处理
type PerfKPI struct{}
// SelectGoldKPI 通过网元指标数据信息
func (r *PerfKPI) SelectGoldKPI(query model.GoldKPIQuery, kpiIds []string) []map[string]any {
// 查询条件拼接
var conditions []string
var params []any
var tableName string = "kpi_report_"
if query.RmUID != "" {
conditions = append(conditions, "gk.rm_uid = ?")
params = append(params, query.RmUID)
}
if query.NeType != "" {
//conditions = append(conditions, "gk.ne_type = ?")
// params = append(params, query.NeType)
tableName += strings.ToLower(query.NeType)
}
if query.StartTime != "" {
conditions = append(conditions, "gk.created_at >= ?")
params = append(params, query.StartTime)
}
if query.EndTime != "" {
conditions = append(conditions, "gk.created_at <= ?")
params = append(params, query.EndTime)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询字段列
var fields = []string{
// fmt.Sprintf("FROM_UNIXTIME(FLOOR(gk.created_at / (%d * 1000)) * %d) AS timeGroup", query.Interval, query.Interval),
fmt.Sprintf("CONCAT(FLOOR(gk.created_at / (%d * 1000)) * (%d * 1000)) AS timeGroup", query.Interval, query.Interval), // 时间戳毫秒
"min(CASE WHEN gk.index != '' THEN gk.index ELSE 0 END) AS startIndex",
"min(CASE WHEN gk.ne_type != '' THEN gk.ne_type ELSE 0 END) AS neType",
"min(CASE WHEN gk.ne_name != '' THEN gk.ne_name ELSE 0 END) AS neName",
}
for i, kid := range kpiIds {
// 特殊字段，只取最后一次收到的非0值
if kid == "AMF.01" || kid == "UDM.01" || kid == "UDM.02" || kid == "UDM.03" || kid == "SMF.01" {
str := fmt.Sprintf("IFNULL(SUBSTRING_INDEX(GROUP_CONCAT( CASE WHEN JSON_EXTRACT(gk.kpi_values, '$[%d].kpi_id') = '%s' THEN JSON_EXTRACT(gk.kpi_values, '$[%d].value') END ), ',', 1), 0) AS '%s'", i, kid, i, kid)
fields = append(fields, str)
} else {
str := fmt.Sprintf("sum(CASE WHEN JSON_EXTRACT(gk.kpi_values, '$[%d].kpi_id') = '%s' THEN JSON_EXTRACT(gk.kpi_values, '$[%d].value') ELSE 0 END) AS '%s'", i, kid, i, kid)
fields = append(fields, str)
}
}
fieldsSql := strings.Join(fields, ",")
// 查询数据
if query.SortField == "" {
query.SortField = "timeGroup"
}
if query.SortOrder == "" {
query.SortOrder = "desc"
}
orderSql := fmt.Sprintf(" order by %s %s", query.SortField, query.SortOrder)
querySql := fmt.Sprintf("SELECT %s FROM %s gk %s GROUP BY timeGroup %s", fieldsSql, tableName, whereSql, orderSql)
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
return results
}
// SelectGoldKPITitle 网元对应的指标名称
func (r *PerfKPI) SelectGoldKPITitle(neType string) []model.GoldKPITitle {
result := []model.GoldKPITitle{}
tx := datasource.DefaultDB().Table("kpi_title").Where("ne_type = ?", neType).Find(&result)
if err := tx.Error; err != nil {
logger.Errorf("Find err => %v", err)
}
return result
}
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
func (r *PerfKPI) SelectUPFTotalFlow(neType, rmUID, startDate, endDate string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if neType != "" {
conditions = append(conditions, "kupf.ne_type = ?")
params = append(params, neType)
}
if rmUID != "" {
conditions = append(conditions, "kupf.rm_uid = ?")
params = append(params, rmUID)
}
if startDate != "" {
conditions = append(conditions, "kupf.created_at >= ?")
params = append(params, startDate)
}
if endDate != "" {
conditions = append(conditions, "kupf.created_at <= ?")
params = append(params, endDate)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := `SELECT
sum( CASE WHEN JSON_EXTRACT(kupf.kpi_values, '$[2].kpi_id') = 'UPF.03' THEN JSON_EXTRACT(kupf.kpi_values, '$[2].value') ELSE 0 END ) AS 'up',
sum( CASE WHEN JSON_EXTRACT(kupf.kpi_values, '$[5].kpi_id') = 'UPF.06' THEN JSON_EXTRACT(kupf.kpi_values, '$[5].value') ELSE 0 END ) AS 'down'
FROM kpi_report_upf kupf`
results, err := datasource.RawDB("", querySql+whereSql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
return results[0]
}

131
src/modules/network_data/repository/perf_kpi.impl.go
View File

@@ -1,131 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 PerfKPIImpl 结构体
var NewPerfKPIImpl = &PerfKPIImpl{}
// PerfKPIImpl 性能统计 数据层处理
type PerfKPIImpl struct{}
// SelectGoldKPI 通过网元指标数据信息
func (r *PerfKPIImpl) SelectGoldKPI(query model.GoldKPIQuery, kpiIds []string) []map[string]any {
// 查询条件拼接
var conditions []string
var params []any
var tableName string = "kpi_report_"
if query.RmUID != "" {
conditions = append(conditions, "gk.rm_uid = ?")
params = append(params, query.RmUID)
}
if query.NeType != "" {
//conditions = append(conditions, "gk.ne_type = ?")
// params = append(params, query.NeType)
tableName += strings.ToLower(query.NeType)
}
if query.StartTime != "" {
conditions = append(conditions, "gk.created_at >= ?")
params = append(params, query.StartTime)
}
if query.EndTime != "" {
conditions = append(conditions, "gk.created_at <= ?")
params = append(params, query.EndTime)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询字段列
var fields = []string{
// fmt.Sprintf("FROM_UNIXTIME(FLOOR(gk.created_at / (%d * 1000)) * %d) AS timeGroup", query.Interval, query.Interval),
fmt.Sprintf("CONCAT(FLOOR(gk.created_at / (%d * 1000)) * (%d * 1000)) AS timeGroup", query.Interval, query.Interval), // 时间戳毫秒
"min(CASE WHEN gk.index != '' THEN gk.index ELSE 0 END) AS startIndex",
"min(CASE WHEN gk.ne_type != '' THEN gk.ne_type ELSE 0 END) AS neType",
"min(CASE WHEN gk.ne_name != '' THEN gk.ne_name ELSE 0 END) AS neName",
}
for i, kid := range kpiIds {
// 特殊字段，只取最后一次收到的非0值
if kid == "AMF.01" || kid == "UDM.01" || kid == "UDM.02" || kid == "UDM.03" || kid == "SMF.01" {
str := fmt.Sprintf("IFNULL(SUBSTRING_INDEX(GROUP_CONCAT( CASE WHEN JSON_EXTRACT(gk.kpi_values, '$[%d].kpi_id') = '%s' THEN JSON_EXTRACT(gk.kpi_values, '$[%d].value') END ), ',', 1), 0) AS '%s'", i, kid, i, kid)
fields = append(fields, str)
} else {
str := fmt.Sprintf("sum(CASE WHEN JSON_EXTRACT(gk.kpi_values, '$[%d].kpi_id') = '%s' THEN JSON_EXTRACT(gk.kpi_values, '$[%d].value') ELSE 0 END) AS '%s'", i, kid, i, kid)
fields = append(fields, str)
}
}
fieldsSql := strings.Join(fields, ",")
// 查询数据
if query.SortField == "" {
query.SortField = "timeGroup"
}
if query.SortOrder == "" {
query.SortOrder = "desc"
}
orderSql := fmt.Sprintf(" order by %s %s", query.SortField, query.SortOrder)
querySql := fmt.Sprintf("SELECT %s FROM %s gk %s GROUP BY timeGroup %s", fieldsSql, tableName, whereSql, orderSql)
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
return results
}
// SelectGoldKPITitle 网元对应的指标名称
func (r *PerfKPIImpl) SelectGoldKPITitle(neType string) []model.GoldKPITitle {
result := []model.GoldKPITitle{}
tx := datasource.DefaultDB().Table("kpi_title").Where("ne_type = ?", neType).Find(&result)
if err := tx.Error; err != nil {
logger.Errorf("Find err => %v", err)
}
return result
}
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
func (r *PerfKPIImpl) SelectUPFTotalFlow(neType, rmUID, startDate, endDate string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if neType != "" {
conditions = append(conditions, "kupf.ne_type = ?")
params = append(params, neType)
}
if rmUID != "" {
conditions = append(conditions, "kupf.rm_uid = ?")
params = append(params, rmUID)
}
if startDate != "" {
conditions = append(conditions, "kupf.created_at >= ?")
params = append(params, startDate)
}
if endDate != "" {
conditions = append(conditions, "kupf.created_at <= ?")
params = append(params, endDate)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := `SELECT
sum( CASE WHEN JSON_EXTRACT(kupf.kpi_values, '$[2].kpi_id') = 'UPF.03' THEN JSON_EXTRACT(kupf.kpi_values, '$[2].value') ELSE 0 END ) AS 'up',
sum( CASE WHEN JSON_EXTRACT(kupf.kpi_values, '$[5].kpi_id') = 'UPF.06' THEN JSON_EXTRACT(kupf.kpi_values, '$[5].value') ELSE 0 END ) AS 'down'
FROM kpi_report_upf kupf`
results, err := datasource.RawDB("", querySql+whereSql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
return results[0]
}

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

@@ -1,15 +1,175 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// UE会话事件AMF 数据层接口
type IUEEventAMF interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.UEEventAMFQuery) map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// SelectByIds 通过ID查询
SelectByIds(ueIds []string) []model.UEEventAMF
// 实例化数据层 UEEventAMF 结构体
var NewUEEventAMF = &UEEventAMF{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, event_type, event_json, created_at from ue_event_amf`,
// DeleteByIds 批量删除信息
DeleteByIds(ueIds []string) int64
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"event_type": "EventType",
"event_json": "EventJSONStr",
"created_at": "CreatedAt",
},
}
// UEEventAMF UE会话事件 数据层处理
type UEEventAMF struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *UEEventAMF) convertResultRows(rows []map[string]any) []model.UEEventAMF {
arr := make([]model.UEEventAMF, 0)
for _, row := range rows {
item := model.UEEventAMF{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
placeholder := repo.KeyPlaceholderByQuery(len(eventTypes))
conditions = append(conditions, fmt.Sprintf("event_type in (%s)", placeholder))
for _, eventType := range eventTypes {
params = append(params, eventType)
}
}
if querys.IMSI != "" {
conditions = append(conditions, "JSON_EXTRACT(event_json, '$.imsi') = ?")
params = append(params, querys.IMSI)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.UEEventAMF{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from ue_event_amf"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *UEEventAMF) SelectByIds(ueIds []string) []model.UEEventAMF {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventAMF{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *UEEventAMF) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_amf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

175
src/modules/network_data/repository/ue_event_amf.impl.go
View File

@@ -1,175 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 UEEventAMFImpl 结构体
var NewUEEventAMFImpl = &UEEventAMFImpl{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, event_type, event_json, created_at from ue_event_amf`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"event_type": "EventType",
"event_json": "EventJSONStr",
"created_at": "CreatedAt",
},
}
// UEEventAMFImpl UE会话事件 数据层处理
type UEEventAMFImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *UEEventAMFImpl) convertResultRows(rows []map[string]any) []model.UEEventAMF {
arr := make([]model.UEEventAMF, 0)
for _, row := range rows {
item := model.UEEventAMF{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *UEEventAMFImpl) SelectPage(querys model.UEEventAMFQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
placeholder := repo.KeyPlaceholderByQuery(len(eventTypes))
conditions = append(conditions, fmt.Sprintf("event_type in (%s)", placeholder))
for _, eventType := range eventTypes {
params = append(params, eventType)
}
}
if querys.IMSI != "" {
conditions = append(conditions, "JSON_EXTRACT(event_json, '$.imsi') = ?")
params = append(params, querys.IMSI)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.UEEventAMF{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from ue_event_amf"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *UEEventAMFImpl) SelectByIds(ueIds []string) []model.UEEventAMF {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventAMF{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *UEEventAMFImpl) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_amf where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

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

@@ -1,15 +1,175 @@
package repository
import "be.ems/src/modules/network_data/model"
import (
"fmt"
"strings"
// UE会话事件MME 数据层接口
type IUEEventMME interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.UEEventMMEQuery) map[string]any
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// SelectByIds 通过ID查询
SelectByIds(ueIds []string) []model.UEEventMME
// 实例化数据层 UEEventMME 结构体
var NewUEEventMME = &UEEventMME{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, event_type, event_json, created_at from ue_event_mme`,
// DeleteByIds 批量删除信息
DeleteByIds(ueIds []string) int64
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"event_type": "EventType",
"event_json": "EventJSONStr",
"created_at": "CreatedAt",
},
}
// UEEventMME UE会话事件 数据层处理
type UEEventMME struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *UEEventMME) convertResultRows(rows []map[string]any) []model.UEEventMME {
arr := make([]model.UEEventMME, 0)
for _, row := range rows {
item := model.UEEventMME{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
placeholder := repo.KeyPlaceholderByQuery(len(eventTypes))
conditions = append(conditions, fmt.Sprintf("event_type in (%s)", placeholder))
for _, eventType := range eventTypes {
params = append(params, eventType)
}
}
if querys.IMSI != "" {
conditions = append(conditions, "JSON_EXTRACT(event_json, '$.imsi') = ?")
params = append(params, querys.IMSI)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.UEEventMME{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from ue_event_mme"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *UEEventMME) SelectByIds(ueIds []string) []model.UEEventMME {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventMME{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *UEEventMME) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_mme where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

175
src/modules/network_data/repository/ue_event_mme.impl.go
View File

@@ -1,175 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model"
)
// 实例化数据层 UEEventMMEImpl 结构体
var NewUEEventMMEImpl = &UEEventMMEImpl{
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, event_type, event_json, created_at from ue_event_mme`,
resultMap: map[string]string{
"id": "ID",
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"event_type": "EventType",
"event_json": "EventJSONStr",
"created_at": "CreatedAt",
},
}
// UEEventMMEImpl UE会话事件 数据层处理
type UEEventMMEImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *UEEventMMEImpl) convertResultRows(rows []map[string]any) []model.UEEventMME {
arr := make([]model.UEEventMME, 0)
for _, row := range rows {
item := model.UEEventMME{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&item, keyMapper, value)
}
}
arr = append(arr, item)
}
return arr
}
// SelectPage 根据条件分页查询
func (r *UEEventMMEImpl) SelectPage(querys model.UEEventMMEQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, querys.NeType)
}
if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?")
params = append(params, querys.RmUID)
}
if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?")
if len(querys.StartTime) == 13 {
querys.StartTime = querys.StartTime[:10]
}
params = append(params, querys.StartTime)
}
if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?")
if len(querys.EndTime) == 13 {
querys.EndTime = querys.EndTime[:10]
}
params = append(params, querys.EndTime)
}
if querys.EventType != "" {
eventTypes := strings.Split(querys.EventType, ",")
placeholder := repo.KeyPlaceholderByQuery(len(eventTypes))
conditions = append(conditions, fmt.Sprintf("event_type in (%s)", placeholder))
for _, eventType := range eventTypes {
params = append(params, eventType)
}
}
if querys.IMSI != "" {
conditions = append(conditions, "JSON_EXTRACT(event_json, '$.imsi') = ?")
params = append(params, querys.IMSI)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{
"total": 0,
"rows": []model.UEEventMME{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from ue_event_mme"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectByIds 通过ID查询
func (r *UEEventMMEImpl) SelectByIds(ueIds []string) []model.UEEventMME {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
querySql := r.selectSql + " where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.UEEventMME{}
}
// 转换实体
return r.convertResultRows(results)
}
// DeleteByIds 批量删除信息
func (r *UEEventMMEImpl) DeleteByIds(ueIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ueIds))
sql := "delete from ue_event_mme where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ueIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

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

@@ -1,12 +1,39 @@
package service
import "be.ems/src/modules/network_data/model"
import (
"fmt"
// 告警 服务层接口
type IAlarm interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.AlarmQuery) map[string]any
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// DeleteByIds 批量删除信息
DeleteByIds(ids []string) (int64, error)
// 实例化数据层 Alarm 结构体
var NewAlarm = &Alarm{
alarmRepository: repository.NewAlarm,
}
// Alarm 告警 服务层处理
type Alarm struct {
alarmRepository *repository.Alarm // 告警数据信息
}
// SelectPage 根据条件分页查询
func (r *Alarm) SelectPage(querys model.AlarmQuery) map[string]any {
return r.alarmRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *Alarm) DeleteByIds(ids []string) (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")
}

40
src/modules/network_data/service/alarm.impl.go
View File

@@ -1,40 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// 实例化数据层 AlarmImpl 结构体
var NewAlarmImpl = &AlarmImpl{
alarmRepository: repository.NewAlarmImpl,
}
// AlarmImpl 告警 服务层处理
type AlarmImpl struct {
// 告警数据信息
alarmRepository repository.IAlarm
}
// SelectPage 根据条件分页查询
func (r *AlarmImpl) SelectPage(querys model.AlarmQuery) map[string]any {
return r.alarmRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *AlarmImpl) DeleteByIds(ids []string) (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")
}

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

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

40
src/modules/network_data/service/cdr_event_ims.impl.go
View File

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

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

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

37
src/modules/network_data/service/cdr_event_smf.impl.go
View File

@@ -1,37 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
var NewCDREventSMFImpl = &CDREventSMFImpl{
cdrEventRepository: repository.NewCDREventSMFImpl,
}
type CDREventSMFImpl struct {
// CDR会话事件数据信息
cdrEventRepository repository.ICDREventSMF
}
func (r *CDREventSMFImpl) SelectPage(querys model.CDREventSMFQuery) map[string]any {
return r.cdrEventRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMFImpl) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在
ids := r.cdrEventRepository.SelectByIds(cdrIds)
if len(ids) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(ids) == len(cdrIds) {
rows := r.cdrEventRepository.DeleteByIds(cdrIds)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}

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

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

37
src/modules/network_data/service/cdr_event_smsc.impl.go
View File

@@ -1,37 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
var NewCDREventSMSCImpl = &CDREventSMSCImpl{
cdrEventRepository: repository.NewCDREventSMSCImpl,
}
type CDREventSMSCImpl struct {
// CDR会话事件数据信息
cdrEventRepository repository.ICDREventSMSC
}
func (r *CDREventSMSCImpl) SelectPage(querys model.CDREventSMSCQuery) map[string]any {
return r.cdrEventRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *CDREventSMSCImpl) DeleteByIds(cdrIds []string) (int64, error) {
// 检查是否存在
ids := r.cdrEventRepository.SelectByIds(cdrIds)
if len(ids) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(ids) == len(cdrIds) {
rows := r.cdrEventRepository.DeleteByIds(cdrIds)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}

84
src/modules/network_data/service/perf_kpi.go
View File

@@ -1,15 +1,79 @@
package service
import "be.ems/src/modules/network_data/model"
import (
"encoding/json"
"fmt"
"time"
// 性能统计 服务层接口
type IPerfKPI interface {
// SelectGoldKPI 通过网元指标数据信息
SelectGoldKPI(query model.GoldKPIQuery) []map[string]any
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/redis"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// SelectGoldKPITitle 网元对应的指标名称
SelectGoldKPITitle(neType string) []model.GoldKPITitle
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
SelectUPFTotalFlow(neType, rmUID string, day int) map[string]any
// 实例化数据层 PerfKPI 结构体
var NewPerfKPI = &PerfKPI{
perfKPIRepository: repository.NewPerfKPI,
}
// PerfKPI 性能统计 服务层处理
type PerfKPI struct {
perfKPIRepository *repository.PerfKPI // 性能统计数据信息
}
// SelectGoldKPI 通过网元指标数据信息
func (r *PerfKPI) SelectGoldKPI(query model.GoldKPIQuery) []map[string]any {
// 获取数据指标id
var kpiIds []string
kpiTitles := r.perfKPIRepository.SelectGoldKPITitle(query.NeType)
for _, kpiId := range kpiTitles {
kpiIds = append(kpiIds, kpiId.KPIID)
}
data := r.perfKPIRepository.SelectGoldKPI(query, kpiIds)
if data == nil {
return []map[string]any{}
}
return data
}
// SelectGoldKPITitle 网元对应的指标名称
func (r *PerfKPI) SelectGoldKPITitle(neType string) []model.GoldKPITitle {
return r.perfKPIRepository.SelectGoldKPITitle(neType)
}
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
func (r *PerfKPI) SelectUPFTotalFlow(neType, rmUID string, day int) map[string]any {
now := time.Now()
// 获取当前日期
endDate := fmt.Sprint(now.UnixMilli())
// 将当前日期前几天数
startDate := fmt.Sprint(now.AddDate(0, 0, -day).Truncate(24 * time.Hour).UnixMilli())
var info map[string]any
// 读取缓存数据 小于2分钟重新缓存
key := fmt.Sprintf("%sUPF:totalFlow:%s_%d", cachekey.NE_DATA_KEY, rmUID, day)
infoStr, _ := redis.Get("", key)
if infoStr != "" {
json.Unmarshal([]byte(infoStr), &info)
expireSecond, _ := redis.GetExpire("", key)
if expireSecond > 120 {
return info
}
}
// down * 8 / 1000 / 1000 单位M
info = r.perfKPIRepository.SelectUPFTotalFlow(neType, rmUID, startDate, endDate)
if v, ok := info["up"]; ok && v == nil {
info["up"] = 0
}
if v, ok := info["down"]; ok && v == nil {
info["down"] = 0
}
// 保存到缓存
infoJSON, _ := json.Marshal(info)
redis.SetByExpire("", key, string(infoJSON), time.Duration(10)*time.Minute)
return info
}

80
src/modules/network_data/service/perf_kpi.impl.go
View File

@@ -1,80 +0,0 @@
package service
import (
"encoding/json"
"fmt"
"time"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/redis"
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// 实例化数据层 PerfKPIImpl 结构体
var NewPerfKPIImpl = &PerfKPIImpl{
perfKPIRepository: repository.NewPerfKPIImpl,
}
// PerfKPIImpl 性能统计 服务层处理
type PerfKPIImpl struct {
// 性能统计数据信息
perfKPIRepository repository.IPerfKPI
}
// SelectGoldKPI 通过网元指标数据信息
func (r *PerfKPIImpl) SelectGoldKPI(query model.GoldKPIQuery) []map[string]any {
// 获取数据指标id
var kpiIds []string
kpiTitles := r.perfKPIRepository.SelectGoldKPITitle(query.NeType)
for _, kpiId := range kpiTitles {
kpiIds = append(kpiIds, kpiId.KPIID)
}
data := r.perfKPIRepository.SelectGoldKPI(query, kpiIds)
if data == nil {
return []map[string]any{}
}
return data
}
// SelectGoldKPITitle 网元对应的指标名称
func (r *PerfKPIImpl) SelectGoldKPITitle(neType string) []model.GoldKPITitle {
return r.perfKPIRepository.SelectGoldKPITitle(neType)
}
// SelectUPFTotalFlow 查询UPF总流量 N3上行 N6下行
func (r *PerfKPIImpl) SelectUPFTotalFlow(neType, rmUID string, day int) map[string]any {
now := time.Now()
// 获取当前日期
endDate := fmt.Sprint(now.UnixMilli())
// 将当前日期前几天数
startDate := fmt.Sprint(now.AddDate(0, 0, -day).Truncate(24 * time.Hour).UnixMilli())
var info map[string]any
// 读取缓存数据 小于2分钟重新缓存
key := fmt.Sprintf("%sUPF:totalFlow:%s_%d", cachekey.NE_DATA_KEY, rmUID, day)
infoStr, _ := redis.Get("", key)
if infoStr != "" {
json.Unmarshal([]byte(infoStr), &info)
expireSecond, _ := redis.GetExpire("", key)
if expireSecond > 120 {
return info
}
}
// down * 8 / 1000 / 1000 单位M
info = r.perfKPIRepository.SelectUPFTotalFlow(neType, rmUID, startDate, endDate)
if v, ok := info["up"]; ok && v == nil {
info["up"] = 0
}
if v, ok := info["down"]; ok && v == nil {
info["down"] = 0
}
// 保存到缓存
infoJSON, _ := json.Marshal(info)
redis.SetByExpire("", key, string(infoJSON), time.Duration(10)*time.Minute)
return info
}

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

@@ -1,12 +1,40 @@
package service
import "be.ems/src/modules/network_data/model"
import (
"fmt"
// UE会话事件AMF 服务层接口
type IUEEventAMF interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.UEEventAMFQuery) map[string]any
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// DeleteByIds 批量删除信息
DeleteByIds(ueIds []string) (int64, error)
// 实例化数据层 UEEventAMF 结构体
var NewUEEventAMF = &UEEventAMF{
ueEventRepository: repository.NewUEEventAMF,
}
// UEEventAMF UE会话事件AMF 服务层处理
type UEEventAMF struct {
// UE会话事件数据信息
ueEventRepository *repository.UEEventAMF
}
// SelectPage 根据条件分页查询
func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) map[string]any {
return r.ueEventRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *UEEventAMF) DeleteByIds(ueIds []string) (int64, error) {
// 检查是否存在
ids := r.ueEventRepository.SelectByIds(ueIds)
if len(ids) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(ids) == len(ueIds) {
rows := r.ueEventRepository.DeleteByIds(ueIds)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}

40
src/modules/network_data/service/ue_event_amf.impl.go
View File

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

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

@@ -1,12 +1,39 @@
package service
import "be.ems/src/modules/network_data/model"
import (
"fmt"
// UE会话事件MME 服务层接口
type IUEEventMME interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.UEEventMMEQuery) map[string]any
"be.ems/src/modules/network_data/model"
"be.ems/src/modules/network_data/repository"
)
// DeleteByIds 批量删除信息
DeleteByIds(ueIds []string) (int64, error)
// 实例化数据层 UEEventMME 结构体
var NewUEEventMME = &UEEventMME{
ueEventRepository: repository.NewUEEventMME,
}
// UEEventMME UE会话事件MME 服务层处理
type UEEventMME struct {
ueEventRepository *repository.UEEventMME // UE会话事件数据信息
}
// SelectPage 根据条件分页查询
func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) map[string]any {
return r.ueEventRepository.SelectPage(querys)
}
// DeleteByIds 批量删除信息
func (r *UEEventMME) DeleteByIds(ueIds []string) (int64, error) {
// 检查是否存在
ids := r.ueEventRepository.SelectByIds(ueIds)
if len(ids) <= 0 {
return 0, fmt.Errorf("no data")
}
if len(ids) == len(ueIds) {
rows := r.ueEventRepository.DeleteByIds(ueIds)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}

40
src/modules/network_data/service/ue_event_mme.impl.go
View File

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