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

24
src/modules/monitor/controller/monitor.go
View File

@@ -1,9 +1,9 @@
package controller
import (
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo/result"
"fmt"
"be.ems/src/framework/resp"
"be.ems/src/modules/monitor/service"
"github.com/gin-gonic/gin"
@@ -29,39 +29,39 @@ type MonitorController struct {
// @Accept json
// @Produce json
// @Param type query string true "Data Type" Enums(all,load,cpu,memory,io,network) default(all)
// @Param startTime query number true "StartTime, timestamp milliseconds" default(1738771200000)
// @Param beginTime query number true "BeginTime, timestamp milliseconds" default(1738771200000)
// @Param endTime query number true "EndTime, timestamp milliseconds" default(1738810051253)
// @Param neType query string false "NE Type, Currently none Default #" default(#)
// @Param neId query string false "NE ID, Currently none Default #" default(#)
// @Param name query string false "Name, Data Type valid for networ and io"
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Resource monitoring information loading
// @Description Resource monitoring information loading
// @Summary Load Resource Utilization Information
// @Description Load Resource Utilization Information
// @Router /monitor/load [get]
func (s *MonitorController) Load(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys struct {
Type string `form:"type" binding:"required,oneof=all load cpu memory io network"` // 数据类型all/load/cpu/memory/io/network
StartTime int64 `form:"startTime" binding:"required"` // 开始时间
BeginTime int64 `form:"beginTime" binding:"required"` // 开始时间
EndTime int64 `form:"endTime" binding:"required"` // 结束时间
NeType string `form:"neType"` // 网元类型
NeID string `form:"neId"` // 网元ID
Name string `form:"name"` // 名称，networ和io时有效
}
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
}
// 查询数据
data := s.monitorService.SelectMonitorInfo(map[string]any{
data := s.monitorService.FindInfo(map[string]any{
"type": querys.Type,
"startTime": querys.StartTime,
"beginTime": querys.BeginTime,
"endTime": querys.EndTime,
"neType": querys.NeType,
"neId": querys.NeID,
"name": querys.Name,
})
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}

212
src/modules/monitor/controller/sys_cache.go
View File

@@ -1,11 +1,13 @@
package controller
import (
"be.ems/src/framework/constants/cachekey"
"fmt"
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/framework/i18n"
"be.ems/src/framework/redis"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo/result"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/modules/monitor/model"
"github.com/gin-gonic/gin"
@@ -32,138 +34,148 @@ type SysCacheController struct{}
// @Description Cache Service Information
// @Router /monitor/cache [get]
func (s *SysCacheController) Info(c *gin.Context) {
c.JSON(200, result.OkData(map[string]any{
c.JSON(200, resp.OkData(map[string]any{
"info": redis.Info(""),
"dbSize": redis.KeySize(""),
"commandStats": redis.CommandStats(""),
}))
}
// 缓存名称列表
// Names 缓存名称列表
//
// GET /getNames
func (s *SysCacheController) Names(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /names
func (s SysCacheController) Names(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
caches := []model.SysCache{
model.NewSysCacheNames(i18n.TKey(language, "cache.name.user"), cachekey.LOGIN_TOKEN_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_config"), cachekey.SYS_CONFIG_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_dict"), cachekey.SYS_DICT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.captcha_codes"), cachekey.CAPTCHA_CODE_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.repeat_submit"), cachekey.REPEAT_SUBMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.rate_limit"), cachekey.RATE_LIMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.pwd_err_cnt"), cachekey.PWD_ERR_CNT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.ne_info"), cachekey.NE_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.ne_data"), cachekey.NE_DATA_KEY),
model.NewNames(i18n.TKey(language, "cache.name.user"), constants.CACHE_LOGIN_TOKEN),
model.NewNames(i18n.TKey(language, "cache.name.sys_config"), constants.CACHE_SYS_CONFIG),
model.NewNames(i18n.TKey(language, "cache.name.sys_dict"), constants.CACHE_SYS_DICT),
model.NewNames(i18n.TKey(language, "cache.name.captcha_codes"), constants.CACHE_CAPTCHA_CODE),
model.NewNames(i18n.TKey(language, "cache.name.repeat_submit"), constants.CACHE_REPEAT_SUBMIT),
model.NewNames(i18n.TKey(language, "cache.name.rate_limit"), constants.CACHE_RATE_LIMIT),
model.NewNames(i18n.TKey(language, "cache.name.pwd_err_cnt"), constants.CACHE_PWD_ERR_COUNT),
model.NewNames(i18n.TKey(language, "cache.name.ne_info"), constants.CACHE_NE_INFO),
model.NewNames(i18n.TKey(language, "cache.name.ne_data"), constants.CACHE_NE_DATA),
}
c.JSON(200, result.OkData(caches))
c.JSON(200, resp.OkData(caches))
}
// 缓存名称下键名列表
// Keys 缓存名称下键名列表
//
// GET /getKeys/:cacheName
func (s *SysCacheController) Keys(c *gin.Context) {
language := ctx.AcceptLanguage(c)
cacheName := c.Param("cacheName")
if cacheName == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /keys?cacheName=xxx
func (s SysCacheController) Keys(c *gin.Context) {
var query struct {
CacheName string `form:"cacheName" binding:"required"` // 键名列表中得到的缓存名称
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
caches := []model.SysCache{}
// 遍历组装
cacheKeys, _ := redis.GetKeys("", cacheName+":*")
cacheKeys, _ := redis.GetKeys("", query.CacheName+":*")
for _, key := range cacheKeys {
caches = append(caches, model.NewSysCacheKeys(cacheName, key))
caches = append(caches, model.NewKeys(query.CacheName, key))
}
c.JSON(200, result.OkData(caches))
c.JSON(200, resp.OkData(caches))
}
// 缓存内容
// Value 缓存内容信息
//
// GET /getValue/:cacheName/:cacheKey
func (s *SysCacheController) Value(c *gin.Context) {
language := ctx.AcceptLanguage(c)
cacheName := c.Param("cacheName")
cacheKey := c.Param("cacheKey")
if cacheName == "" || cacheKey == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /value?cacheName=xxx&cacheKey=xxx
func (s SysCacheController) Value(c *gin.Context) {
var query struct {
CacheName string `form:"cacheName" binding:"required"` // 键名列表中得到的缓存名称
CacheKey string `form:"cacheKey" binding:"required"` // 键名列表中得到的缓存键名
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
cacheValue, err := redis.Get("", cacheName+":"+cacheKey)
cacheValue, err := redis.Get("", query.CacheName+":"+query.CacheKey)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
sysCache := model.NewSysCacheValue(cacheName, cacheKey, cacheValue)
c.JSON(200, result.OkData(sysCache))
sysCache := model.NewValue(query.CacheName, query.CacheKey, cacheValue)
c.JSON(200, resp.OkData(sysCache))
}
// 删除缓存名称下键名列表
// CleanNames 缓存名称列表安全删除
//
// DELETE /clearCacheName/:cacheName
func (s *SysCacheController) ClearCacheName(c *gin.Context) {
language := ctx.AcceptLanguage(c)
cacheName := c.Param("cacheName")
if cacheName == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
cacheKeys, err := redis.GetKeys("", cacheName+":*")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
ok, _ := redis.DelKeys("", cacheKeys)
if ok {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 删除缓存键名
//
// DELETE /clearCacheKey/:cacheName/:cacheKey
func (s *SysCacheController) ClearCacheKey(c *gin.Context) {
language := ctx.AcceptLanguage(c)
cacheName := c.Param("cacheName")
cacheKey := c.Param("cacheKey")
if cacheName == "" || cacheKey == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
ok, _ := redis.Del("", cacheName+":"+cacheKey)
if ok {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 安全清理缓存名称
//
// DELETE /clearCacheSafe
func (s *SysCacheController) ClearCacheSafe(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// DELETE /names
func (s SysCacheController) CleanNames(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
caches := []model.SysCache{
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_config"), cachekey.SYS_CONFIG_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_dict"), cachekey.SYS_DICT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.repeat_submit"), cachekey.REPEAT_SUBMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.rate_limit"), cachekey.RATE_LIMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.pwd_err_cnt"), cachekey.PWD_ERR_CNT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.ne_info"), cachekey.NE_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.ne_data"), cachekey.NE_DATA_KEY),
model.NewNames(i18n.TKey(language, "cache.name.sys_config"), constants.CACHE_SYS_CONFIG),
model.NewNames(i18n.TKey(language, "cache.name.sys_dict"), constants.CACHE_SYS_DICT),
model.NewNames(i18n.TKey(language, "cache.name.repeat_submit"), constants.CACHE_REPEAT_SUBMIT),
model.NewNames(i18n.TKey(language, "cache.name.rate_limit"), constants.CACHE_RATE_LIMIT),
model.NewNames(i18n.TKey(language, "cache.name.pwd_err_cnt"), constants.CACHE_PWD_ERR_COUNT),
model.NewNames(i18n.TKey(language, "cache.name.ne_info"), constants.CACHE_NE_INFO),
model.NewNames(i18n.TKey(language, "cache.name.ne_data"), constants.CACHE_NE_DATA),
}
for _, v := range caches {
cacheKeys, err := redis.GetKeys("", v.CacheName+":*")
if err != nil {
continue
}
redis.DelKeys("", cacheKeys)
_ = redis.DelKeys("", cacheKeys)
}
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
}
// CleanKeys 缓存名称下键名删除
//
// DELETE /keys?cacheName=xxx
func (s SysCacheController) CleanKeys(c *gin.Context) {
var query struct {
CacheName string `form:"cacheName" binding:"required"` // 键名列表中得到的缓存名称
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if constants.CACHE_LOGIN_TOKEN == query.CacheName {
c.JSON(200, resp.ErrMsg("Cannot delete user information cache"))
return
}
cacheKeys, err := redis.GetKeys("", query.CacheName+":*")
if err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
if err = redis.DelKeys("", cacheKeys); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}
// CleanValue 缓存内容删除
//
// DELETE /value?cacheName=xxx&cacheKey=xxx
func (s SysCacheController) CleanValue(c *gin.Context) {
var query struct {
CacheName string `form:"cacheName" binding:"required"` // 键名列表中得到的缓存名称
CacheKey string `form:"cacheKey" binding:"required"` // 键名列表中得到的缓存键名
}
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if err := redis.Del("", query.CacheName+":"+query.CacheKey); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
c.JSON(200, resp.Ok(nil))
}

248
src/modules/monitor/controller/sys_job.go
View File

@@ -4,20 +4,18 @@ import (
"encoding/json"
"fmt"
"strconv"
"strings"
"time"
"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/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/service"
systemService "be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysJobLogController 结构体
@@ -38,15 +36,14 @@ type SysJobController struct {
//
// GET /list
func (s *SysJobController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["jobName"]; ok && v != "" {
querys["jobName"] = i18n.TFindKeyPrefix(language, "job", v.(string))
if v, ok := query["jobName"]; ok && v != "" {
query["jobName"] = i18n.TFindKeyPrefix(language, "job", v)
}
data := s.sysJobService.SelectJobPage(querys)
rows := data["rows"].([]model.SysJob)
rows, total := s.sysJobService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysJob) {
@@ -57,40 +54,44 @@ func (s *SysJobController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 调度任务信息
//
// GET /:jobId
func (s *SysJobController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
jobId := c.Param("jobId")
if jobId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
jobId := parse.Number(c.Param("jobId"))
if jobId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: jobId is empty"))
return
}
data := s.sysJobService.SelectJobById(jobId)
if data.JobID == jobId {
data := s.sysJobService.FindById(jobId)
if data.JobId == jobId {
// 处理多语言
data.JobName = i18n.TKey(language, data.JobName)
data.Remark = i18n.TKey(language, data.Remark)
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 *SysJobController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysJob
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.JobID != "" {
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 body.JobId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: jobId not is empty"))
return
}
@@ -98,7 +99,7 @@ func (s *SysJobController) Add(c *gin.Context) {
if parse.CronExpression(body.CronExpression) == 0 {
// 调度任务新增【%s】失败，Cron表达式不正确
msg := i18n.TTemplate(language, "job.errCronExpression", map[string]any{"name": body.JobName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
@@ -107,42 +108,46 @@ func (s *SysJobController) Add(c *gin.Context) {
// 调度任务新增【%s】失败，任务传入参数json字符串不正确
msg := i18n.TTemplate(language, "job.errTargetParams", map[string]any{"name": body.JobName})
if len(body.TargetParams) < 7 {
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
if !json.Valid([]byte(body.TargetParams)) {
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
// 检查属性值唯一
uniqueJob := s.sysJobService.CheckUniqueJobName(body.JobName, body.JobGroup, "")
uniqueJob := s.sysJobService.CheckUniqueByJobName(body.JobName, body.JobGroup, 0)
if !uniqueJob {
// 调度任务新增【%s】失败，同任务组内有相同任务名称
msg := i18n.TTemplate(language, "job.errJobExists", map[string]any{"name": body.JobName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysJobService.InsertJob(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysJobService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务修改
//
// PUT /
func (s *SysJobController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysJob
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.JobID == "" {
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 body.JobId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: jobId is empty"))
return
}
@@ -150,7 +155,7 @@ func (s *SysJobController) Edit(c *gin.Context) {
if parse.CronExpression(body.CronExpression) == 0 {
// 调度任务修改【%s】失败，Cron表达式不正确
msg := i18n.TTemplate(language, "job.errCronExpression", map[string]any{"name": body.JobName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
@@ -159,179 +164,188 @@ func (s *SysJobController) Edit(c *gin.Context) {
// 调度任务修改【%s】失败，任务传入参数json字符串不正确
msg := i18n.TTemplate(language, "job.errTargetParams", map[string]any{"name": body.JobName})
if len(body.TargetParams) < 7 {
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
if !json.Valid([]byte(body.TargetParams)) {
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
// 检查是否存在
job := s.sysJobService.SelectJobById(body.JobID)
if job.JobID != body.JobID {
jobInfo := s.sysJobService.FindById(body.JobId)
if jobInfo.JobId != body.JobId {
// 没有可访问调度任务数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "job.noData")))
return
}
// 检查属性值唯一
uniqueJob := s.sysJobService.CheckUniqueJobName(body.JobName, body.JobGroup, body.JobID)
uniqueJob := s.sysJobService.CheckUniqueByJobName(body.JobName, body.JobGroup, body.JobId)
if !uniqueJob {
// 调度任务修改【%s】失败，同任务组内有相同任务名称
msg := i18n.TTemplate(language, "job.errJobExists", map[string]any{"name": body.JobName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, job.JobName)
if i18nValue != job.JobName {
i18n.UpdateKeyValue(language, job.JobName, body.JobName)
body.JobName = job.JobName
i18nValue := i18n.TKey(language, jobInfo.JobName)
if i18nValue != jobInfo.JobName {
systemService.NewSysI18n.UpdateKeyValue(language, jobInfo.JobName, body.JobName)
body.JobName = jobInfo.JobName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, job.Remark)
if i18nValue2 != job.Remark {
i18n.UpdateKeyValue(language, job.Remark, body.Remark)
body.Remark = job.Remark
i18nValue2 := i18n.TKey(language, jobInfo.Remark)
if i18nValue2 != jobInfo.Remark {
systemService.NewSysI18n.UpdateKeyValue(language, jobInfo.Remark, body.Remark)
body.Remark = jobInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysJobService.UpdateJob(body)
jobInfo.JobName = body.JobName
jobInfo.JobGroup = body.JobGroup
jobInfo.InvokeTarget = body.InvokeTarget
jobInfo.TargetParams = body.TargetParams
jobInfo.CronExpression = body.CronExpression
jobInfo.MisfirePolicy = body.MisfirePolicy
jobInfo.Concurrent = body.Concurrent
jobInfo.StatusFlag = body.StatusFlag
jobInfo.SaveLog = body.SaveLog
jobInfo.Remark = body.Remark
jobInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysJobService.Update(jobInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务删除
//
// DELETE /:jobIds
// DELETE /:jobId
func (s *SysJobController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
jobIds := c.Param("jobIds")
if jobIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
jobId := c.Param("jobId")
if jobId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: jobId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(jobIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(jobId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.sysJobService.DeleteJobByIds(uniqueIDs)
rows, err := s.sysJobService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(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))
}
// 调度任务修改状态
//
// PUT /changeStatus
func (s *SysJobController) Status(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
// 任务ID
JobId string `json:"jobId" binding:"required"`
// 状态
Status string `json:"status" binding:"required"`
JobId int64 `json:"jobId" binding:"required"`
StatusFlag string `json:"statusFlag" binding:"required,oneof=0 1 2"`
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if 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
}
// 检查是否存在
job := s.sysJobService.SelectJobById(body.JobId)
if job.JobID != body.JobId {
// 检查是否存在
jobInfo := s.sysJobService.FindById(body.JobId)
if jobInfo.JobId != body.JobId {
// 没有可访问调度任务数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "job.noData")))
return
}
// 与旧值相等不变更
if job.Status == body.Status {
if jobInfo.StatusFlag == body.StatusFlag {
// 变更状态与旧值相等！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.statusEq")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "job.statusEq")))
return
}
// 更新状态
job.Status = body.Status
job.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysJobService.UpdateJob(job)
jobInfo.StatusFlag = body.StatusFlag
jobInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysJobService.Update(jobInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务立即执行一次
//
// PUT /run/:jobId
func (s *SysJobController) Run(c *gin.Context) {
language := ctx.AcceptLanguage(c)
jobId := c.Param("jobId")
if jobId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
jobId := parse.Number(c.Param("jobId"))
if jobId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: jobId is empty"))
return
}
// 检查是否存在
job := s.sysJobService.SelectJobById(jobId)
if job.JobID != jobId {
job := s.sysJobService.FindById(jobId)
if job.JobId != jobId {
// 没有可访问调度任务数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "job.noData")))
return
}
ok := s.sysJobService.RunQueueJob(job)
ok := s.sysJobService.Run(job)
if ok {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务重置刷新队列
//
// PUT /resetQueueJob
func (s *SysJobController) ResetQueueJob(c *gin.Context) {
s.sysJobService.ResetQueueJob()
c.JSON(200, result.Ok(nil))
s.sysJobService.Reset()
c.JSON(200, resp.Ok(nil))
}
// 导出调度任务信息
// Export 导出调度任务信息
//
// POST /export
// GET /export
func (s *SysJobController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysJobService.SelectJobPage(querys)
if parse.Number(data["total"]) == 0 {
query := reqctx.QueryMap(c)
rows, total := s.sysJobService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysJob)
// rows := s.sysJobService.SelectJobList(model.SysJob{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -358,7 +372,7 @@ func (s *SysJobController) Export(c *gin.Context) {
// "E1": i18n.TKey(language, "job.export.targetParams"),
}
// 读取任务组名字典数据
dictSysJobGroup := s.sysDictDataService.SelectDictDataByType("sys_job_group")
dictSysJobGroup := s.sysDictDataService.FindByType("sys_job_group")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
@@ -366,19 +380,19 @@ func (s *SysJobController) Export(c *gin.Context) {
// 任务组名
sysJobGroup := ""
for _, v := range dictSysJobGroup {
if row.JobGroup == v.DictValue {
sysJobGroup = i18n.TKey(language, v.DictLabel)
if row.JobGroup == v.DataValue {
sysJobGroup = i18n.TKey(language, v.DataLabel)
break
}
}
// 状态
statusValue := i18n.TKey(language, "dictData.fail")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.success")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.JobID,
"A" + idx: row.JobId,
"B" + idx: row.JobName,
"C" + idx: sysJobGroup,
"D" + idx: row.InvokeTarget,
@@ -392,7 +406,7 @@ func (s *SysJobController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

121
src/modules/monitor/controller/sys_job_log.go
View File

@@ -3,15 +3,14 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"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/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/service"
systemService "be.ems/src/modules/system/service"
@@ -21,6 +20,7 @@ import (
// 实例化控制层 SysJobLogController 结构体
var NewSysJobLog = &SysJobLogController{
sysJobService: service.NewSysJob,
sysJobLogService: service.NewSysJobLog,
sysDictDataService: systemService.NewSysDictData,
}
@@ -29,6 +29,7 @@ var NewSysJobLog = &SysJobLogController{
//
// PATH /monitor/jobLog
type SysJobLogController struct {
sysJobService *service.SysJob // 调度任务服务
sysJobLogService *service.SysJobLog // 调度任务日志服务
sysDictDataService *systemService.SysDictData // 字典数据服务
}
@@ -37,22 +38,23 @@ type SysJobLogController struct {
//
// GET /list
func (s *SysJobLogController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
// 查询参数转换map
querys := ctx.QueryMap(c)
query := reqctx.QueryMap(c)
// 任务ID优先级更高
if v, ok := querys["jobId"]; ok && v != nil {
jobInfo := service.NewSysJob.SelectJobById(v.(string))
querys["jobName"] = jobInfo.JobName
querys["jobGroup"] = jobInfo.JobGroup
if jobIdStr := c.Query("jobId"); jobIdStr != "" {
if jobId := parse.Number(jobIdStr); jobId > 0 {
job := s.sysJobService.FindById(jobId)
query["jobName"] = job.JobName
query["jobGroup"] = job.JobGroup
}
}
// 多语言值转key查询
if v, ok := querys["jobName"]; ok && v != "" {
querys["jobName"] = i18n.TFindKeyPrefix(language, "job", v.(string))
if v, ok := query["jobName"]; ok && v != "" {
query["jobName"] = i18n.TFindKeyPrefix(language, "job", v)
}
data := s.sysJobLogService.SelectJobLogPage(querys)
rows := data["rows"].([]model.SysJobLog)
rows, total := s.sysJobLogService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysJobLog) {
@@ -62,88 +64,89 @@ func (s *SysJobLogController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 调度任务日志信息
//
// GET /:jobLogId
// GET /:logId
func (s *SysJobLogController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
jobLogId := c.Param("jobLogId")
if jobLogId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
logId := parse.Number(c.Param("logId"))
if logId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: logId is empty"))
return
}
data := s.sysJobLogService.SelectJobLogById(jobLogId)
if data.JobLogID == jobLogId {
c.JSON(200, result.OkData(data))
jobLogInfo := s.sysJobLogService.FindById(logId)
if jobLogInfo.LogId == logId {
c.JSON(200, resp.OkData(jobLogInfo))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务日志删除
//
// DELETE /:jobLogIds
// DELETE /:logId
func (s *SysJobLogController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
jobLogIds := c.Param("jobLogIds")
if jobLogIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
logId := c.Param("logId")
if logId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: logId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(jobLogIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(logId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows := s.sysJobLogService.DeleteJobLogByIds(uniqueIDs)
rows := s.sysJobLogService.DeleteByIds(ids)
if rows > 0 {
// 删除成功：%d
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 调度任务日志清空
//
// DELETE /clean
func (s *SysJobLogController) Clean(c *gin.Context) {
err := s.sysJobLogService.CleanJobLog()
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.Ok(nil))
rows := s.sysJobLogService.Clean()
c.JSON(200, resp.OkData(rows))
}
// 导出调度任务日志信息
// Export 导出调度任务日志信息
//
// POST /export
// GET /export
func (s *SysJobLogController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysJobLogService.SelectJobLogPage(querys)
if parse.Number(data["total"]) == 0 {
query := reqctx.QueryMap(c)
if jobIdStr := c.Query("jobId"); jobIdStr != "" {
if jobId := parse.Number(jobIdStr); jobId > 0 {
job := s.sysJobService.FindById(jobId)
query["jobName"] = job.JobName
query["jobGroup"] = job.JobGroup
}
}
rows, total := s.sysJobLogService.FindByPage(query)
if total == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysJobLog)
// rows := s.sysJobLogService.SelectJobLogList(model.SysJobLog{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -170,7 +173,7 @@ func (s *SysJobLogController) Export(c *gin.Context) {
"G1": i18n.TKey(language, "log.operate.export.costTime"),
}
// 读取任务组名字典数据
dictSysJobGroup := s.sysDictDataService.SelectDictDataByType("sys_job_group")
dictSysJobGroup := s.sysDictDataService.FindByType("sys_job_group")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
@@ -178,18 +181,18 @@ func (s *SysJobLogController) Export(c *gin.Context) {
// 任务组名
sysJobGroup := ""
for _, v := range dictSysJobGroup {
if row.JobGroup == v.DictValue {
sysJobGroup = i18n.TKey(language, v.DictLabel)
if row.JobGroup == v.DataValue {
sysJobGroup = i18n.TKey(language, v.DataLabel)
break
}
}
// 状态
statusValue := i18n.TKey(language, "dictData.fail")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.success")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.JobLogID,
"A" + idx: row.LogId,
"B" + idx: row.JobName,
"C" + idx: sysJobGroup,
"D" + idx: row.InvokeTarget,
@@ -204,7 +207,7 @@ func (s *SysJobLogController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

86
src/modules/monitor/controller/sys_user_online.go
View File

@@ -2,15 +2,15 @@ package controller
import (
"encoding/json"
"fmt"
"sort"
"strings"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/i18n"
"be.ems/src/framework/redis"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo"
"be.ems/src/framework/vo/result"
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/framework/resp"
"be.ems/src/framework/token"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/service"
@@ -42,12 +42,11 @@ type SysUserOnlineController struct {
// @Description System Online User List
// @Router /monitor/online/list [get]
func (s *SysUserOnlineController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
ipaddr := c.Query("ipaddr")
loginIp := c.Query("loginIp")
userName := c.Query("userName")
// 获取所有在线用户key
keys, _ := redis.GetKeys("", cachekey.LOGIN_TOKEN_KEY+"*")
keys, _ := redis.GetKeys("", constants.CACHE_LOGIN_TOKEN+":*")
// 分批获取
arr := make([]string, 0)
@@ -59,81 +58,84 @@ func (s *SysUserOnlineController) List(c *gin.Context) {
chunk := keys[i:end]
values, _ := redis.GetBatch("", chunk)
for _, v := range values {
arr = append(arr, v.(string))
arr = append(arr, fmt.Sprint(v))
}
}
// 遍历字符串信息解析组合可用对象
userOnlines := make([]model.SysUserOnline, 0)
var userOnlines []model.SysUserOnline
for _, str := range arr {
if str == "" {
continue
}
var loginUser vo.LoginUser
err := json.Unmarshal([]byte(str), &loginUser)
var tokenInfo token.TokenInfo
err := json.Unmarshal([]byte(str), &tokenInfo)
if err != nil {
continue
}
onlineUser := s.sysUserOnlineService.LoginUserToUserOnline(loginUser)
onlineUser := s.sysUserOnlineService.TokenInfoToUserOnline(tokenInfo)
if onlineUser.TokenID != "" {
onlineUser.LoginLocation = i18n.TKey(language, onlineUser.LoginLocation)
userOnlines = append(userOnlines, onlineUser)
}
}
// 根据查询条件过滤
filteredUserOnlines := make([]model.SysUserOnline, 0)
if ipaddr != "" && userName != "" {
filteredUserOnline := make([]model.SysUserOnline, 0)
if loginIp != "" && userName != "" {
for _, o := range userOnlines {
if strings.Contains(o.IPAddr, ipaddr) && strings.Contains(o.UserName, userName) {
filteredUserOnlines = append(filteredUserOnlines, o)
if strings.Contains(o.LoginIp, loginIp) && strings.Contains(o.UserName, userName) {
filteredUserOnline = append(filteredUserOnline, o)
}
}
} else if ipaddr != "" {
} else if loginIp != "" {
for _, o := range userOnlines {
if strings.Contains(o.IPAddr, ipaddr) {
filteredUserOnlines = append(filteredUserOnlines, o)
if strings.Contains(o.LoginIp, loginIp) {
filteredUserOnline = append(filteredUserOnline, o)
}
}
} else if userName != "" {
for _, o := range userOnlines {
if strings.Contains(o.UserName, userName) {
filteredUserOnlines = append(filteredUserOnlines, o)
filteredUserOnline = append(filteredUserOnline, o)
}
}
} else {
filteredUserOnlines = userOnlines
filteredUserOnline = userOnlines
}
// 按登录时间排序
sort.Slice(filteredUserOnlines, func(i, j int) bool {
return filteredUserOnlines[j].LoginTime > filteredUserOnlines[i].LoginTime
sort.Slice(filteredUserOnline, func(i, j int) bool {
return filteredUserOnline[j].LoginTime > filteredUserOnline[i].LoginTime
})
c.JSON(200, result.Ok(map[string]any{
"total": len(filteredUserOnlines),
"rows": filteredUserOnlines,
c.JSON(200, resp.OkData(map[string]any{
"total": len(filteredUserOnline),
"rows": filteredUserOnline,
}))
}
// 在线用户强制退出
// Logout 在线用户强制退出
//
// DELETE /:tokenId
func (s *SysUserOnlineController) ForceLogout(c *gin.Context) {
language := ctx.AcceptLanguage(c)
tokenId := c.Param("tokenId")
if tokenId == "" || tokenId == "*" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// DELETE /logout/:tokenId
func (s SysUserOnlineController) Logout(c *gin.Context) {
tokenIdStr := c.Param("tokenId")
if tokenIdStr == "" || strings.Contains(tokenIdStr, "*") {
c.JSON(400, resp.CodeMsg(40010, "bind err: tokenId is empty"))
return
}
// 删除token
ok, _ := redis.Del("", cachekey.LOGIN_TOKEN_KEY+tokenId)
if ok {
c.JSON(200, result.Ok(nil))
return
// 处理字符转id数组后去重
ids := strings.Split(tokenIdStr, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
for _, v := range uniqueIDs {
key := constants.CACHE_LOGIN_TOKEN + ":" + v
if err := redis.Del("", key); err != nil {
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Ok(nil))
}

37
src/modules/monitor/controller/system_info.go
View File

@@ -1,22 +1,23 @@
package controller
import (
"be.ems/src/framework/vo/result"
"be.ems/src/framework/resp"
"be.ems/src/modules/monitor/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SystemInfoController 结构体
var NewSystemInfo = &SystemInfoController{
systemInfogService: service.NewSystemInfo,
// NewSystem 实例化控制层
var NewSystem = &SystemController{
systemInfoService: service.NewSystemInfo,
}
// 服务器监控信息
// SystemController 服务器监控信息 控制层处理
//
// PATH /monitor/system-info
type SystemInfoController struct {
systemInfogService *service.SystemInfo // 服务器系统相关信息服务
// PATH /monitor/system
type SystemController struct {
// 服务器系统相关信息服务
systemInfoService *service.SystemInfo
}
// 服务器信息
@@ -28,17 +29,17 @@ type SystemInfoController struct {
// @Produce json
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Server Information
// @Description Server Information
// @Summary System Server Information
// @Description System Server Information
// @Router /monitor/system-info [get]
func (s *SystemInfoController) Info(c *gin.Context) {
func (s SystemController) Info(c *gin.Context) {
data := map[string]any{
"cpu": s.systemInfogService.CPUInfo(),
"memory": s.systemInfogService.MemoryInfo(),
"network": s.systemInfogService.NetworkInfo(),
"time": s.systemInfogService.TimeInfo(),
"system": s.systemInfogService.SystemInfo(),
"disk": s.systemInfogService.DiskInfo(),
"cpu": s.systemInfoService.CPUInfo(),
"memory": s.systemInfoService.MemoryInfo(),
"network": s.systemInfoService.NetworkInfo(),
"time": s.systemInfoService.TimeInfo(),
"system": s.systemInfoService.SystemInfo(),
"disk": s.systemInfoService.DiskInfo(),
}
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}

18
src/modules/monitor/model/monitor_base.go
View File

@@ -3,15 +3,15 @@ package model
// MonitorBase 监控_基本信息 monitor_base
type MonitorBase struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
CPU float64 `json:"cpu" gorm:"cpu"` // cpu使用率
LoadUsage float64 `json:"loadUsage" gorm:"load_usage"` // cpu平均使用率
CPULoad1 float64 `json:"cpuLoad1" gorm:"cpu_load1"` // cpu使用1分钟
CPULoad5 float64 `json:"cpuLoad5" gorm:"cpu_load5"` // cpu使用5分钟
CPULoad15 float64 `json:"cpuLoad15" gorm:"cpu_load15"` // cpu使用15分钟
Memory float64 `json:"memory" gorm:"memory"` // 内存使用率
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
CPU float64 `json:"cpu" gorm:"column:cpu"` // cpu使用率
LoadUsage float64 `json:"loadUsage" gorm:"column:load_usage"` // cpu平均使用率
CPULoad1 float64 `json:"cpuLoad1" gorm:"column:cpu_load1"` // cpu使用1分钟
CPULoad5 float64 `json:"cpuLoad5" gorm:"column:cpu_load5"` // cpu使用5分钟
CPULoad15 float64 `json:"cpuLoad15" gorm:"column:cpu_load15"` // cpu使用15分钟
Memory float64 `json:"memory" gorm:"column:memory"` // 内存使用率
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeID string `json:"neId" gorm:"column:ne_id"` // 网元ID
}
// TableName 表名称

16
src/modules/monitor/model/monitor_io.go
View File

@@ -3,14 +3,14 @@ package model
// MonitorIO 监控_磁盘IO monitor_io
type MonitorIO struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
Name string `json:"name" gorm:"name"` // 磁盘名
Read int64 `json:"read" gorm:"read"` // 读取K
Write int64 `json:"write" gorm:"write"` // 写入K
Count int64 `json:"count" gorm:"count"` // 读写次数
Time int64 `json:"time" gorm:"time"` // 读写延迟
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
Name string `json:"name" gorm:"column:name"` // 磁盘名
Read int64 `json:"read" gorm:"column:read"` // 读取K
Write int64 `json:"write" gorm:"column:write"` // 写入K
Count int64 `json:"count" gorm:"column:count"` // 读写次数
Time int64 `json:"time" gorm:"column:time"` // 读写延迟
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeID string `json:"neId" gorm:"column:ne_id"` // 网元ID
}
// TableName 表名称

12
src/modules/monitor/model/monitor_network.go
View File

@@ -3,12 +3,12 @@ package model
// MonitorNetwork 监控_网络IO monitor_network
type MonitorNetwork struct {
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
Name string `json:"name" gorm:"name"` // 网卡名
Up float64 `json:"up" gorm:"up"` // 上行
Down float64 `json:"down" gorm:"down"` // 下行
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
Name string `json:"name" gorm:"column:name"` // 网卡名
Up float64 `json:"up" gorm:"column:up"` // 上行
Down float64 `json:"down" gorm:"column:down"` // 下行
NeType string `json:"neType" gorm:"column:ne_type"` // 网元类型
NeID string `json:"neId" gorm:"column:ne_id"` // 网元ID
}
// TableName 表名称

14
src/modules/monitor/model/sys_cache.go
View File

@@ -10,18 +10,18 @@ type SysCache struct {
Remark string `json:"remark"` // 备注
}
// NewSysCacheNames 创建新的缓存名称列表项实例
func NewSysCacheNames(cacheName string, cacheKey string) SysCache {
// NewNames 创建新的缓存名称列表项实例
func NewNames(cacheName string, cacheKey string) SysCache {
return SysCache{
CacheName: cacheKey[:len(cacheKey)-1],
CacheName: cacheKey,
CacheKey: "",
CacheValue: "",
Remark: cacheName,
}
}
// NewSysCacheKeys 创建新的缓存键名列表项实例
func NewSysCacheKeys(cacheName string, cacheKey string) SysCache {
// NewKeys 创建新的缓存键名列表项实例
func NewKeys(cacheName string, cacheKey string) SysCache {
return SysCache{
CacheName: cacheName,
CacheKey: strings.Replace(cacheKey, cacheName+":", "", 1),
@@ -30,8 +30,8 @@ func NewSysCacheKeys(cacheName string, cacheKey string) SysCache {
}
}
// NewSysCacheValue 创建新的缓存键名内容项实例
func NewSysCacheValue(cacheName string, cacheKey string, cacheValue string) SysCache {
// NewValue 创建新的缓存键名内容项实例
func NewValue(cacheName string, cacheKey string, cacheValue string) SysCache {
return SysCache{
CacheName: cacheName,
CacheKey: cacheKey,

52
src/modules/monitor/model/sys_job.go
View File

@@ -1,35 +1,25 @@
package model
// SysJob 调度任务信息表 sys_job
// SysJob 调度任务调度表
type SysJob struct {
// 任务ID
JobID string `json:"jobId"`
// 任务名称
JobName string `json:"jobName" binding:"required"`
// 任务组名
JobGroup string `json:"jobGroup" binding:"required"`
// 调用目标字符串
InvokeTarget string `json:"invokeTarget" binding:"required"`
// 调用目标传入参数
TargetParams string `json:"targetParams"`
// cron执行表达式
CronExpression string `json:"cronExpression" binding:"required"`
// 计划执行错误策略（1立即执行 2执行一次 3放弃执行）
MisfirePolicy string `json:"misfirePolicy"`
// 是否并发执行（0禁止 1允许）
Concurrent string `json:"concurrent"`
// 任务状态（0暂停 1正常）
Status string `json:"status"`
// 是否记录任务日志
SaveLog string `json:"saveLog"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
JobId int64 `json:"jobId" gorm:"column:job_id;primaryKey;autoIncrement"` // 任务ID
JobName string `json:"jobName" gorm:"column:job_name" binding:"required"` // 任务名称
JobGroup string `json:"jobGroup" gorm:"column:job_group" binding:"required"` // 任务组名
InvokeTarget string `json:"invokeTarget" gorm:"column:invoke_target" binding:"required"` // 调用目标字符串
TargetParams string `json:"targetParams" gorm:"column:target_params"` // 调用目标传入参数
CronExpression string `json:"cronExpression" gorm:"column:cron_expression" binding:"required"` // cron执行表达式
MisfirePolicy string `json:"misfirePolicy" gorm:"column:misfire_policy"` // 计划执行错误策略（1立即执行 2执行一次 3放弃执行）
Concurrent string `json:"concurrent" gorm:"column:concurrent"` // 是否并发执行（0禁止 1允许）
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 任务状态（0暂停 1正常）
SaveLog string `json:"saveLog" gorm:"column:save_log"` // 是否记录任务日志（0不记录 1记录）
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"` // 备注
}
// TableName 表名称
func (*SysJob) TableName() string {
return "sys_job"
}

34
src/modules/monitor/model/sys_job_log.go
View File

@@ -1,23 +1,19 @@
package model
// SysJobLog 定时任务调度日志表 sys_job_log
// SysJobLog 调度任务调度日志表
type SysJobLog struct {
// 日志序号
JobLogID string `json:"jobLogId"`
// 任务名称
JobName string `json:"jobName"`
// 任务组名
JobGroup string `json:"jobGroup"`
// 调用目标字符串
InvokeTarget string `json:"invokeTarget"`
// 调用目标传入参数
TargetParams string `json:"targetParams"`
// 日志信息
JobMsg string `json:"jobMsg"`
// 执行状态（0失败 1正常）
Status string `json:"status"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 消耗时间（毫秒）
CostTime int64 `json:"costTime"`
LogId int64 `json:"logId" gorm:"column:log_id;primaryKey;autoIncrement"` // 任务日志ID
JobName string `json:"jobName" gorm:"column:job_name"` // 任务名称
JobGroup string `json:"jobGroup" gorm:"column:job_group"` // 任务组名
InvokeTarget string `json:"invokeTarget" gorm:"column:invoke_target"` // 调用目标字符串
TargetParams string `json:"targetParams" gorm:"column:target_params"` // 调用目标传入参数
JobMsg string `json:"jobMsg" gorm:"column:job_msg"` // 日志信息
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 执行状态（0失败 1正常）
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
CostTime int64 `json:"costTime" gorm:"column:cost_time"` // 消耗时间（毫秒）
}
// TableName 表名称
func (*SysJobLog) TableName() string {
return "sys_job_log"
}

24
src/modules/monitor/model/sys_user_online.go
View File

@@ -2,20 +2,12 @@ package model
// SysUserOnline 当前在线会话对象
type SysUserOnline struct {
// 会话编号
TokenID string `json:"tokenId"`
// 部门名称
DeptName string `json:"deptName"`
// 用户名称
UserName string `json:"userName"`
// 登录IP地址
IPAddr string `json:"ipaddr"`
// 登录地址
LoginLocation string `json:"loginLocation"`
// 浏览器类型
Browser string `json:"browser"`
// 操作系统
OS string `json:"os"`
// 登录时间
LoginTime int64 `json:"loginTime"`
TokenID string `json:"tokenId"` // 会话编号
DeptName string `json:"deptName"` // 部门名称
UserName string `json:"userName"` // 用户名称
LoginIp string `json:"loginIp"` // 登录IP地址
LoginLocation string `json:"loginLocation"` // 登录地址
Browser string `json:"browser"` // 浏览器类型
OS string `json:"os"` // 操作系统
LoginTime int64 `json:"loginTime"` // 登录时间
}

66
src/modules/monitor/monitor.go
View File

@@ -28,13 +28,26 @@ func Setup(router *gin.Engine) {
)
}
// 服务器服务信息
router.GET("/monitor/system-info",
// 服务器信息
router.GET("/monitor/system",
// middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:system:info"}}),
middleware.PreAuthorize(nil),
controller.NewSystemInfo.Info,
controller.NewSystem.Info,
)
// 在线用户监控
sysUserOnlineGroup := router.Group("/monitor/user-online")
{
sysUserOnlineGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:online:list"}}),
controller.NewSysUserOnline.List,
)
sysUserOnlineGroup.DELETE("/logout/:tokenId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:online:logout"}}),
controller.NewSysUserOnline.Logout,
)
}
// 缓存服务信息
sysCacheGroup := router.Group("/monitor/cache")
{
@@ -43,29 +56,29 @@ func Setup(router *gin.Engine) {
middleware.PreAuthorize(nil),
controller.NewSysCache.Info,
)
sysCacheGroup.GET("/getNames",
sysCacheGroup.GET("/names",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:list"}}),
controller.NewSysCache.Names,
)
sysCacheGroup.GET("/getKeys/:cacheName",
sysCacheGroup.GET("/keys",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:list"}}),
controller.NewSysCache.Keys,
)
sysCacheGroup.GET("/getValue/:cacheName/:cacheKey",
sysCacheGroup.GET("/value",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:query"}}),
controller.NewSysCache.Value,
)
sysCacheGroup.DELETE("/clearCacheName/:cacheName",
sysCacheGroup.DELETE("/names",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
controller.NewSysCache.ClearCacheName,
controller.NewSysCache.CleanNames,
)
sysCacheGroup.DELETE("/clearCacheKey/:cacheName/:cacheKey",
sysCacheGroup.DELETE("/keys",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
controller.NewSysCache.ClearCacheKey,
controller.NewSysCache.CleanKeys,
)
sysCacheGroup.DELETE("/clearCacheSafe",
sysCacheGroup.DELETE("/value",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
controller.NewSysCache.ClearCacheSafe,
controller.NewSysCache.CleanValue,
)
}
@@ -76,11 +89,11 @@ func Setup(router *gin.Engine) {
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:list"}}),
controller.NewSysJobLog.List,
)
sysJobLogGroup.GET("/:jobLogId",
sysJobLogGroup.GET("/:logId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:query"}}),
controller.NewSysJobLog.Info,
)
sysJobLogGroup.DELETE("/:jobLogIds",
sysJobLogGroup.DELETE("/:logId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJobLog", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysJobLog.Remove,
@@ -91,7 +104,7 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJobLog", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysJobLog.Clean,
)
sysJobLogGroup.POST("/export",
sysJobLogGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJobLog", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysJobLog.Export,
@@ -119,12 +132,12 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysJob.Edit,
)
sysJobGroup.DELETE("/:jobIds",
sysJobGroup.DELETE("/:jobId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysJob.Remove,
)
sysJobGroup.PUT("/changeStatus",
sysJobGroup.PUT("/status",
repeat.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:changeStatus"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
@@ -136,30 +149,17 @@ func Setup(router *gin.Engine) {
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysJob.Run,
)
sysJobGroup.PUT("/resetQueueJob",
sysJobGroup.PUT("/reset",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:changeStatus"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysJob.ResetQueueJob,
)
sysJobGroup.POST("/export",
sysJobGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysJob.Export,
)
}
// 在线用户监控
sysUserOnlineGroup := router.Group("/monitor/online")
{
sysUserOnlineGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:online:list"}}),
controller.NewSysUserOnline.List,
)
sysUserOnlineGroup.DELETE("/:tokenId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:online:forceLogout"}}),
controller.NewSysUserOnline.ForceLogout,
)
}
}
// InitLoad 初始参数
@@ -167,5 +167,5 @@ func InitLoad() {
// 初始化定时任务处理
processor.InitCronQueue()
// 启动时，初始化调度任务
service.NewSysJob.ResetQueueJob()
service.NewSysJob.Reset()
}

4
src/modules/monitor/processor/bar/bar.go
View File

@@ -26,7 +26,7 @@ func (s *BarProcessor) Execute(data any) (any, error) {
options := data.(cron.JobData)
sysJob := options.SysJob
logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
logger.Infof("重复 %v 任务ID %d", options.Repeat, sysJob.JobId)
// 实现任务处理逻辑
i := 0
@@ -34,7 +34,7 @@ func (s *BarProcessor) Execute(data any) (any, error) {
for i < 5 {
// 获取任务进度
progress := s.progress
logger.Infof("jonId: %s => 任务进度：%d", sysJob.JobID, progress)
logger.Infof("jonId: %d => 任务进度：%d", sysJob.JobId, progress)
// 延迟响应
time.Sleep(time.Second * 2)
// 程序中途执行错误

4
src/modules/monitor/processor/foo/foo.go
View File

@@ -26,7 +26,7 @@ func (s *FooProcessor) Execute(data any) (any, error) {
options := data.(cron.JobData)
sysJob := options.SysJob
logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
logger.Infof("重复 %v 任务ID %d", options.Repeat, sysJob.JobId)
// 实现任务处理逻辑
i := 0
@@ -34,7 +34,7 @@ func (s *FooProcessor) Execute(data any) (any, error) {
for i < 20 {
// 获取任务进度
progress := s.progress
logger.Infof("jonId: %s => 任务进度：%d", sysJob.JobID, progress)
logger.Infof("jonId: %d => 任务进度：%d", sysJob.JobId, progress)
// 延迟响应
time.Sleep(time.Second * 2)
i++

2
src/modules/monitor/processor/simple/simple.go
View File

@@ -14,7 +14,7 @@ func (s *simpleProcessor) Execute(data any) (any, error) {
options := data.(cron.JobData)
sysJob := options.SysJob
logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
logger.Infof("重复 %v 任务ID %d", options.Repeat, sysJob.JobId)
// 返回结果，用于记录执行结果
result := map[string]any{

133
src/modules/monitor/repository/monitor.go
View File

@@ -1,33 +1,114 @@
package repository
import "be.ems/src/modules/monitor/model"
import (
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
)
// IMonitor 监控服务资源相关信息 数据接口
type IMonitor interface {
// CreateMonitorBase 创建监控_基本信息
CreateMonitorBase(m model.MonitorBase) error
// 实例化数据层 Monitor 结构体
var NewMonitor = &Monitor{}
// DelMonitorBase 删除监控_基本信息
DelMonitorBase(ltTime int64) error
// Monitor 监控服务资源相关信息 数据层处理
type Monitor struct{}
// SelectMonitorBase 查询监控_基本信息
SelectMonitorBase(query map[string]any) []model.MonitorBase
// SelectByBase 查询监控_基本信息
func (r Monitor) SelectByBase(query map[string]any) []model.MonitorBase {
tx := db.DB("").Model(&model.MonitorBase{})
// 查询条件拼接
if v, ok := query["neType"]; ok && v != "" {
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
tx.Where("create_time >= ? and create_time <= ?", query["beginTime"], query["endTime"])
// BatchCreateMonitorIO 批量创建监控_IO
BatchCreateMonitorIO(ioList []model.MonitorIO) error
// DelMonitorIO 删除监控_IO
DelMonitorIO(ltTime int64) error
// SelectMonitorIO 查询监控_IO
SelectMonitorIO(query map[string]any) []model.MonitorIO
// BatchCreateMonitorNet 批量创建监控_网络
BatchCreateMonitorNet(netList []model.MonitorNetwork) error
// DelMonitorNet 删除监控_网络
DelMonitorNet(ltTime int64) error
// SelectMonitorNetwork 查询监控_网络
SelectMonitorNetwork(query map[string]any) []model.MonitorNetwork
// 查询数据
rows := []model.MonitorBase{}
if err := tx.Order("create_time asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// InsertByBase 创建监控_基本信息
func (r Monitor) InsertByBase(param model.MonitorBase) error {
return db.DB("").Create(&param).Error
}
// DeleteByBase 删除监控_基本信息
func (r Monitor) DeleteByBase(ltTime int64) error {
return db.DB("").Where("create_time < ?", ltTime).Delete(&model.MonitorBase{}).Error
}
// SelectByIO 查询监控_IO
func (r Monitor) SelectByIO(query map[string]any) []model.MonitorIO {
tx := db.DB("").Model(&model.MonitorIO{})
// 查询条件拼接
if v, ok := query["name"]; ok && v != "" {
tx = tx.Where("name = ?", v)
}
if v, ok := query["neType"]; ok && v != "" {
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
tx.Where("create_time >= ? and create_time <= ?", query["beginTime"], query["endTime"])
// 查询数据
rows := []model.MonitorIO{}
if err := tx.Order("create_time asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// BatchInsertByIO 批量创建监控_IO
func (r Monitor) BatchInsertByIO(arr []model.MonitorIO) error {
return db.DB("").CreateInBatches(arr, 100).Error
}
// DeleteByIO 删除监控_IO
func (r Monitor) DeleteByIO(ltTime int64) error {
return db.DB("").Where("create_time < ?", ltTime).Delete(&model.MonitorIO{}).Error
}
// SelectByNetwork 查询监控_网络
func (r Monitor) SelectByNetwork(query map[string]any) []model.MonitorNetwork {
tx := db.DB("").Model(&model.MonitorNetwork{})
// 查询条件拼接
if v, ok := query["name"]; ok && v != "" {
tx = tx.Where("name = ?", v)
} else {
tx = tx.Where("name = 'all'")
}
if v, ok := query["neType"]; ok && v != "" {
tx = tx.Where("ne_type = ?", v)
}
if v, ok := query["neId"]; ok && v != "" {
tx = tx.Where("ne_id = ?", v)
}
tx.Where("create_time >= ? and create_time <= ?", query["beginTime"], query["endTime"])
// 查询数据
rows := []model.MonitorNetwork{}
if err := tx.Order("create_time asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// BatchInsertByNetwork 批量创建监控_网络
func (r Monitor) BatchInsertByNetwork(arr []model.MonitorNetwork) error {
return db.DB("").CreateInBatches(arr, 100).Error
}
// DeleteByNetwork 删除监控_网络
func (r Monitor) DeleteByNetwork(ltTime int64) error {
return db.DB("").Where("create_time < ?", ltTime).Delete(&model.MonitorNetwork{}).Error
}

105
src/modules/monitor/repository/monitor.impl.go
View File

@@ -1,105 +0,0 @@
package repository
import (
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
"gorm.io/gorm"
)
// 实例化数据层 MonitorImpl 结构体
var NewMonitorImpl = &MonitorImpl{
db: datasource.DefaultDB,
}
// MonitorImpl 监控服务资源相关信息 数据层处理
type MonitorImpl struct {
// 数据库实例
db func() *gorm.DB
}
// CreateMonitorBase 创建监控_基本信息
func (r *MonitorImpl) CreateMonitorBase(m model.MonitorBase) error {
return r.db().Create(&m).Error
}
// DelMonitorBase 删除监控_基本信息
func (r *MonitorImpl) DelMonitorBase(ltTime int64) error {
return r.db().Where("create_time < ?", ltTime).Delete(&model.MonitorBase{}).Error
}
// SelectMonitorBase 查询监控_基本信息
func (r *MonitorImpl) SelectMonitorBase(query map[string]any) []model.MonitorBase {
var bases []model.MonitorBase
dbConn := r.db()
if query["neType"] != "" && query["neId"] != "" {
dbConn = dbConn.Where("ne_type = ? and ne_id = ?", query["neType"], query["neId"])
}
dbConn = dbConn.Where("create_time >= ? and create_time <= ?", query["startTime"], query["endTime"])
err := dbConn.Order("create_time asc").Find(&bases).Error
if err != nil {
logger.Errorf("SelectMonitorBase %v", err)
return bases
}
return bases
}
// BatchCreateMonitorIO 批量创建监控_IO
func (r *MonitorImpl) BatchCreateMonitorIO(ioList []model.MonitorIO) error {
return r.db().CreateInBatches(ioList, len(ioList)).Error
}
// DelMonitorIO 删除监控_IO
func (r *MonitorImpl) DelMonitorIO(ltTime int64) error {
return r.db().Where("create_time < ?", ltTime).Delete(&model.MonitorIO{}).Error
}
// SelectMonitorIO 查询监控_IO
func (r *MonitorImpl) SelectMonitorIO(query map[string]any) []model.MonitorIO {
var ios []model.MonitorIO
dbConn := r.db()
if query["name"] != "" {
dbConn = dbConn.Where("name = ?", query["name"])
}
if query["neType"] != "" && query["neId"] != "" {
dbConn = dbConn.Where("ne_type = ? and ne_id = ?", query["neType"], query["neId"])
}
dbConn = dbConn.Where("create_time >= ? and create_time <= ?", query["startTime"], query["endTime"])
err := dbConn.Order("create_time asc").Find(&ios).Error
if err != nil {
logger.Errorf("SelectMonitorIO %v", err)
return ios
}
return ios
}
// BatchCreateMonitorNet 批量创建监控_网络
func (r *MonitorImpl) BatchCreateMonitorNet(netList []model.MonitorNetwork) error {
return r.db().CreateInBatches(netList, len(netList)).Error
}
// DelMonitorNet 删除监控_网络
func (r *MonitorImpl) DelMonitorNet(ltTime int64) error {
return r.db().Where("create_time < ?", ltTime).Delete(&model.MonitorNetwork{}).Error
}
// SelectMonitorNetwork 查询监控_网络
func (r *MonitorImpl) SelectMonitorNetwork(query map[string]any) []model.MonitorNetwork {
var networks []model.MonitorNetwork
dbConn := r.db()
if query["name"] != "" {
dbConn = dbConn.Where("name = ?", query["name"])
} else {
dbConn = dbConn.Where("name = ?", "all")
}
if query["neType"] != "" && query["neId"] != "" {
dbConn = dbConn.Where("ne_type = ? and ne_id = ?", query["neType"], query["neId"])
}
dbConn = dbConn.Where("create_time >= ? and create_time <= ?", query["startTime"], query["endTime"])
err := dbConn.Order("create_time asc").Find(&networks).Error
if err != nil {
logger.Errorf("SelectMonitorNetwork %v", err)
return networks
}
return networks
}

169
src/modules/monitor/repository/sys_job.go
View File

@@ -1,29 +1,164 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
)
// ISysJob 调度任务表 数据层接口
type ISysJob interface {
// SelectJobPage 分页查询调度任务集合
SelectJobPage(query map[string]any) map[string]any
// NewSysJob 实例化数据层
var NewSysJob = &SysJob{}
// SelectJobList 查询调度任务集合
SelectJobList(sysJob model.SysJob) []model.SysJob
// SysJob 调度任务 数据层处理
type SysJob struct{}
// SelectJobByIds 通过调度ID查询调度任务信息
SelectJobByIds(jobIds []string) []model.SysJob
// SelectByPage 分页查询集合
func (r SysJob) SelectByPage(query map[string]string) ([]model.SysJob, int64) {
tx := db.DB("").Model(&model.SysJob{})
// 查询条件拼接
if v, ok := query["jobName"]; ok && v != "" {
tx = tx.Where("job_name like concat(?, '%')", v)
}
if v, ok := query["jobGroup"]; ok && v != "" {
tx = tx.Where("job_group = ?", v)
}
if v, ok := query["invokeTarget"]; ok && v != "" {
tx = tx.Where("invoke_target like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
// CheckUniqueJob 校验调度任务是否唯一
CheckUniqueJob(sysJob model.SysJob) string
// 查询结果
var total int64 = 0
rows := []model.SysJob{}
// InsertJob 新增调度任务信息
InsertJob(sysJob model.SysJob) string
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// UpdateJob 修改调度任务信息
UpdateJob(sysJob model.SysJob) int64
// DeleteJobByIds 批量删除调度任务信息
DeleteJobByIds(jobIds []string) int64
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysJob) Select(sysJob model.SysJob) []model.SysJob {
tx := db.DB("").Model(&model.SysJob{})
// 查询条件拼接
if sysJob.JobName != "" {
tx = tx.Where("job_name like concat(?, '%')", sysJob.JobName)
}
if sysJob.JobGroup != "" {
tx = tx.Where("job_group = ?", sysJob.JobGroup)
}
if sysJob.InvokeTarget != "" {
tx = tx.Where("invoke_target like concat(?, '%')", sysJob.InvokeTarget)
}
if sysJob.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysJob.StatusFlag)
}
// 查询数据
rows := []model.SysJob{}
if err := tx.Order("job_id asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysJob) SelectByIds(jobIds []int64) []model.SysJob {
rows := []model.SysJob{}
if len(jobIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysJob{})
// 构建查询条件
tx = tx.Where("job_id in ?", jobIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysJob) Insert(sysJob model.SysJob) int64 {
if sysJob.CreateBy != "" {
ms := time.Now().UnixMilli()
sysJob.UpdateBy = sysJob.CreateBy
sysJob.UpdateTime = ms
sysJob.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysJob).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysJob.JobId
}
// Update 修改信息
func (r SysJob) Update(sysJob model.SysJob) int64 {
if sysJob.JobId <= 0 {
return 0
}
if sysJob.UpdateBy != "" {
sysJob.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysJob{})
// 构建查询条件
tx = tx.Where("job_id = ?", sysJob.JobId)
tx = tx.Omit("config_id", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysJob).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息
func (r SysJob) DeleteByIds(jobIds []int64) int64 {
if len(jobIds) <= 0 {
return 0
}
tx := db.DB("").Where("job_id in ?", jobIds)
if err := tx.Delete(&model.SysJob{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 校验信息是否唯一
func (r SysJob) CheckUnique(sysJob model.SysJob) int64 {
tx := db.DB("").Model(&model.SysJob{})
// 查询条件拼接
if sysJob.JobName != "" {
tx = tx.Where("job_name = ?", sysJob.JobName)
}
if sysJob.JobGroup != "" {
tx = tx.Where("job_group = ?", sysJob.JobGroup)
}
// 查询数据
var id int64 = 0
if err := tx.Select("job_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}

343
src/modules/monitor/repository/sys_job.impl.go
View File

@@ -1,343 +0,0 @@
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/monitor/model"
)
// 实例化数据层 SysJobImpl 结构体
var NewSysJobImpl = &SysJobImpl{
selectSql: `select job_id, job_name, job_group, invoke_target, target_params, cron_expression,
misfire_policy, concurrent, status, save_log, create_by, create_time, remark from sys_job`,
resultMap: map[string]string{
"job_id": "JobID",
"job_name": "JobName",
"job_group": "JobGroup",
"invoke_target": "InvokeTarget",
"target_params": "TargetParams",
"cron_expression": "CronExpression",
"misfire_policy": "MisfirePolicy",
"concurrent": "Concurrent",
"status": "Status",
"save_log": "SaveLog",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
}
// SysJobImpl 调度任务表 数据层处理
type SysJobImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysJobImpl) convertResultRows(rows []map[string]any) []model.SysJob {
arr := make([]model.SysJob, 0)
for _, row := range rows {
sysJob := model.SysJob{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysJob, keyMapper, value)
}
}
arr = append(arr, sysJob)
}
return arr
}
// SelectJobPage 分页查询调度任务集合
func (r *SysJobImpl) SelectJobPage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["jobName"]; ok && v != "" {
conditions = append(conditions, "job_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["jobGroup"]; ok && v != "" {
conditions = append(conditions, "job_group = ?")
params = append(params, v)
}
if v, ok := query["invokeTarget"]; ok && v != "" {
conditions = append(conditions, "invoke_target like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysJob{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_job"
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)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectJobList 查询调度任务集合
func (r *SysJobImpl) SelectJobList(sysJob model.SysJob) []model.SysJob {
// 查询条件拼接
var conditions []string
var params []any
if sysJob.JobName != "" {
conditions = append(conditions, "job_name like concat(?, '%')")
params = append(params, sysJob.JobName)
}
if sysJob.JobGroup != "" {
conditions = append(conditions, "job_group = ?")
params = append(params, sysJob.JobGroup)
}
if sysJob.InvokeTarget != "" {
conditions = append(conditions, "invoke_target like concat(?, '%')")
params = append(params, sysJob.InvokeTarget)
}
if sysJob.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysJob.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysJob{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectJobByIds 通过调度ID查询调度任务信息
func (r *SysJobImpl) SelectJobByIds(jobIds []string) []model.SysJob {
placeholder := repo.KeyPlaceholderByQuery(len(jobIds))
querySql := r.selectSql + " where job_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(jobIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysJob{}
}
// 转换实体
return r.convertResultRows(results)
}
// CheckUniqueJob 校验调度任务是否唯一
func (r *SysJobImpl) CheckUniqueJob(sysJob model.SysJob) string {
// 查询条件拼接
var conditions []string
var params []any
if sysJob.JobName != "" {
conditions = append(conditions, "job_name = ?")
params = append(params, sysJob.JobName)
}
if sysJob.JobGroup != "" {
conditions = append(conditions, "job_group = ?")
params = append(params, sysJob.JobGroup)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select job_id as 'str' from sys_job " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// InsertJob 新增调度任务信息
func (r *SysJobImpl) InsertJob(sysJob model.SysJob) string {
// 参数拼接
params := make(map[string]any)
if sysJob.JobID != "" {
params["job_id"] = sysJob.JobID
}
if sysJob.JobName != "" {
params["job_name"] = sysJob.JobName
}
if sysJob.JobGroup != "" {
params["job_group"] = sysJob.JobGroup
}
if sysJob.InvokeTarget != "" {
params["invoke_target"] = sysJob.InvokeTarget
}
params["target_params"] = sysJob.TargetParams
if sysJob.CronExpression != "" {
params["cron_expression"] = sysJob.CronExpression
}
if sysJob.MisfirePolicy != "" {
params["misfire_policy"] = sysJob.MisfirePolicy
}
if sysJob.Concurrent != "" {
params["concurrent"] = sysJob.Concurrent
}
if sysJob.Status != "" {
params["status"] = sysJob.Status
}
if sysJob.SaveLog != "" {
params["save_log"] = sysJob.SaveLog
}
params["remark"] = sysJob.Remark
if sysJob.CreateBy != "" {
params["create_by"] = sysJob.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_job (" + 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
}
// UpdateJob 修改调度任务信息
func (r *SysJobImpl) UpdateJob(sysJob model.SysJob) int64 {
// 参数拼接
params := make(map[string]any)
if sysJob.JobName != "" {
params["job_name"] = sysJob.JobName
}
if sysJob.JobGroup != "" {
params["job_group"] = sysJob.JobGroup
}
if sysJob.InvokeTarget != "" {
params["invoke_target"] = sysJob.InvokeTarget
}
params["target_params"] = sysJob.TargetParams
if sysJob.CronExpression != "" {
params["cron_expression"] = sysJob.CronExpression
}
if sysJob.MisfirePolicy != "" {
params["misfire_policy"] = sysJob.MisfirePolicy
}
if sysJob.Concurrent != "" {
params["concurrent"] = sysJob.Concurrent
}
if sysJob.Status != "" {
params["status"] = sysJob.Status
}
if sysJob.SaveLog != "" {
params["save_log"] = sysJob.SaveLog
}
params["remark"] = sysJob.Remark
if sysJob.UpdateBy != "" {
params["update_by"] = sysJob.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_job set " + strings.Join(keys, ",") + " where job_id = ?"
// 执行更新
values = append(values, sysJob.JobID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteJobByIds 批量删除调度任务信息
func (r *SysJobImpl) DeleteJobByIds(jobIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(jobIds))
sql := "delete from sys_job where job_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(jobIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

146
src/modules/monitor/repository/sys_job_log.go
View File

@@ -1,26 +1,144 @@
package repository
import (
"fmt"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
)
// 调度任务日志表 数据层接口
type ISysJobLog interface {
// 分页查询调度任务日志集合
SelectJobLogPage(query map[string]any) map[string]any
// NewSysJobLog 实例化数据层
var NewSysJobLog = &SysJobLog{}
// 查询调度任务日志集合
SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog
// SysJobLog 调度任务日志表 数据层处理
type SysJobLog struct{}
// 通过调度ID查询调度任务日志信息
SelectJobLogById(jobLogId string) model.SysJobLog
// SelectByPage 分页查询集合
func (r SysJobLog) SelectByPage(query map[string]string) ([]model.SysJobLog, int64) {
tx := db.DB("").Model(&model.SysJobLog{})
// 查询条件拼接
if v, ok := query["jobName"]; ok && v != "" {
tx = tx.Where("job_name = ?", v)
}
if v, ok := query["jobGroup"]; ok && v != "" {
tx = tx.Where("job_group = ?", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["invokeTarget"]; ok && v != "" {
tx = tx.Where("invoke_target like concat(?, '%')", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("create_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("create_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time <= ?", v)
}
}
// 新增调度任务日志信息
InsertJobLog(sysJobLog model.SysJobLog) string
// 查询结果
var total int64 = 0
rows := []model.SysJobLog{}
// 批量删除调度任务日志信息
DeleteJobLogByIds(jobLogId []string) int64
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 清空调度任务日志
CleanJobLog() error
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysJobLog) Select(sysJobLog model.SysJobLog) []model.SysJobLog {
tx := db.DB("").Model(&model.SysJobLog{})
// 查询条件拼接
if sysJobLog.JobName != "" {
tx = tx.Where("job_name like concat(?, '%')", sysJobLog.JobName)
}
if sysJobLog.JobGroup != "" {
tx = tx.Where("job_group = ?", sysJobLog.JobGroup)
}
if sysJobLog.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysJobLog.StatusFlag)
}
if sysJobLog.InvokeTarget != "" {
tx = tx.Where("invoke_target like concat(?, '%')", sysJobLog.InvokeTarget)
}
// 查询数据
rows := []model.SysJobLog{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectById 通过ID查询信息
func (r SysJobLog) SelectById(logId int64) model.SysJobLog {
item := model.SysJobLog{}
if logId <= 0 {
return item
}
tx := db.DB("").Model(&model.SysJobLog{})
// 构建查询条件
tx = tx.Where("log_id = ?", logId)
// 查询数据
if err := tx.Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return item
}
return item
}
// Insert 新增信息
func (r SysJobLog) Insert(sysJobLog model.SysJobLog) int64 {
// 执行插入
if err := db.DB("").Create(&sysJobLog).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysJobLog.LogId
}
// DeleteByIds 批量删除信息
func (r SysJobLog) DeleteByIds(logIds []int64) int64 {
if len(logIds) <= 0 {
return 0
}
tx := db.DB("").Where("log_id in ?", logIds)
if err := tx.Delete(&model.SysJobLog{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// Clean 清空集合数据
func (r SysJobLog) Clean() int64 {
tx := db.DB("").Delete(&model.SysJobLog{})
if err := tx.Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

269
src/modules/monitor/repository/sys_job_log.impl.go
View File

@@ -1,269 +0,0 @@
package repository
import (
"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/monitor/model"
)
// 实例化数据层 SysJobLogImpl 结构体
var NewSysJobLogImpl = &SysJobLogImpl{
selectSql: `select job_log_id, job_name, job_group, invoke_target,
target_params, job_msg, status, create_time, cost_time from sys_job_log`,
resultMap: map[string]string{
"job_log_id": "JobLogID",
"job_name": "JobName",
"job_group": "JobGroup",
"invoke_target": "InvokeTarget",
"target_params": "TargetParams",
"job_msg": "JobMsg",
"status": "Status",
"create_time": "CreateTime",
"cost_time": "CostTime",
},
}
// SysJobLogImpl 调度任务日志表 数据层处理
type SysJobLogImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysJobLogImpl) convertResultRows(rows []map[string]any) []model.SysJobLog {
arr := make([]model.SysJobLog, 0)
for _, row := range rows {
sysJobLog := model.SysJobLog{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysJobLog, keyMapper, value)
}
}
arr = append(arr, sysJobLog)
}
return arr
}
// 分页查询调度任务日志集合
func (r *SysJobLogImpl) SelectJobLogPage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["jobName"]; ok && v != "" {
conditions = append(conditions, "job_name = ?")
params = append(params, v)
}
if v, ok := query["jobGroup"]; ok && v != "" {
conditions = append(conditions, "job_group = ?")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
if v, ok := query["invokeTarget"]; ok && v != "" {
conditions = append(conditions, "invoke_target like concat(?, '%')")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "create_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysJobLog{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_job_log"
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 := " order by job_log_id desc limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// 查询调度任务日志集合
func (r *SysJobLogImpl) SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog {
// 查询条件拼接
var conditions []string
var params []any
if sysJobLog.JobName != "" {
conditions = append(conditions, "job_name like concat(?, '%')")
params = append(params, sysJobLog.JobName)
}
if sysJobLog.JobGroup != "" {
conditions = append(conditions, "job_group = ?")
params = append(params, sysJobLog.JobGroup)
}
if sysJobLog.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysJobLog.Status)
}
if sysJobLog.InvokeTarget != "" {
conditions = append(conditions, "invoke_target like concat(?, '%')")
params = append(params, sysJobLog.InvokeTarget)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysJobLog{}
}
// 转换实体
return r.convertResultRows(results)
}
// 通过调度ID查询调度任务日志信息
func (r *SysJobLogImpl) SelectJobLogById(jobLogId string) model.SysJobLog {
querySql := r.selectSql + " where job_log_id = ?"
results, err := datasource.RawDB("", querySql, []any{jobLogId})
if err != nil {
logger.Errorf("query err => %v", err)
return model.SysJobLog{}
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}
return model.SysJobLog{}
}
// 新增调度任务日志信息
func (r *SysJobLogImpl) InsertJobLog(sysJobLog model.SysJobLog) string {
// 参数拼接
params := make(map[string]any)
params["create_time"] = time.Now().UnixMilli()
if sysJobLog.JobLogID != "" {
params["job_log_id"] = sysJobLog.JobLogID
}
if sysJobLog.JobName != "" {
params["job_name"] = sysJobLog.JobName
}
if sysJobLog.JobGroup != "" {
params["job_group"] = sysJobLog.JobGroup
}
if sysJobLog.InvokeTarget != "" {
params["invoke_target"] = sysJobLog.InvokeTarget
}
if sysJobLog.TargetParams != "" {
params["target_params"] = sysJobLog.TargetParams
}
if sysJobLog.JobMsg != "" {
params["job_msg"] = sysJobLog.JobMsg
}
if sysJobLog.Status != "" {
params["status"] = sysJobLog.Status
}
if sysJobLog.CostTime > 0 {
params["cost_time"] = sysJobLog.CostTime
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_job_log (" + 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
}
// 批量删除调度任务日志信息
func (r *SysJobLogImpl) DeleteJobLogByIds(jobLogIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(jobLogIds))
sql := "delete from sys_job_log where job_log_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(jobLogIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// 清空调度任务日志
func (r *SysJobLogImpl) CleanJobLog() error {
sql := "truncate table sys_job_log"
_, err := datasource.ExecDB("", sql, []any{})
return err
}

49
src/modules/monitor/service/monitor.go
View File

@@ -9,6 +9,7 @@ import (
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
systemService "be.ems/src/modules/system/service"
"github.com/shirou/gopsutil/v4/cpu"
"github.com/shirou/gopsutil/v4/disk"
"github.com/shirou/gopsutil/v4/load"
@@ -18,18 +19,16 @@ import (
// 实例化服务层 Monitor 结构体
var NewMonitor = &Monitor{
sysConfigService: systemService.NewSysConfigImpl,
monitorRepository: repository.NewMonitorImpl,
sysConfigService: systemService.NewSysConfig,
monitorRepository: repository.NewMonitor,
diskIO: make(chan []disk.IOCountersStat, 2),
netIO: make(chan []net.IOCountersStat, 2),
}
// Monitor 服务器系统相关信息 服务层处理
type Monitor struct {
// 参数配置服务
sysConfigService systemService.ISysConfig
// 监控服务资源数据信息
monitorRepository repository.IMonitor
sysConfigService *systemService.SysConfig // 参数配置服务
monitorRepository *repository.Monitor // 监控服务资源数据信息
// 磁盘网络IO 数据通道
diskIO chan ([]disk.IOCountersStat)
netIO chan ([]net.IOCountersStat)
@@ -59,8 +58,8 @@ func (s *Monitor) RunMonitor() {
memoryInfo, _ := mem.VirtualMemory()
itemBase.Memory = memoryInfo.UsedPercent
if err := s.monitorRepository.CreateMonitorBase(itemBase); err != nil {
logger.Errorf("CreateMonitorBase err: %v", err)
if err := s.monitorRepository.InsertByBase(itemBase); err != nil {
logger.Errorf("InsertByBase err: %v", err)
}
// 将当前资源发送到chan中处理保存
@@ -68,13 +67,13 @@ func (s *Monitor) RunMonitor() {
s.loadNetIO()
// 监控系统资源-保留天数
storeDays := s.sysConfigService.SelectConfigValueByKey("monitor.sysResource.storeDays")
storeDays := s.sysConfigService.FindValueByKey("monitor.sysResource.storeDays")
if storeDays != "" {
storeDays, _ := strconv.Atoi(storeDays)
ltTime := time.Now().AddDate(0, 0, -storeDays).UnixMilli()
_ = s.monitorRepository.DelMonitorBase(ltTime)
_ = s.monitorRepository.DelMonitorIO(ltTime)
_ = s.monitorRepository.DelMonitorNet(ltTime)
_ = s.monitorRepository.DeleteByBase(ltTime)
_ = s.monitorRepository.DeleteByIO(ltTime)
_ = s.monitorRepository.DeleteByNetwork(ltTime)
}
}
@@ -171,8 +170,8 @@ func (s *Monitor) saveIODataToDB(ctx context.Context, interval float64) {
}
}
}
if err := s.monitorRepository.BatchCreateMonitorIO(ioList); err != nil {
logger.Errorf("BatchCreateMonitorIO err: %v", err)
if err := s.monitorRepository.BatchInsertByIO(ioList); err != nil {
logger.Errorf("BatchInsertByIO err: %v", err)
}
s.diskIO <- ioStat2
}
@@ -214,8 +213,8 @@ func (s *Monitor) saveNetDataToDB(ctx context.Context, interval float64) {
}
}
if err := s.monitorRepository.BatchCreateMonitorNet(netList); err != nil {
logger.Errorf("BatchCreateMonitorNet err: %v", err)
if err := s.monitorRepository.BatchInsertByNetwork(netList); err != nil {
logger.Errorf("BatchInsertByNetwork err: %v", err)
}
s.netIO <- netStat2
}
@@ -223,10 +222,10 @@ func (s *Monitor) saveNetDataToDB(ctx context.Context, interval float64) {
}
}
// SelectMonitorInfo 查询监控资源信息
func (s *Monitor) SelectMonitorInfo(query map[string]any) map[string]any {
// FindInfo 查询监控资源信息
func (s *Monitor) FindInfo(query map[string]any) map[string]any {
infoType := query["type"]
startTimeMilli := query["startTime"]
beginTimeMilli := query["beginTime"]
endTimeMilli := query["endTime"]
neType := query["neType"]
neId := query["neId"]
@@ -237,8 +236,8 @@ func (s *Monitor) SelectMonitorInfo(query map[string]any) map[string]any {
// 基本信息
if infoType == "all" || infoType == "load" || infoType == "cpu" || infoType == "memory" {
rows := s.monitorRepository.SelectMonitorBase(map[string]any{
"startTime": startTimeMilli,
rows := s.monitorRepository.SelectByBase(map[string]any{
"beginTime": beginTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
@@ -248,8 +247,8 @@ func (s *Monitor) SelectMonitorInfo(query map[string]any) map[string]any {
// 磁盘IO
if infoType == "all" || infoType == "io" {
rows := s.monitorRepository.SelectMonitorIO(map[string]any{
"startTime": startTimeMilli,
rows := s.monitorRepository.SelectByIO(map[string]any{
"beginTime": beginTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
@@ -260,8 +259,8 @@ func (s *Monitor) SelectMonitorInfo(query map[string]any) map[string]any {
// 网络
if infoType == "all" || infoType == "network" {
rows := s.monitorRepository.SelectMonitorNetwork(map[string]any{
"startTime": startTimeMilli,
rows := s.monitorRepository.SelectByNetwork(map[string]any{
"beginTime": beginTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,

251
src/modules/monitor/service/sys_job.go
View File

@@ -2,131 +2,112 @@ package service
import (
"fmt"
"strconv"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/constants"
"be.ems/src/framework/cron"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
systemService "be.ems/src/modules/system/service"
)
// 实例化服务层 SysJob 结构体
// NewSysJob 服务层实例化
var NewSysJob = &SysJob{
sysJobRepository: repository.NewSysJobImpl,
sysJobRepository: repository.NewSysJob,
sysDictTypeService: systemService.NewSysDictType,
}
// SysJob 调度任务 服务层处理
type SysJob struct {
// 调度任务数据信息
sysJobRepository repository.ISysJob
sysJobRepository *repository.SysJob // 调度任务数据信息
sysDictTypeService *systemService.SysDictType // 字典类型服务
}
// SelectJobPage 分页查询调度任务集合
func (r *SysJob) SelectJobPage(query map[string]any) map[string]any {
return r.sysJobRepository.SelectJobPage(query)
// FindByPage 分页查询
func (s SysJob) FindByPage(query map[string]string) ([]model.SysJob, int64) {
return s.sysJobRepository.SelectByPage(query)
}
// SelectJobList 查询调度任务集合
func (r *SysJob) SelectJobList(sysJob model.SysJob) []model.SysJob {
return r.sysJobRepository.SelectJobList(sysJob)
// Find 查询
func (s SysJob) Find(sysJob model.SysJob) []model.SysJob {
return s.sysJobRepository.Select(sysJob)
}
// SelectJobById 通过调度ID查询调度任务信息
func (r *SysJob) SelectJobById(jobId string) model.SysJob {
if jobId == "" {
// FindById 通过ID查询
func (s SysJob) FindById(jobId int64) model.SysJob {
if jobId <= 0 {
return model.SysJob{}
}
jobs := r.sysJobRepository.SelectJobByIds([]string{jobId})
jobs := s.sysJobRepository.SelectByIds([]int64{jobId})
if len(jobs) > 0 {
return jobs[0]
}
return model.SysJob{}
}
// CheckUniqueJobName 校验调度任务名称和组是否唯一
func (r *SysJob) CheckUniqueJobName(jobName, jobGroup, jobId string) bool {
uniqueId := r.sysJobRepository.CheckUniqueJob(model.SysJob{
// Insert 新增
func (s SysJob) Insert(sysJob model.SysJob) int64 {
insertId := s.sysJobRepository.Insert(sysJob)
if insertId > 0 && sysJob.StatusFlag == constants.STATUS_YES {
sysJob.JobId = insertId
s.insertQueueJob(sysJob, true)
}
return insertId
}
// Update 修改
func (s SysJob) Update(sysJob model.SysJob) int64 {
rows := s.sysJobRepository.Update(sysJob)
if rows > 0 {
//状态正常添加队列任务
if sysJob.StatusFlag == constants.STATUS_YES {
s.insertQueueJob(sysJob, true)
}
// 状态禁用删除队列任务
if sysJob.StatusFlag == constants.STATUS_NO {
s.deleteQueueJob(sysJob)
}
}
return rows
}
// DeleteByIds 批量删除
func (s SysJob) DeleteByIds(jobIds []int64) (int64, error) {
// 检查是否存在
jobs := s.sysJobRepository.SelectByIds(jobIds)
if len(jobs) <= 0 {
return 0, fmt.Errorf("没有权限访问调度任务数据！")
}
if len(jobs) == len(jobIds) {
// 清除任务
for _, job := range jobs {
s.deleteQueueJob(job)
}
return s.sysJobRepository.DeleteByIds(jobIds), nil
}
return 0, fmt.Errorf("删除调度任务信息失败！")
}
// CheckUniqueByJobName 校验调度任务名称和组是否唯一
func (s SysJob) CheckUniqueByJobName(jobName, jobGroup string, jobId int64) bool {
uniqueId := s.sysJobRepository.CheckUnique(model.SysJob{
JobName: jobName,
JobGroup: jobGroup,
})
if uniqueId == jobId {
return true
}
return uniqueId == ""
return uniqueId == 0
}
// InsertJob 新增调度任务信息
func (r *SysJob) InsertJob(sysJob model.SysJob) string {
insertId := r.sysJobRepository.InsertJob(sysJob)
if insertId == "" && sysJob.Status == common.STATUS_YES {
sysJob.JobID = insertId
r.insertQueueJob(sysJob, true)
}
return insertId
}
// UpdateJob 修改调度任务信息
func (r *SysJob) UpdateJob(sysJob model.SysJob) int64 {
rows := r.sysJobRepository.UpdateJob(sysJob)
if rows > 0 {
//状态正常添加队列任务
if sysJob.Status == common.STATUS_YES {
r.insertQueueJob(sysJob, true)
}
// 状态禁用删除队列任务
if sysJob.Status == common.STATUS_NO {
r.deleteQueueJob(sysJob)
}
}
return rows
}
// DeleteJobByIds 批量删除调度任务信息
func (r *SysJob) DeleteJobByIds(jobIds []string) (int64, error) {
// 检查是否存在
jobs := r.sysJobRepository.SelectJobByIds(jobIds)
if len(jobs) <= 0 {
// 没有可访问调度任务数据！
return 0, fmt.Errorf("there is no accessible scheduling task data")
}
if len(jobs) == len(jobIds) {
// 清除任务
for _, job := range jobs {
r.deleteQueueJob(job)
}
rows := r.sysJobRepository.DeleteJobByIds(jobIds)
return rows, nil
}
// 删除调度任务信息失败！
return 0, fmt.Errorf("failed to delete scheduling task information")
}
// ResetQueueJob 重置初始调度任务
func (r *SysJob) ResetQueueJob() {
// 获取注册的队列名称
queueNames := cron.QueueNames()
if len(queueNames) == 0 {
return
}
// 查询系统中定义状态为正常启用的任务
sysJobs := r.sysJobRepository.SelectJobList(model.SysJob{
Status: common.STATUS_YES,
})
for _, sysJob := range sysJobs {
for _, name := range queueNames {
if name == sysJob.InvokeTarget {
r.insertQueueJob(sysJob, true)
}
}
}
}
// RunQueueJob 立即运行一次调度任务
func (r *SysJob) RunQueueJob(sysJob model.SysJob) bool {
return r.insertQueueJob(sysJob, false)
// Run 立即运行一次调度任务
func (s SysJob) Run(sysJob model.SysJob) bool {
return s.insertQueueJob(sysJob, false)
}
// insertQueueJob 添加调度任务
func (r *SysJob) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
func (s SysJob) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
@@ -143,7 +124,7 @@ func (r *SysJob) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
if !repeat {
// 执行单次任务
status := queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
JobId: fmt.Sprint(sysJob.JobId),
})
// 执行中或等待中的都返回正常
return status == cron.Active || status == cron.Waiting
@@ -151,19 +132,101 @@ func (r *SysJob) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
// 执行重复任务
queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
JobId: fmt.Sprint(sysJob.JobId),
Cron: sysJob.CronExpression,
})
return true
}
// deleteQueueJob 删除调度任务
func (r *SysJob) deleteQueueJob(sysJob model.SysJob) bool {
func (s SysJob) deleteQueueJob(sysJob model.SysJob) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
return false
}
return queue.RemoveJob(sysJob.JobID)
return queue.RemoveJob(fmt.Sprint(sysJob.JobId))
}
// Reset 重置初始调度任务
func (s SysJob) Reset() {
// 获取注册的队列名称
queueNames := cron.QueueNames()
if len(queueNames) == 0 {
return
}
// 查询系统中定义状态为正常启用的任务
sysJobs := s.sysJobRepository.Select(model.SysJob{
StatusFlag: constants.STATUS_YES,
})
for _, sysJob := range sysJobs {
for _, name := range queueNames {
if name == sysJob.InvokeTarget {
s.deleteQueueJob(sysJob)
s.insertQueueJob(sysJob, true)
}
}
}
}
// ExportData 导出数据表格
func (s SysJob) ExportData(rows []model.SysJob, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "任务编号",
"B1": "任务名称",
"C1": "任务组名",
"D1": "调用目标",
"E1": "传入参数",
"F1": "执行表达式",
"G1": "出错策略",
"H1": "并发执行",
"I1": "任务状态",
"J1": "备注说明",
}
// 读取任务组名字典数据
dictSysJobGroup := s.sysDictTypeService.FindDataByType("sys_job_group")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 任务组名
sysJobGroup := ""
for _, v := range dictSysJobGroup {
if row.JobGroup == v.DataValue {
sysJobGroup = v.DataLabel
break
}
}
misfirePolicy := "放弃执行"
if row.MisfirePolicy == "1" {
misfirePolicy = "立即执行"
} else if row.MisfirePolicy == "2" {
misfirePolicy = "执行一次"
}
concurrent := "禁止"
if row.Concurrent == "1" {
concurrent = "允许"
}
// 状态
statusValue := "失败"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.JobId,
"B" + idx: row.JobName,
"C" + idx: sysJobGroup,
"D" + idx: row.InvokeTarget,
"E" + idx: row.TargetParams,
"F" + idx: row.CronExpression,
"G" + idx: misfirePolicy,
"H" + idx: concurrent,
"I" + idx: statusValue,
"J" + idx: row.Remark,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

93
src/modules/monitor/service/sys_job_log.go
View File

@@ -1,42 +1,97 @@
package service
import (
"strconv"
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
systemService "be.ems/src/modules/system/service"
)
// 实例化服务层 SysJobLog 结构体
// NewSysJobLog 服务层实例化
var NewSysJobLog = &SysJobLog{
sysJobLogRepository: repository.NewSysJobLogImpl,
sysJobLogRepository: repository.NewSysJobLog,
sysDictTypeService: systemService.NewSysDictType,
}
// SysJobLog 调度任务日志 服务层处理
type SysJobLog struct {
// 调度任务日志数据信息
sysJobLogRepository repository.ISysJobLog
sysJobLogRepository *repository.SysJobLog // 调度任务日志数据信息
sysDictTypeService *systemService.SysDictType // 字典类型服务
}
// SelectJobLogPage 分页查询调度任务日志集合
func (s *SysJobLog) SelectJobLogPage(query map[string]any) map[string]any {
return s.sysJobLogRepository.SelectJobLogPage(query)
// FindByPage 分页查询
func (s SysJobLog) FindByPage(query map[string]string) ([]model.SysJobLog, int64) {
return s.sysJobLogRepository.SelectByPage(query)
}
// SelectJobLogList 查询调度任务日志集合
func (s *SysJobLog) SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogList(sysJobLog)
// Find 查询
func (s SysJobLog) Find(sysJobLog model.SysJobLog) []model.SysJobLog {
return s.sysJobLogRepository.Select(sysJobLog)
}
// SelectJobLogById 通过调度ID查询调度任务日志信息
func (s *SysJobLog) SelectJobLogById(jobLogId string) model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogById(jobLogId)
// FindById 通过ID查询
func (s SysJobLog) FindById(logId int64) model.SysJobLog {
return s.sysJobLogRepository.SelectById(logId)
}
// DeleteJobLogByIds 批量删除调度任务日志信息
func (s *SysJobLog) DeleteJobLogByIds(jobLogIds []string) int64 {
return s.sysJobLogRepository.DeleteJobLogByIds(jobLogIds)
// RemoveByIds 批量删除
func (s SysJobLog) DeleteByIds(logIds []int64) int64 {
return s.sysJobLogRepository.DeleteByIds(logIds)
}
// CleanJobLog 清空调度任务日志
func (s *SysJobLog) CleanJobLog() error {
return s.sysJobLogRepository.CleanJobLog()
// Clean 清空
func (s SysJobLog) Clean() int64 {
return s.sysJobLogRepository.Clean()
}
// ExportData 导出数据表格
func (s SysJobLog) ExportData(rows []model.SysJobLog, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "日志序号",
"B1": "任务名称",
"C1": "任务组名",
"D1": "调用目标",
"E1": "传入参数",
"F1": "日志信息",
"G1": "执行状态",
"H1": "记录时间",
}
// 读取任务组名字典数据
dictSysJobGroup := s.sysDictTypeService.FindDataByType("sys_job_group")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 任务组名
sysJobGroup := ""
for _, v := range dictSysJobGroup {
if row.JobGroup == v.DataValue {
sysJobGroup = v.DataLabel
break
}
}
// 状态
statusValue := "失败"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.LogId,
"B" + idx: row.JobName,
"C" + idx: sysJobGroup,
"D" + idx: row.InvokeTarget,
"E" + idx: row.TargetParams,
"F" + idx: row.JobMsg,
"G" + idx: statusValue,
"H" + idx: date.ParseDateToStr(row.CreateTime, date.YYYY_MM_DD_HH_MM_SS),
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

26
src/modules/monitor/service/sys_user_online.go
View File

@@ -1,7 +1,7 @@
package service
import (
"be.ems/src/framework/vo"
"be.ems/src/framework/token"
"be.ems/src/modules/monitor/model"
)
@@ -11,23 +11,23 @@ var NewSysUserOnline = &SysUserOnline{}
// SysUserOnline 在线用户 服务层处理
type SysUserOnline struct{}
// LoginUserToUserOnline 设置在线用户信息
func (r *SysUserOnline) LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline {
if loginUser.UserID == "" {
// TokenInfoToUserOnline 在线用户信息
func (s SysUserOnline) TokenInfoToUserOnline(tokenInfo token.TokenInfo) model.SysUserOnline {
if tokenInfo.UserId <= 0 {
return model.SysUserOnline{}
}
sysUserOnline := model.SysUserOnline{
TokenID: loginUser.UUID,
UserName: loginUser.User.UserName,
IPAddr: loginUser.IPAddr,
LoginLocation: loginUser.LoginLocation,
Browser: loginUser.Browser,
OS: loginUser.OS,
LoginTime: loginUser.LoginTime,
TokenID: tokenInfo.UUID,
UserName: tokenInfo.User.UserName,
LoginIp: tokenInfo.LoginIp,
LoginLocation: tokenInfo.LoginLocation,
Browser: tokenInfo.Browser,
OS: tokenInfo.OS,
LoginTime: tokenInfo.LoginTime,
}
if loginUser.User.DeptID != "" {
sysUserOnline.DeptName = loginUser.User.Dept.DeptName
if tokenInfo.User.DeptId > 0 {
sysUserOnline.DeptName = tokenInfo.User.Dept.DeptName
}
return sysUserOnline
}

42
src/modules/monitor/service/system_info.go
View File

@@ -91,9 +91,9 @@ func (s *SystemInfo) MemoryInfo() map[string]any {
// CPUInfo CPU信息
func (s *SystemInfo) CPUInfo() map[string]any {
var core int = 0
var speed string = "未知"
var model string = "未知"
var core = 0
var speed = "-"
var model = "-"
cpuInfo, err := cpu.Info()
if err == nil {
core = runtime.NumCPU()
@@ -101,11 +101,11 @@ func (s *SystemInfo) CPUInfo() map[string]any {
model = strings.TrimSpace(cpuInfo[0].ModelName)
}
useds := []string{}
var used []string
cpuPercent, err := cpu.Percent(0, true)
if err == nil {
for _, v := range cpuPercent {
useds = append(useds, fmt.Sprintf("%.2f", v))
used = append(used, fmt.Sprintf("%.2f", v))
}
}
@@ -113,39 +113,39 @@ func (s *SystemInfo) CPUInfo() map[string]any {
"model": model,
"speed": speed,
"core": core,
"coreUsed": useds,
"coreUsed": used,
}
}
// NetworkInfo 网络信息
func (s *SystemInfo) NetworkInfo() map[string]string {
ipAddrs := make(map[string]string)
ipAdders := make(map[string]string)
interfaces, err := net.Interfaces()
if err == nil {
for _, iface := range interfaces {
name := iface.Name
for _, v := range interfaces {
name := v.Name
if name[len(name)-1] == '0' {
name = name[0 : len(name)-1]
name = strings.Trim(name, "")
}
// ignore localhost
if name == "lo" {
if strings.HasPrefix(name, "lo") || strings.HasPrefix(name, "veth") || strings.HasPrefix(name, "Loopback") {
continue
}
var addrs []string
for _, v := range iface.Addrs {
var adders []string
for _, v := range v.Addrs {
prefix := strings.Split(v.Addr, "/")[0]
if strings.Contains(prefix, "::") {
addrs = append(addrs, fmt.Sprintf("IPv6 %s", prefix))
adders = append(adders, fmt.Sprintf("IPv6 %s", prefix))
}
if strings.Contains(prefix, ".") {
addrs = append(addrs, fmt.Sprintf("IPv4 %s", prefix))
adders = append(adders, fmt.Sprintf("IPv4 %s", prefix))
}
}
ipAddrs[name] = strings.Join(addrs, " / ")
ipAdders[name] = strings.Join(adders, " / ")
}
}
return ipAddrs
return ipAdders
}
// DiskInfo 磁盘信息
@@ -166,11 +166,11 @@ func (s *SystemInfo) DiskInfo() []map[string]string {
continue
}
disks = append(disks, map[string]string{
"size": parse.Bit(float64(usage.Total)),
"used": parse.Bit(float64(usage.Used)),
"avail": parse.Bit(float64(usage.Free)),
"pcent": fmt.Sprintf("%.1f%%", usage.UsedPercent),
"target": partition.Device,
"size": parse.Bit(float64(usage.Total)),
"used": parse.Bit(float64(usage.Used)),
"avail": parse.Bit(float64(usage.Free)),
"percent": fmt.Sprintf("%.1f%%", usage.UsedPercent),
"target": partition.Device,
})
}
return disks