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

feat: 更新多个模块以支持新的数据结构和日志格式

Browse Source
This commit is contained in:
TsMask
2025-02-20 10:08:27 +08:00
parent 045a2b6b01
commit f3c33b31ac
272 changed files with 13246 additions and 15885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/modules/trace/controller/packet.go
View File

@@ -1,12 +1,14 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo/result"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 PacketController 结构体
@@ -26,85 +28,89 @@ type PacketController struct {
// GET /devices
func (s *PacketController) Devices(c *gin.Context) {
data := s.packetService.NetworkDevices()
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}
// 信令跟踪开始
//
// POST /start
func (s *PacketController) Start(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
TaskNo string `json:"taskNo" binding:"required"` // 任务编号
Device string `json:"device" binding:"required"` // 网卡设备
Filter string `json:"filter" ` // 过滤表达式（port 33030 or 33040）
OutputPCAP bool `json:"outputPCAP" ` // 输出PCAP文件 （默认false）
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
msg, err := s.packetService.LiveStart(body.TaskNo, body.Device, body.Filter, body.OutputPCAP)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.OkData(msg))
c.JSON(200, resp.OkData(msg))
}
// 信令跟踪结束
//
// POST /stop
func (s *PacketController) Stop(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
TaskNo string `json:"taskNo" binding:"required"` // 任务编号
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if err := s.packetService.LiveStop(body.TaskNo); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}
// 信令跟踪过滤
//
// PUT /filter
func (s *PacketController) Filter(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
TaskNo string `json:"taskNo" binding:"required"` // 任务编号
Expr string `json:"expr" ` // 过滤表达式（port 33030 or 33040）
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if err := s.packetService.LiveFilter(body.TaskNo, body.Expr); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}
// 信令跟踪续期保活
//
// PUT /keep-alive
func (s *PacketController) KeepAlive(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
TaskNo string `json:"taskNo" binding:"required"` // 任务编号
Duration int `json:"duration" ` // 服务失效的时间，默认设置为120秒
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
@@ -114,8 +120,8 @@ func (s *PacketController) KeepAlive(c *gin.Context) {
}
if err := s.packetService.LiveTimeout(body.TaskNo, body.Duration); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}

33
src/modules/trace/controller/tcpdump.go
View File

