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

feat: 跟踪任务 网元HLR功能接口

Browse Source
This commit is contained in:
TsMask
2024-09-06 14:20:54 +08:00
parent 56b531536d
commit a7b57af939
7 changed files with 741 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
src/modules/trace/controller/trace_task_hlr.go Normal file
View File

@@ -0,0 +1,178 @@
package controller
import (
"strings"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"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 结构体
var NewTraceTaskHlr = &TraceTaskHlrController{
neInfoService: neService.NewNeInfoImpl,
traceTaskHlrService: traceService.NewTraceTaskHlrImpl,
}
// 网元SMF
//
// PATH /task/hlr
type TraceTaskHlrController struct {
// 网元信息服务
neInfoService neService.INeInfo
// 跟踪_任务给HRL网元信息服务
traceTaskHlrService traceService.ITraceTaskHlr
}
// 跟踪任务列表
//
// 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")))
return
}
// 查询数据
data := s.traceTaskHlrService.SelectPage(querys)
c.JSON(200, result.Ok(data))
}
// 跟踪任务删除
//
// DELETE /:ids
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")))
return
}
// 处理字符转id数组后去重
ids := strings.Split(rowIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.traceTaskHlrService.DeleteByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
return
}
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
}
// 跟踪任务创建
//
// POST /start
func (s *TraceTaskHlrController) Start(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var body struct {
IMSI string `json:"imsi"` // IMSI
MSISDN string `json:"msisdn"` // MSISDN
StartTime int64 `json:"startTime"` // 开始时间
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")))
return
}
if body.IMSI == "" && body.MSISDN == "" {
c.JSON(400, result.CodeMsg(400, "imsi amd msisdn is empty"))
return
}
task := model.TraceTaskHlr{
IMSI: body.IMSI,
MSISDN: body.MSISDN,
StartTime: body.StartTime,
EndTime: body.EndTime,
Remark: body.Remark,
CreateBy: ctx.LoginUserToUserName(c),
}
id, err := s.traceTaskHlrService.Start(task)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(id))
}
// 跟踪任务停止
//
// POST /stop
func (s *TraceTaskHlrController) Stop(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var body struct {
ID string `json:"id"` // 任务ID
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.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
}
errArr := []map[string]any{}
for _, id := range uniqueIDs {
task := s.traceTaskHlrService.SelectById(id)
if task.ID != id || task.ID == "" {
errArr = append(errArr, map[string]any{"id": id, "err": "task not found"})
continue
}
task.UpdateBy = ctx.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))
}
// 跟踪任务文件
//
// POST /file
func (s *TraceTaskHlrController) File(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var body struct {
ID string `json:"id"` // 任务ID
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
task := s.traceTaskHlrService.SelectById(body.ID)
if task.ID != body.ID || task.ID == "" {
c.JSON(200, result.CodeMsg(400, "task not found"))
return
}
task.UpdateBy = ctx.LoginUserToUserName(c)
list, err := s.traceTaskHlrService.File(task)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.OkData(list))
}

35
src/modules/trace/model/trace_task_hlr.go Normal file
View File

@@ -0,0 +1,35 @@
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"` // 更新时间
}
// TableName 表名称
func (*TraceTaskHlr) TableName() string {
return "trace_task_hlr"
}
// TraceTaskHlrQuery 查询参数结构体
type TraceTaskHlrQuery struct {
IMSI string `json:"imsi" form:"imsi"` // imsi
MSISDN string `json:"msisdn" form:"msisdn"` // msisdn
StartTime string `json:"startTime" form:"startTime"`
EndTime string `json:"endTime" form:"endTime"`
SortField string `json:"sortField" form:"sortField" binding:"omitempty,oneof=imsi msisdn"` // 排序字段，填写结果字段
SortOrder string `json:"sortOrder" form:"sortOrder" binding:"omitempty,oneof=asc desc"` // 排序升降序，asc desc
PageNum int64 `json:"pageNum" form:"pageNum" binding:"required"`
PageSize int64 `json:"pageSize" form:"pageSize" binding:"required"`
}

24
src/modules/trace/repository/trace_task_hlr.go Normal file
View File

