feat: omc原始代码

2024-03-12 10:58:33 +08:00
parent 5133c93971
commit 2d01bb86d1
432 changed files with 66597 additions and 1 deletions
--- a/src/modules/monitor/controller/monitor.go
+++ b/src/modules/monitor/controller/monitor.go
@@ -0,0 +1,60 @@
+package controller
+
+import (
+	"nms_nbi/src/framework/i18n"
+	"nms_nbi/src/framework/utils/ctx"
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 实例化控制层 MonitorInfoController 结构体
+var NewMonitor = &MonitorController{
+	monitorService: service.NewMonitorImpl,
+}
+
+// 服务器资源监控信息
+//
+// PATH /monitor
+type MonitorController struct {
+	// 服务器系统相关信息服务
+	monitorService service.IMonitor
+}
+
+// 资源监控信息加载
+//
+// GET /load
+func (s *MonitorController) Load(c *gin.Context) {
+	language := ctx.AcceptLanguage(c)
+	var querys struct {
+		// 数据类型all/load/cpu/memory/io/network
+		Type string `form:"type" binding:"required,oneof=all load cpu memory io network"`
+		// 开始时间
+		StartTime int64 `form:"startTime" binding:"required"`
+		// 结束时间
+		EndTime int64 `form:"endTime" binding:"required"`
+		// 网元类型
+		NeType string `form:"neType"`
+		// 网元ID
+		NeID string `form:"neId"`
+		// 名称，networ和iok时有效
+		Name string `form:"name"`
+	}
+	err := c.ShouldBindQuery(&querys)
+	if err != nil {
+		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
+		return
+	}
+
+	// 查询数据
+	data := s.monitorService.SelectMonitorInfo(map[string]any{
+		"type":      querys.Type,
+		"startTime": querys.StartTime,
+		"endTime":   querys.EndTime,
+		"neType":    querys.NeType,
+		"neId":      querys.NeID,
+		"name":      querys.Name,
+	})
+	c.JSON(200, result.OkData(data))
+}
--- a/src/modules/monitor/controller/sys_cache.go
+++ b/src/modules/monitor/controller/sys_cache.go
@@ -0,0 +1,162 @@
+package controller
+
+import (
+	"nms_nbi/src/framework/constants/cachekey"
+	"nms_nbi/src/framework/i18n"
+	"nms_nbi/src/framework/redis"
+	"nms_nbi/src/framework/utils/ctx"
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/model"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 实例化控制层 SysCacheController 结构体
+var NewSysCache = &SysCacheController{}
+
+// 缓存监控信息
+//
+// PATH /monitor/cache
+type SysCacheController struct{}
+
+// Redis信息
+//
+// GET /
+func (s *SysCacheController) Info(c *gin.Context) {
+	c.JSON(200, result.OkData(map[string]any{
+		"info":         redis.Info(""),
+		"dbSize":       redis.KeySize(""),
+		"commandStats": redis.CommandStats(""),
+	}))
+}
+
+// 缓存名称列表
+//
+// GET /getNames
+func (s *SysCacheController) Names(c *gin.Context) {
+	language := ctx.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),
+	}
+	c.JSON(200, result.OkData(caches))
+}
+
+// 缓存名称下键名列表
+//
+// 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")))
+		return
+	}
+	caches := []model.SysCache{}
+
+	// 遍历组装
+	cacheKeys, _ := redis.GetKeys("", cacheName+":*")
+	for _, key := range cacheKeys {
+		caches = append(caches, model.NewSysCacheKeys(cacheName, key))
+	}
+
+	c.JSON(200, result.OkData(caches))
+}
+
+// 缓存内容
+//
+// 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")))
+		return
+	}
+
+	cacheValue, err := redis.Get("", cacheName+":"+cacheKey)
+	if err != nil {
+		c.JSON(200, result.ErrMsg(err.Error()))
+		return
+	}
+	sysCache := model.NewSysCacheValue(cacheName, cacheKey, cacheValue)
+	c.JSON(200, result.OkData(sysCache))
+}
+
+// 删除缓存名称下键名列表
+//
+// 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)
+	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),
+	}
+	for _, v := range caches {
+		cacheKeys, err := redis.GetKeys("", v.CacheName+":*")
+		if err != nil {
+			continue
+		}
+		redis.DelKeys("", cacheKeys)
+	}
+	c.JSON(200, result.Ok(nil))
+}
--- a/src/modules/monitor/controller/sys_job.go
+++ b/src/modules/monitor/controller/sys_job.go
@@ -0,0 +1,388 @@
+package controller
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"nms_nbi/src/framework/i18n"
+	"nms_nbi/src/framework/utils/ctx"
+	"nms_nbi/src/framework/utils/file"
+	"nms_nbi/src/framework/utils/parse"
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/service"
+	systemService "nms_nbi/src/modules/system/service"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+)
+
+// 实例化控制层 SysJobLogController 结构体
+var NewSysJob = &SysJobController{
+	sysJobService:      service.NewSysJobImpl,
+	sysDictDataService: systemService.NewSysDictDataImpl,
+}
+
+// 调度任务信息
+//
+// PATH /monitor/job
+type SysJobController struct {
+	// 调度任务服务
+	sysJobService service.ISysJob
+	// 字典数据服务
+	sysDictDataService systemService.ISysDictData
+}
+
+// 调度任务列表
+//
+// GET /list
+func (s *SysJobController) List(c *gin.Context) {
+	querys := ctx.QueryMap(c)
+	data := s.sysJobService.SelectJobPage(querys)
+
+	rows := data["rows"].([]model.SysJob)
+	// 闭包函数处理多语言
+	language := ctx.AcceptLanguage(c)
+	converI18n := func(language string, arr *[]model.SysJob) {
+		for i := range *arr {
+			(*arr)[i].JobName = i18n.TKey(language, (*arr)[i].JobName)
+			(*arr)[i].Remark = i18n.TKey(language, (*arr)[i].Remark)
+		}
+	}
+	converI18n(language, &rows)
+
+	c.JSON(200, result.Ok(data))
+}
+
+// 调度任务信息
+//
+// 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")))
+		return
+	}
+
+	data := s.sysJobService.SelectJobById(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))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
+
+// 调度任务新增
+//
+// POST /
+func (s *SysJobController) Add(c *gin.Context) {
+	language := ctx.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")))
+		return
+	}
+
+	// 检查cron表达式格式
+	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))
+		return
+	}
+
+	// 检查任务调用传入参数是否json格式
+	if body.TargetParams != "" {
+		// 调度任务新增【%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))
+			return
+		}
+		if !json.Valid([]byte(body.TargetParams)) {
+			c.JSON(200, result.ErrMsg(msg))
+			return
+		}
+	}
+
+	// 检查属性值唯一
+	uniqueJob := s.sysJobService.CheckUniqueJobName(body.JobName, body.JobGroup, "")
+	if !uniqueJob {
+		// 调度任务新增【%s】失败，同任务组内有相同任务名称
+		msg := i18n.TTemplate(language, "job.errJobExists", map[string]any{"name": body.JobName})
+		c.JSON(200, result.ErrMsg(msg))
+		return
+	}
+
+	body.CreateBy = ctx.LoginUserToUserName(c)
+	insertId := s.sysJobService.InsertJob(body)
+	if insertId != "" {
+		c.JSON(200, result.Ok(nil))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
+
+// 调度任务修改
+//
+// PUT /
+func (s *SysJobController) Edit(c *gin.Context) {
+	language := ctx.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")))
+		return
+	}
+
+	// 检查cron表达式格式
+	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))
+		return
+	}
+
+	// 检查任务调用传入参数是否json格式
+	if body.TargetParams != "" {
+		// 调度任务修改【%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))
+			return
+		}
+		if !json.Valid([]byte(body.TargetParams)) {
+			c.JSON(200, result.ErrMsg(msg))
+			return
+		}
+	}
+
+	// 检查是否存在
+	job := s.sysJobService.SelectJobById(body.JobID)
+	if job.JobID != body.JobID {
+		// 没有可访问调度任务数据！
+		c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
+		return
+	}
+
+	// 检查属性值唯一
+	uniqueJob := s.sysJobService.CheckUniqueJobName(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))
+		return
+	}
+
+	// 多语言非原始值
+	i18nValue := i18n.TKey(language, job.JobName)
+	if i18nValue != job.JobName {
+		i18n.UpdateKeyValue(language, job.JobName, body.JobName)
+		body.JobName = job.JobName
+	}
+	// 多语言非原始值
+	i18nValue2 := i18n.TKey(language, job.Remark)
+	if i18nValue2 != job.Remark {
+		i18n.UpdateKeyValue(language, job.Remark, body.Remark)
+		body.Remark = job.Remark
+	}
+
+	body.UpdateBy = ctx.LoginUserToUserName(c)
+	rows := s.sysJobService.UpdateJob(body)
+	if rows > 0 {
+		c.JSON(200, result.Ok(nil))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
+
+// 调度任务删除
+//
+// DELETE /:jobIds
+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")))
+		return
+	}
+	// 处理字符转id数组后去重
+	ids := strings.Split(jobIds, ",")
+	uniqueIDs := parse.RemoveDuplicates(ids)
+	if len(uniqueIDs) <= 0 {
+		c.JSON(200, result.Err(nil))
+		return
+	}
+	rows, err := s.sysJobService.DeleteJobByIds(uniqueIDs)
+	if err != nil {
+		c.JSON(200, result.ErrMsg(err.Error()))
+		return
+	}
+	msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
+	c.JSON(200, result.OkMsg(msg))
+}
+
+// 调度任务修改状态
+//
+// PUT /changeStatus
+func (s *SysJobController) Status(c *gin.Context) {
+	language := ctx.AcceptLanguage(c)
+	var body struct {
+		// 任务ID
+		JobId string `json:"jobId" binding:"required"`
+		// 状态
+		Status string `json:"status" binding:"required"`
+	}
+	err := c.ShouldBindBodyWith(&body, binding.JSON)
+	if err != nil {
+		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
+		return
+	}
+
+	// 检查是否存在
+	job := s.sysJobService.SelectJobById(body.JobId)
+	if job.JobID != body.JobId {
+		// 没有可访问调度任务数据！
+		c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
+		return
+	}
+
+	// 与旧值相等不变更
+	if job.Status == body.Status {
+		// 变更状态与旧值相等！
+		c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.statusEq")))
+		return
+	}
+
+	// 更新状态
+	job.Status = body.Status
+	job.UpdateBy = ctx.LoginUserToUserName(c)
+	rows := s.sysJobService.UpdateJob(job)
+	if rows > 0 {
+		c.JSON(200, result.Ok(nil))
+		return
+	}
+	c.JSON(200, result.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")))
+		return
+	}
+
+	// 检查是否存在
+	job := s.sysJobService.SelectJobById(jobId)
+	if job.JobID != jobId {
+		// 没有可访问调度任务数据！
+		c.JSON(200, result.ErrMsg(i18n.TKey(language, "job.noData")))
+		return
+	}
+
+	ok := s.sysJobService.RunQueueJob(job)
+	if ok {
+		c.JSON(200, result.Ok(nil))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
+
+// 调度任务重置刷新队列
+//
+// PUT /resetQueueJob
+func (s *SysJobController) ResetQueueJob(c *gin.Context) {
+	s.sysJobService.ResetQueueJob()
+	c.JSON(200, result.Ok(nil))
+}
+
+// 导出调度任务信息
+//
+// POST /export
+func (s *SysJobController) Export(c *gin.Context) {
+	language := ctx.AcceptLanguage(c)
+	// 查询结果，根据查询条件结果，单页最大值限制
+	querys := ctx.BodyJSONMap(c)
+	data := s.sysJobService.SelectJobPage(querys)
+	if data["total"].(int64) == 0 {
+		// 导出数据记录为空
+		c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
+		return
+	}
+	rows := data["rows"].([]model.SysJob)
+
+	// 闭包函数处理多语言
+	converI18n := func(language string, arr *[]model.SysJob) {
+		for i := range *arr {
+			(*arr)[i].JobName = i18n.TKey(language, (*arr)[i].JobName)
+			(*arr)[i].Remark = i18n.TKey(language, (*arr)[i].Remark)
+		}
+	}
+	converI18n(language, &rows)
+
+	// 导出文件名称
+	fileName := fmt.Sprintf("job_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
+	// 第一行表头标题
+	headerCells := map[string]string{
+		"A1": i18n.TKey(language, "job.export.jobID"),
+		"B1": i18n.TKey(language, "job.export.jobName"),
+		"C1": i18n.TKey(language, "job.export.jobGroupName"),
+		"D1": i18n.TKey(language, "job.export.invokeTarget"),
+		"E1": i18n.TKey(language, "job.export.targetParams"),
+		"F1": i18n.TKey(language, "job.export.cronExpression"),
+		"G1": i18n.TKey(language, "job.export.status"),
+		"H1": i18n.TKey(language, "job.export.remark"),
+	}
+	// 读取任务组名字典数据
+	dictSysJobGroup := s.sysDictDataService.SelectDictDataByType("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.DictValue {
+				sysJobGroup = i18n.TKey(language, v.DictLabel)
+				break
+			}
+		}
+
+		// 状态
+		statusValue := i18n.TKey(language, "dictData.fail")
+		if row.Status == "1" {
+			statusValue = i18n.TKey(language, "dictData.success")
+		}
+		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: statusValue,
+			"H" + idx: row.Remark,
+		})
+	}
+
+	// 导出数据表格
+	saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
+	if err != nil {
+		c.JSON(200, result.ErrMsg(err.Error()))
+		return
+	}
+
+	c.FileAttachment(saveFilePath, fileName)
+}
--- a/src/modules/monitor/controller/sys_job_log.go
+++ b/src/modules/monitor/controller/sys_job_log.go
@@ -0,0 +1,197 @@
+package controller
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"nms_nbi/src/framework/i18n"
+	"nms_nbi/src/framework/utils/ctx"
+	"nms_nbi/src/framework/utils/date"
+	"nms_nbi/src/framework/utils/file"
+	"nms_nbi/src/framework/utils/parse"
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/service"
+	systemService "nms_nbi/src/modules/system/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 实例化控制层 SysJobLogController 结构体
+var NewSysJobLog = &SysJobLogController{
+	sysJobLogService:   service.NewSysJobLogImpl,
+	sysDictDataService: systemService.NewSysDictDataImpl,
+}
+
+// 调度任务日志信息
+//
+// PATH /monitor/jobLog
+type SysJobLogController struct {
+	// 调度任务日志服务
+	sysJobLogService service.ISysJobLog
+	// 字典数据服务
+	sysDictDataService systemService.ISysDictData
+}
+
+// 调度任务日志列表
+//
+// GET /list
+func (s *SysJobLogController) List(c *gin.Context) {
+	// 查询参数转换map
+	querys := ctx.QueryMap(c)
+	// 任务ID优先级更高
+	if v, ok := querys["jobId"]; ok && v != nil {
+		jobInfo := service.NewSysJobImpl.SelectJobById(v.(string))
+		querys["jobName"] = jobInfo.JobName
+		querys["jobGroup"] = jobInfo.JobGroup
+	}
+	data := s.sysJobLogService.SelectJobLogPage(querys)
+
+	rows := data["rows"].([]model.SysJobLog)
+	// 闭包函数处理多语言
+	language := ctx.AcceptLanguage(c)
+	converI18n := func(language string, arr *[]model.SysJobLog) {
+		for i := range *arr {
+			(*arr)[i].JobName = i18n.TKey(language, (*arr)[i].JobName)
+		}
+	}
+	converI18n(language, &rows)
+
+	c.JSON(200, result.Ok(data))
+}
+
+// 调度任务日志信息
+//
+// GET /:jobLogId
+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")))
+		return
+	}
+	data := s.sysJobLogService.SelectJobLogById(jobLogId)
+	if data.JobLogID == jobLogId {
+		c.JSON(200, result.OkData(data))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
+
+// 调度任务日志删除
+//
+// DELETE /:jobLogIds
+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")))
+		return
+	}
+
+	// 处理字符转id数组后去重
+	ids := strings.Split(jobLogIds, ",")
+	uniqueIDs := parse.RemoveDuplicates(ids)
+	if len(uniqueIDs) <= 0 {
+		c.JSON(200, result.Err(nil))
+		return
+	}
+	rows := s.sysJobLogService.DeleteJobLogByIds(uniqueIDs)
+	if rows > 0 {
+		// 删除成功：%d
+		msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
+		c.JSON(200, result.OkMsg(msg))
+		return
+	}
+	c.JSON(200, result.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))
+}
+
+// 导出调度任务日志信息
+//
+// POST /export
+func (s *SysJobLogController) Export(c *gin.Context) {
+	// 查询结果，根据查询条件结果，单页最大值限制
+	querys := ctx.BodyJSONMap(c)
+	data := s.sysJobLogService.SelectJobLogPage(querys)
+	if data["total"].(int64) == 0 {
+		c.JSON(200, result.ErrMsg("Export data record is empty"))
+		return
+	}
+	rows := data["rows"].([]model.SysJobLog)
+
+	// 闭包函数处理多语言
+	language := ctx.AcceptLanguage(c)
+	converI18n := func(language string, arr *[]model.SysJobLog) {
+		for i := range *arr {
+			(*arr)[i].JobName = i18n.TKey(language, (*arr)[i].JobName)
+		}
+	}
+	converI18n(language, &rows)
+
+	// 导出文件名称
+	fileName := fmt.Sprintf("jobLog_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
+	// 第一行表头标题
+	headerCells := map[string]string{
+		"A1": i18n.TKey(language, "job.export.jobLogID"),
+		"B1": i18n.TKey(language, "job.export.jobName"),
+		"C1": i18n.TKey(language, "job.export.jobGroupName"),
+		"D1": i18n.TKey(language, "job.export.invokeTarget"),
+		"E1": i18n.TKey(language, "job.export.targetParams"),
+		"F1": i18n.TKey(language, "job.export.jobID"),
+		"G1": i18n.TKey(language, "job.export.jobLogStatus"),
+		"H1": i18n.TKey(language, "job.export.jobLogTime"),
+	}
+	// 读取任务组名字典数据
+	dictSysJobGroup := s.sysDictDataService.SelectDictDataByType("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.DictValue {
+				sysJobGroup = i18n.TKey(language, v.DictLabel)
+				break
+			}
+		}
+		// 状态
+		statusValue := i18n.TKey(language, "dictData.fail")
+		if row.Status == "1" {
+			statusValue = i18n.TKey(language, "dictData.success")
+		}
+		dataCells = append(dataCells, map[string]any{
+			"A" + idx: row.JobLogID,
+			"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),
+		})
+	}
+
+	// 导出数据表格
+	saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
+	if err != nil {
+		c.JSON(200, result.ErrMsg(err.Error()))
+		return
+	}
+
+	c.FileAttachment(saveFilePath, fileName)
+}
--- a/src/modules/monitor/controller/sys_user_online.go
+++ b/src/modules/monitor/controller/sys_user_online.go
@@ -0,0 +1,131 @@
+package controller
+
+import (
+	"encoding/json"
+	"sort"
+	"strings"
+
+	"nms_nbi/src/framework/constants/cachekey"
+	"nms_nbi/src/framework/i18n"
+	"nms_nbi/src/framework/redis"
+	"nms_nbi/src/framework/utils/ctx"
+	"nms_nbi/src/framework/vo"
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 实例化控制层 SysUserOnlineController 结构体
+var NewSysUserOnline = &SysUserOnlineController{
+	sysUserOnlineService: service.NewSysUserOnlineImpl,
+}
+
+// 在线用户监控
+//
+// PATH /monitor/online
+type SysUserOnlineController struct {
+	// 在线用户服务
+	sysUserOnlineService service.ISysUserOnline
+}
+
+// 在线用户列表
+//
+// GET /list
+func (s *SysUserOnlineController) List(c *gin.Context) {
+	language := ctx.AcceptLanguage(c)
+	ipaddr := c.Query("ipaddr")
+	userName := c.Query("userName")
+
+	// 获取所有在线用户key
+	keys, _ := redis.GetKeys("", cachekey.LOGIN_TOKEN_KEY+"*")
+
+	// 分批获取
+	arr := make([]string, 0)
+	for i := 0; i < len(keys); i += 20 {
+		end := i + 20
+		if end > len(keys) {
+			end = len(keys)
+		}
+		chunk := keys[i:end]
+		values, _ := redis.GetBatch("", chunk)
+		for _, v := range values {
+			arr = append(arr, v.(string))
+		}
+	}
+
+	// 遍历字符串信息解析组合可用对象
+	userOnlines := make([]model.SysUserOnline, 0)
+	for _, str := range arr {
+		if str == "" {
+			continue
+		}
+
+		var loginUser vo.LoginUser
+		err := json.Unmarshal([]byte(str), &loginUser)
+		if err != nil {
+			continue
+		}
+
+		onlineUser := s.sysUserOnlineService.LoginUserToUserOnline(loginUser)
+		if onlineUser.TokenID != "" {
+			onlineUser.LoginLocation = i18n.TKey(language, onlineUser.LoginLocation)
+			userOnlines = append(userOnlines, onlineUser)
+		}
+	}
+
+	// 根据查询条件过滤
+	filteredUserOnlines := make([]model.SysUserOnline, 0)
+	if ipaddr != "" && userName != "" {
+		for _, o := range userOnlines {
+			if strings.Contains(o.IPAddr, ipaddr) && strings.Contains(o.UserName, userName) {
+				filteredUserOnlines = append(filteredUserOnlines, o)
+			}
+		}
+	} else if ipaddr != "" {
+		for _, o := range userOnlines {
+			if strings.Contains(o.IPAddr, ipaddr) {
+				filteredUserOnlines = append(filteredUserOnlines, o)
+			}
+		}
+	} else if userName != "" {
+		for _, o := range userOnlines {
+			if strings.Contains(o.UserName, userName) {
+				filteredUserOnlines = append(filteredUserOnlines, o)
+			}
+		}
+	} else {
+		filteredUserOnlines = userOnlines
+	}
+
+	// 按登录时间排序
+	sort.Slice(filteredUserOnlines, func(i, j int) bool {
+		return filteredUserOnlines[j].LoginTime > filteredUserOnlines[i].LoginTime
+	})
+
+	c.JSON(200, result.Ok(map[string]any{
+		"total": len(filteredUserOnlines),
+		"rows":  filteredUserOnlines,
+	}))
+}
+
+// 在线用户强制退出
+//
+// 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")))
+		return
+	}
+
+	// 删除token
+	ok, _ := redis.Del("", cachekey.LOGIN_TOKEN_KEY+tokenId)
+	if ok {
+		c.JSON(200, result.Ok(nil))
+		return
+	}
+	c.JSON(200, result.Err(nil))
+}
--- a/src/modules/monitor/controller/system_info.go
+++ b/src/modules/monitor/controller/system_info.go
@@ -0,0 +1,35 @@
+package controller
+
+import (
+	"nms_nbi/src/framework/vo/result"
+	"nms_nbi/src/modules/monitor/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 实例化控制层 SystemInfoController 结构体
+var NewSystemInfo = &SystemInfoController{
+	systemInfogService: service.NewSystemInfoImpl,
+}
+
+// 服务器监控信息
+//
+// PATH /monitor/system-info
+type SystemInfoController struct {
+	// 服务器系统相关信息服务
+	systemInfogService service.ISystemInfo
+}
+
+// 服务器信息
+//
+// GET /
+func (s *SystemInfoController) Info(c *gin.Context) {
+	c.JSON(200, result.OkData(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(),
+	}))
+}
--- a/src/modules/monitor/model/monitor_base.go
+++ b/src/modules/monitor/model/monitor_base.go
@@ -0,0 +1,29 @@
+package model
+
+// MonitorBase 监控_基本信息 monitor_base
+type MonitorBase struct {
+	// id
+	ID int64 `json:"id" gorm:"primaryKey"`
+	// 创建时间
+	CreateTime int64 `json:"createTime"`
+	// cpu使用率
+	CPU float64 `json:"cpu"`
+	// cpu平均使用率
+	LoadUsage float64 `json:"loadUsage"`
+	// cpu使用1分钟
+	CPULoad1 float64 `json:"cpuLoad1"`
+	// cpu使用5分钟
+	CPULoad5 float64 `json:"cpuLoad5"`
+	// cpu使用15分钟
+	CPULoad15 float64 `json:"cpuLoad15"`
+	// 内存使用率
+	Memory float64 `json:"memory"`
+	// 网元ID
+	NeType string `json:"neType"`
+	// 网元类型
+	NeID string `json:"neId"`
+}
+
+func (MonitorBase) TableName() string {
+	return "monitor_base"
+}
--- a/src/modules/monitor/model/monitor_io.go
+++ b/src/modules/monitor/model/monitor_io.go
@@ -0,0 +1,27 @@
+package model
+
+// MonitorIO 监控_磁盘IO monitor_io
+type MonitorIO struct {
+	// id
+	ID int64 `json:"id" gorm:"primaryKey"`
+	// 创建时间
+	CreateTime int64 `json:"createTime"`
+	// 磁盘名
+	Name string `json:"name"`
+	// 读取K
+	Read int64 `json:"read"`
+	// 写入K
+	Write int64 `json:"write"`
+	// 次数
+	Count int64 `json:"count"`
+	// 耗时
+	Time int64 `json:"time"`
+	// 网元ID
+	NeType string `json:"neType"`
+	// 网元类型
+	NeID string `json:"neId"`
+}
+
+func (MonitorIO) TableName() string {
+	return "monitor_io"
+}
--- a/src/modules/monitor/model/monitor_network.go
+++ b/src/modules/monitor/model/monitor_network.go
@@ -0,0 +1,23 @@
+package model
+
+// MonitorNetwork 监控_网络IO monitor_network
+type MonitorNetwork struct {
+	// id
+	ID int64 `json:"id" gorm:"primaryKey"`
+	// 创建时间
+	CreateTime int64 `json:"createTime"`
+	// 网卡名
+	Name string `json:"name"`
+	// 上行
+	Up float64 `json:"up"`
+	// 下行
+	Down float64 `json:"down"`
+	// 网元ID 本机#号
+	NeType string `json:"neType"`
+	// 网元类型 本机#号
+	NeID string `json:"neId"`
+}
+
+func (MonitorNetwork) TableName() string {
+	return "monitor_network"
+}
--- a/src/modules/monitor/model/sys_cache.go
+++ b/src/modules/monitor/model/sys_cache.go
@@ -0,0 +1,41 @@
+package model
+
+import "strings"
+
+// SysCache 缓存信息对象
+type SysCache struct {
+	CacheName  string `json:"cacheName"`  // 缓存名称
+	CacheKey   string `json:"cacheKey"`   // 缓存键名
+	CacheValue string `json:"cacheValue"` // 缓存内容
+	Remark     string `json:"remark"`     // 备注
+}
+
+// NewSysCacheNames 创建新的缓存名称列表项实例
+func NewSysCacheNames(cacheName string, cacheKey string) SysCache {
+	return SysCache{
+		CacheName:  cacheKey[:len(cacheKey)-1],
+		CacheKey:   "",
+		CacheValue: "",
+		Remark:     cacheName,
+	}
+}
+
+// NewSysCacheKeys 创建新的缓存键名列表项实例
+func NewSysCacheKeys(cacheName string, cacheKey string) SysCache {
+	return SysCache{
+		CacheName:  cacheName,
+		CacheKey:   strings.Replace(cacheKey, cacheName+":", "", 1),
+		CacheValue: "",
+		Remark:     "",
+	}
+}
+
+// NewSysCacheValue 创建新的缓存键名内容项实例
+func NewSysCacheValue(cacheName string, cacheKey string, cacheValue string) SysCache {
+	return SysCache{
+		CacheName:  cacheName,
+		CacheKey:   cacheKey,
+		CacheValue: cacheValue,
+		Remark:     "",
+	}
+}
--- a/src/modules/monitor/model/sys_job.go
+++ b/src/modules/monitor/model/sys_job.go
@@ -0,0 +1,35 @@
+package model
+
+// SysJob 调度任务信息表 sys_job
+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"`
+}
--- a/src/modules/monitor/model/sys_job_log.go
+++ b/src/modules/monitor/model/sys_job_log.go
@@ -0,0 +1,23 @@
+package model
+
+// SysJobLog 定时任务调度日志表 sys_job_log
+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"`
+}
--- a/src/modules/monitor/model/sys_user_online.go
+++ b/src/modules/monitor/model/sys_user_online.go
@@ -0,0 +1,21 @@
+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"`
+}
--- a/src/modules/monitor/monitor.go
+++ b/src/modules/monitor/monitor.go
@@ -0,0 +1,169 @@
+package monitor
+
+import (
+	"nms_nbi/src/framework/logger"
+	"nms_nbi/src/framework/middleware"
+	"nms_nbi/src/framework/middleware/collectlogs"
+	"nms_nbi/src/framework/middleware/repeat"
+	"nms_nbi/src/modules/monitor/controller"
+	"nms_nbi/src/modules/monitor/processor"
+	"nms_nbi/src/modules/monitor/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Setup 模块路由注册
+func Setup(router *gin.Engine) {
+	logger.Infof("开始加载 ====> monitor 模块路由")
+
+	// 启动时需要的初始参数
+	InitLoad()
+
+	// 服务器资源监控信息
+	monitorGroup := router.Group("/monitor")
+	{
+		monitorGroup.GET("/load",
+			// middleware.PreAuthorize(nil),
+			controller.NewMonitor.Load,
+		)
+	}
+
+	// 服务器服务信息
+	router.GET("/monitor/system-info",
+		middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:system:info"}}),
+		controller.NewSystemInfo.Info,
+	)
+
+	// 缓存服务信息
+	sysCacheGroup := router.Group("/monitor/cache")
+	{
+		sysCacheGroup.GET("",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:info"}}),
+			controller.NewSysCache.Info,
+		)
+		sysCacheGroup.GET("/getNames",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:list"}}),
+			controller.NewSysCache.Names,
+		)
+		sysCacheGroup.GET("/getKeys/:cacheName",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:list"}}),
+			controller.NewSysCache.Keys,
+		)
+		sysCacheGroup.GET("/getValue/:cacheName/:cacheKey",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:query"}}),
+			controller.NewSysCache.Value,
+		)
+		sysCacheGroup.DELETE("/clearCacheName/:cacheName",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
+			controller.NewSysCache.ClearCacheName,
+		)
+		sysCacheGroup.DELETE("/clearCacheKey/:cacheName/:cacheKey",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
+			controller.NewSysCache.ClearCacheKey,
+		)
+		sysCacheGroup.DELETE("/clearCacheSafe",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:cache:remove"}}),
+			controller.NewSysCache.ClearCacheSafe,
+		)
+	}
+
+	// 调度任务日志信息
+	sysJobLogGroup := router.Group("/monitor/jobLog")
+	{
+		sysJobLogGroup.GET("/list",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:list"}}),
+			controller.NewSysJobLog.List,
+		)
+		sysJobLogGroup.GET("/:jobLogId",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:query"}}),
+			controller.NewSysJobLog.Info,
+		)
+		sysJobLogGroup.DELETE("/:jobLogIds",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:remove"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJobLog", collectlogs.BUSINESS_TYPE_DELETE)),
+			controller.NewSysJobLog.Remove,
+		)
+		sysJobLogGroup.DELETE("/clean",
+			repeat.RepeatSubmit(5),
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:remove"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJobLog", collectlogs.BUSINESS_TYPE_CLEAN)),
+			controller.NewSysJobLog.Clean,
+		)
+		sysJobLogGroup.POST("/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,
+		)
+	}
+
+	// 调度任务信息
+	sysJobGroup := router.Group("/monitor/job")
+	{
+		sysJobGroup.GET("/list",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:list"}}),
+			controller.NewSysJob.List,
+		)
+		sysJobGroup.GET("/:jobId",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:query"}}),
+			controller.NewSysJob.Info,
+		)
+		sysJobGroup.POST("",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:add"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_INSERT)),
+			controller.NewSysJob.Add,
+		)
+		sysJobGroup.PUT("",
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:edit"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
+			controller.NewSysJob.Edit,
+		)
+		sysJobGroup.DELETE("/:jobIds",
+			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",
+			repeat.RepeatSubmit(5),
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:changeStatus"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
+			controller.NewSysJob.Status,
+		)
+		sysJobGroup.PUT("/run/:jobId",
+			repeat.RepeatSubmit(10),
+			middleware.PreAuthorize(map[string][]string{"hasPerms": {"monitor:job:changeStatus"}}),
+			collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysJob", collectlogs.BUSINESS_TYPE_UPDATE)),
+			controller.NewSysJob.Run,
+		)
+		sysJobGroup.PUT("/resetQueueJob",
+			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",
+			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 初始参数
+func InitLoad() {
+	// 初始化定时任务处理
+	processor.InitCronQueue()
+	// 启动时，初始化调度任务
+	service.NewSysJobImpl.ResetQueueJob()
+}
--- a/src/modules/monitor/processor/bar/bar.go
+++ b/src/modules/monitor/processor/bar/bar.go
@@ -0,0 +1,61 @@
+package bar
+
+import (
+	"time"
+
+	"nms_nbi/src/framework/cron"
+	"nms_nbi/src/framework/logger"
+)
+
+var NewProcessor = &BarProcessor{
+	progress: 0,
+	count:    0,
+}
+
+// bar 队列任务处理
+type BarProcessor struct {
+	// 任务进度
+	progress int
+	// 执行次数
+	count int
+}
+
+func (s *BarProcessor) Execute(data any) (any, error) {
+	logger.Infof("执行 %d 次，上次进度： %d ", s.count, s.progress)
+	s.count++
+
+	options := data.(cron.JobData)
+	sysJob := options.SysJob
+	logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
+
+	// 实现任务处理逻辑
+	i := 0
+	s.progress = i
+	for i < 5 {
+		// 获取任务进度
+		progress := s.progress
+		logger.Infof("jonId: %s => 任务进度：%d", sysJob.JobID, progress)
+		// 延迟响应
+		time.Sleep(time.Second * 2)
+		// 程序中途执行错误
+		if i == 3 {
+			// arr := [1]int{1}
+			// arr[i] = 3
+			// fmt.Println(arr)
+			// return "i = 3"
+			panic("程序中途执行错误")
+		}
+		i++
+		// 改变任务进度
+		s.progress = i
+	}
+
+	// 返回结果，用于记录执行结果
+	result := map[string]any{
+		"repeat":       options.Repeat,
+		"jobName":      sysJob.JobName,
+		"invokeTarget": sysJob.InvokeTarget,
+		"targetParams": sysJob.TargetParams,
+	}
+	return result, nil
+}
--- a/src/modules/monitor/processor/foo/foo.go
+++ b/src/modules/monitor/processor/foo/foo.go
@@ -0,0 +1,53 @@
+package foo
+
+import (
+	"time"
+
+	"nms_nbi/src/framework/cron"
+	"nms_nbi/src/framework/logger"
+)
+
+var NewProcessor = &FooProcessor{
+	progress: 0,
+	count:    0,
+}
+
+// foo 队列任务处理
+type FooProcessor struct {
+	// 任务进度
+	progress int
+	// 执行次数
+	count int
+}
+
+func (s *FooProcessor) Execute(data any) (any, error) {
+	logger.Infof("执行 %d 次，上次进度： %d ", s.count, s.progress)
+	s.count++
+
+	options := data.(cron.JobData)
+	sysJob := options.SysJob
+	logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
+
+	// 实现任务处理逻辑
+	i := 0
+	s.progress = i
+	for i < 20 {
+		// 获取任务进度
+		progress := s.progress
+		logger.Infof("jonId: %s => 任务进度：%d", sysJob.JobID, progress)
+		// 延迟响应
+		time.Sleep(time.Second * 2)
+		i++
+		// 改变任务进度
+		s.progress = i
+	}
+
+	// 返回结果，用于记录执行结果
+	result := map[string]any{
+		"repeat":       options.Repeat,
+		"jobName":      sysJob.JobName,
+		"invokeTarget": sysJob.InvokeTarget,
+		"targetParams": sysJob.TargetParams,
+	}
+	return result, nil
+}
--- a/src/modules/monitor/processor/processor.go
+++ b/src/modules/monitor/processor/processor.go
@@ -0,0 +1,15 @@
+package processor
+
+import (
+	"nms_nbi/src/framework/cron"
+	"nms_nbi/src/modules/monitor/processor/bar"
+	"nms_nbi/src/modules/monitor/processor/foo"
+	"nms_nbi/src/modules/monitor/processor/simple"
+)
+
+// InitCronQueue 初始定时任务队列
+func InitCronQueue() {
+	cron.CreateQueue("simple", simple.NewProcessor)
+	cron.CreateQueue("foo", foo.NewProcessor)
+	cron.CreateQueue("bar", bar.NewProcessor)
+}
--- a/src/modules/monitor/processor/simple/simple.go
+++ b/src/modules/monitor/processor/simple/simple.go
@@ -0,0 +1,27 @@
+package simple
+
+import (
+	"nms_nbi/src/framework/cron"
+	"nms_nbi/src/framework/logger"
+)
+
+var NewProcessor = &simpleProcessor{}
+
+// simple 队列任务处理
+type simpleProcessor struct{}
+
+func (s *simpleProcessor) Execute(data any) (any, error) {
+	options := data.(cron.JobData)
+
+	sysJob := options.SysJob
+	logger.Infof("重复 %v 任务ID %s", options.Repeat, sysJob.JobID)
+
+	// 返回结果，用于记录执行结果
+	result := map[string]any{
+		"repeat":       options.Repeat,
+		"jobName":      sysJob.JobName,
+		"invokeTarget": sysJob.InvokeTarget,
+		"targetParams": sysJob.TargetParams,
+	}
+	return result, nil
+}
--- a/src/modules/monitor/repository/monitor.go
+++ b/src/modules/monitor/repository/monitor.go
@@ -0,0 +1,33 @@
+package repository
+
+import "nms_nbi/src/modules/monitor/model"
+
+// IMonitor 监控服务资源相关信息 数据接口
+type IMonitor interface {
+	// CreateMonitorBase 创建监控_基本信息
+	CreateMonitorBase(m model.MonitorBase) error
+
+	// DelMonitorBase 删除监控_基本信息
+	DelMonitorBase(ltTime int64) error
+
+	// SelectMonitorBase 查询监控_基本信息
+	SelectMonitorBase(query map[string]any) []model.MonitorBase
+
+	// 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
+}
--- a/src/modules/monitor/repository/monitor.impl.go
+++ b/src/modules/monitor/repository/monitor.impl.go
@@ -0,0 +1,106 @@
+package repository
+
+import (
+	"nms_nbi/src/framework/datasource"
+	"nms_nbi/src/framework/logger"
+	"nms_nbi/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
+}
--- a/src/modules/monitor/repository/sys_job.go
+++ b/src/modules/monitor/repository/sys_job.go
@@ -0,0 +1,29 @@
+package repository
+
+import (
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// ISysJob 调度任务表 数据层接口
+type ISysJob interface {
+	// SelectJobPage 分页查询调度任务集合
+	SelectJobPage(query map[string]any) map[string]any
+
+	// SelectJobList 查询调度任务集合
+	SelectJobList(sysJob model.SysJob) []model.SysJob
+
+	// SelectJobByIds 通过调度ID查询调度任务信息
+	SelectJobByIds(jobIds []string) []model.SysJob
+
+	// CheckUniqueJob 校验调度任务是否唯一
+	CheckUniqueJob(sysJob model.SysJob) string
+
+	// InsertJob 新增调度任务信息
+	InsertJob(sysJob model.SysJob) string
+
+	// UpdateJob 修改调度任务信息
+	UpdateJob(sysJob model.SysJob) int64
+
+	// DeleteJobByIds 批量删除调度任务信息
+	DeleteJobByIds(jobIds []string) int64
+}
--- a/src/modules/monitor/repository/sys_job.impl.go
+++ b/src/modules/monitor/repository/sys_job.impl.go
@@ -0,0 +1,343 @@
+package repository
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"nms_nbi/src/framework/datasource"
+	"nms_nbi/src/framework/logger"
+	"nms_nbi/src/framework/utils/parse"
+	"nms_nbi/src/framework/utils/repo"
+	"nms_nbi/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
+}
--- a/src/modules/monitor/repository/sys_job_log.go
+++ b/src/modules/monitor/repository/sys_job_log.go
@@ -0,0 +1,26 @@
+package repository
+
+import (
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// 调度任务日志表 数据层接口
+type ISysJobLog interface {
+	// 分页查询调度任务日志集合
+	SelectJobLogPage(query map[string]any) map[string]any
+
+	// 查询调度任务日志集合
+	SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog
+
+	// 通过调度ID查询调度任务日志信息
+	SelectJobLogById(jobLogId string) model.SysJobLog
+
+	// 新增调度任务日志信息
+	InsertJobLog(sysJobLog model.SysJobLog) string
+
+	// 批量删除调度任务日志信息
+	DeleteJobLogByIds(jobLogId []string) int64
+
+	// 清空调度任务日志
+	CleanJobLog() error
+}
--- a/src/modules/monitor/repository/sys_job_log.impl.go
+++ b/src/modules/monitor/repository/sys_job_log.impl.go
@@ -0,0 +1,272 @@
+package repository
+
+import (
+	"strings"
+	"time"
+
+	"nms_nbi/src/framework/datasource"
+	"nms_nbi/src/framework/logger"
+	"nms_nbi/src/framework/utils/date"
+	"nms_nbi/src/framework/utils/parse"
+	"nms_nbi/src/framework/utils/repo"
+	"nms_nbi/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 >= ?")
+		beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
+		params = append(params, beginDate.UnixMilli())
+	}
+	endTime, ok := query["endTime"]
+	if !ok {
+		endTime, ok = query["params[endTime]"]
+	}
+	if ok && endTime != "" {
+		conditions = append(conditions, "create_time <= ?")
+		endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
+		params = append(params, endDate.UnixMilli())
+	}
+
+	// 构建查询条件语句
+	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
+}
--- a/src/modules/monitor/service/monitor.go
+++ b/src/modules/monitor/service/monitor.go
@@ -0,0 +1,14 @@
+package service
+
+// IMonitor 服务器系统相关信息 服务层接口
+type IMonitor interface {
+	// RunMonitor 执行资源监控
+	RunMonitor()
+
+	// RunMonitorDataCancel 启动资源监控数据存储io/network通道 移除之前的chan上下文后在设置新的均值
+	// interval 采集的平均值（分钟）
+	RunMonitorDataCancel(removeBefore bool, interval float64)
+
+	// SelectMonitorInfo 查询监控资源信息
+	SelectMonitorInfo(query map[string]any) map[string]any
+}
--- a/src/modules/monitor/service/monitor.impl.go
+++ b/src/modules/monitor/service/monitor.impl.go
@@ -0,0 +1,272 @@
+package service
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"nms_nbi/src/framework/logger"
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/repository"
+	systemService "nms_nbi/src/modules/system/service"
+
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v3/load"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
+)
+
+// 实例化服务层 MonitorImpl 结构体
+var NewMonitorImpl = &MonitorImpl{
+	sysConfigService:  systemService.NewSysConfigImpl,
+	monitorRepository: repository.NewMonitorImpl,
+	diskIO:            make(chan []disk.IOCountersStat, 2),
+	netIO:             make(chan []net.IOCountersStat, 2),
+}
+
+// MonitorImpl 服务器系统相关信息 服务层处理
+type MonitorImpl struct {
+	// 参数配置服务
+	sysConfigService systemService.ISysConfig
+	// 监控服务资源数据信息
+	monitorRepository repository.IMonitor
+	// 磁盘网络IO 数据通道
+	diskIO chan ([]disk.IOCountersStat)
+	netIO  chan ([]net.IOCountersStat)
+}
+
+// RunMonitor 执行资源监控
+func (s *MonitorImpl) RunMonitor() {
+	var itemBase model.MonitorBase
+	itemBase.CreateTime = time.Now().UnixMilli()
+	itemBase.NeType = "#"
+	itemBase.NeID = "#"
+	totalPercent, _ := cpu.Percent(3*time.Second, false)
+	if len(totalPercent) == 1 {
+		itemBase.CPU = totalPercent[0]
+	}
+	cpuCount, _ := cpu.Counts(false)
+
+	loadInfo, _ := load.Avg()
+	itemBase.CPULoad1 = loadInfo.Load1
+	itemBase.CPULoad5 = loadInfo.Load5
+	itemBase.CPULoad15 = loadInfo.Load15
+	itemBase.LoadUsage = loadInfo.Load1 / (float64(cpuCount*2) * 0.75) * 100
+
+	memoryInfo, _ := mem.VirtualMemory()
+	itemBase.Memory = memoryInfo.UsedPercent
+
+	if err := s.monitorRepository.CreateMonitorBase(itemBase); err != nil {
+		logger.Errorf("CreateMonitorBase err: %v", err)
+	}
+
+	// 将当前资源发送到chan中处理保存
+	s.loadDiskIO()
+	s.loadNetIO()
+
+	// 监控系统资源-保留天数
+	storeDays := s.sysConfigService.SelectConfigValueByKey("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)
+	}
+}
+
+func (s *MonitorImpl) loadDiskIO() {
+	ioStat, _ := disk.IOCounters()
+	var diskIOList []disk.IOCountersStat
+	for _, io := range ioStat {
+		diskIOList = append(diskIOList, io)
+	}
+	s.diskIO <- diskIOList
+}
+
+func (s *MonitorImpl) loadNetIO() {
+	netStat, _ := net.IOCounters(true)
+	netStatAll, _ := net.IOCounters(false)
+	var netList []net.IOCountersStat
+	netList = append(netList, netStat...)
+	netList = append(netList, netStatAll...)
+	s.netIO <- netList
+}
+
+// monitorCancel 监控搜集IO/Network上下文
+var monitorCancel context.CancelFunc
+
+// RunMonitorDataCancel 启动资源监控数据存储io/network通道 移除之前的chan上下文后在设置新的均值
+// interval 采集的平均值（分钟）
+func (s *MonitorImpl) RunMonitorDataCancel(removeBefore bool, interval float64) {
+	// 是否取消之前的
+	if removeBefore {
+		monitorCancel()
+	}
+
+	// 上下文控制
+	ctx, cancel := context.WithCancel(context.Background())
+	monitorCancel = cancel
+
+	// chanl 通道进行存储数据
+	go s.saveIODataToDB(ctx, interval)
+	go s.saveNetDataToDB(ctx, interval)
+}
+
+func (s *MonitorImpl) saveIODataToDB(ctx context.Context, interval float64) {
+	defer close(s.diskIO)
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case ioStat := <-s.diskIO:
+			select {
+			case <-ctx.Done():
+				return
+			case ioStat2 := <-s.diskIO:
+				var ioList []model.MonitorIO
+				timeMilli := time.Now().UnixMilli()
+				for _, io2 := range ioStat2 {
+					for _, io1 := range ioStat {
+						if io2.Name == io1.Name {
+							var itemIO model.MonitorIO
+							itemIO.CreateTime = timeMilli
+							itemIO.NeType = "#"
+							itemIO.NeID = "#"
+							itemIO.Name = io1.Name
+
+							if io2.ReadBytes != 0 && io1.ReadBytes != 0 && io2.ReadBytes > io1.ReadBytes {
+								itemIO.Read = int64(float64(io2.ReadBytes-io1.ReadBytes) / interval / 60)
+							}
+							if io2.WriteBytes != 0 && io1.WriteBytes != 0 && io2.WriteBytes > io1.WriteBytes {
+								itemIO.Write = int64(float64(io2.WriteBytes-io1.WriteBytes) / interval / 60)
+							}
+
+							if io2.ReadCount != 0 && io1.ReadCount != 0 && io2.ReadCount > io1.ReadCount {
+								itemIO.Count = int64(float64(io2.ReadCount-io1.ReadCount) / interval / 60)
+							}
+							writeCount := int64(0)
+							if io2.WriteCount != 0 && io1.WriteCount != 0 && io2.WriteCount > io1.WriteCount {
+								writeCount = int64(float64(io2.WriteCount-io1.WriteCount) / interval * 60)
+							}
+							if writeCount > itemIO.Count {
+								itemIO.Count = writeCount
+							}
+
+							if io2.ReadTime != 0 && io1.ReadTime != 0 && io2.ReadTime > io1.ReadTime {
+								itemIO.Time = int64(float64(io2.ReadTime-io1.ReadTime) / interval / 60)
+							}
+							writeTime := int64(0)
+							if io2.WriteTime != 0 && io1.WriteTime != 0 && io2.WriteTime > io1.WriteTime {
+								writeTime = int64(float64(io2.WriteTime-io1.WriteTime) / interval / 60)
+							}
+							if writeTime > itemIO.Time {
+								itemIO.Time = writeTime
+							}
+							ioList = append(ioList, itemIO)
+							break
+						}
+					}
+				}
+				if err := s.monitorRepository.BatchCreateMonitorIO(ioList); err != nil {
+					logger.Errorf("BatchCreateMonitorIO err: %v", err)
+				}
+				s.diskIO <- ioStat2
+			}
+		}
+	}
+}
+
+func (s *MonitorImpl) saveNetDataToDB(ctx context.Context, interval float64) {
+	defer close(s.netIO)
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case netStat := <-s.netIO:
+			select {
+			case <-ctx.Done():
+				return
+			case netStat2 := <-s.netIO:
+				var netList []model.MonitorNetwork
+				timeMilli := time.Now().UnixMilli()
+				for _, net2 := range netStat2 {
+					for _, net1 := range netStat {
+						if net2.Name == net1.Name {
+							var itemNet model.MonitorNetwork
+							itemNet.CreateTime = timeMilli
+							itemNet.NeType = "#"
+							itemNet.NeID = "#"
+							itemNet.Name = net1.Name
+
+							if net2.BytesSent != 0 && net1.BytesSent != 0 && net2.BytesSent > net1.BytesSent {
+								itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / interval / 60
+							}
+							if net2.BytesRecv != 0 && net1.BytesRecv != 0 && net2.BytesRecv > net1.BytesRecv {
+								itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / interval / 60
+							}
+							netList = append(netList, itemNet)
+							break
+						}
+					}
+				}
+
+				if err := s.monitorRepository.BatchCreateMonitorNet(netList); err != nil {
+					logger.Errorf("BatchCreateMonitorNet err: %v", err)
+				}
+				s.netIO <- netStat2
+			}
+		}
+	}
+}
+
+// SelectMonitorInfo 查询监控资源信息
+func (s *MonitorImpl) SelectMonitorInfo(query map[string]any) map[string]any {
+	infoType := query["type"]
+	startTimeMilli := query["startTime"]
+	endTimeMilli := query["endTime"]
+	neType := query["neType"]
+	neId := query["neId"]
+	name := query["name"]
+
+	// 返回数据
+	backDatas := map[string]any{}
+
+	// 基本信息
+	if infoType == "all" || infoType == "load" || infoType == "cpu" || infoType == "memory" {
+		rows := s.monitorRepository.SelectMonitorBase(map[string]any{
+			"startTime": startTimeMilli,
+			"endTime":   endTimeMilli,
+			"neType":    neType,
+			"neId":      neId,
+		})
+		backDatas["base"] = rows
+	}
+
+	// 磁盘IO
+	if infoType == "all" || infoType == "io" {
+		rows := s.monitorRepository.SelectMonitorIO(map[string]any{
+			"startTime": startTimeMilli,
+			"endTime":   endTimeMilli,
+			"neType":    neType,
+			"neId":      neId,
+			"name":      name,
+		})
+		backDatas["io"] = rows
+	}
+
+	// 网络
+	if infoType == "all" || infoType == "network" {
+		rows := s.monitorRepository.SelectMonitorNetwork(map[string]any{
+			"startTime": startTimeMilli,
+			"endTime":   endTimeMilli,
+			"neType":    neType,
+			"neId":      neId,
+			"name":      name,
+		})
+		backDatas["network"] = rows
+	}
+
+	return backDatas
+}
--- a/src/modules/monitor/service/monitor_test.go
+++ b/src/modules/monitor/service/monitor_test.go
@@ -0,0 +1,183 @@
+package service
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v3/load"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
+)
+
+func init() {
+
+}
+
+func TestInfo(t *testing.T) {
+	s := MonitorInfo{}
+	s.load(0.5) // 0.5 半分钟
+
+	fmt.Println(s)
+	select {}
+}
+
+// MonitorInfo 机器资源信息
+type MonitorInfo struct {
+	MonitorBase    MonitorBase      `json:"base"`    // 监控_基本信息
+	MonitorIO      []MonitorIO      `json:"io"`      // 监控_磁盘IO
+	MonitorNetwork []MonitorNetwork `json:"network"` // 监控_网络IO
+}
+
+// load 执行资源获取
+func (m *MonitorInfo) load(interval float64) {
+	var itemBase MonitorBase
+	itemBase.CreateTime = time.Now().UnixMilli()
+
+	totalPercent, _ := cpu.Percent(3*time.Second, false)
+	if len(totalPercent) == 1 {
+		itemBase.CPU = totalPercent[0]
+	}
+	cpuCount, _ := cpu.Counts(false)
+
+	loadInfo, _ := load.Avg()
+	itemBase.CPULoad1 = loadInfo.Load1
+	itemBase.CPULoad5 = loadInfo.Load5
+	itemBase.CPULoad15 = loadInfo.Load15
+	itemBase.LoadUsage = loadInfo.Load1 / (float64(cpuCount*2) * 0.75) * 100
+
+	memoryInfo, _ := mem.VirtualMemory()
+	itemBase.Memory = memoryInfo.UsedPercent
+
+	m.MonitorBase = itemBase
+
+	// 求平均
+	m.MonitorIO = loadDiskIO(interval)
+	m.MonitorNetwork = loadNetIO(interval)
+}
+
+// MonitorBase 监控_基本信息 monitor_base
+type MonitorBase struct {
+	CreateTime int64   `json:"createTime"` // 创建时间
+	CPU        float64 `json:"cpu"`        // cpu使用率
+	LoadUsage  float64 `json:"loadUsage"`  // cpu平均使用率
+	CPULoad1   float64 `json:"cpuLoad1"`   // cpu使用1分钟
+	CPULoad5   float64 `json:"cpuLoad5"`   // cpu使用5分钟
+	CPULoad15  float64 `json:"cpuLoad15"`  // cpu使用15分钟
+	Memory     float64 `json:"memory"`     // 内存使用率
+}
+
+// MonitorIO 监控_磁盘IO monitor_io
+type MonitorIO struct {
+	CreateTime int64  `json:"createTime"` // 创建时间
+	Name       string `json:"name"`       // 磁盘名
+	Read       int64  `json:"read"`       // 读取K
+	Write      int64  `json:"write"`      // 写入K
+	Count      int64  `json:"count"`      // 次数
+	Time       int64  `json:"time"`       // 耗时
+}
+
+// MonitorNetwork 监控_网络IO monitor_network
+type MonitorNetwork struct {
+	CreateTime int64   `json:"createTime"` // 创建时间
+	Name       string  `json:"name"`       // 网卡名
+	Up         float64 `json:"up"`         // 上行
+	Down       float64 `json:"down"`       // 下行
+}
+
+// loadDiskIO 磁盘读写，interval表示采集的平均值（分钟）
+func loadDiskIO(interval float64) []MonitorIO {
+	ioStat, _ := disk.IOCounters()
+
+	time.Sleep(time.Duration(interval) * time.Minute)
+
+	ioStat2, _ := disk.IOCounters()
+	var ioList []MonitorIO
+	timeMilli := time.Now().UnixMilli()
+	for _, io2 := range ioStat2 {
+		for _, io1 := range ioStat {
+			if io2.Name == io1.Name {
+				var itemIO MonitorIO
+				itemIO.CreateTime = timeMilli
+				itemIO.Name = io1.Name
+
+				if io2.ReadBytes != 0 && io1.ReadBytes != 0 && io2.ReadBytes > io1.ReadBytes {
+					itemIO.Read = int64(float64(io2.ReadBytes-io1.ReadBytes) / interval / 60)
+				}
+				if io2.WriteBytes != 0 && io1.WriteBytes != 0 && io2.WriteBytes > io1.WriteBytes {
+					itemIO.Write = int64(float64(io2.WriteBytes-io1.WriteBytes) / interval / 60)
+				}
+
+				if io2.ReadCount != 0 && io1.ReadCount != 0 && io2.ReadCount > io1.ReadCount {
+					itemIO.Count = int64(float64(io2.ReadCount-io1.ReadCount) / interval / 60)
+				}
+				writeCount := int64(0)
+				if io2.WriteCount != 0 && io1.WriteCount != 0 && io2.WriteCount > io1.WriteCount {
+					writeCount = int64(float64(io2.WriteCount-io1.WriteCount) / interval * 60)
+				}
+				if writeCount > itemIO.Count {
+					itemIO.Count = writeCount
+				}
+
+				if io2.ReadTime != 0 && io1.ReadTime != 0 && io2.ReadTime > io1.ReadTime {
+					itemIO.Time = int64(float64(io2.ReadTime-io1.ReadTime) / interval / 60)
+				}
+				writeTime := int64(0)
+				if io2.WriteTime != 0 && io1.WriteTime != 0 && io2.WriteTime > io1.WriteTime {
+					writeTime = int64(float64(io2.WriteTime-io1.WriteTime) / interval / 60)
+				}
+				if writeTime > itemIO.Time {
+					itemIO.Time = writeTime
+				}
+				ioList = append(ioList, itemIO)
+				break
+			}
+		}
+	}
+	return ioList
+}
+
+// loadNetIO 网络接口（包括虚拟接口），interval表示采集的平均值（分钟）
+func loadNetIO(interval float64) []MonitorNetwork {
+	// 获取当前时刻
+	netStat, _ := net.IOCounters(true)
+	netStatAll, _ := net.IOCounters(false)
+	var netStatList []net.IOCountersStat
+	netStatList = append(netStatList, netStat...)
+	netStatList = append(netStatList, netStatAll...)
+
+	time.Sleep(time.Duration(interval) * time.Minute)
+
+	// 获取结束时刻
+	netStat2, _ := net.IOCounters(true)
+	netStat2All, _ := net.IOCounters(false)
+	var netStat2List []net.IOCountersStat
+	netStat2List = append(netStat2List, netStat2...)
+	netStat2List = append(netStat2List, netStat2All...)
+
+	var netList []MonitorNetwork
+	timeMilli := time.Now().UnixMilli()
+	for _, net2 := range netStat2List {
+		for _, net1 := range netStatList {
+			if net2.Name == net1.Name {
+				var itemNet MonitorNetwork
+				itemNet.CreateTime = timeMilli
+				itemNet.Name = net1.Name
+
+				// 如果结束时刻发送字节数和当前时刻发送字节数都不为零，并且结束时刻发送字节数大于当前时刻发送字节数
+				if net2.BytesSent != 0 && net1.BytesSent != 0 && net2.BytesSent > net1.BytesSent {
+					itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / interval / 60
+				}
+				if net2.BytesRecv != 0 && net1.BytesRecv != 0 && net2.BytesRecv > net1.BytesRecv {
+					itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / interval / 60
+				}
+				netList = append(netList, itemNet)
+				break
+			}
+		}
+	}
+
+	return netList
+}
--- a/src/modules/monitor/service/sys_job.go
+++ b/src/modules/monitor/service/sys_job.go
@@ -0,0 +1,35 @@
+package service
+
+import (
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// ISysJob 调度任务信息 服务层接口
+type ISysJob interface {
+	// SelectJobPage 分页查询调度任务集合
+	SelectJobPage(query map[string]any) map[string]any
+
+	// SelectJobList 查询调度任务集合
+	SelectJobList(sysJob model.SysJob) []model.SysJob
+
+	// SelectJobById 通过调度ID查询调度任务信息
+	SelectJobById(jobId string) model.SysJob
+
+	// CheckUniqueJobName 校验调度任务名称和组是否唯一
+	CheckUniqueJobName(jobName, jobGroup, jobId string) bool
+
+	// InsertJob 新增调度任务信息
+	InsertJob(sysJob model.SysJob) string
+
+	// UpdateJob 修改调度任务信息
+	UpdateJob(sysJob model.SysJob) int64
+
+	// DeleteJobByIds 批量删除调度任务信息
+	DeleteJobByIds(jobIds []string) (int64, error)
+
+	// RunQueueJob 立即运行一次调度任务
+	RunQueueJob(sysJob model.SysJob) bool
+
+	// ResetQueueJob 重置初始调度任务
+	ResetQueueJob()
+}
--- a/src/modules/monitor/service/sys_job.impl.go
+++ b/src/modules/monitor/service/sys_job.impl.go
@@ -0,0 +1,169 @@
+package service
+
+import (
+	"fmt"
+
+	"nms_nbi/src/framework/constants/common"
+	"nms_nbi/src/framework/cron"
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/repository"
+)
+
+// 实例化服务层 SysJobImpl 结构体
+var NewSysJobImpl = &SysJobImpl{
+	sysJobRepository: repository.NewSysJobImpl,
+}
+
+// SysJobImpl 调度任务 服务层处理
+type SysJobImpl struct {
+	// 调度任务数据信息
+	sysJobRepository repository.ISysJob
+}
+
+// SelectJobPage 分页查询调度任务集合
+func (r *SysJobImpl) SelectJobPage(query map[string]any) map[string]any {
+	return r.sysJobRepository.SelectJobPage(query)
+}
+
+// SelectJobList 查询调度任务集合
+func (r *SysJobImpl) SelectJobList(sysJob model.SysJob) []model.SysJob {
+	return r.sysJobRepository.SelectJobList(sysJob)
+}
+
+// SelectJobById 通过调度ID查询调度任务信息
+func (r *SysJobImpl) SelectJobById(jobId string) model.SysJob {
+	if jobId == "" {
+		return model.SysJob{}
+	}
+	jobs := r.sysJobRepository.SelectJobByIds([]string{jobId})
+	if len(jobs) > 0 {
+		return jobs[0]
+	}
+	return model.SysJob{}
+}
+
+// CheckUniqueJobName 校验调度任务名称和组是否唯一
+func (r *SysJobImpl) CheckUniqueJobName(jobName, jobGroup, jobId string) bool {
+	uniqueId := r.sysJobRepository.CheckUniqueJob(model.SysJob{
+		JobName:  jobName,
+		JobGroup: jobGroup,
+	})
+	if uniqueId == jobId {
+		return true
+	}
+	return uniqueId == ""
+}
+
+// InsertJob 新增调度任务信息
+func (r *SysJobImpl) 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 *SysJobImpl) 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 *SysJobImpl) 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 *SysJobImpl) 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 *SysJobImpl) RunQueueJob(sysJob model.SysJob) bool {
+	return r.insertQueueJob(sysJob, false)
+}
+
+// insertQueueJob 添加调度任务
+func (r *SysJobImpl) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
+	// 获取队列 Processor
+	queue := cron.GetQueue(sysJob.InvokeTarget)
+	if queue.Name != sysJob.InvokeTarget {
+		return false
+	}
+
+	// 给执行任务数据参数
+	options := cron.JobData{
+		Repeat: repeat,
+		SysJob: sysJob,
+	}
+
+	// 不是重复任务的情况，立即执行一次
+	if !repeat {
+		// 执行单次任务
+		status := queue.RunJob(options, cron.JobOptions{
+			JobId: sysJob.JobID,
+		})
+		// 执行中或等待中的都返回正常
+		return status == cron.Active || status == cron.Waiting
+	}
+
+	// 执行重复任务
+	queue.RunJob(options, cron.JobOptions{
+		JobId: sysJob.JobID,
+		Cron:  sysJob.CronExpression,
+	})
+
+	return true
+}
+
+// deleteQueueJob 删除调度任务
+func (r *SysJobImpl) deleteQueueJob(sysJob model.SysJob) bool {
+	// 获取队列 Processor
+	queue := cron.GetQueue(sysJob.InvokeTarget)
+	if queue.Name != sysJob.InvokeTarget {
+		return false
+	}
+	return queue.RemoveJob(sysJob.JobID)
+}
--- a/src/modules/monitor/service/sys_job_log.go
+++ b/src/modules/monitor/service/sys_job_log.go
@@ -0,0 +1,23 @@
+package service
+
+import (
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// ISysJobLog 调度任务日志 服务层接口
+type ISysJobLog interface {
+	// SelectJobLogPage 分页查询调度任务日志集合
+	SelectJobLogPage(query map[string]any) map[string]any
+
+	// SelectJobLogList 查询调度任务日志集合
+	SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog
+
+	// SelectJobLogById 通过调度ID查询调度任务日志信息
+	SelectJobLogById(jobLogId string) model.SysJobLog
+
+	// DeleteJobLogByIds 批量删除调度任务日志信息
+	DeleteJobLogByIds(jobLogIds []string) int64
+
+	// CleanJobLog 清空调度任务日志
+	CleanJobLog() error
+}
--- a/src/modules/monitor/service/sys_job_log.impl.go
+++ b/src/modules/monitor/service/sys_job_log.impl.go
@@ -0,0 +1,42 @@
+package service
+
+import (
+	"nms_nbi/src/modules/monitor/model"
+	"nms_nbi/src/modules/monitor/repository"
+)
+
+// 实例化服务层 SysJobLogImpl 结构体
+var NewSysJobLogImpl = &SysJobLogImpl{
+	sysJobLogRepository: repository.NewSysJobLogImpl,
+}
+
+// SysJobLogImpl 调度任务日志 服务层处理
+type SysJobLogImpl struct {
+	// 调度任务日志数据信息
+	sysJobLogRepository repository.ISysJobLog
+}
+
+// SelectJobLogPage 分页查询调度任务日志集合
+func (s *SysJobLogImpl) SelectJobLogPage(query map[string]any) map[string]any {
+	return s.sysJobLogRepository.SelectJobLogPage(query)
+}
+
+// SelectJobLogList 查询调度任务日志集合
+func (s *SysJobLogImpl) SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog {
+	return s.sysJobLogRepository.SelectJobLogList(sysJobLog)
+}
+
+// SelectJobLogById 通过调度ID查询调度任务日志信息
+func (s *SysJobLogImpl) SelectJobLogById(jobLogId string) model.SysJobLog {
+	return s.sysJobLogRepository.SelectJobLogById(jobLogId)
+}
+
+// DeleteJobLogByIds 批量删除调度任务日志信息
+func (s *SysJobLogImpl) DeleteJobLogByIds(jobLogIds []string) int64 {
+	return s.sysJobLogRepository.DeleteJobLogByIds(jobLogIds)
+}
+
+// CleanJobLog 清空调度任务日志
+func (s *SysJobLogImpl) CleanJobLog() error {
+	return s.sysJobLogRepository.CleanJobLog()
+}
--- a/src/modules/monitor/service/sys_user_online.go
+++ b/src/modules/monitor/service/sys_user_online.go
@@ -0,0 +1,12 @@
+package service
+
+import (
+	"nms_nbi/src/framework/vo"
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// ISysUserOnline 在线用户 服务层接口
+type ISysUserOnline interface {
+	// LoginUserToUserOnline 设置在线用户信息
+	LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline
+}
--- a/src/modules/monitor/service/sys_user_online.impl.go
+++ b/src/modules/monitor/service/sys_user_online.impl.go
@@ -0,0 +1,33 @@
+package service
+
+import (
+	"nms_nbi/src/framework/vo"
+	"nms_nbi/src/modules/monitor/model"
+)
+
+// 实例化服务层 SysUserOnlineImpl 结构体
+var NewSysUserOnlineImpl = &SysUserOnlineImpl{}
+
+// SysUserOnlineImpl 在线用户 服务层处理
+type SysUserOnlineImpl struct{}
+
+// LoginUserToUserOnline 设置在线用户信息
+func (r *SysUserOnlineImpl) LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline {
+	if loginUser.UserID == "" {
+		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,
+	}
+	if loginUser.User.DeptID != "" {
+		sysUserOnline.DeptName = loginUser.User.Dept.DeptName
+	}
+	return sysUserOnline
+}
--- a/src/modules/monitor/service/system_info.go
+++ b/src/modules/monitor/service/system_info.go
@@ -0,0 +1,22 @@
+package service
+
+// ISystemInfo 服务器系统相关信息 服务层接口
+type ISystemInfo interface {
+	// SystemInfo 系统信息
+	SystemInfo() map[string]any
+
+	// TimeInfo 系统时间信息
+	TimeInfo() map[string]string
+
+	// MemoryInfo 内存信息
+	MemoryInfo() map[string]any
+
+	// CPUInfo CPU信息
+	CPUInfo() map[string]any
+
+	// NetworkInfo 网络信息
+	NetworkInfo() map[string]string
+
+	// DiskInfo 磁盘信息
+	DiskInfo() []map[string]string
+}
--- a/src/modules/monitor/service/system_info.impl.go
+++ b/src/modules/monitor/service/system_info.impl.go
@@ -0,0 +1,173 @@
+package service
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"nms_nbi/src/framework/config"
+	"nms_nbi/src/framework/utils/parse"
+
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v3/host"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
+)
+
+// 实例化服务层 SystemInfoImpl 结构体
+var NewSystemInfoImpl = &SystemInfoImpl{}
+
+// SystemInfoImpl 服务器系统相关信息 服务层处理
+type SystemInfoImpl struct{}
+
+// SystemInfo 系统信息
+func (s *SystemInfoImpl) SystemInfo() map[string]any {
+	info, err := host.Info()
+	if err != nil {
+		info.Platform = err.Error()
+	}
+	// 获取主机运行时间
+	bootTime := time.Since(time.Unix(int64(info.BootTime), 0)).Seconds()
+	// 获取程序运行时间
+	runTime := time.Since(config.RunTime()).Abs().Seconds()
+	return map[string]any{
+		"platform":        info.Platform,
+		"platformVersion": info.PlatformVersion,
+		"arch":            info.KernelArch,
+		"archVersion":     info.KernelVersion,
+		"os":              info.OS,
+		"hostname":        info.Hostname,
+		"bootTime":        int64(bootTime),
+		"processId":       os.Getpid(),
+		"runArch":         runtime.GOARCH,
+		"runVersion":      runtime.Version(),
+		"runTime":         int64(runTime),
+	}
+}
+
+// TimeInfo 系统时间信息
+func (s *SystemInfoImpl) TimeInfo() map[string]string {
+	now := time.Now()
+	// 获取当前时间
+	current := now.Format("2006-01-02 15:04:05")
+	// 获取时区
+	timezone := now.Format("-0700 MST")
+	// 获取时区名称
+	timezoneName := now.Format("MST")
+
+	return map[string]string{
+		"current":      current,
+		"timezone":     timezone,
+		"timezoneName": timezoneName,
+	}
+}
+
+// MemoryInfo 内存信息
+func (s *SystemInfoImpl) MemoryInfo() map[string]any {
+	memInfo, err := mem.VirtualMemory()
+	if err != nil {
+		memInfo.UsedPercent = 0
+		memInfo.Available = 0
+		memInfo.Total = 0
+	}
+
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+
+	return map[string]any{
+		"usage":     fmt.Sprintf("%.2f", memInfo.UsedPercent),            // 内存利用率
+		"freemem":   parse.Bit(float64(memInfo.Available)),               // 可用内存大小（GB）
+		"totalmem":  parse.Bit(float64(memInfo.Total)),                   // 总内存大小（GB）
+		"rss":       parse.Bit(float64(memStats.Sys)),                    // 常驻内存大小（RSS）
+		"heapTotal": parse.Bit(float64(memStats.HeapSys)),                // 堆总大小
+		"heapUsed":  parse.Bit(float64(memStats.HeapAlloc)),              // 堆已使用大小
+		"external":  parse.Bit(float64(memStats.Sys - memStats.HeapSys)), // 外部内存大小（非堆）
+	}
+}
+
+// CPUInfo CPU信息
+func (s *SystemInfoImpl) CPUInfo() map[string]any {
+	var core int = 0
+	var speed string = "未知"
+	var model string = "未知"
+	cpuInfo, err := cpu.Info()
+	if err == nil {
+		core = runtime.NumCPU()
+		speed = fmt.Sprintf("%.0fMHz", cpuInfo[0].Mhz)
+		model = strings.TrimSpace(cpuInfo[0].ModelName)
+	}
+
+	useds := []string{}
+	cpuPercent, err := cpu.Percent(0, true)
+	if err == nil {
+		for _, v := range cpuPercent {
+			useds = append(useds, fmt.Sprintf("%.2f", v))
+		}
+	}
+
+	return map[string]any{
+		"model":    model,
+		"speed":    speed,
+		"core":     core,
+		"coreUsed": useds,
+	}
+}
+
+// NetworkInfo 网络信息
+func (s *SystemInfoImpl) NetworkInfo() map[string]string {
+	ipAddrs := make(map[string]string)
+	interfaces, err := net.Interfaces()
+	if err == nil {
+		for _, iface := range interfaces {
+			name := iface.Name
+			if name[len(name)-1] == '0' {
+				name = name[0 : len(name)-1]
+				name = strings.Trim(name, "")
+			}
+			// ignore localhost
+			if name == "lo" {
+				continue
+			}
+			var addrs []string
+			for _, v := range iface.Addrs {
+				prefix := strings.Split(v.Addr, "/")[0]
+				if strings.Contains(prefix, "::") {
+					addrs = append(addrs, fmt.Sprintf("IPv6 %s", prefix))
+				}
+				if strings.Contains(prefix, ".") {
+					addrs = append(addrs, fmt.Sprintf("IPv4 %s", prefix))
+				}
+			}
+			ipAddrs[name] = strings.Join(addrs, " / ")
+		}
+	}
+	return ipAddrs
+}
+
+// DiskInfo 磁盘信息
+func (s *SystemInfoImpl) DiskInfo() []map[string]string {
+	disks := make([]map[string]string, 0)
+
+	partitions, err := disk.Partitions(false)
+	if err != nil {
+		return disks
+	}
+
+	for _, partition := range partitions {
+		usage, err := disk.Usage(partition.Mountpoint)
+		if err != nil {
+			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,
+		})
+	}
+	return disks
+}