@@ -1,9 +1,11 @@
package controller
import (
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo/result"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"
@@ -35,7 +37,7 @@ type TCPdumpController struct {
// @Description Network Element Capture Packet PACP Start
// @Router /trace/tcpdump/start [post]
func (s *TCPdumpController) DumpStart(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
NeType string `json:"neType" binding:"required"` // 网元类型
NeId string `json:"neId" binding:"required"` // 网元ID
@@ -43,16 +45,17 @@ func (s *TCPdumpController) DumpStart(c *gin.Context) {
}
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
taskCode, err := s.tcpdumpService.DumpStart(body.NeType, body.NeId, body.Cmd)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.OkData(taskCode))
c.JSON(200, resp.OkData(taskCode))
}
// 网元抓包PACP 结束
@@ -69,7 +72,7 @@ func (s *TCPdumpController) DumpStart(c *gin.Context) {
// @Description Network Element Capture Packet PACP Stop
// @Router /trace/tcpdump/stop [post]
func (s *TCPdumpController) DumpStop(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
NeType string `json:"neType" binding:"required"` // 网元类型
NeId string `json:"neId" binding:"required"` // 网元ID
@@ -77,16 +80,17 @@ func (s *TCPdumpController) DumpStop(c *gin.Context) {
}
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
logFiles, err := s.tcpdumpService.DumpStop(body.NeType, body.NeId, body.TaskCode)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.OkData(logFiles))
c.JSON(200, resp.OkData(logFiles))
}
// UPF标准版内部抓包
@@ -103,7 +107,7 @@ func (s *TCPdumpController) DumpStop(c *gin.Context) {
// @Description UPF Standard Edition Internal Grab Bag
// @Router /trace/tcpdump/upf [post]
func (s *TCPdumpController) UPFTrace(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
NeType string `json:"neType" binding:"required"` // 网元类型
NeId string `json:"neId" binding:"required"` // 网元ID
@@ -111,14 +115,15 @@ func (s *TCPdumpController) UPFTrace(c *gin.Context) {
}
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
msg, err := s.tcpdumpService.UPFTrace(body.NeType, body.NeId, body.Cmd)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.OkData(msg))
c.JSON(200, resp.OkData(msg))
}

46
src/modules/trace/controller/trace_data.go
View File

@@ -1,13 +1,12 @@
package controller
import (
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"
)
@@ -20,43 +19,42 @@ var NewTraceData = &TraceDataController{
//
// PATH /data
type TraceDataController struct {
// 跟踪_数据信息服务
traceDataService *traceService.TraceData
traceDataService *traceService.TraceData // 跟踪_数据信息服务
}
// 跟踪任务数据列表
//
// GET /list
func (s *TraceDataController) List(c *gin.Context) {
query := ctx.QueryMap(c)
// 查询数据
data := s.traceDataService.SelectPage(query)
c.JSON(200, result.Ok(data))
query := reqctx.QueryMap(c)
rows, total := s.traceDataService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 跟踪任务数据删除
//
// DELETE /:ids
// DELETE /:id
func (s *TraceDataController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
rowIds := c.Param("ids")
if rowIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(rowIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.traceDataService.DeleteByIds(uniqueIDs)
rows, err := s.traceDataService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}

102
src/modules/trace/controller/trace_task.go
View File

@@ -4,16 +4,15 @@ import (
"fmt"
"path/filepath"
"runtime"
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/trace/model"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 TraceTaskController 结构体
@@ -33,116 +32,125 @@ type TraceTaskController struct {
//
// GET /list
func (s *TraceTaskController) List(c *gin.Context) {
query := ctx.QueryMap(c)
// 查询数据
data := s.traceTaskService.SelectPage(query)
c.JSON(200, result.Ok(data))
query := reqctx.QueryMap(c)
rows, total := s.traceTaskService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 跟踪任务信息
//
// GET /:id
func (s *TraceTaskController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
id := parse.Number(c.Param("id"))
if id <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: id is empty"))
return
}
data := s.traceTaskService.SelectById(id)
data := s.traceTaskService.FindById(id)
if data.ID == id {
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 跟踪任务新增
//
// POST /
func (s *TraceTaskController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.TraceTask
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.ID > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: id not is empty"))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
body.CreateBy = reqctx.LoginUserToUserName(c)
if err = s.traceTaskService.Insert(body); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}
// 跟踪任务修改
//
// PUT /
func (s *TraceTaskController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.TraceTask
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
err := c.ShouldBindBodyWithJSON(&body)
if err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.ID == 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: id is empty"))
return
}
// 检查是否存在
taskInfo := s.traceTaskService.SelectById(body.ID)
taskInfo := s.traceTaskService.FindById(body.ID)
if taskInfo.ID != body.ID {
// 没有可访问任务信息数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "task.noData")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "task.noData")))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
body.UpdateBy = reqctx.LoginUserToUserName(c)
if err = s.traceTaskService.Update(body); err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}
// 跟踪任务删除
//
// DELETE /:ids
// DELETE /:id
func (s *TraceTaskController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
rowIds := c.Param("ids")
if rowIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(rowIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.traceTaskService.DeleteByIds(uniqueIDs)
rows, err := s.traceTaskService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 跟踪任务文件
//
// GET /filePull
func (s *TraceTaskController) FilePull(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var querys struct {
TraceId string `form:"traceId" binding:"required"`
}
if err := c.ShouldBindQuery(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}

121
src/modules/trace/controller/trace_task_hlr.go
View File

@@ -5,18 +5,17 @@ import (
"os"
"path/filepath"
"runtime"
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/generate"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
neService "be.ems/src/modules/network_element/service"
"be.ems/src/modules/trace/model"
traceService "be.ems/src/modules/trace/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 TraceTaskHlrController 结构体
@@ -37,49 +36,50 @@ type TraceTaskHlrController struct {
//
// GET /list
func (s *TraceTaskHlrController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys model.TraceTaskHlrQuery
if err := c.ShouldBindQuery(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
var query model.TraceTaskHlrQuery
if err := c.ShouldBindQuery(&query); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 查询数据
data := s.traceTaskHlrService.SelectPage(querys)
c.JSON(200, result.Ok(data))
rows, total := s.traceTaskHlrService.FindByPage(query)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 跟踪任务删除
//
// DELETE /:ids
// DELETE /:id
func (s *TraceTaskHlrController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
rowIds := c.Param("ids")
if rowIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
id := c.Param("id")
if id == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: id is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(rowIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(id, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.traceTaskHlrService.DeleteByIds(uniqueIDs)
rows, err := s.traceTaskHlrService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 跟踪任务创建
//
// POST /start
func (s *TraceTaskHlrController) Start(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
IMSI string `json:"imsi"` // IMSI
MSISDN string `json:"msisdn"` // MSISDN
@@ -87,13 +87,13 @@ func (s *TraceTaskHlrController) Start(c *gin.Context) {
EndTime int64 `json:"endTime"` // 结束时间
Remark string `json:"remark"` // 备注说明
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
if body.IMSI == "" && body.MSISDN == "" {
c.JSON(400, result.CodeMsg(400, "imsi amd msisdn is empty"))
c.JSON(400, resp.CodeMsg(400, "imsi amd msisdn is empty"))
return
}
@@ -103,88 +103,88 @@ func (s *TraceTaskHlrController) Start(c *gin.Context) {
StartTime: body.StartTime,
EndTime: body.EndTime,
Remark: body.Remark,
CreateBy: ctx.LoginUserToUserName(c),
CreateBy: reqctx.LoginUserToUserName(c),
}
id, err := s.traceTaskHlrService.Start(task)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(id))
c.JSON(200, resp.OkData(id))
}
// 跟踪任务停止
//
// POST /stop
func (s *TraceTaskHlrController) Stop(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
ID string `json:"id" binding:"required"` // 任务ID
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
c.JSON(400, resp.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 处理字符转id数组后去重
ids := strings.Split(body.ID, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(body.ID, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
errArr := []map[string]any{}
for _, id := range uniqueIDs {
task := s.traceTaskHlrService.SelectById(id)
if task.ID != id || task.ID == "" {
for _, id := range ids {
task := s.traceTaskHlrService.FindById(id)
if task.ID == 0 || task.ID != id {
errArr = append(errArr, map[string]any{"id": id, "err": "task not found"})
continue
}
task.UpdateBy = ctx.LoginUserToUserName(c)
task.UpdateBy = reqctx.LoginUserToUserName(c)
err := s.traceTaskHlrService.Stop(task)
if err != nil {
errArr = append(errArr, map[string]any{"id": id, "err": err.Error()})
continue
}
}
c.JSON(200, result.OkData(errArr))
c.JSON(200, resp.OkData(errArr))
}
// 跟踪任务文件
//
// POST /file
func (s *TraceTaskHlrController) File(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var body struct {
ID string `json:"id" binding:"required"` // 任务ID
ID int64 `json:"id" binding:"required"` // 任务ID
Dir string `json:"dir" binding:"required"` // 网元文件目录
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
task := s.traceTaskHlrService.SelectById(body.ID)
if task.ID != body.ID || task.ID == "" {
c.JSON(200, result.CodeMsg(400, "task not found"))
task := s.traceTaskHlrService.FindById(body.ID)
if task.ID == 0 || task.ID != body.ID {
c.JSON(200, resp.CodeMsg(400, "task not found"))
return
}
list, err := s.traceTaskHlrService.File(task.TraceId, body.Dir)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(list))
c.JSON(200, resp.OkData(list))
}
// 跟踪任务文件从网元到本地
//
// GET /filePull
func (s *TraceTaskHlrController) FilePull(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var querys struct {
NeType string `form:"neType" binding:"required"`
NeID string `form:"neId" binding:"required"`
@@ -193,28 +193,29 @@ func (s *TraceTaskHlrController) FilePull(c *gin.Context) {
DelTemp bool `form:"delTemp"` // 删除本地临时文件
}
if err := c.ShouldBindQuery(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 查询网元获取IP
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(querys.NeType, querys.NeID)
neInfo := s.neInfoService.FindByNeTypeAndNeID(querys.NeType, querys.NeID)
if neInfo.NeId != querys.NeID || neInfo.IP == "" {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.noNEInfo")))
return
}
// 网元主机的SSH客户端
sshClient, err := s.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer sshClient.Close()
// 网元主机的SSH客户端进行文件传输
sftpClient, err := sshClient.NewClientSFTP()
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
defer sftpClient.Close()
@@ -227,7 +228,7 @@ func (s *TraceTaskHlrController) FilePull(c *gin.Context) {
}
// 复制到本地
if err = sftpClient.CopyFileRemoteToLocal(nePath, localFilePath); err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

26
src/modules/trace/model/trace_data.go
View File

@@ -2,19 +2,19 @@ package model
// TraceData 跟踪_数据 trace_data
type TraceData struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
TaskId int64 `json:"taskId" gorm:"task_id"` // 任务ID
IMSI string `json:"imsi" gorm:"imsi"`
MSISDN string `json:"msisdn" gorm:"msisdn"` // 可能存在
SrcAddr string `json:"srcAddr" gorm:"src_addr"` // 源地址带端口
DstAddr string `json:"dstAddr" gorm:"dst_addr"` // 目标地址带端口
IfType int64 `json:"ifType" gorm:"if_type"` // 接口类型，未分类
MsgType int64 `json:"msgType" gorm:"msg_type"`
MsgDirect int64 `json:"msgDirect" gorm:"msg_direct"`
Length int64 `json:"length" gorm:"length"` // 去除头后的原始数据byte长度
Timestamp int64 `json:"timestamp" gorm:"timestamp"` // 毫秒
RawMsg string `json:"rawMsg" gorm:"raw_msg"` // 去除头后的原始数据byteBase64
DecMsg string `json:"decMsg" gorm:"dec_msg"` // TCP内容消息
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
TaskId int64 `json:"taskId" gorm:"column:task_id"` // 任务ID
IMSI string `json:"imsi" gorm:"column:imsi"`
MSISDN string `json:"msisdn" gorm:"column:msisdn"` // 可能存在
SrcAddr string `json:"srcAddr" gorm:"column:src_addr"` // 源地址带端口
DstAddr string `json:"dstAddr" gorm:"column:dst_addr"` // 目标地址带端口
IfType int64 `json:"ifType" gorm:"column:if_type"` // 接口类型，未分类
MsgType int64 `json:"msgType" gorm:"column:msg_type"`
MsgDirect int64 `json:"msgDirect" gorm:"column:msg_direct"`
Length int64 `json:"length" gorm:"column:length"` // 去除头后的原始数据byte长度
Timestamp int64 `json:"timestamp" gorm:"column:timestamp"` // 毫秒
RawMsg string `json:"rawMsg" gorm:"column:raw_msg"` // 去除头后的原始数据byteBase64
DecMsg string `json:"decMsg" gorm:"column:dec_msg"` // TCP内容消息
}
// TableName 表名称

42
src/modules/trace/model/trace_task.go
View File

@@ -2,27 +2,27 @@ package model
// TraceTask 跟踪_任务
type TraceTask struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 跟踪任务ID
TraceId string `json:"traceId" gorm:"trace_id"` // 任务编号
TraceType string `json:"traceType" gorm:"trace_type"` // 1-Interface,2-Device,3-User
StartTime int64 `json:"startTime" gorm:"start_time"` // 开始时间 毫秒
EndTime int64 `json:"endTime" gorm:"end_time"` // 结束时间 毫秒
Interfaces string `json:"interfaces" gorm:"interfaces"` // 接口跟踪必须 例如 N8,N10
IMSI string `json:"imsi" gorm:"imsi"` // 用户跟踪必须
MSISDN string `json:"msisdn" gorm:"msisdn"` // 用户跟踪可选
UeIp string `json:"ueIp" gorm:"ue_ip"` // 设备跟踪必须 IP
SrcIp string `json:"srcIp" gorm:"src_ip"` // 源地址IP
DstIp string `json:"dstIp" gorm:"dst_ip"` // 目标地址IP
SignalPort int64 `json:"signalPort" gorm:"signal_port"` // 地址IP端口
CreateBy string `json:"createBy" gorm:"create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"update_time"` // 更新时间
Remark string `json:"remark" gorm:"remark"` // 备注
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeId string `json:"neId" gorm:"ne_id"` // 网元ID
NotifyUrl string `json:"notifyUrl" gorm:"notify_url"` // 信息数据通知回调地址UDP 例如udp:192.168.5.58:29500
FetchMsg string `json:"fetchMsg" gorm:"fetch_msg"` // 任务下发请求响应消息
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 跟踪任务ID
TraceId string `json:"traceId" gorm:"column:trace_id"` // 任务编号
TraceType string `json:"traceType" gorm:"column:trace_type"` // 1-Interface,2-Device,3-User
StartTime int64 `json:"startTime" gorm:"column:start_time"` // 开始时间 毫秒
EndTime int64 `json:"endTime" gorm:"column:end_time"` // 结束时间 毫秒
Interfaces string `json:"interfaces" gorm:"column:interfaces"` // 接口跟踪必须 例如 N8,N10
IMSI string `json:"imsi" gorm:"column:imsi"` // 用户跟踪必须
MSISDN string `json:"msisdn" gorm:"column:msisdn"` // 用户跟踪可选
UeIp string `json:"ueIp" gorm:"column:ue_ip"` // 设备跟踪必须 IP
SrcIp string `json:"srcIp" gorm:"column:src_ip"` // 源地址IP
DstIp string `json:"dstIp" gorm:"column:dst_ip"` // 目标地址IP
SignalPort int64 `json:"signalPort" gorm:"column:signal_port"` // 地址IP端口
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeId string `json:"neId" gorm:"column:ne_id"` // 网元ID
NotifyUrl string `json:"notifyUrl" gorm:"column:notify_url"` // 信息数据通知回调地址UDP 例如udp:192.168.5.58:29500
FetchMsg string `json:"fetchMsg" gorm:"column:fetch_msg"` // 任务下发请求响应消息
}
// TableName 表名称

26
src/modules/trace/model/trace_task_hlr.go
View File

@@ -2,19 +2,19 @@ package model
// TraceTaskHlr 跟踪_任务给HRL网元 trace_task_hlr
type TraceTaskHlr struct {
ID string `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
TraceId string `json:"traceId" gorm:"trace_id"` // 任务编号
IMSI string `json:"imsi" gorm:"imsi"` // IMSI
MSISDN string `json:"msisdn" gorm:"msisdn"` // MSISDN
StartTime int64 `json:"startTime" gorm:"start_time"` // 开始时间
EndTime int64 `json:"endTime" gorm:"end_time"` // 结束时间
Status string `json:"status" gorm:"status"` // 任务状态（0停止 1进行）
Msg string `json:"msg" gorm:"msg"` // 任务信息
Remark string `json:"remark" gorm:"remark"` // 备注说明
CreateBy string `json:"createBy" gorm:"create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"update_time"` // 更新时间
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
TraceId string `json:"traceId" gorm:"column:trace_id"` // 任务编号
IMSI string `json:"imsi" gorm:"column:imsi"` // IMSI
MSISDN string `json:"msisdn" gorm:"column:msisdn"` // MSISDN
StartTime int64 `json:"startTime" gorm:"column:start_time"` // 开始时间
EndTime int64 `json:"endTime" gorm:"column:end_time"` // 结束时间
Status string `json:"status" gorm:"column:status"` // 任务状态（0停止 1进行）
Msg string `json:"msg" gorm:"column:msg"` // 任务信息
Remark string `json:"remark" gorm:"column:remark"` // 备注说明
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
}
// TableName 表名称

278
src/modules/trace/repository/trace_data.go
View File

@@ -1,246 +1,102 @@
package repository
import (
"strings"
"fmt"
"be.ems/src/framework/datasource"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/trace/model"
)
// 实例化数据层 TraceData 结构体
var NewTraceData = &TraceData{
selectSql: `select id, task_id, imsi, msisdn, src_addr, dst_addr, if_type, msg_type, msg_direct, length, timestamp, raw_msg, dec_msg from trace_data`,
resultMap: map[string]string{
"id": "ID",
"task_id": "TaskId",
"imsi": "IMSI",
"msisdn": "MSISDN",
"src_addr": "SrcAddr",
"dst_addr": "DstAddr",
"if_type": "IfType",
"msg_type": "MsgType",
"msg_direct": "MsgDirect",
"length": "Length",
"timestamp": "Timestamp",
"raw_msg": "RawMsg",
"dec_msg": "DecMsg",
},
}
var NewTraceData = &TraceData{}
// CDREventIMSImpl 跟踪_任务给HRL网元 数据层处理
type TraceData struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type TraceData struct{}
// convertResultRows 将结果记录转实体结果组
func (r *TraceData) convertResultRows(rows []map[string]any) []model.TraceData {
arr := make([]model.TraceData, 0)
for _, row := range rows {
item := model.TraceData{}
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 *TraceData) SelectPage(query map[string]any) map[string]any {
// SelectByPage 分页查询集合
func (r TraceData) SelectByPage(query map[string]string) ([]model.TraceData, int64) {
tx := db.DB("").Model(&model.TraceData{})
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["imsi"]; ok && v != "" {
conditions = append(conditions, "imsi like concat(?, '%')")
params = append(params, v)
tx = tx.Where("imsi like concat(?, '%')", v)
}
if v, ok := query["msisdn"]; ok && v != "" {
conditions = append(conditions, "msisdn like concat(?, '%')")
params = append(params, v)
tx = tx.Where("msisdn like concat(?, '%')", v)
}
if v, ok := query["startTime"]; ok && v != "" {
conditions = append(conditions, "timestamp >= ?")
params = append(params, v)
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("timestamp >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("timestamp >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
conditions = append(conditions, "timestamp <= ?")
params = append(params, v)
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("timestamp <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("timestamp <= ?", v)
}
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
// 查询结果
var total int64 = 0
rows := []model.TraceData{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
result := map[string]any{
"total": 0,
"rows": []model.TraceData{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from trace_data"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("total err => %v", err)
return result
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
return rows, total
}
// SelectByIds 通过ID查询信息
func (r TraceData) SelectByIds(ids []int64) []model.TraceData {
rows := []model.TraceData{}
if len(ids) <= 0 {
return rows
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
tx := db.DB("").Model(&model.TraceData{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
return rows
}
// SelectList 根据实体查询
func (r *TraceData) SelectList(data model.TraceData) []model.TraceData {
// 查询条件拼接
var conditions []string
var params []any
if data.IMSI != "" {
conditions = append(conditions, "imsi = ?")
params = append(params, data.IMSI)
}
if data.MSISDN != "" {
conditions = append(conditions, "msisdn = ?")
params = append(params, data.MSISDN)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql + " order by id desc "
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
return r.convertResultRows(results)
}
// SelectByIds 通过ID查询
func (r *TraceData) SelectByIds(ids []string) []model.TraceData {
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.TraceData{}
}
// 转换实体
return r.convertResultRows(results)
}
// Insert 新增信息
func (r *TraceData) Insert(data model.TraceData) string {
// 参数拼接
params := make(map[string]any)
if data.TaskId > 0 {
params["task_id"] = data.TaskId
}
if data.IMSI != "" {
params["imsi"] = data.IMSI
}
if data.MSISDN != "" {
params["msisdn"] = data.MSISDN
}
if data.SrcAddr != "" {
params["src_addr"] = data.SrcAddr
}
if data.DstAddr != "" {
params["dst_addr"] = data.DstAddr
}
if data.IfType > -1 {
params["if_type"] = data.IfType
}
if data.MsgType > -1 {
params["msg_type"] = data.MsgType
}
if data.MsgDirect > -1 {
params["msg_direct"] = data.MsgDirect
}
if data.Length > 0 {
params["length"] = data.Length
}
if data.Timestamp > 0 {
params["timestamp"] = data.Timestamp
}
if data.RawMsg != "" {
params["raw_msg"] = data.RawMsg
}
if data.DecMsg != "" {
params["dec_msg"] = data.DecMsg
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into trace_data (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// Insert 新增信息 返回新增数据ID
func (r TraceData) Insert(param model.TraceData) int64 {
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// DeleteByIds 批量删除信息
func (r *TraceData) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
sql := "delete from trace_data where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return results
return param.ID
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r TraceData) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.TraceData{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

403
src/modules/trace/repository/trace_task.go
View File

@@ -1,358 +1,147 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/trace/model"
)
// 实例化数据层 TraceTask 结构体
var NewTraceTask = &TraceTask{
selectSql: `select id, trace_id, trace_type, start_time, end_time,
interfaces, imsi, msisdn,
ue_ip, src_ip, dst_ip, signal_port,
create_by, create_time, update_by, update_time, remark,
ne_type, ne_id, notify_url, fetch_msg
from trace_task`,
resultMap: map[string]string{
"id": "ID",
"trace_id": "TraceId",
"trace_type": "TraceType",
"start_time": "StartTime",
"end_time": "EndTime",
"interfaces": "Interfaces",
"imsi": "IMSI",
"msisdn": "MSISDN",
"ue_ip": "UeIp",
"src_ip": "SrcIp",
"dst_ip": "DstIp",
"signal_port": "SignalPort",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
"ne_type": "NeType",
"ne_id": "NeId",
"notify_url": "NotifyUrl",
"fetch_msg": "FetchMsg",
},
}
var NewTraceTask = &TraceTask{}
// TraceTask 跟踪_任务 数据层处理
type TraceTask struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type TraceTask struct{}
// convertResultRows 将结果记录转实体结果组
func (r *TraceTask) convertResultRows(rows []map[string]any) []model.TraceTask {
arr := make([]model.TraceTask, 0)
for _, row := range rows {
item := model.TraceTask{}
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 *TraceTask) SelectPage(query map[string]any) map[string]any {
// SelectByPage 分页查询集合
func (r TraceTask) SelectByPage(query map[string]string) ([]model.TraceTask, int64) {
tx := db.DB("").Model(&model.TraceTask{})
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["neType"]; ok && v != "" {
conditions = append(conditions, "ne_type = ?")
params = append(params, v)
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["imsi"]; ok && v != "" {
conditions = append(conditions, "imsi like concat(?, '%')")
params = append(params, v)
tx = tx.Where("imsi like concat(?, '%')", v)
}
if v, ok := query["msisdn"]; ok && v != "" {
conditions = append(conditions, "msisdn like concat(?, '%')")
params = append(params, v)
tx = tx.Where("msisdn like concat(?, '%')", v)
}
if v, ok := query["startTime"]; ok && v != "" {
conditions = append(conditions, "start_time >= ?")
params = append(params, v)
tx = tx.Where("start_time >= ?", v)
}
if v, ok := query["endTime"]; ok && v != "" {
conditions = append(conditions, "end_time <= ?")
params = append(params, v)
tx = tx.Where("end_time >= ?", v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
// 查询结果
var total int64 = 0
rows := []model.TraceTask{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
result := map[string]any{
"total": 0,
"rows": []model.TraceTask{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from trace_task"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
// 排序
orderSql := ""
if v, ok := query["sortField"]; ok && v != "" {
sortSql := v.(string)
sortSql := v
if v, ok := query["sortOrder"]; ok && v != "" {
if v.(string) == "desc" {
if v == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s ", sortSql)
tx.Order(sortSql)
}
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询信息
func (r TraceTask) SelectByIds(ids []int64) []model.TraceTask {
rows := []model.TraceTask{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.TraceTask{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
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
}
// SelectList 根据实体查询
func (r *TraceTask) SelectList(task model.TraceTask) []model.TraceTask {
// 查询条件拼接
var conditions []string
var params []any
if task.IMSI != "" {
conditions = append(conditions, "imsi = ?")
params = append(params, task.IMSI)
}
if task.SrcIp != "" {
conditions = append(conditions, "src_ip = ?")
params = append(params, task.SrcIp)
}
if task.DstIp != "" {
conditions = append(conditions, "dst_ip = ?")
params = append(params, task.DstIp)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql + " order by id desc "
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
return r.convertResultRows(results)
}
// SelectByIds 通过ID查询
func (r *TraceTask) SelectByIds(ids []string) []model.TraceTask {
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.TraceTask{}
}
// 转换实体
return r.convertResultRows(results)
}
// Insert 新增信息
func (r *TraceTask) Insert(task model.TraceTask) string {
// 参数拼接
params := make(map[string]any)
if task.TraceId != "" {
params["trace_id"] = task.TraceId
}
if task.TraceType != "" {
params["trace_type"] = task.TraceType
}
if task.StartTime > 0 {
params["start_time"] = task.StartTime
}
if task.EndTime > 0 {
params["end_time"] = task.EndTime
}
if task.Interfaces != "" {
params["interfaces"] = task.Interfaces
}
if task.IMSI != "" {
params["imsi"] = task.IMSI
}
if task.MSISDN != "" {
params["msisdn"] = task.MSISDN
}
if task.UeIp != "" {
params["ue_ip"] = task.UeIp
}
if task.SrcIp != "" {
params["src_ip"] = task.SrcIp
}
if task.DstIp != "" {
params["dst_ip"] = task.DstIp
}
if task.SignalPort != 0 {
params["signal_port"] = task.SignalPort
}
if task.NeType != "" {
params["ne_type"] = task.NeType
}
if task.NeId != "" {
params["ne_id"] = task.NeId
}
if task.NotifyUrl != "" {
params["notify_url"] = task.NotifyUrl
}
if task.FetchMsg != "" {
params["fetch_msg"] = task.FetchMsg
}
if task.Remark != "" {
params["remark"] = task.Remark
}
if task.CreateBy != "" {
params["create_by"] = task.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into trace_task (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// Update 修改信息
func (r *TraceTask) Update(task model.TraceTask) int64 {
// 参数拼接
params := make(map[string]any)
params["trace_id"] = task.TraceId
params["trace_type"] = task.TraceType
params["ne_type"] = task.NeType
params["ne_id"] = task.NeId
params["notify_url"] = task.NotifyUrl
params["start_time"] = task.StartTime
params["end_time"] = task.EndTime
params["fetch_msg"] = task.FetchMsg
params["remark"] = task.Remark
params["interfaces"] = task.Interfaces
params["imsi"] = task.IMSI
params["msisdn"] = task.MSISDN
params["ue_ip"] = task.UeIp
params["src_ip"] = task.SrcIp
params["dst_ip"] = task.DstIp
params["signal_port"] = task.SignalPort
if task.UpdateBy != "" {
params["update_by"] = task.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update trace_task set " + strings.Join(keys, ",") + " where id = ?"
// 执行更新
values = append(values, task.ID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *TraceTask) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
sql := "delete from trace_task where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
// Insert 新增信息 返回新增数据ID
func (r TraceTask) Insert(param model.TraceTask) int64 {
if param.CreateBy != "" {
ms := time.Now().UnixMilli()
param.UpdateBy = param.CreateBy
param.UpdateTime = ms
param.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return results
return param.ID
}
// Update 修改信息 返回受影响行数
func (r TraceTask) Update(param model.TraceTask) int64 {
if param.ID <= 0 {
return 0
}
if param.UpdateBy != "" {
param.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.TraceTask{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "create_by", "create_time")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r TraceTask) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.TraceTask{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// LastID 最后一条ID
func (r *TraceTask) LastID() int64 {
func (r TraceTask) LastID() int64 {
tx := db.DB("").Model(&model.TraceTask{})
// 查询数据
querySql := "SELECT id as 'str' FROM trace_task ORDER BY id DESC LIMIT 1"
results, err := datasource.RawDB("", querySql, nil)
if err != nil {
logger.Errorf("query err %v", err)
return 0
var id int64 = 0
if err := tx.Select("id").Order("id DESC").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
if len(results) > 0 {
return parse.Number(results[0]["str"])
}
return 0
return id
}

373
src/modules/trace/repository/trace_task_hlr.go
View File

@@ -2,315 +2,144 @@ package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/trace/model"
)
// 实例化数据层 TraceTaskHlr 结构体
var NewTraceTaskHlr = &TraceTaskHlr{
selectSql: `select id, trace_id, imsi, msisdn, start_time, end_time, status, msg, remark, create_by, create_time, update_by, update_time from trace_task_hlr`,
resultMap: map[string]string{
"id": "ID",
"trace_id": "TraceId",
"imsi": "IMSI",
"msisdn": "MSISDN",
"start_time": "StartTime",
"end_time": "EndTime",
"status": "Status",
"msg": "Msg",
"remark": "Remark",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
},
}
var NewTraceTaskHlr = &TraceTaskHlr{}
// TraceTaskHlr 跟踪_任务给HRL网元 数据层处理
type TraceTaskHlr struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
type TraceTaskHlr struct{}
// convertResultRows 将结果记录转实体结果组
func (r *TraceTaskHlr) convertResultRows(rows []map[string]any) []model.TraceTaskHlr {
arr := make([]model.TraceTaskHlr, 0)
for _, row := range rows {
item := model.TraceTaskHlr{}
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 *TraceTaskHlr) SelectPage(querys model.TraceTaskHlrQuery) map[string]any {
// SelectByPage 分页查询集合
func (r TraceTaskHlr) SelectByPage(query model.TraceTaskHlrQuery) ([]model.TraceTaskHlr, int64) {
tx := db.DB("").Model(&model.TraceTaskHlr{})
// 查询条件拼接
var conditions []string
var params []any
if querys.IMSI != "" {
conditions = append(conditions, "imsi like concat(?, '%')")
params = append(params, querys.IMSI)
if query.IMSI != "" {
tx = tx.Where("imsi like concat(?, '%')", query.IMSI)
}
if querys.MSISDN != "" {
conditions = append(conditions, "msisdn like concat(?, '%')")
params = append(params, querys.MSISDN)
if query.MSISDN != "" {
tx = tx.Where("msisdn like concat(?, '%')", query.MSISDN)
}
if querys.StartTime != "" && len(querys.StartTime) == 13 {
conditions = append(conditions, "start_time >= ?")
params = append(params, querys.StartTime)
if query.StartTime != "" && len(query.StartTime) == 13 {
tx = tx.Where("start_time >= ?", query.StartTime)
}
if querys.EndTime != "" && len(querys.EndTime) == 13 {
conditions = append(conditions, "end_time <= ?")
params = append(params, querys.EndTime)
if query.EndTime != "" && len(query.EndTime) == 13 {
tx = tx.Where("end_time >= ?", query.StartTime)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
// 查询结果
var total int64 = 0
rows := []model.TraceTaskHlr{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
result := map[string]any{
"total": 0,
"rows": []model.TraceTaskHlr{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from trace_task_hlr"
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)
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query.PageNum, query.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
if query.SortField != "" {
sortSql := query.SortField
if query.SortOrder != "" {
if query.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
tx.Order(fmt.Sprintf("id desc, %s ", sortSql))
}
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// SelectByIds 通过ID查询信息
func (r TraceTaskHlr) SelectByIds(ids []int64) []model.TraceTaskHlr {
rows := []model.TraceTaskHlr{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.TraceTaskHlr{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 查询数据
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
}
// SelectList 根据实体查询
func (r *TraceTaskHlr) SelectList(task model.TraceTaskHlr) []model.TraceTaskHlr {
// 查询条件拼接
var conditions []string
var params []any
if task.IMSI != "" {
conditions = append(conditions, "imsi = ?")
params = append(params, task.IMSI)
}
if task.MSISDN != "" {
conditions = append(conditions, "msisdn = ?")
params = append(params, task.MSISDN)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql + " order by id desc "
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
return r.convertResultRows(results)
}
// SelectByIds 通过ID查询
func (r *TraceTaskHlr) SelectByIds(ids []string) []model.TraceTaskHlr {
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.TraceTaskHlr{}
}
// 转换实体
return r.convertResultRows(results)
}
// Insert 新增信息
func (r *TraceTaskHlr) Insert(task model.TraceTaskHlr) string {
// 参数拼接
params := make(map[string]any)
if task.TraceId != "" {
params["trace_id"] = task.TraceId
}
if task.IMSI != "" {
params["imsi"] = task.IMSI
}
if task.MSISDN != "" {
params["msisdn"] = task.MSISDN
}
if task.StartTime != 0 {
params["start_time"] = task.StartTime
}
if task.EndTime != 0 {
params["end_time"] = task.EndTime
}
if task.Status != "" {
params["status"] = task.Status
}
if task.Msg != "" {
params["msg"] = task.Msg
}
if task.Remark != "" {
params["remark"] = task.Remark
}
if task.CreateBy != "" {
params["create_by"] = task.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into trace_task_hlr (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// Update 修改信息
func (r *TraceTaskHlr) Update(task model.TraceTaskHlr) int64 {
// 参数拼接
params := make(map[string]any)
if task.TraceId != "" {
params["trace_id"] = task.TraceId
}
if task.IMSI != "" {
params["imsi"] = task.IMSI
}
if task.MSISDN != "" {
params["msisdn"] = task.MSISDN
}
if task.StartTime != 0 {
params["start_time"] = task.StartTime
}
if task.EndTime != 0 {
params["end_time"] = task.EndTime
}
if task.Status != "" {
params["status"] = task.Status
}
if task.Msg != "" {
params["msg"] = task.Msg
}
if task.Remark != "" {
params["remark"] = task.Remark
}
if task.UpdateBy != "" {
params["update_by"] = task.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update trace_task_hlr set " + strings.Join(keys, ",") + " where id = ?"
// 执行更新
values = append(values, task.ID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// DeleteByIds 批量删除信息
func (r *TraceTaskHlr) DeleteByIds(ids []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(ids))
sql := "delete from trace_task_hlr where id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(ids)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
// Insert 新增信息 返回新增数据ID
func (r TraceTaskHlr) Insert(param model.TraceTaskHlr) int64 {
if param.CreateBy != "" {
ms := time.Now().UnixMilli()
param.UpdateBy = param.CreateBy
param.UpdateTime = ms
param.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return results
return param.ID
}
// Update 修改信息 返回受影响行数
func (r TraceTaskHlr) Update(param model.TraceTaskHlr) int64 {
if param.ID <= 0 {
return 0
}
if param.UpdateBy != "" {
param.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.TraceTaskHlr{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "create_by", "create_time")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r TraceTaskHlr) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Where("id in ?", ids)
if err := tx.Delete(&model.TraceTaskHlr{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// LastID 最后一条ID
func (r *TraceTaskHlr) LastID() int64 {
func (r TraceTaskHlr) LastID() int64 {
tx := db.DB("").Model(&model.TraceTaskHlr{})
// 查询数据
querySql := "SELECT id as 'str' FROM trace_task_hlr ORDER BY id DESC LIMIT 1"
results, err := datasource.RawDB("", querySql, nil)
if err != nil {
logger.Errorf("query err %v", err)
return 0
var id int64 = 0
if err := tx.Select("id").Order("id DESC").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
if len(results) > 0 {
return parse.Number(results[0]["str"])
}
return 0
return id
}

15
src/modules/trace/service/packet.go
View File

@@ -1,7 +1,6 @@
package service
import (
"be.ems/src/framework/vo"
packetTask "be.ems/src/modules/trace/packet_task"
)
@@ -12,8 +11,8 @@ var NewPacket = &Packet{}
type Packet struct{}
// NetworkDevices 获取网卡设备信息
func (s *Packet) NetworkDevices() []vo.TreeSelect {
arr := make([]vo.TreeSelect, 0)
func (s *Packet) NetworkDevices() []map[string]any {
arr := make([]map[string]any, 0)
devices, err := packetTask.NetworkDevices()
if err != nil {
return arr
@@ -28,16 +27,16 @@ func (s *Packet) NetworkDevices() []vo.TreeSelect {
if lable == "" {
lable = device.Name
}
item := vo.TreeSelect{
ID: device.Name,
Label: lable,
Children: []vo.TreeSelect{},
item := map[string]any{
"id": device.Name,
"label": lable,
"children": []map[string]any{},
}
for _, address := range device.Addresses {
if address.IP != nil {
ip := address.IP.String()
item.Children = append(item.Children, vo.TreeSelect{ID: ip, Label: ip})
item["children"] = append(item["children"].([]map[string]any), map[string]any{"id": ip, "label": ip})
}
}
arr = append(arr, item)

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

@@ -9,7 +9,7 @@ import (
"time"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/ssh"
"be.ems/src/framework/ssh"
neService "be.ems/src/modules/network_element/service"
)
@@ -34,7 +34,7 @@ func (s *TCPdump) DumpStart(neType, neId, cmdStr string) (string, error) {
}
// 查询网元获取IP
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(neType, neId)
neInfo := s.neInfoService.FindByNeTypeAndNeID(neType, neId)
if neInfo.NeId != neId || neInfo.IP == "" {
return "", fmt.Errorf("app.common.noNEInfo")
}
@@ -96,7 +96,7 @@ func (s *TCPdump) DumpStart(neType, neId, cmdStr string) (string, error) {
// DumpStop 停止已存在抓包句柄
func (s *TCPdump) DumpStop(neType, neId, taskCode string) ([]string, error) {
// 查询网元获取IP
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(neType, neId)
neInfo := s.neInfoService.FindByNeTypeAndNeID(neType, neId)
if neInfo.NeId != neId || neInfo.IP == "" {
return []string{}, fmt.Errorf("app.common.noNEInfo")
}
@@ -214,7 +214,7 @@ func (s *TCPdump) UPFTrace(neType, neId, cmdStr string) (string, error) {
}
// 查询网元获取IP
neInfo := s.neInfoService.SelectNeInfoByNeTypeAndNeID(neType, neId)
neInfo := s.neInfoService.FindByNeTypeAndNeID(neType, neId)
if neInfo.NeId != neId || neInfo.IP == "" {
return "", fmt.Errorf("app.common.noNEInfo")
}

16
src/modules/trace/service/trace_data.go
View File

@@ -18,14 +18,14 @@ type TraceData struct {
traceDataRepository *repository.TraceData
}
// SelectPage 根据条件分页查询
func (r *TraceData) SelectPage(query map[string]any) map[string]any {
return r.traceDataRepository.SelectPage(query)
// FindByPage 根据条件分页查询
func (r *TraceData) FindByPage(query map[string]string) ([]model.TraceData, int64) {
return r.traceDataRepository.SelectByPage(query)
}
// SelectById 通过ID查询
func (r *TraceData) SelectById(id string) model.TraceData {
tasks := r.traceDataRepository.SelectByIds([]string{id})
// FindById 通过ID查询
func (r *TraceData) FindById(id int64) model.TraceData {
tasks := r.traceDataRepository.SelectByIds([]int64{id})
if len(tasks) > 0 {
return tasks[0]
}
@@ -33,12 +33,12 @@ func (r *TraceData) SelectById(id string) model.TraceData {
}
// Insert 新增信息
func (r *TraceData) Insert(task model.TraceData) string {
func (r *TraceData) Insert(task model.TraceData) int64 {
return r.traceDataRepository.Insert(task)
}
// DeleteByIds 批量删除信息
func (r *TraceData) DeleteByIds(ids []string) (int64, error) {
func (r *TraceData) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
rows := r.traceDataRepository.SelectByIds(ids)
if len(rows) <= 0 {

20
src/modules/trace/service/trace_task.go
View File

@@ -176,14 +176,14 @@ func (r *TraceTask) CloseUDP() {
r.udpService.Close()
}
// SelectPage 根据条件分页查询
func (r *TraceTask) SelectPage(query map[string]any) map[string]any {
return r.traceTaskRepository.SelectPage(query)
// FindByPage 根据条件分页查询
func (r *TraceTask) FindByPage(query map[string]string) ([]model.TraceTask, int64) {
return r.traceTaskRepository.SelectByPage(query)
}
// SelectById 通过ID查询
func (r *TraceTask) SelectById(id string) model.TraceTask {
tasks := r.traceTaskRepository.SelectByIds([]string{id})
// FindById 通过ID查询
func (r *TraceTask) FindById(id int64) model.TraceTask {
tasks := r.traceTaskRepository.SelectByIds([]int64{id})
if len(tasks) > 0 {
return tasks[0]
}
@@ -209,7 +209,7 @@ func (r *TraceTask) Insert(task model.TraceTask) error {
task.NotifyUrl = fmt.Sprintf("udp:%s:%d", host, port)
// 查询网元获取IP
neInfo := neService.NewNeInfo.SelectNeInfoByNeTypeAndNeID(task.NeType, task.NeId)
neInfo := neService.NewNeInfo.FindByNeTypeAndNeID(task.NeType, task.NeId)
if neInfo.NeId != task.NeId || neInfo.IP == "" {
return fmt.Errorf("app.common.noNEInfo")
}
@@ -274,7 +274,7 @@ func (r *TraceTask) Update(task model.TraceTask) error {
task.NotifyUrl = fmt.Sprintf("udp:%s:%d", host, port)
// 查询网元获取IP
neInfo := neService.NewNeInfo.SelectNeInfoByNeTypeAndNeID(task.NeType, task.NeId)
neInfo := neService.NewNeInfo.FindByNeTypeAndNeID(task.NeType, task.NeId)
if neInfo.NeId != task.NeId || neInfo.IP == "" {
return fmt.Errorf("app.common.noNEInfo")
}
@@ -319,7 +319,7 @@ func (r *TraceTask) Update(task model.TraceTask) error {
}
// DeleteByIds 批量删除信息
func (r *TraceTask) DeleteByIds(ids []string) (int64, error) {
func (r *TraceTask) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
rows := r.traceTaskRepository.SelectByIds(ids)
if len(rows) <= 0 {
@@ -329,7 +329,7 @@ func (r *TraceTask) DeleteByIds(ids []string) (int64, error) {
if len(rows) == len(ids) {
// 停止任务
for _, v := range rows {
neInfo := neService.NewNeInfo.SelectNeInfoByNeTypeAndNeID(v.NeType, v.NeId)
neInfo := neService.NewNeInfo.FindByNeTypeAndNeID(v.NeType, v.NeId)
if neInfo.NeId != v.NeId || neInfo.IP == "" {
continue
}

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

@@ -5,8 +5,8 @@ import (
"fmt"
"path/filepath"
"be.ems/src/framework/ssh"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/ssh"
neFetchlink "be.ems/src/modules/network_element/fetch_link"
neModel "be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
@@ -26,14 +26,14 @@ type TraceTaskHlr struct {
neInfoService *neService.NeInfo // 网元信息服务
}
// SelectPage 根据条件分页查询
func (r *TraceTaskHlr) SelectPage(querys model.TraceTaskHlrQuery) map[string]any {
return r.traceTaskHlrRepository.SelectPage(querys)
// FindByPage 根据条件分页查询
func (r *TraceTaskHlr) FindByPage(querys model.TraceTaskHlrQuery) ([]model.TraceTaskHlr, int64) {
return r.traceTaskHlrRepository.SelectByPage(querys)
}
// SelectById 通过ID查询
func (r *TraceTaskHlr) SelectById(id string) model.TraceTaskHlr {
tasks := r.traceTaskHlrRepository.SelectByIds([]string{id})
// FindById 通过ID查询
func (r *TraceTaskHlr) FindById(id int64) model.TraceTaskHlr {
tasks := r.traceTaskHlrRepository.SelectByIds([]int64{id})
if len(tasks) > 0 {
return tasks[0]
}
@@ -41,7 +41,7 @@ func (r *TraceTaskHlr) SelectById(id string) model.TraceTaskHlr {
}
// Insert 新增信息
func (r *TraceTaskHlr) Insert(task model.TraceTaskHlr) string {
func (r *TraceTaskHlr) Insert(task model.TraceTaskHlr) int64 {
return r.traceTaskHlrRepository.Insert(task)
}
@@ -51,7 +51,7 @@ func (r *TraceTaskHlr) Update(task model.TraceTaskHlr) int64 {
}
// DeleteByIds 批量删除信息
func (r *TraceTaskHlr) DeleteByIds(ids []string) (int64, error) {
func (r *TraceTaskHlr) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
rows := r.traceTaskHlrRepository.SelectByIds(ids)
if len(rows) <= 0 {
@@ -60,7 +60,7 @@ func (r *TraceTaskHlr) DeleteByIds(ids []string) (int64, error) {
if len(rows) == len(ids) {
// 停止任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
neInfos := r.neInfoService.Find(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, r := range rows {
if r.Status == "0" {
continue
@@ -79,7 +79,7 @@ func (r *TraceTaskHlr) DeleteByIds(ids []string) (int64, error) {
}
// Start 创建任务
func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (int64, error) {
hlrList := []map[string]any{}
traceId := r.traceTaskHlrRepository.LastID() + 1 // 生成任务ID < 65535
data := map[string]any{
@@ -88,7 +88,7 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
"msisdn": task.MSISDN,
}
if task.StartTime > task.EndTime {
return "", fmt.Errorf("startTime must less than endTime")
return 0, fmt.Errorf("startTime must less than endTime")
}
if task.StartTime > 0 {
data["startTime"] = date.ParseDateToStr(task.StartTime, date.YYYY_MM_DDTHH_MM_SSZ)
@@ -98,7 +98,7 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
}
// 发送创建任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
neInfos := r.neInfoService.Find(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, neInfo := range neInfos {
hlrItem := map[string]any{
"neType": neInfo.NeType,
@@ -119,8 +119,8 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
task.Status = "1"
task.TraceId = fmt.Sprint(traceId)
id := r.traceTaskHlrRepository.Insert(task)
if id == "" {
return "", fmt.Errorf("start task fail")
if id <= 0 {
return 0, fmt.Errorf("start task fail")
}
return id, nil
}
@@ -129,7 +129,7 @@ func (r *TraceTaskHlr) Start(task model.TraceTaskHlr) (string, error) {
func (r *TraceTaskHlr) Stop(task model.TraceTaskHlr) error {
hlrList := []map[string]any{}
// 发送停止任务
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
neInfos := r.neInfoService.Find(neModel.NeInfo{NeType: "HLR"}, false, false)
for _, neInfo := range neInfos {
hlrItem := map[string]any{
"neType": neInfo.NeType,
@@ -161,7 +161,7 @@ func (r *TraceTaskHlr) Stop(task model.TraceTaskHlr) error {
func (r *TraceTaskHlr) File(traceId, dirPath string) ([]map[string]any, error) {
hlrList := []map[string]any{}
// 查询所有匹配的网元类型
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
neInfos := r.neInfoService.Find(neModel.NeInfo{NeType: "HLR"}, false, false)
if len(neInfos) == 0 {
return nil, fmt.Errorf("not found network element")
}

6
src/modules/trace/trace.go
View File

@@ -71,7 +71,7 @@ func Setup(router *gin.Engine) {
taskHLRGroup.GET("/list",
controller.NewTraceTaskHlr.List,
)
taskHLRGroup.DELETE("/:ids",
taskHLRGroup.DELETE("/:id",
controller.NewTraceTaskHlr.Remove,
)
taskHLRGroup.POST("/start",
@@ -109,7 +109,7 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewTraceTask.Edit,
)
taskGroup.DELETE("/:ids",
taskGroup.DELETE("/:id",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewTraceTask.Remove,
@@ -127,7 +127,7 @@ func Setup(router *gin.Engine) {
middleware.PreAuthorize(nil),
controller.NewTraceData.List,
)
taskDataGroup.DELETE("/:ids",
taskDataGroup.DELETE("/:id",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.taskData", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewTraceData.Remove,