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

feat: 调整cdr数据查询

Browse Source
This commit is contained in:
TsMask
2024-12-20 16:34:36 +08:00
parent 7710d3cd81
commit 4c57fe2c85
19 changed files with 474 additions and 759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@@ -57,8 +57,8 @@ func (s *IMSController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
// 查询数据 // 查询数据
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
c.JSON(200, result.Ok(data)) c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
} }
// CDR会话删除 // CDR会话删除
@@ -109,13 +109,12 @@ func (s *IMSController) CDRExport(c *gin.Context) {
return return
} }
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
if parse.Number(data["total"]) == 0 { if total == 0 {
// 导出数据记录为空 // 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty"))) c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return return
} }
rows := data["rows"].([]model.CDREventIMS)
// 导出文件名称 // 导出文件名称
fileName := fmt.Sprintf("ims_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli()) fileName := fmt.Sprintf("ims_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
@@ -150,16 +149,6 @@ func (s *IMSController) CDRExport(c *gin.Context) {
if v, ok := cdrJSON["recordType"]; ok && v != nil { if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string) recordType = v.(string)
} }
// 被叫
called := ""
if v, ok := cdrJSON["calledParty"]; ok && v != nil {
called = v.(string)
}
// 主叫
caller := ""
if v, ok := cdrJSON["callerParty"]; ok && v != nil {
caller = v.(string)
}
// 呼叫类型 // 呼叫类型
callType := "sms" callType := "sms"
callTypeLable := "SMS" callTypeLable := "SMS"
@@ -172,6 +161,16 @@ func (s *IMSController) CDRExport(c *gin.Context) {
} }
} }
} }
// 被叫
called := ""
if v, ok := cdrJSON["calledParty"]; ok && v != nil {
called = v.(string)
}
// 主叫
caller := ""
if v, ok := cdrJSON["callerParty"]; ok && v != nil {
caller = v.(string)
}
// 时长 // 时长
duration := "-" duration := "-"
if v, ok := cdrJSON["callDuration"]; ok && v != nil && callType != "sms" { if v, ok := cdrJSON["callDuration"]; ok && v != nil && callType != "sms" {
@@ -191,8 +190,11 @@ func (s *IMSController) CDRExport(c *gin.Context) {
// 取时间 // 取时间
timeStr := "" timeStr := ""
if v, ok := cdrJSON["releaseTime"]; ok && v != nil { if v, ok := cdrJSON["releaseTime"]; ok && v != nil {
releaseTime := parse.Number(v) if releaseTime := parse.Number(v); releaseTime > 0 {
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ) timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
timeStr = v.(string)
}
} }
dataCells = append(dataCells, map[string]any{ dataCells = append(dataCells, map[string]any{

265
src/modules/network_data/controller/sgwc.go
View File

@@ -17,7 +17,6 @@ import (
neDataService "be.ems/src/modules/network_data/service" neDataService "be.ems/src/modules/network_data/service"
neService "be.ems/src/modules/network_element/service" neService "be.ems/src/modules/network_element/service"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
) )
// 实例化控制层 SGWCController 结构体 // 实例化控制层 SGWCController 结构体
@@ -57,10 +56,7 @@ func (s *SGWCController) CDRList(c *gin.Context) {
// 查询数据 // 查询数据
rows, total := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
c.JSON(200, result.Ok(map[string]any{ c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
"total": total,
"rows": rows,
}))
} }
// CDR会话删除 // CDR会话删除
@@ -96,7 +92,7 @@ func (s *SGWCController) CDRExport(c *gin.Context) {
language := ctx.AcceptLanguage(c) language := ctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制 // 查询结果，根据查询条件结果，单页最大值限制
var querys model.CDREventSGWCQuery var querys model.CDREventSGWCQuery
if err := c.ShouldBindBodyWith(&querys, binding.JSON); err != nil { if err := c.ShouldBindBodyWithJSON(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400"))) c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return return
} }
@@ -119,35 +115,33 @@ func (s *SGWCController) CDRExport(c *gin.Context) {
} }
// 导出文件名称 // 导出文件名称
fileName := fmt.Sprintf("SGWC_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli()) fileName := fmt.Sprintf("sgwc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题 // 第一行表头标题
headerCells := map[string]string{ headerCells := map[string]string{
"A1": "ID", "A1": "ID",
"B1": "Charging ID", "B1": "NE Name",
"C1": "NE Name", "C1": "Resource Unique ID",
"D1": "Resource Unique ID", "D1": "Charging ID",
"E1": "Subscriber ID Data", "E1": "IMSI",
"F1": "Subscriber ID Type", "F1": "MSISDN",
"G1": "Data Volume Uplink", "G1": "GPRS Uplink",
"H1": "Data Volume Downlink", "H1": "GPRS Downlink",
"I1": "Data Total Volume", "I1": "Duration",
"J1": "Duration", "J1": "Invocation Time",
"K1": "Invocation Time", "K1": "PGW Address Used",
"L1": "User Identifier", "L1": "SGW Address",
"M1": "SSC Mode", "M1": "RAT Type",
"N1": "DNN ID", "N1": "PDPPDN Type",
"O1": "PDU Type", "O1": "PDPPDN Address",
"P1": "RAT Type", "P1": "Node Address",
"Q1": "PDU IPv4 Address", "Q1": "Node Type",
"R1": "Network Function IPv4", "R1": "Record Access Point Name NI",
"S1": "PDU IPv6 Address Swith Prefix", "S1": "Record Cause For Rec Closing",
"T1": "Record Network Function ID", "T1": "Record Sequence Number",
"U1": "Record Type", "U1": "Local Record Sequence Number",
"V1": "Record Opening Time",
} }
// 从第二行开始的数据 // 从第二行开始的数据
dataCells := make([]map[string]any, 0) dataCells := make([]map[string]any, 0)
for i, row := range rows { for i, row := range rows {
idx := strconv.Itoa(i + 2) idx := strconv.Itoa(i + 2)
// 解析 JSON 字符串为 map // 解析 JSON 字符串为 map
@@ -162,51 +156,91 @@ func (s *SGWCController) CDRExport(c *gin.Context) {
if v, ok := cdrJSON["chargingID"]; ok && v != nil { if v, ok := cdrJSON["chargingID"]; ok && v != nil {
chargingID = fmt.Sprint(parse.Number(v)) chargingID = fmt.Sprint(parse.Number(v))
} }
// 订阅 ID 类型 // IMSI
subscriptionIDType := "-" servedIMSI := ""
// 订阅 ID 数据 if v, ok := cdrJSON["servedIMSI"]; ok && v != nil {
subscriptionIDData := "-" servedIMSI = fmt.Sprint(v)
if v, ok := cdrJSON["subscriberIdentifier"]; ok && v != nil { }
if sub, subOk := v.(map[string]any); subOk && sub != nil { // MSISDN
subscriptionIDType = sub["subscriptionIDType"].(string) servedMSISDN := ""
subscriptionIDData = sub["subscriptionIDData"].(string) if v, ok := cdrJSON["servedMSISDN"]; ok && v != nil {
servedMSISDN = fmt.Sprint(v)
}
// pGWAddressUsed
pGWAddressUsed := ""
if v, ok := cdrJSON["pGWAddressUsed"]; ok && v != nil {
pGWAddressUsed = fmt.Sprint(v)
}
// sGWAddress
sGWAddress := ""
if v, ok := cdrJSON["sGWAddress"]; ok && v != nil {
sGWAddress = fmt.Sprint(v)
}
// rATType
rATType := ""
if v, ok := cdrJSON["rATType"]; ok && v != nil {
rATType = fmt.Sprint(v)
}
// pdpPDNType
pdpPDNType := ""
if v, ok := cdrJSON["pdpPDNType"]; ok && v != nil {
pdpPDNType = fmt.Sprint(v)
}
// servedPDPPDNAddress
servedPDPPDNAddress := ""
if v, ok := cdrJSON["servedPDPPDNAddress"]; ok && v != nil {
servedPDPPDNAddress = fmt.Sprint(v)
}
// servedPDPPDNAddress
servingNodeAddress := []string{}
if v, ok := cdrJSON["servingNodeAddress"]; ok && v != nil {
for _, v := range v.([]any) {
servingNodeAddress = append(servingNodeAddress, fmt.Sprint(v))
} }
} }
// servingNodeType
// 网络功能 IPv4 地址 servingNodeType := []string{}
networkFunctionIPv4Address := "" if v, ok := cdrJSON["servingNodeType"]; ok && v != nil {
if v, ok := cdrJSON["nFunctionConsumerInformation"]; ok && v != nil { for _, v := range v.([]any) {
if conInfo, conInfoOk := v.(map[string]any); conInfoOk && conInfo != nil { if v, ok := v.(map[string]any)["servingNodeType"]; ok && v != nil {
networkFunctionIPv4Address = conInfo["networkFunctionIPv4Address"].(string) servingNodeType = append(servingNodeType, fmt.Sprint(v))
}
} }
} }
// accessPointNameNI
accessPointNameNI := ""
if v, ok := cdrJSON["accessPointNameNI"]; ok && v != nil {
accessPointNameNI = fmt.Sprint(v)
}
// causeForRecClosing
causeForRecClosing := ""
if v, ok := cdrJSON["causeForRecClosing"]; ok && v != nil {
causeForRecClosing = fmt.Sprint(v)
}
// recordSequenceNumber
recordSequenceNumber := ""
if v, ok := cdrJSON["recordSequenceNumber"]; ok && v != nil {
recordSequenceNumber = fmt.Sprint(v)
}
// localRecordSequenceNumber
localRecordSequenceNumber := ""
if v, ok := cdrJSON["localRecordSequenceNumber"]; ok && v != nil {
localRecordSequenceNumber = fmt.Sprint(v)
}
// 数据量上行链路 // 数据量上行链路
dataVolumeUplink := []string{} dataVolumeGPRSUplink := []string{}
// 数据量下行链路 // 数据量下行链路
dataVolumeDownlink := []string{} dataVolumeGPRSDownlink := []string{}
// 数据总量 if v, ok := cdrJSON["listOfTrafficVolumes"]; ok && v != nil {
dataTotalVolume := []string{}
if v, ok := cdrJSON["listOfMultipleUnitUsage"]; ok && v != nil {
usageList := v.([]any) usageList := v.([]any)
if len(usageList) > 0 { if len(usageList) > 0 {
for _, used := range usageList { for _, used := range usageList {
usedUnit := used.(map[string]any) usedUnit := used.(map[string]any)
usedUnitList := usedUnit["usedUnitContainer"].([]any) if dup, dupOk := usedUnit["dataVolumeGPRSUplink"]; dupOk {
if len(usedUnitList) > 0 { dataVolumeGPRSUplink = append(dataVolumeGPRSUplink, fmt.Sprint(parse.Number(dup)))
for _, data := range usedUnitList { }
udata := data.(map[string]any) if ddown, ddownOk := usedUnit["dataVolumeGPRSDownlink"]; ddownOk {
if dup, dupOk := udata["dataVolumeUplink"]; dupOk { dataVolumeGPRSDownlink = append(dataVolumeGPRSDownlink, fmt.Sprint(parse.Number(ddown)))
dataVolumeUplink = append(dataVolumeUplink, fmt.Sprint(parse.Number(dup)))
}
if ddown, ddownOk := udata["dataVolumeDownlink"]; ddownOk {
dataVolumeDownlink = append(dataVolumeDownlink, fmt.Sprint(parse.Number(ddown)))
}
if dt, dtOk := udata["dataTotalVolume"]; dtOk {
dataTotalVolume = append(dataTotalVolume, fmt.Sprint(parse.Number(dt)))
}
}
} }
} }
} }
@@ -218,93 +252,32 @@ func (s *SGWCController) CDRExport(c *gin.Context) {
} }
// 调用时间 // 调用时间
invocationTimestamp := "" invocationTimestamp := ""
if v, ok := cdrJSON["invocationTimestamp"]; ok && v != nil {
invocationTimestamp = v.(string)
}
// 记录打开时间
User_Identifier := ""
SSC_Mode := ""
RAT_Type := ""
DNN_ID := ""
PDU_Type := ""
PDU_IPv4 := ""
PDU_IPv6 := ""
if v, ok := cdrJSON["pDUSessionChargingInformation"]; ok && v != nil {
pduInfo := v.(map[string]any)
if v, ok := pduInfo["userIdentifier"]; ok && v != nil {
User_Identifier = v.(string)
}
if v, ok := pduInfo["sSCMode"]; ok && v != nil {
SSC_Mode = v.(string)
}
if v, ok := pduInfo["rATType"]; ok && v != nil {
RAT_Type = v.(string)
}
if v, ok := pduInfo["dNNID"]; ok && v != nil {
DNN_ID = v.(string)
}
if v, ok := pduInfo["pDUType"]; ok && v != nil {
PDU_Type = v.(string)
}
if v, ok := pduInfo["pDUAddress"]; ok && v != nil {
pDUAddress := v.(map[string]any)
if addr, ok := pDUAddress["pDUIPv4Address"]; ok && addr != nil {
PDU_IPv4 = addr.(string)
}
if addr, ok := pDUAddress["pDUIPv6AddresswithPrefix"]; ok && addr != nil {
PDU_IPv6 = addr.(string)
}
}
// pduSessionChargingInformation = fmt.Sprintf(`User Identifier: %s
// SSC Mode: %s RAT Type: %s DNN ID: %s
// PDU Type: %s
// PDU IPv4 Address: %s
// PDU IPv6 Addres Swith Prefix: %s`, User_Identifier, SSC_Mode, RAT_Type, DNN_ID, PDU_Type, PDU_IPv4, PDU_IPv6)
}
// 记录网络参数ID
recordNFID := ""
if v, ok := cdrJSON["recordingNetworkFunctionID"]; ok && v != nil {
recordNFID = v.(string)
}
//记录开始时间
recordOpeningTime := ""
if v, ok := cdrJSON["recordOpeningTime"]; ok && v != nil { if v, ok := cdrJSON["recordOpeningTime"]; ok && v != nil {
recordOpeningTime = v.(string) invocationTimestamp = v.(string)
}
//记录类型
recordType := ""
if v, ok := cdrJSON["recordType"]; ok && v != nil {
recordType = v.(string)
} }
dataCells = append(dataCells, map[string]any{ dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID, "A" + idx: row.ID,
"B" + idx: chargingID, "B" + idx: row.NeName,
"C" + idx: row.NeName, "C" + idx: row.RmUID,
"D" + idx: row.RmUID, "D" + idx: chargingID,
"E" + idx: subscriptionIDData, "E" + idx: servedIMSI,
"F" + idx: subscriptionIDType, "F" + idx: servedMSISDN,
"G" + idx: strings.Join(dataVolumeUplink, ","), "G" + idx: strings.Join(dataVolumeGPRSUplink, ","),
"H" + idx: strings.Join(dataVolumeDownlink, ","), "H" + idx: strings.Join(dataVolumeGPRSDownlink, ","),
"I" + idx: strings.Join(dataTotalVolume, ","), "I" + idx: duration,
"J" + idx: duration, "J" + idx: invocationTimestamp,
"K" + idx: invocationTimestamp, "K" + idx: pGWAddressUsed,
"L" + idx: User_Identifier, "L" + idx: sGWAddress,
"M" + idx: SSC_Mode, "M" + idx: rATType,
"N" + idx: DNN_ID, "N" + idx: pdpPDNType,
"O" + idx: PDU_Type, "O" + idx: servedPDPPDNAddress,
"P" + idx: RAT_Type, "P" + idx: strings.Join(servingNodeAddress, ","),
"Q" + idx: PDU_IPv4, "Q" + idx: strings.Join(servingNodeType, ","),
"R" + idx: networkFunctionIPv4Address, "R" + idx: accessPointNameNI,
"S" + idx: PDU_IPv6, "S" + idx: causeForRecClosing,
"T" + idx: recordNFID, "T" + idx: recordSequenceNumber,
"U" + idx: recordType, "U" + idx: localRecordSequenceNumber,
"V" + idx: recordOpeningTime,
}) })
} }

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

@@ -57,8 +57,8 @@ func (s *SMFController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
// 查询数据 // 查询数据
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
c.JSON(200, result.Ok(data)) c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
} }
// CDR会话删除 // CDR会话删除
@@ -109,13 +109,12 @@ func (s *SMFController) CDRExport(c *gin.Context) {
return return
} }
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
if parse.Number(data["total"]) == 0 { if total == 0 {
// 导出数据记录为空 // 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty"))) c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return return
} }
rows := data["rows"].([]model.CDREventSMF)
// 导出文件名称 // 导出文件名称
fileName := fmt.Sprintf("smf_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli()) fileName := fmt.Sprintf("smf_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())

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

@@ -17,6 +17,7 @@ import (
"be.ems/src/modules/network_data/model" "be.ems/src/modules/network_data/model"
neDataService "be.ems/src/modules/network_data/service" neDataService "be.ems/src/modules/network_data/service"
neService "be.ems/src/modules/network_element/service" neService "be.ems/src/modules/network_element/service"
sysService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding" "github.com/gin-gonic/gin/binding"
) )
@@ -55,8 +56,8 @@ func (s *SMSCController) CDRList(c *gin.Context) {
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
// 查询数据 // 查询数据
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
c.JSON(200, result.Ok(data)) c.JSON(200, result.Ok(map[string]any{"rows": rows, "total": total}))
} }
// CDR会话删除 // CDR会话删除
@@ -107,13 +108,12 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
return return
} }
querys.RmUID = neInfo.RmUID querys.RmUID = neInfo.RmUID
data := s.cdrEventService.SelectPage(querys) rows, total := s.cdrEventService.SelectPage(querys)
if parse.Number(data["total"]) == 0 { if total == 0 {
// 导出数据记录为空 // 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty"))) c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return return
} }
rows := data["rows"].([]model.CDREventSMSC)
// 导出文件名称 // 导出文件名称
fileName := fmt.Sprintf("smsc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli()) fileName := fmt.Sprintf("smsc_cdr_event_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
@@ -127,6 +127,8 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
"F1": "Result", "F1": "Result",
"G1": "Time", "G1": "Time",
} }
// 读取字典数据 CDR 原因码
dictCDRCauseCode := sysService.NewSysDictData.SelectDictDataByType("cdr_cause_code")
// 从第二行开始的数据 // 从第二行开始的数据
dataCells := make([]map[string]any, 0) dataCells := make([]map[string]any, 0)
for i, row := range rows { for i, row := range rows {
@@ -166,11 +168,24 @@ func (s *SMSCController) CDRExport(c *gin.Context) {
callResult = "Success" callResult = "Success"
} }
} }
// 结果原因
if v, ok := cdrJSON["cause"]; ok && v != nil && callResult == "Fail" {
cause := fmt.Sprint(v)
for _, v := range dictCDRCauseCode {
if cause == v.DictValue {
callResult = fmt.Sprintf("%s, %s", callResult, i18n.TKey(language, v.DictLabel))
break
}
}
}
// 取时间 // 取时间
timeStr := "" timeStr := ""
if v, ok := cdrJSON["updateTime"]; ok && v != nil { if v, ok := cdrJSON["updateTime"]; ok && v != nil {
releaseTime := parse.Number(v) if releaseTime := parse.Number(v); releaseTime > 0 {
timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ) timeStr = date.ParseDateToStr(releaseTime, date.YYYY_MM_DDTHH_MM_SSZ)
} else {
timeStr = v.(string)
}
} }
dataCells = append(dataCells, map[string]any{ dataCells = append(dataCells, map[string]any{

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

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

5
src/modules/network_data/model/cdr_event_ims.go
View File

@@ -13,6 +13,11 @@ type CDREventIMS struct {
CreatedAt time.Time `json:"createdAt" gorm:"column:created_at;default:CURRENT_TIMESTAMP"` CreatedAt time.Time `json:"createdAt" gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
} }
// TableName 表名称
func (*CDREventIMS) TableName() string {
return "cdr_event_ims"
}
// CDREventIMSQuery CDR会话对象IMS查询参数结构体 // CDREventIMSQuery CDR会话对象IMS查询参数结构体
type CDREventIMSQuery struct { type CDREventIMSQuery struct {
NeType string `json:"neType" form:"neType" binding:"required"` // 网元类型IMS NeType string `json:"neType" form:"neType" binding:"required"` // 网元类型IMS

22
src/modules/network_data/model/cdr_event_sgwc.go
View File

@@ -22,15 +22,15 @@ func (*CDREventSGWC) TableName() string {
// CDREventSGWCQuery CDR会话对象SGWC查询参数结构体 // CDREventSGWCQuery CDR会话对象SGWC查询参数结构体
type CDREventSGWCQuery struct { type CDREventSGWCQuery struct {
NeType string `json:"neType" form:"neType" binding:"required,oneof=SGWC"` // SGWC NeType string `json:"neType" form:"neType" binding:"required,oneof=SGWC"` // SGWC
NeID string `json:"neId" form:"neId" binding:"required"` NeID string `json:"neId" form:"neId" binding:"required"`
RmUID string `json:"rmUID" form:"rmUID"` RmUID string `json:"rmUID" form:"rmUID"`
RecordType string `json:"recordType" form:"recordType"` // 暂时没用到 IMSI string `json:"imsi" form:"imsi"`
SubscriberID string `json:"subscriberID" form:"subscriberID"` MSISDN string `json:"msisdn" form:"msisdn"`
StartTime string `json:"startTime" form:"startTime"` StartTime string `json:"startTime" form:"startTime"`
EndTime string `json:"endTime" form:"endTime"` EndTime string `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=timestamp"` // 排序字段，填写结果字段 SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=timestamp"` // 排序字段，填写结果字段
SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc
PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"` PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"`
PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"` PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"`
} }

5
src/modules/network_data/model/cdr_event_smf.go
View File

@@ -15,6 +15,11 @@ type CDREventSMF struct {
// ====== 非数据库字段属性 ====== // ====== 非数据库字段属性 ======
} }
// TableName 表名称
func (*CDREventSMF) TableName() string {
return "cdr_event_smf"
}
// CDREventSMFQuery CDR会话对象SMF查询参数结构体 // CDREventSMFQuery CDR会话对象SMF查询参数结构体
type CDREventSMFQuery struct { type CDREventSMFQuery struct {
NeType string `json:"neType" form:"neType" binding:"required"` // SMF NeType string `json:"neType" form:"neType" binding:"required"` // SMF

5
src/modules/network_data/model/cdr_event_smsc.go
View File

@@ -13,6 +13,11 @@ type CDREventSMSC struct {
CreatedAt time.Time `json:"createdAt" gorm:"column:created_at;default:CURRENT_TIMESTAMP"` CreatedAt time.Time `json:"createdAt" gorm:"column:created_at;default:CURRENT_TIMESTAMP"`
} }
// TableName 表名称
func (*CDREventSMSC) TableName() string {
return "cdr_event_smsc"
}
// CDREventSMSCQuery CDR会话对象SMSC查询参数结构体 // CDREventSMSCQuery CDR会话对象SMSC查询参数结构体
type CDREventSMSCQuery struct { type CDREventSMSCQuery struct {
NeType string `json:"neType" form:"neType" binding:"required"` // 网元类型SMSC NeType string `json:"neType" form:"neType" binding:"required"` // 网元类型SMSC

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

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

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

@@ -6,184 +6,110 @@ import (
"be.ems/src/framework/datasource" "be.ems/src/framework/datasource"
"be.ems/src/framework/logger" "be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model" "be.ems/src/modules/network_data/model"
) )
// 实例化数据层 CDREventIMS 结构体 // 实例化数据层 CDREventIMS 结构体
var NewCDREventIMS = &CDREventIMS{ var NewCDREventIMS = &CDREventIMS{}
selectSql: `select id, ne_type, ne_name, rm_uid, timestamp, cdr_json, created_at from cdr_event_ims`,
resultMap: map[string]string{ // CDREventIMS CDR会话事件 数据层处理
"id": "ID", type CDREventIMS struct{}
"ne_type": "NeType",
"ne_name": "NeName",
"rm_uid": "RmUID",
"timestamp": "Timestamp",
"cdr_json": "CDRJSONStr",
"created_at": "CreatedAt",
},
}
// CDREventIMS CDR会话事件IMS 数据层处理 // SelectByPage 分页查询集合
type CDREventIMS struct { func (r CDREventIMS) SelectByPage(querys model.CDREventIMSQuery) ([]model.CDREventIMS, int64) {
// 查询视图对象SQL tx := datasource.DB("").Model(&model.CDREventIMS{})
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 != "" { if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?") tx = tx.Where("ne_type = ?", querys.NeType)
params = append(params, querys.NeType)
} }
if querys.RmUID != "" { if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?") tx = tx.Where("rm_uid = ?", querys.RmUID)
params = append(params, querys.RmUID)
} }
if querys.StartTime != "" { if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?") startTime := querys.StartTime
if len(querys.StartTime) == 13 { if len(startTime) == 13 {
querys.StartTime = querys.StartTime[:10] startTime = startTime[:10]
} }
params = append(params, querys.StartTime) tx = tx.Where("timestamp >= ?", startTime)
} }
if querys.EndTime != "" { if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?") endTime := querys.EndTime
if len(querys.EndTime) == 13 { if len(endTime) == 13 {
querys.EndTime = querys.EndTime[:10] endTime = endTime[:10]
} }
params = append(params, querys.EndTime) tx = tx.Where("timestamp <= ?", endTime)
} }
if querys.CallerParty != "" { if querys.CallerParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.callerParty') = ?") tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') = ?", querys.CallerParty)
params = append(params, querys.CallerParty)
} }
if querys.CalledParty != "" { if querys.CalledParty != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.calledParty') = ?") tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') = ?", querys.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 != "" { if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",") recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string var queryStrArr []string
for _, recordType := range recordTypes { for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?") queryStrArr = append(queryStrArr, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') = '%s'", recordType))
params = append(params, recordType)
} }
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR "))) tx = tx.Where(fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
} }
// 构建查询条件语句 // 查询结果
whereSql := "" var total int64 = 0
if len(conditions) > 0 { rows := []model.CDREventIMS{}
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{ // 查询数量为0直接返回
"total": 0, if err := tx.Count(&total).Error; err != nil || total <= 0 {
"rows": []model.CDREventIMS{}, return rows, total
} }
// 查询数量 长度为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 != "" { if querys.SortField != "" {
sortSql := querys.SortField sortField := querys.SortField
if querys.SortOrder != "" { if querys.SortOrder == "desc" {
if querys.SortOrder == "desc" { sortField = sortField + " desc"
sortSql += " desc "
} else {
sortSql += " asc "
}
} }
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql) tx = tx.Order(sortField)
} }
// 查询数据 // 查询数据分页
querySql := r.selectSql + whereSql + orderSql + pageSql pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
results, err := datasource.RawDB("", querySql, params) tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil { if err != nil {
logger.Errorf("query err => %v", err) logger.Errorf("query find err => %v", err.Error())
return rows, total
} }
return rows, total
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
} }
// SelectByIds 通过ID查询 // SelectByIds 通过ID查询
func (r *CDREventIMS) SelectByIds(cdrIds []string) []model.CDREventIMS { func (r *CDREventIMS) SelectByIds(ids []string) []model.CDREventIMS {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) rows := []model.CDREventIMS{}
querySql := r.selectSql + " where id in (" + placeholder + ")" if len(ids) <= 0 {
parameters := repo.ConvertIdsSlice(cdrIds) return rows
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventIMS{}
} }
// 转换实体 tx := datasource.DB("").Model(&model.CDREventIMS{})
return r.convertResultRows(results) // 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
} }
// DeleteByIds 批量删除信息 // DeleteByIds 批量删除信息
func (r *CDREventIMS) DeleteByIds(cdrIds []string) int64 { func (r *CDREventIMS) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) if len(ids) <= 0 {
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 0
} }
return results tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventIMS{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
} }

17
src/modules/network_data/repository/cdr_event_sgwc.go
View File

@@ -36,11 +36,11 @@ func (r CDREventSGWC) SelectByPage(querys model.CDREventSGWCQuery) ([]model.CDRE
} }
tx = tx.Where("timestamp <= ?", endTime) tx = tx.Where("timestamp <= ?", endTime)
} }
if querys.RecordType != "" { if querys.IMSI != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.recordType') = ?", querys.RecordType) tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedIMSI') = ?", querys.IMSI)
} }
if querys.SubscriberID != "" { if querys.MSISDN != "" {
tx = tx.Where("JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?", querys.SubscriberID) tx = tx.Where("JSON_EXTRACT(cdr_json, '$.servedMSISDN') = ?", querys.MSISDN)
} }
// 查询结果 // 查询结果
@@ -52,6 +52,15 @@ func (r CDREventSGWC) SelectByPage(querys model.CDREventSGWCQuery) ([]model.CDRE
return rows, total return rows, total
} }
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页 // 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize) pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum) tx = tx.Limit(pageSize).Offset(pageSize * pageNum)

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

@@ -1,170 +1,103 @@
package repository package repository
import ( import (
"fmt"
"strings"
"be.ems/src/framework/datasource" "be.ems/src/framework/datasource"
"be.ems/src/framework/logger" "be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model" "be.ems/src/modules/network_data/model"
) )
// 实例化数据层 CDREventSMF 结构体 // 实例化数据层 CDREventSMF 结构体
var NewCDREventSMF = &CDREventSMF{ var NewCDREventSMF = &CDREventSMF{}
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",
},
}
// CDREventSMF CDR会话事件 数据层处理 // CDREventSMF CDR会话事件 数据层处理
type CDREventSMF struct { type CDREventSMF struct{}
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组 // SelectByPage 分页查询集合
func (r *CDREventSMF) convertResultRows(rows []map[string]any) []model.CDREventSMF { func (r CDREventSMF) SelectByPage(querys model.CDREventSMFQuery) ([]model.CDREventSMF, int64) {
arr := make([]model.CDREventSMF, 0) tx := datasource.DB("").Model(&model.CDREventSMF{})
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 != "" { if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?") tx = tx.Where("ne_type = ?", querys.NeType)
params = append(params, querys.NeType)
} }
if querys.RmUID != "" { if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?") tx = tx.Where("rm_uid = ?", querys.RmUID)
params = append(params, querys.RmUID)
} }
if querys.StartTime != "" { if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?") startTime := querys.StartTime
if len(querys.StartTime) == 13 { if len(startTime) == 13 {
querys.StartTime = querys.StartTime[:10] startTime = startTime[:10]
} }
params = append(params, querys.StartTime) tx = tx.Where("timestamp >= ?", startTime)
} }
if querys.EndTime != "" { if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?") endTime := querys.EndTime
if len(querys.EndTime) == 13 { if len(endTime) == 13 {
querys.EndTime = querys.EndTime[:10] endTime = endTime[:10]
} }
params = append(params, querys.EndTime) tx = tx.Where("timestamp <= ?", endTime)
} }
if querys.RecordType != "" { if querys.RecordType != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.recordType') = ?") tx = tx.Where("JSON_EXTRACT(cdr_json, '$.recordType') = ?", querys.RecordType)
params = append(params, querys.RecordType)
} }
if querys.SubscriberID != "" { if querys.SubscriberID != "" {
conditions = append(conditions, "JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?") tx = tx.Where("JSON_EXTRACT(cdr_json, '$.subscriberIdentifier.subscriptionIDData') = ?", querys.SubscriberID)
params = append(params, querys.SubscriberID)
} }
// 构建查询条件语句 // 查询结果
whereSql := "" var total int64 = 0
if len(conditions) > 0 { rows := []model.CDREventSMF{}
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{ // 查询数量为0直接返回
"total": 0, if err := tx.Count(&total).Error; err != nil || total <= 0 {
"rows": []model.CDREventSMF{}, return rows, total
} }
// 查询数量 长度为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 != "" { if querys.SortField != "" {
sortSql := querys.SortField sortField := querys.SortField
if querys.SortOrder != "" { if querys.SortOrder == "desc" {
if querys.SortOrder == "desc" { sortField = sortField + " desc"
sortSql += " desc "
} else {
sortSql += " asc "
}
} }
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql) tx = tx.Order(sortField)
} }
// 查询数据 // 查询数据分页
querySql := r.selectSql + whereSql + orderSql + pageSql pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
results, err := datasource.RawDB("", querySql, params) tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil { if err != nil {
logger.Errorf("query err => %v", err) logger.Errorf("query find err => %v", err.Error())
return rows, total
} }
return rows, total
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
} }
// SelectByIds 通过ID查询 // SelectByIds 通过ID查询
func (r *CDREventSMF) SelectByIds(cdrIds []string) []model.CDREventSMF { func (r *CDREventSMF) SelectByIds(ids []string) []model.CDREventSMF {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) rows := []model.CDREventSMF{}
querySql := r.selectSql + " where id in (" + placeholder + ")" if len(ids) <= 0 {
parameters := repo.ConvertIdsSlice(cdrIds) return rows
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMF{}
} }
// 转换实体 tx := datasource.DB("").Model(&model.CDREventSMF{})
return r.convertResultRows(results) // 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
} }
// DeleteByIds 批量删除信息 // DeleteByIds 批量删除信息
func (r *CDREventSMF) DeleteByIds(cdrIds []string) int64 { func (r *CDREventSMF) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) if len(ids) <= 0 {
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 0
} }
return results tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventSMF{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
} }

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

@@ -6,176 +6,110 @@ import (
"be.ems/src/framework/datasource" "be.ems/src/framework/datasource"
"be.ems/src/framework/logger" "be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/network_data/model" "be.ems/src/modules/network_data/model"
) )
// 实例化数据层 CDREventSMSC 结构体 // 实例化数据层 CDREventSMSC 结构体
var NewCDREventSMSC = &CDREventSMSC{ var NewCDREventSMSC = &CDREventSMSC{}
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",
},
}
// CDREventSMSC CDR会话事件 数据层处理 // CDREventSMSC CDR会话事件 数据层处理
type CDREventSMSC struct { type CDREventSMSC struct{}
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组 // SelectByPage 分页查询集合
func (r *CDREventSMSC) convertResultRows(rows []map[string]any) []model.CDREventSMSC { func (r CDREventSMSC) SelectByPage(querys model.CDREventSMSCQuery) ([]model.CDREventSMSC, int64) {
arr := make([]model.CDREventSMSC, 0) tx := datasource.DB("").Model(&model.CDREventSMSC{})
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 != "" { if querys.NeType != "" {
conditions = append(conditions, "ne_type = ?") tx = tx.Where("ne_type = ?", querys.NeType)
params = append(params, querys.NeType)
} }
if querys.RmUID != "" { if querys.RmUID != "" {
conditions = append(conditions, "rm_uid = ?") tx = tx.Where("rm_uid = ?", querys.RmUID)
params = append(params, querys.RmUID)
} }
if querys.StartTime != "" { if querys.StartTime != "" {
conditions = append(conditions, "timestamp >= ?") startTime := querys.StartTime
if len(querys.StartTime) == 13 { if len(startTime) == 13 {
querys.StartTime = querys.StartTime[:10] startTime = startTime[:10]
} }
params = append(params, querys.StartTime) tx = tx.Where("timestamp >= ?", startTime)
} }
if querys.EndTime != "" { if querys.EndTime != "" {
conditions = append(conditions, "timestamp <= ?") endTime := querys.EndTime
if len(querys.EndTime) == 13 { if len(endTime) == 13 {
querys.EndTime = querys.EndTime[:10] endTime = endTime[:10]
} }
params = append(params, querys.EndTime) tx = tx.Where("timestamp <= ?", endTime)
} }
// MySQL8支持的 if querys.CallerParty != "" {
// if querys.RecordType != "" { tx = tx.Where("JSON_EXTRACT(cdr_json, '$.callerParty') = ?", querys.CallerParty)
// recordTypes := strings.Split(querys.RecordType, ",") }
// placeholder := repo.KeyPlaceholderByQuery(len(recordTypes)) if querys.CalledParty != "" {
// conditions = append(conditions, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') in (%s)", placeholder)) tx = tx.Where("JSON_EXTRACT(cdr_json, '$.calledParty') = ?", querys.CalledParty)
// for _, recordType := range recordTypes { }
// params = append(params, recordType)
// }
// }
// Mariadb不支持json in查询改or
if querys.RecordType != "" { if querys.RecordType != "" {
recordTypes := strings.Split(querys.RecordType, ",") recordTypes := strings.Split(querys.RecordType, ",")
var queryStrArr []string var queryStrArr []string
for _, recordType := range recordTypes { for _, recordType := range recordTypes {
queryStrArr = append(queryStrArr, "JSON_EXTRACT(cdr_json, '$.recordType') = ?") queryStrArr = append(queryStrArr, fmt.Sprintf("JSON_EXTRACT(cdr_json, '$.recordType') = '%s'", recordType))
params = append(params, recordType)
} }
conditions = append(conditions, fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR "))) tx = tx.Where(fmt.Sprintf("( %s )", strings.Join(queryStrArr, " OR ")))
} }
// 构建查询条件语句 // 查询结果
whereSql := "" var total int64 = 0
if len(conditions) > 0 { rows := []model.CDREventSMSC{}
whereSql += " where " + strings.Join(conditions, " and ")
}
result := map[string]any{ // 查询数量为0直接返回
"total": 0, if err := tx.Count(&total).Error; err != nil || total <= 0 {
"rows": []model.CDREventSMSC{}, return rows, total
} }
// 查询数量 长度为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 != "" { if querys.SortField != "" {
sortSql := querys.SortField sortField := querys.SortField
if querys.SortOrder != "" { if querys.SortOrder == "desc" {
if querys.SortOrder == "desc" { sortField = sortField + " desc"
sortSql += " desc "
} else {
sortSql += " asc "
}
} }
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql) tx = tx.Order(sortField)
} }
// 查询数据 // 查询数据分页
querySql := r.selectSql + whereSql + orderSql + pageSql pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
results, err := datasource.RawDB("", querySql, params) tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil { if err != nil {
logger.Errorf("query err => %v", err) logger.Errorf("query find err => %v", err.Error())
return rows, total
} }
return rows, total
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
} }
// SelectByIds 通过ID查询 // SelectByIds 通过ID查询
func (r *CDREventSMSC) SelectByIds(cdrIds []string) []model.CDREventSMSC { func (r *CDREventSMSC) SelectByIds(ids []string) []model.CDREventSMSC {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) rows := []model.CDREventSMSC{}
querySql := r.selectSql + " where id in (" + placeholder + ")" if len(ids) <= 0 {
parameters := repo.ConvertIdsSlice(cdrIds) return rows
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.CDREventSMSC{}
} }
// 转换实体 tx := datasource.DB("").Model(&model.CDREventSMSC{})
return r.convertResultRows(results) // 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
} }
// DeleteByIds 批量删除信息 // DeleteByIds 批量删除信息
func (r *CDREventSMSC) DeleteByIds(cdrIds []string) int64 { func (r *CDREventSMSC) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(cdrIds)) if len(ids) <= 0 {
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 0
} }
return results tx := datasource.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.CDREventSMSC{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
} }

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

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

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

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

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

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

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

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