@@ -0,0 +1,24 @@
package repository
import "be.ems/src/modules/trace/model"
// 跟踪_任务给HRL网元 数据层接口
type ITraceTaskHlr interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.TraceTaskHlrQuery) map[string]any
// SelectList 根据实体查询
SelectList(neHost model.TraceTaskHlr) []model.TraceTaskHlr
// SelectByIds 通过ID查询
SelectByIds(ids []string) []model.TraceTaskHlr
// Insert 新增信息
Insert(task model.TraceTaskHlr) string
// Update 修改信息
Update(task model.TraceTaskHlr) int64
// DeleteByIds 批量删除信息
DeleteByIds(ids []string) int64
}

301
src/modules/trace/repository/trace_task_hlr.impl.go Normal file
View File

@@ -0,0 +1,301 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/trace/model"
)
// 实例化数据层 TraceTaskHlr 结构体
var NewTraceTaskHlrImpl = &TraceTaskHlrImpl{
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",
},
}
// CDREventIMSImpl 跟踪_任务给HRL网元 数据层处理
type TraceTaskHlrImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *TraceTaskHlrImpl) 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 *TraceTaskHlrImpl) SelectPage(querys model.TraceTaskHlrQuery) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if querys.IMSI != "" {
conditions = append(conditions, "imsi like concat(?, '%')")
params = append(params, querys.IMSI)
}
if querys.MSISDN != "" {
conditions = append(conditions, "msisdn like concat(?, '%')")
params = append(params, querys.MSISDN)
}
if querys.StartTime != "" && len(querys.StartTime) == 13 {
conditions = append(conditions, "start_time >= ?")
params = append(params, querys.StartTime)
}
if querys.EndTime != "" && len(querys.EndTime) == 13 {
conditions = append(conditions, "end_time <= ?")
params = append(params, querys.EndTime)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
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)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by id desc, %s ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectList 根据实体查询
func (r *TraceTaskHlrImpl) SelectList(neHost model.TraceTaskHlr) []model.TraceTaskHlr {
// 查询条件拼接
var conditions []string
var params []any
if neHost.IMSI != "" {
conditions = append(conditions, "imsi = ?")
params = append(params, neHost.IMSI)
}
if neHost.MSISDN != "" {
conditions = append(conditions, "msisdn = ?")
params = append(params, neHost.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 *TraceTaskHlrImpl) 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 *TraceTaskHlrImpl) 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 *TraceTaskHlrImpl) 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
}
return rows
}
// DeleteByIds 批量删除信息
func (r *TraceTaskHlrImpl) 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)
return 0
}
return results
}

24
src/modules/trace/service/trace_task_hlr.go Normal file
View File

@@ -0,0 +1,24 @@
package service
import "be.ems/src/modules/trace/model"
// 跟踪_任务给HRL网元 服务层接口
type ITraceTaskHlr interface {
// SelectPage 根据条件分页查询
SelectPage(querys model.TraceTaskHlrQuery) map[string]any
// SelectById 通过ID查询
SelectById(id string) model.TraceTaskHlr
// DeleteByIds 批量删除信息
DeleteByIds(ids []string) (int64, error)
// Start 创建任务
Start(task model.TraceTaskHlr) (string, error)
// Stop 停止任务
Stop(task model.TraceTaskHlr) error
// File 任务文件
File(task model.TraceTaskHlr) ([]map[string]any, error)
}

150
src/modules/trace/service/trace_task_hlr.impl.go Normal file
View File

@@ -0,0 +1,150 @@
package service
import (
"fmt"
"path/filepath"
"be.ems/src/framework/utils/generate"
"be.ems/src/framework/utils/ssh"
neModel "be.ems/src/modules/network_element/model"
neService "be.ems/src/modules/network_element/service"
"be.ems/src/modules/trace/model"
"be.ems/src/modules/trace/repository"
)
// 实例化数据层 TraceTaskHlrImpl 结构体
var NewTraceTaskHlrImpl = &TraceTaskHlrImpl{
traceTaskHlrRepository: repository.NewTraceTaskHlrImpl,
neInfoService: neService.NewNeInfoImpl,
}
// TraceTaskHlrImpl 跟踪_任务给HRL网元 服务层处理
type TraceTaskHlrImpl struct {
// 跟踪_任务给HRL网元数据信息
traceTaskHlrRepository repository.ITraceTaskHlr
// 网元信息服务
neInfoService neService.INeInfo
}
// SelectPage 根据条件分页查询
func (r *TraceTaskHlrImpl) SelectPage(querys model.TraceTaskHlrQuery) map[string]any {
return r.traceTaskHlrRepository.SelectPage(querys)
}
// SelectById 通过ID查询
func (r *TraceTaskHlrImpl) SelectById(id string) model.TraceTaskHlr {
tasks := r.traceTaskHlrRepository.SelectByIds([]string{id})
if len(tasks) > 0 {
return tasks[0]
}
return model.TraceTaskHlr{}
}
// Insert 新增信息
func (r *TraceTaskHlrImpl) Insert(task model.TraceTaskHlr) string {
return r.traceTaskHlrRepository.Insert(task)
}
// Update 修改信息
func (r *TraceTaskHlrImpl) Update(task model.TraceTaskHlr) int64 {
return r.traceTaskHlrRepository.Update(task)
}
// DeleteByIds 批量删除信息
func (r *TraceTaskHlrImpl) DeleteByIds(ids []string) (int64, error) {
// 检查是否存在
rows := r.traceTaskHlrRepository.SelectByIds(ids)
if len(rows) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(rows) == len(ids) {
rows := r.traceTaskHlrRepository.DeleteByIds(ids)
return rows, nil
}
// 删除信息失败！
return 0, fmt.Errorf("delete fail")
}
// Start 创建任务
func (r *TraceTaskHlrImpl) Start(task model.TraceTaskHlr) (string, error) {
ingList := r.traceTaskHlrRepository.SelectList(model.TraceTaskHlr{Status: "1"})
if len(ingList) >= 10 {
return "", fmt.Errorf("maximum running tasks 10")
}
task.TraceId = generate.Code(6)
// 发送创建任务
task.Status = "1"
task.Msg = "111111"
id := r.traceTaskHlrRepository.Insert(task)
if id == "" {
return "", fmt.Errorf("start fail")
}
return id, nil
}
// Stop 停止任务
func (r *TraceTaskHlrImpl) Stop(task model.TraceTaskHlr) error {
// 发送停止任务
task.Status = "0"
task.Msg = "0000"
rows := r.traceTaskHlrRepository.Update(task)
if rows <= 0 {
return fmt.Errorf("stop fail")
}
return nil
}
// File 任务文件
func (r *TraceTaskHlrImpl) File(task model.TraceTaskHlr) ([]map[string]any, error) {
hlrList := []map[string]any{}
hlrTraceId := task.TraceId
hlrTraceDirPath := "/usr/local/etc/hlr/trace"
// task.TraceId
neInfos := r.neInfoService.SelectList(neModel.NeInfo{NeType: "HLR"}, false, false)
if len(neInfos) == 0 {
return nil, fmt.Errorf("not found ne for HLR")
}
// 遍历多个网元主机获取文件
for _, neInfo := range neInfos {
hlrItem := map[string]any{
"neType": neInfo.NeType,
"neId": neInfo.NeId,
"err": "",
}
// 网元主机的SSH客户端
sshClient, err := r.neInfoService.NeRunSSHClient(neInfo.NeType, neInfo.NeId)
if err != nil {
hlrItem["err"] = "ssh link fail"
hlrList = append(hlrList, hlrItem)
continue
}
defer sshClient.Close()
// 获取文件列表
_, rows, err := ssh.FileList(sshClient, hlrTraceDirPath, hlrTraceId)
if err != nil {
hlrItem["err"] = "file not found"
hlrList = append(hlrList, hlrItem)
continue
}
// 遍历组装
for _, v := range rows {
if v.FileType == "file" {
hlrItem["fileName"] = v.FileName
hlrItem["filePath"] = filepath.ToSlash(filepath.Join(hlrTraceDirPath, v.FileName))
hlrList = append(hlrList, hlrItem)
}
}
}
return hlrList, nil
}

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

@@ -38,4 +38,33 @@ func Setup(router *gin.Engine) {
controller.NewTcpdump.UPFTrace,
)
}
// 跟踪任务 网元HLR
taskHLRGroup := traceGroup.Group("/task/hlr")
{
taskHLRGroup.GET("/list",
middleware.PreAuthorize(nil),
controller.NewTraceTaskHlr.List,
)
taskHLRGroup.DELETE("/:ids",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewTraceTaskHlr.Remove,
)
taskHLRGroup.POST("/start",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewTraceTaskHlr.Start,
)
taskHLRGroup.POST("/stop",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewTraceTaskHlr.Stop,
)
taskHLRGroup.POST("/file",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.task", collectlogs.BUSINESS_TYPE_OTHER)),
controller.NewTraceTaskHlr.File,
)
}
}