初始化v1.2

This commit is contained in:
gaoyutao
2025-11-24 16:19:09 +08:00
parent c0f51ef007
commit de49404116
918 changed files with 4236 additions and 4239 deletions
@@ -0,0 +1,134 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialBandwidthTraffic;
import com.tongran.rocketmq.service.IInitialBandwidthTrafficService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 初始带宽流量Controller
*
* @author gyt
* @date 2025-08-20
*/
@RestController
@RequestMapping("/traffic")
public class InitialBandwidthTrafficController extends BaseController
{
@Autowired
private IInitialBandwidthTrafficService initialBandwidthTrafficService;
/**
* 查询初始带宽流量列表
*/
@RequiresPermissions("rocketmq:traffic:list")
@GetMapping("/list")
public TableDataInfo list(InitialBandwidthTraffic initialBandwidthTraffic)
{
startPage();
List<InitialBandwidthTraffic> list = initialBandwidthTrafficService.selectInitialBandwidthTrafficList(initialBandwidthTraffic);
return getDataTable(list);
}
/**
* 导出初始带宽流量列表
*/
@RequiresPermissions("rocketmq:traffic:export")
@Log(title = "初始带宽流量", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialBandwidthTraffic initialBandwidthTraffic)
{
List<InitialBandwidthTraffic> list = initialBandwidthTrafficService.selectInitialBandwidthTrafficList(initialBandwidthTraffic);
ExcelUtil<InitialBandwidthTraffic> util = new ExcelUtil<InitialBandwidthTraffic>(InitialBandwidthTraffic.class);
util.exportExcel(response, list, "初始带宽流量数据");
}
/**
* 获取初始带宽流量详细信息
*/
@RequiresPermissions("rocketmq:traffic:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialBandwidthTrafficService.selectInitialBandwidthTrafficById(id));
}
/**
* 新增初始带宽流量
*/
@RequiresPermissions("rocketmq:traffic:add")
@Log(title = "初始带宽流量", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialBandwidthTraffic initialBandwidthTraffic)
{
return toAjax(initialBandwidthTrafficService.insertInitialBandwidthTraffic(initialBandwidthTraffic));
}
/**
* 修改初始带宽流量
*/
@RequiresPermissions("rocketmq:traffic:edit")
@Log(title = "初始带宽流量", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialBandwidthTraffic initialBandwidthTraffic)
{
return toAjax(initialBandwidthTrafficService.updateInitialBandwidthTraffic(initialBandwidthTraffic));
}
/**
* 删除初始带宽流量
*/
@RequiresPermissions("rocketmq:traffic:remove")
@Log(title = "初始带宽流量", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialBandwidthTrafficService.deleteInitialBandwidthTrafficByIds(ids));
}
/**
* 网络接口基础信息
* @param initialBandwidthTraffic
* @return
*/
@RequiresPermissions("rocketmq:traffic:list")
@PostMapping("/netInterfaceDetailsMsg")
public AjaxResult netInterfaceDetailsMsg(@RequestBody InitialBandwidthTraffic initialBandwidthTraffic) {
InitialBandwidthTraffic netInterfaceDetailsMsg = initialBandwidthTrafficService.getNetInterfaceDetailsMsg(initialBandwidthTraffic);
return success(netInterfaceDetailsMsg);
}
/**
* 查询eth0流量信息并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:traffic:list")
@PostMapping("/netInterfaceTrafficEcharts")
public AjaxResult netInterfaceTrafficEcharts(@RequestBody InitialBandwidthTraffic initialBandwidthTraffic) {
Map<String, Object> echartsData = initialBandwidthTrafficService.netInterfaceTrafficEcharts(initialBandwidthTraffic);
return success(echartsData);
}
/**
* eth0丢包数
* @param initialBandwidthTraffic
* @return
*/
@RequiresPermissions("rocketmq:traffic:list")
@PostMapping("/netInterfaceDroppedEcharts")
public AjaxResult netInterfaceDroppedEcharts(@RequestBody InitialBandwidthTraffic initialBandwidthTraffic) {
Map<String, Object> echartsData = initialBandwidthTrafficService.netInterfaceDroppedEcharts(initialBandwidthTraffic);
return success(echartsData);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialBandwidthTrafficTemp;
import com.tongran.rocketmq.service.IInitialBandwidthTrafficTempService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 初始带宽流量临时表Controller
*
* @author gyt
* @date 2025-11-05
*/
@RestController
@RequestMapping("/trafficTemp")
public class InitialBandwidthTrafficTempController extends BaseController
{
@Autowired
private IInitialBandwidthTrafficTempService initialBandwidthTrafficTempService;
/**
* 查询初始带宽流量临时表列表
*/
@RequiresPermissions("rocketmq:trafficTemp:list")
@GetMapping("/list")
public TableDataInfo list(InitialBandwidthTrafficTemp initialBandwidthTrafficTemp)
{
startPage();
List<InitialBandwidthTrafficTemp> list = initialBandwidthTrafficTempService.selectInitialBandwidthTrafficTempList(initialBandwidthTrafficTemp);
return getDataTable(list);
}
/**
* 导出初始带宽流量临时表列表
*/
@RequiresPermissions("rocketmq:trafficTemp:export")
@Log(title = "初始带宽流量临时表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialBandwidthTrafficTemp initialBandwidthTrafficTemp)
{
List<InitialBandwidthTrafficTemp> list = initialBandwidthTrafficTempService.selectInitialBandwidthTrafficTempList(initialBandwidthTrafficTemp);
ExcelUtil<InitialBandwidthTrafficTemp> util = new ExcelUtil<InitialBandwidthTrafficTemp>(InitialBandwidthTrafficTemp.class);
util.exportExcel(response, list, "初始带宽流量临时表数据");
}
/**
* 获取初始带宽流量临时表详细信息
*/
@RequiresPermissions("rocketmq:trafficTemp:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialBandwidthTrafficTempService.selectInitialBandwidthTrafficTempById(id));
}
/**
* 新增初始带宽流量临时表
*/
@RequiresPermissions("rocketmq:trafficTemp:add")
@Log(title = "初始带宽流量临时表", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialBandwidthTrafficTemp initialBandwidthTrafficTemp)
{
return toAjax(initialBandwidthTrafficTempService.insertInitialBandwidthTrafficTemp(initialBandwidthTrafficTemp));
}
/**
* 修改初始带宽流量临时表
*/
@RequiresPermissions("rocketmq:trafficTemp:edit")
@Log(title = "初始带宽流量临时表", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialBandwidthTrafficTemp initialBandwidthTrafficTemp)
{
return toAjax(initialBandwidthTrafficTempService.updateInitialBandwidthTrafficTemp(initialBandwidthTrafficTemp));
}
/**
* 删除初始带宽流量临时表
*/
@RequiresPermissions("rocketmq:trafficTemp:remove")
@Log(title = "初始带宽流量临时表", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialBandwidthTrafficTempService.deleteInitialBandwidthTrafficTempByIds(ids));
}
}
@@ -0,0 +1,122 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialCpuInfo;
import com.tongran.rocketmq.service.IInitialCpuInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* CPU监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/cpuInfo")
public class InitialCpuInfoController extends BaseController
{
@Autowired
private IInitialCpuInfoService initialCpuInfoService;
/**
* 查询CPU监控信息列表
*/
@RequiresPermissions("rocketmq:cpuInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialCpuInfo initialCpuInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialCpuInfo.getPageNum());
pageDomain.setPageSize(initialCpuInfo.getPageSize());
startPage(pageDomain);
List<InitialCpuInfo> list = initialCpuInfoService.selectInitialCpuInfoList(initialCpuInfo);
return getDataTable(list);
}
/**
* 导出CPU监控信息列表
*/
@RequiresPermissions("rocketmq:cpuInfo:export")
@Log(title = "CPU监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialCpuInfo initialCpuInfo)
{
List<InitialCpuInfo> list = initialCpuInfoService.selectInitialCpuInfoList(initialCpuInfo);
ExcelUtil<InitialCpuInfo> util = new ExcelUtil<InitialCpuInfo>(InitialCpuInfo.class);
util.exportExcel(response, list, "CPU监控信息数据");
}
/**
* 获取CPU监控信息详细信息
*/
@RequiresPermissions("rocketmq:cpuInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialCpuInfoService.selectInitialCpuInfoById(id));
}
/**
* 新增CPU监控信息
*/
@RequiresPermissions("rocketmq:cpuInfo:add")
@Log(title = "CPU监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialCpuInfo initialCpuInfo)
{
return toAjax(initialCpuInfoService.insertInitialCpuInfo(initialCpuInfo));
}
/**
* 修改CPU监控信息
*/
@RequiresPermissions("rocketmq:cpuInfo:edit")
@Log(title = "CPU监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialCpuInfo initialCpuInfo)
{
return toAjax(initialCpuInfoService.updateInitialCpuInfo(initialCpuInfo));
}
/**
* 删除CPU监控信息
*/
@RequiresPermissions("rocketmq:cpuInfo:remove")
@Log(title = "CPU监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialCpuInfoService.deleteInitialCpuInfoByIds(ids));
}
/**
* 查询CPU监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:cpuInfo:list")
@PostMapping("/cpuLoadEcharts")
public AjaxResult cpuLoadEcharts(@RequestBody InitialCpuInfo initialCpuInfo) {
Map<String, Object> echartsData = initialCpuInfoService.cupLoadEcharts(initialCpuInfo);
return success(echartsData);
}
/**
* 查询CPU监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:cpuInfo:list")
@PostMapping("/cpuTimeEcharts")
public AjaxResult cpuTimeEcharts(@RequestBody InitialCpuInfo initialCpuInfo) {
Map<String, Object> echartsData = initialCpuInfoService.cpuTimeEcharts(initialCpuInfo);
return success(echartsData);
}
}
@@ -0,0 +1,161 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialDiskInfo;
import com.tongran.rocketmq.service.IInitialDiskInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 磁盘监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/diskInfo")
public class InitialDiskInfoController extends BaseController
{
@Autowired
private IInitialDiskInfoService initialDiskInfoService;
/**
* 查询磁盘监控信息列表
*/
@RequiresPermissions("rocketmq:diskInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialDiskInfo initialDiskInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialDiskInfo.getPageNum());
pageDomain.setPageSize(initialDiskInfo.getPageSize());
startPage(pageDomain);
List<InitialDiskInfo> list = initialDiskInfoService.selectInitialDiskInfoList(initialDiskInfo);
return getDataTable(list);
}
/**
* 导出磁盘监控信息列表
*/
@RequiresPermissions("rocketmq:diskInfo:export")
@Log(title = "磁盘监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialDiskInfo initialDiskInfo)
{
List<InitialDiskInfo> list = initialDiskInfoService.selectInitialDiskInfoList(initialDiskInfo);
ExcelUtil<InitialDiskInfo> util = new ExcelUtil<InitialDiskInfo>(InitialDiskInfo.class);
util.exportExcel(response, list, "磁盘监控信息数据");
}
/**
* 获取磁盘监控信息详细信息
*/
@RequiresPermissions("rocketmq:diskInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialDiskInfoService.selectInitialDiskInfoById(id));
}
/**
* 新增磁盘监控信息
*/
@RequiresPermissions("rocketmq:diskInfo:add")
@Log(title = "磁盘监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialDiskInfo initialDiskInfo)
{
return toAjax(initialDiskInfoService.insertInitialDiskInfo(initialDiskInfo));
}
/**
* 修改磁盘监控信息
*/
@RequiresPermissions("rocketmq:diskInfo:edit")
@Log(title = "磁盘监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialDiskInfo initialDiskInfo)
{
return toAjax(initialDiskInfoService.updateInitialDiskInfo(initialDiskInfo));
}
/**
* 删除磁盘监控信息
*/
@RequiresPermissions("rocketmq:diskInfo:remove")
@Log(title = "磁盘监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialDiskInfoService.deleteInitialDiskInfoByIds(ids));
}
/**
* 磁盘设备/dev/sda基础信息
* @param initialDiskInfo
* @return
*/
@RequiresPermissions("rocketmq:distInfo:list")
@PostMapping("/getDistDetailsMsg")
public AjaxResult distDetailsMsg(@RequestBody InitialDiskInfo initialDiskInfo){
return success(initialDiskInfoService.getDistDetailsMsg(initialDiskInfo));
}
/**
* /dev/sda读写速率(KB/s)
* @param initialDiskInfo
* @return
*/
@RequiresPermissions("rocketmq:distInfo:list")
@PostMapping("/rwSpeedEcharts")
public AjaxResult rwSpeedEcharts(@RequestBody InitialDiskInfo initialDiskInfo){
Map<String, Object> echartsData = initialDiskInfoService.rwSpeedEcharts(initialDiskInfo);
return success(echartsData);
}
/**
* /dev/sda读写次数
* @param initialDiskInfo
* @return
*/
@RequiresPermissions("rocketmq:distInfo:list")
@PostMapping("/rwTimesEcharts")
public AjaxResult rwTimesEcharts(@RequestBody InitialDiskInfo initialDiskInfo){
Map<String, Object> echartsData = initialDiskInfoService.rwTimesEcharts(initialDiskInfo);
return success(echartsData);
}
/**
* /dev/sda读写字节
* @param initialDiskInfo
* @return
*/
@RequiresPermissions("rocketmq:distInfo:list")
@PostMapping("/rwBytesEcharts")
public AjaxResult rwBytesEcharts(@RequestBody InitialDiskInfo initialDiskInfo){
Map<String, Object> echartsData = initialDiskInfoService.rwBytesEcharts(initialDiskInfo);
return success(echartsData);
}
/**
* 获取指定服务器的磁盘名称
* @param initialDiskInfo
* @return
*/
@RequiresPermissions("rocketmq:mountPointInfo:list")
@PostMapping("/getAllDistName")
public AjaxResult getAllDistName(@RequestBody InitialDiskInfo initialDiskInfo){
List<Map> list = initialDiskInfoService.getAllDistName(initialDiskInfo);
return success(list);
}
}
@@ -0,0 +1,160 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialDockerInfo;
import com.tongran.rocketmq.service.IInitialDockerInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 容器监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/dockerInfo")
public class InitialDockerInfoController extends BaseController
{
@Autowired
private IInitialDockerInfoService initialDockerInfoService;
/**
* 查询容器监控信息列表
*/
@RequiresPermissions("rocketmq:dockerInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialDockerInfo initialDockerInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialDockerInfo.getPageNum());
pageDomain.setPageSize(initialDockerInfo.getPageSize());
startPage(pageDomain);
List<InitialDockerInfo> list = initialDockerInfoService.selectInitialDockerInfoList(initialDockerInfo);
return getDataTable(list);
}
/**
* 导出容器监控信息列表
*/
@RequiresPermissions("rocketmq:dockerInfo:export")
@Log(title = "容器监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialDockerInfo initialDockerInfo)
{
List<InitialDockerInfo> list = initialDockerInfoService.selectInitialDockerInfoList(initialDockerInfo);
ExcelUtil<InitialDockerInfo> util = new ExcelUtil<InitialDockerInfo>(InitialDockerInfo.class);
util.exportExcel(response, list, "容器监控信息数据");
}
/**
* 获取容器监控信息详细信息
*/
@RequiresPermissions("rocketmq:dockerInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialDockerInfoService.selectInitialDockerInfoById(id));
}
/**
* 新增容器监控信息
*/
@RequiresPermissions("rocketmq:dockerInfo:add")
@Log(title = "容器监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialDockerInfo initialDockerInfo)
{
return toAjax(initialDockerInfoService.insertInitialDockerInfo(initialDockerInfo));
}
/**
* 修改容器监控信息
*/
@RequiresPermissions("rocketmq:dockerInfo:edit")
@Log(title = "容器监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialDockerInfo initialDockerInfo)
{
return toAjax(initialDockerInfoService.updateInitialDockerInfo(initialDockerInfo));
}
/**
* 删除容器监控信息
*/
@RequiresPermissions("rocketmq:dockerInfo:remove")
@Log(title = "容器监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialDockerInfoService.deleteInitialDockerInfoByIds(ids));
}
/**
* 容器基础信息
* @param initialDockerInfo
* @return
*/
@RequiresPermissions("rocketmq:dockerInfo:list")
@PostMapping("/getDockerDetailsMsg")
public AjaxResult dockerDetailsMsg(@RequestBody InitialDockerInfo initialDockerInfo){
return success(initialDockerInfoService.getDockerDetailsMsg(initialDockerInfo));
}
/**
* cpu利用率
* @param initialDockerInfo
* @return
*/
@RequiresPermissions("rocketmq:dockerInfo:list")
@PostMapping("/cpuUtilEcharts")
public AjaxResult cpuUtilEcharts(@RequestBody InitialDockerInfo initialDockerInfo){
Map<String, Object> echartsData = initialDockerInfoService.cpuUtilEcharts(initialDockerInfo);
return success(echartsData);
}
/**
* 内存利用率
* @param initialDockerInfo
* @return
*/
@RequiresPermissions("rocketmq:dockerInfo:list")
@PostMapping("/memUtilEcharts")
public AjaxResult memUtilEcharts(@RequestBody InitialDockerInfo initialDockerInfo){
Map<String, Object> echartsData = initialDockerInfoService.memUtilEcharts(initialDockerInfo);
return success(echartsData);
}
/**
* 容器的网络速率(KB/s)
* @param initialDockerInfo
* @return
*/
@RequiresPermissions("rocketmq:dockerInfo:list")
@PostMapping("/netSpeedEcharts")
public AjaxResult netSpeedEcharts(@RequestBody InitialDockerInfo initialDockerInfo){
Map<String, Object> echartsData = initialDockerInfoService.netSpeedEcharts(initialDockerInfo);
return success(echartsData);
}
/**
* 获取指定服务器的容器id
* @param initialDockerInfo
* @return
*/
@RequiresPermissions("rocketmq:mountPointInfo:list")
@PostMapping("/getAllDockerId")
public AjaxResult getAllDockerId(@RequestBody InitialDockerInfo initialDockerInfo){
List<Map> list = initialDockerInfoService.getAllDockerId(initialDockerInfo);
return success(list);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialHeartbeatListen;
import com.tongran.rocketmq.service.IInitialHeartbeatListenService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 心跳信息Controller
*
* @author gyt
* @date 2025-09-08
*/
@RestController
@RequestMapping("/heartbeatListen")
public class InitialHeartbeatListenController extends BaseController
{
@Autowired
private IInitialHeartbeatListenService initialHeartbeatListenService;
/**
* 查询心跳信息列表
*/
@RequiresPermissions("rocketmq:heartbeatListen:list")
@GetMapping("/list")
public TableDataInfo list(InitialHeartbeatListen initialHeartbeatListen)
{
startPage();
List<InitialHeartbeatListen> list = initialHeartbeatListenService.selectInitialHeartbeatListenList(initialHeartbeatListen);
return getDataTable(list);
}
/**
* 导出心跳信息列表
*/
@RequiresPermissions("rocketmq:heartbeatListen:export")
@Log(title = "心跳信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialHeartbeatListen initialHeartbeatListen)
{
List<InitialHeartbeatListen> list = initialHeartbeatListenService.selectInitialHeartbeatListenList(initialHeartbeatListen);
ExcelUtil<InitialHeartbeatListen> util = new ExcelUtil<InitialHeartbeatListen>(InitialHeartbeatListen.class);
util.exportExcel(response, list, "心跳信息数据");
}
/**
* 获取心跳信息详细信息
*/
@RequiresPermissions("rocketmq:heartbeatListen:query")
@GetMapping(value = "/{clientId}")
public AjaxResult getInfo(@PathVariable("clientId") String clientId)
{
return success(initialHeartbeatListenService.selectInitialHeartbeatListenByClientId(clientId));
}
/**
* 新增心跳信息
*/
@RequiresPermissions("rocketmq:heartbeatListen:add")
@Log(title = "心跳信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialHeartbeatListen initialHeartbeatListen)
{
return toAjax(initialHeartbeatListenService.insertInitialHeartbeatListen(initialHeartbeatListen));
}
/**
* 修改心跳信息
*/
@RequiresPermissions("rocketmq:heartbeatListen:edit")
@Log(title = "心跳信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialHeartbeatListen initialHeartbeatListen)
{
return toAjax(initialHeartbeatListenService.updateInitialHeartbeatListen(initialHeartbeatListen));
}
/**
* 删除心跳信息
*/
@RequiresPermissions("rocketmq:heartbeatListen:remove")
@Log(title = "心跳信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{clientIds}")
public AjaxResult remove(@PathVariable String[] clientIds)
{
return toAjax(initialHeartbeatListenService.deleteInitialHeartbeatListenByClientIds(clientIds));
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialHeartbeatListenLog;
import com.tongran.rocketmq.service.IInitialHeartbeatListenLogService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 心跳信息日志Controller
*
* @author gyt
* @date 2025-09-08
*/
@RestController
@RequestMapping("/log")
public class InitialHeartbeatListenLogController extends BaseController
{
@Autowired
private IInitialHeartbeatListenLogService initialHeartbeatListenLogService;
/**
* 查询心跳信息日志列表
*/
@RequiresPermissions("rocketmq:log:list")
@GetMapping("/list")
public TableDataInfo list(InitialHeartbeatListenLog initialHeartbeatListenLog)
{
startPage();
List<InitialHeartbeatListenLog> list = initialHeartbeatListenLogService.selectInitialHeartbeatListenLogList(initialHeartbeatListenLog);
return getDataTable(list);
}
/**
* 导出心跳信息日志列表
*/
@RequiresPermissions("rocketmq:log:export")
@Log(title = "心跳信息日志", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialHeartbeatListenLog initialHeartbeatListenLog)
{
List<InitialHeartbeatListenLog> list = initialHeartbeatListenLogService.selectInitialHeartbeatListenLogList(initialHeartbeatListenLog);
ExcelUtil<InitialHeartbeatListenLog> util = new ExcelUtil<InitialHeartbeatListenLog>(InitialHeartbeatListenLog.class);
util.exportExcel(response, list, "心跳信息日志数据");
}
/**
* 获取心跳信息日志详细信息
*/
@RequiresPermissions("rocketmq:log:query")
@GetMapping(value = "/{clientId}")
public AjaxResult getInfo(@PathVariable("clientId") String clientId)
{
return success(initialHeartbeatListenLogService.selectInitialHeartbeatListenLogByClientId(clientId));
}
/**
* 新增心跳信息日志
*/
@RequiresPermissions("rocketmq:log:add")
@Log(title = "心跳信息日志", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialHeartbeatListenLog initialHeartbeatListenLog)
{
return toAjax(initialHeartbeatListenLogService.insertInitialHeartbeatListenLog(initialHeartbeatListenLog));
}
/**
* 修改心跳信息日志
*/
@RequiresPermissions("rocketmq:log:edit")
@Log(title = "心跳信息日志", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialHeartbeatListenLog initialHeartbeatListenLog)
{
return toAjax(initialHeartbeatListenLogService.updateInitialHeartbeatListenLog(initialHeartbeatListenLog));
}
/**
* 删除心跳信息日志
*/
@RequiresPermissions("rocketmq:log:remove")
@Log(title = "心跳信息日志", businessType = BusinessType.DELETE)
@DeleteMapping("/{clientIds}")
public AjaxResult remove(@PathVariable String[] clientIds)
{
return toAjax(initialHeartbeatListenLogService.deleteInitialHeartbeatListenLogByClientIds(clientIds));
}
}
@@ -0,0 +1,154 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialMemoryInfo;
import com.tongran.rocketmq.service.IInitialMemoryInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 内存监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/memoryInfo")
public class InitialMemoryInfoController extends BaseController
{
@Autowired
private IInitialMemoryInfoService initialMemoryInfoService;
/**
* 查询内存监控信息列表
*/
@RequiresPermissions("rocketmq:memoryInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialMemoryInfo initialMemoryInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialMemoryInfo.getPageNum());
pageDomain.setPageSize(initialMemoryInfo.getPageSize());
startPage(pageDomain);
List<InitialMemoryInfo> list = initialMemoryInfoService.selectInitialMemoryInfoList(initialMemoryInfo);
return getDataTable(list);
}
/**
* 导出内存监控信息列表
*/
@RequiresPermissions("rocketmq:memoryInfo:export")
@Log(title = "内存监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialMemoryInfo initialMemoryInfo)
{
List<InitialMemoryInfo> list = initialMemoryInfoService.selectInitialMemoryInfoList(initialMemoryInfo);
ExcelUtil<InitialMemoryInfo> util = new ExcelUtil<InitialMemoryInfo>(InitialMemoryInfo.class);
util.exportExcel(response, list, "内存监控信息数据");
}
/**
* 获取内存监控信息详细信息
*/
@RequiresPermissions("rocketmq:memoryInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialMemoryInfoService.selectInitialMemoryInfoById(id));
}
/**
* 新增内存监控信息
*/
@RequiresPermissions("rocketmq:memoryInfo:add")
@Log(title = "内存监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialMemoryInfo initialMemoryInfo)
{
return toAjax(initialMemoryInfoService.insertInitialMemoryInfo(initialMemoryInfo));
}
/**
* 修改内存监控信息
*/
@RequiresPermissions("rocketmq:memoryInfo:edit")
@Log(title = "内存监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialMemoryInfo initialMemoryInfo)
{
return toAjax(initialMemoryInfoService.updateInitialMemoryInfo(initialMemoryInfo));
}
/**
* 删除内存监控信息
*/
@RequiresPermissions("rocketmq:memoryInfo:remove")
@Log(title = "内存监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialMemoryInfoService.deleteInitialMemoryInfoByIds(ids));
}
/**
* 查询交换空间可用量监控数据
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/swapSizeFreeEcharts")
public AjaxResult swapSizeFreeEcharts(@RequestBody InitialMemoryInfo initialMemoryInfo) {
Map<String, Object> echartsData = initialMemoryInfoService.swapSizeFreeEcharts(initialMemoryInfo);
return AjaxResult.success(echartsData);
}
/**
* 查询内存利用率监控数据
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/untilzationEcharts")
public AjaxResult untilzationEcharts(@RequestBody InitialMemoryInfo initialMemoryInfo) {
Map<String, Object> echartsData = initialMemoryInfoService.untilzationEcharts(initialMemoryInfo);
return AjaxResult.success(echartsData);
}
/**
* 查询内存可用量监控数据(KB)
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/availableMemoryEcharts")
public AjaxResult availableMemoryEcharts(@RequestBody InitialMemoryInfo initialMemoryInfo) {
Map<String, Object> echartsData = initialMemoryInfoService.availableMemoryEcharts(initialMemoryInfo);
return AjaxResult.success(echartsData);
}
/**
* 查询交换空间百分比监控数据
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/swapSizePercentEcharts")
public AjaxResult swapSizePercentEcharts(@RequestBody InitialMemoryInfo initialMemoryInfo) {
Map<String, Object> echartsData = initialMemoryInfoService.swapSizePercentEcharts(initialMemoryInfo);
return AjaxResult.success(echartsData);
}
/**
* 查询可用内存百分比监控数据
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/percentEcharts")
public AjaxResult percentEcharts(@RequestBody InitialMemoryInfo initialMemoryInfo) {
Map<String, Object> echartsData = initialMemoryInfoService.percentEcharts(initialMemoryInfo);
return AjaxResult.success(echartsData);
}
}
@@ -0,0 +1,145 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialMountPointInfo;
import com.tongran.rocketmq.service.IInitialMountPointInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 挂载点监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/mountPointInfo")
public class InitialMountPointInfoController extends BaseController
{
@Autowired
private IInitialMountPointInfoService initialMountPointInfoService;
/**
* 查询挂载点监控信息列表
*/
@RequiresPermissions("rocketmq:mountPointInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialMountPointInfo.getPageNum());
pageDomain.setPageSize(initialMountPointInfo.getPageSize());
startPage(pageDomain);
List<InitialMountPointInfo> list = initialMountPointInfoService.selectInitialMountPointInfoList(initialMountPointInfo);
return getDataTable(list);
}
/**
* 导出挂载点监控信息列表
*/
@RequiresPermissions("rocketmq:mountPointInfo:export")
@Log(title = "挂载点监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialMountPointInfo initialMountPointInfo)
{
List<InitialMountPointInfo> list = initialMountPointInfoService.selectInitialMountPointInfoList(initialMountPointInfo);
ExcelUtil<InitialMountPointInfo> util = new ExcelUtil<InitialMountPointInfo>(InitialMountPointInfo.class);
util.exportExcel(response, list, "挂载点监控信息数据");
}
/**
* 获取挂载点监控信息详细信息
*/
@RequiresPermissions("rocketmq:mountPointInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialMountPointInfoService.selectInitialMountPointInfoById(id));
}
/**
* 新增挂载点监控信息
*/
@RequiresPermissions("rocketmq:mountPointInfo:add")
@Log(title = "挂载点监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
return toAjax(initialMountPointInfoService.insertInitialMountPointInfo(initialMountPointInfo));
}
/**
* 修改挂载点监控信息
*/
@RequiresPermissions("rocketmq:mountPointInfo:edit")
@Log(title = "挂载点监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
return toAjax(initialMountPointInfoService.updateInitialMountPointInfo(initialMountPointInfo));
}
/**
* 删除挂载点监控信息
*/
@RequiresPermissions("rocketmq:mountPointInfo:remove")
@Log(title = "挂载点监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialMountPointInfoService.deleteInitialMountPointInfoByIds(ids));
}
/**
* 获取挂载点监控信息详细信息
*/
@RequiresPermissions("rocketmq:mountPointInfo:query")
@PostMapping(value = "/pointDetailsMsg")
public AjaxResult pointDetailsMsg(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
InitialMountPointInfo mountPointInfo = initialMountPointInfoService.pointDetailsMsg(initialMountPointInfo);
return success(mountPointInfo);
}
/**
* 获取挂载文件系统/的空间图形
*/
@RequiresPermissions("rocketmq:mountPointInfo:query")
@PostMapping(value = "/spaceEcharts")
public AjaxResult spaceEcharts(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
Map<String, Object> echartsData = initialMountPointInfoService.spaceEcharts(initialMountPointInfo);
return success(echartsData);
}
/**
* 获取挂载文件系统/的空间利用率图形
*/
@RequiresPermissions("rocketmq:mountPointInfo:query")
@PostMapping(value = "/spaceRateEcharts")
public AjaxResult spaceRateEcharts(@RequestBody InitialMountPointInfo initialMountPointInfo)
{
Map<String, Object> echartsData = initialMountPointInfoService.spaceRateEcharts(initialMountPointInfo);
return success(echartsData);
}
/**
* 获取指定服务器的挂载文件系统名
* @param initialMountPointInfo
* @return
*/
@RequiresPermissions("rocketmq:mountPointInfo:list")
@PostMapping("/getAllMountName")
public AjaxResult getAllMountName(@RequestBody InitialMountPointInfo initialMountPointInfo){
List<Map> list = initialMountPointInfoService.getAllMountName(initialMountPointInfo);
return success(list);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialOtherSystemMonitorData;
import com.tongran.rocketmq.service.IInitialOtherSystemMonitorDataService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 系统其他信息监控数据Controller
*
* @author gyt
* @date 2025-09-23
*/
@RestController
@RequestMapping("/otherSystemData")
public class InitialOtherSystemMonitorDataController extends BaseController
{
@Autowired
private IInitialOtherSystemMonitorDataService initialOtherSystemMonitorDataService;
/**
* 查询系统其他信息监控数据列表
*/
@RequiresPermissions("rocketmq:otherSystemData:list")
@GetMapping("/list")
public TableDataInfo list(InitialOtherSystemMonitorData initialOtherSystemMonitorData)
{
startPage();
List<InitialOtherSystemMonitorData> list = initialOtherSystemMonitorDataService.selectInitialOtherSystemMonitorDataList(initialOtherSystemMonitorData);
return getDataTable(list);
}
/**
* 导出系统其他信息监控数据列表
*/
@RequiresPermissions("rocketmq:otherSystemData:export")
@Log(title = "系统其他信息监控数据", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialOtherSystemMonitorData initialOtherSystemMonitorData)
{
List<InitialOtherSystemMonitorData> list = initialOtherSystemMonitorDataService.selectInitialOtherSystemMonitorDataList(initialOtherSystemMonitorData);
ExcelUtil<InitialOtherSystemMonitorData> util = new ExcelUtil<InitialOtherSystemMonitorData>(InitialOtherSystemMonitorData.class);
util.exportExcel(response, list, "系统其他信息监控数据数据");
}
/**
* 获取系统其他信息监控数据详细信息
*/
@RequiresPermissions("rocketmq:otherSystemData:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialOtherSystemMonitorDataService.selectInitialOtherSystemMonitorDataById(id));
}
/**
* 新增系统其他信息监控数据
*/
@RequiresPermissions("rocketmq:otherSystemData:add")
@Log(title = "系统其他信息监控数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialOtherSystemMonitorData initialOtherSystemMonitorData)
{
return toAjax(initialOtherSystemMonitorDataService.insertInitialOtherSystemMonitorData(initialOtherSystemMonitorData));
}
/**
* 修改系统其他信息监控数据
*/
@RequiresPermissions("rocketmq:otherSystemData:edit")
@Log(title = "系统其他信息监控数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialOtherSystemMonitorData initialOtherSystemMonitorData)
{
return toAjax(initialOtherSystemMonitorDataService.updateInitialOtherSystemMonitorData(initialOtherSystemMonitorData));
}
/**
* 删除系统其他信息监控数据
*/
@RequiresPermissions("rocketmq:otherSystemData:remove")
@Log(title = "系统其他信息监控数据", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialOtherSystemMonitorDataService.deleteInitialOtherSystemMonitorDataByIds(ids));
}
}
@@ -0,0 +1,122 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchFanInfo;
import com.tongran.rocketmq.service.IInitialSwitchFanInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 风扇信息Controller
*
* @author gyt
* @date 2025-09-22
*/
@RestController
@RequestMapping("/switchFanInfo")
public class InitialSwitchFanInfoController extends BaseController
{
@Autowired
private IInitialSwitchFanInfoService initialSwitchFanInfoService;
/**
* 查询风扇信息列表
*/
@RequiresPermissions("rocketmq:info:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchFanInfo initialSwitchFanInfo)
{
startPage();
List<InitialSwitchFanInfo> list = initialSwitchFanInfoService.selectInitialSwitchFanInfoList(initialSwitchFanInfo);
return getDataTable(list);
}
/**
* 导出风扇信息列表
*/
@RequiresPermissions("rocketmq:info:export")
@Log(title = "风扇信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchFanInfo initialSwitchFanInfo)
{
List<InitialSwitchFanInfo> list = initialSwitchFanInfoService.selectInitialSwitchFanInfoList(initialSwitchFanInfo);
ExcelUtil<InitialSwitchFanInfo> util = new ExcelUtil<InitialSwitchFanInfo>(InitialSwitchFanInfo.class);
util.exportExcel(response, list, "风扇信息数据");
}
/**
* 获取风扇信息详细信息
*/
@RequiresPermissions("rocketmq:info:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchFanInfoService.selectInitialSwitchFanInfoById(id));
}
/**
* 新增风扇信息
*/
@RequiresPermissions("rocketmq:info:add")
@Log(title = "风扇信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchFanInfo initialSwitchFanInfo)
{
return toAjax(initialSwitchFanInfoService.insertInitialSwitchFanInfo(initialSwitchFanInfo));
}
/**
* 修改风扇信息
*/
@RequiresPermissions("rocketmq:info:edit")
@Log(title = "风扇信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchFanInfo initialSwitchFanInfo)
{
return toAjax(initialSwitchFanInfoService.updateInitialSwitchFanInfo(initialSwitchFanInfo));
}
/**
* 删除风扇信息
*/
@RequiresPermissions("rocketmq:info:remove")
@Log(title = "风扇信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchFanInfoService.deleteInitialSwitchFanInfoByIds(ids));
}
/**
* 获取指定交换机的风扇名称
* @param initialSwitchFanInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getAllFanName")
public AjaxResult getAllFanName(@RequestBody InitialSwitchFanInfo initialSwitchFanInfo){
List<Map> list = initialSwitchFanInfoService.getAllFanName(initialSwitchFanInfo);
return success(list);
}
/**
* 获取风扇基础信息
* @param initialSwitchFanInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getFanMsg")
public AjaxResult getFanMsg(@RequestBody InitialSwitchFanInfo initialSwitchFanInfo){
List<InitialSwitchFanInfo> list = initialSwitchFanInfoService.getFanMsg(initialSwitchFanInfo);
return success(list);
}
}
@@ -0,0 +1,155 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchInfo;
import com.tongran.rocketmq.service.IInitialSwitchInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 交换机流量监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/switchInfo")
public class InitialSwitchInfoController extends BaseController
{
@Autowired
private IInitialSwitchInfoService initialSwitchInfoService;
/**
* 查询交换机流量监控信息列表
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchInfo initialSwitchInfo)
{
startPage();
List<InitialSwitchInfo> list = initialSwitchInfoService.selectInitialSwitchInfoList(initialSwitchInfo);
return getDataTable(list);
}
/**
* 导出交换机流量监控信息列表
*/
@RequiresPermissions("rocketmq:switchInfo:export")
@Log(title = "交换机流量监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchInfo initialSwitchInfo)
{
List<InitialSwitchInfo> list = initialSwitchInfoService.selectInitialSwitchInfoList(initialSwitchInfo);
ExcelUtil<InitialSwitchInfo> util = new ExcelUtil<InitialSwitchInfo>(InitialSwitchInfo.class);
util.exportExcel(response, list, "交换机流量监控信息数据");
}
/**
* 获取交换机流量监控信息详细信息
*/
@RequiresPermissions("rocketmq:switchInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchInfoService.selectInitialSwitchInfoById(id));
}
/**
* 新增交换机流量监控信息
*/
@RequiresPermissions("rocketmq:switchInfo:add")
@Log(title = "交换机流量监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchInfo initialSwitchInfo)
{
return toAjax(initialSwitchInfoService.insertInitialSwitchInfo(initialSwitchInfo));
}
/**
* 修改交换机流量监控信息
*/
@RequiresPermissions("rocketmq:switchInfo:edit")
@Log(title = "交换机流量监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchInfo initialSwitchInfo)
{
return toAjax(initialSwitchInfoService.updateInitialSwitchInfo(initialSwitchInfo));
}
/**
* 删除交换机流量监控信息
*/
@RequiresPermissions("rocketmq:switchInfo:remove")
@Log(title = "交换机流量监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchInfoService.deleteInitialSwitchInfoByIds(ids));
}
/**
* 获取网络端口基础信息
* @param initialSwitchInfo
* @return
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@PostMapping("/getSwitchNetDetailsMsg")
public AjaxResult switchNetDetailsMsg(@RequestBody InitialSwitchInfo initialSwitchInfo){
return success(initialSwitchInfoService.getSwitchNetDetailsMsg(initialSwitchInfo));
}
/**
* 获取网络端口网络速率
* @param initialSwitchInfo
* @return
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@PostMapping("/switchNetSpeedEcharts")
public AjaxResult switchNetSpeedEcharts(@RequestBody InitialSwitchInfo initialSwitchInfo){
Map<String, Object> echartsData = initialSwitchInfoService.switchNetSpeedEcharts(initialSwitchInfo);
return success(echartsData);
}
/**
* 获取网络端口丢包数
* @param initialSwitchInfo
* @return
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@PostMapping("/switchNetDiscardsEcharts")
public AjaxResult switchNetDiscardsEcharts(@RequestBody InitialSwitchInfo initialSwitchInfo){
Map<String, Object> echartsData = initialSwitchInfoService.switchNetDiscardsEcharts(initialSwitchInfo);
return success(echartsData);
}
/**
* 获取网络端口bites总数
* @param initialSwitchInfo
* @return
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@PostMapping("/switchNetTotalEcharts")
public AjaxResult switchNetTotalEcharts(@RequestBody InitialSwitchInfo initialSwitchInfo){
Map<String, Object> echartsData = initialSwitchInfoService.switchNetTotalEcharts(initialSwitchInfo);
return success(echartsData);
}
/**
* 获取网络端口的错误包数
* @param initialSwitchInfo
* @return
*/
@RequiresPermissions("rocketmq:switchInfo:list")
@PostMapping("/switchNetErrDiscardsEcharts")
public AjaxResult switchNetErrDiscardsEcharts(@RequestBody InitialSwitchInfo initialSwitchInfo){
Map<String, Object> echartsData = initialSwitchInfoService.switchNetErrDiscardsEcharts(initialSwitchInfo);
return success(echartsData);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchInfoTemp;
import com.tongran.rocketmq.service.IInitialSwitchInfoTempService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 交换机监控信息Controller
*
* @author gyt
* @date 2025-08-26
*/
@RestController
@RequestMapping("/temp")
public class InitialSwitchInfoTempController extends BaseController
{
@Autowired
private IInitialSwitchInfoTempService initialSwitchInfoTempService;
/**
* 查询交换机监控信息列表
*/
@RequiresPermissions("rocketmq:temp:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchInfoTemp initialSwitchInfoTemp)
{
startPage();
List<InitialSwitchInfoTemp> list = initialSwitchInfoTempService.selectInitialSwitchInfoTempList(initialSwitchInfoTemp);
return getDataTable(list);
}
/**
* 导出交换机监控信息列表
*/
@RequiresPermissions("rocketmq:temp:export")
@Log(title = "交换机监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchInfoTemp initialSwitchInfoTemp)
{
List<InitialSwitchInfoTemp> list = initialSwitchInfoTempService.selectInitialSwitchInfoTempList(initialSwitchInfoTemp);
ExcelUtil<InitialSwitchInfoTemp> util = new ExcelUtil<InitialSwitchInfoTemp>(InitialSwitchInfoTemp.class);
util.exportExcel(response, list, "交换机监控信息数据");
}
/**
* 获取交换机监控信息详细信息
*/
@RequiresPermissions("rocketmq:temp:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchInfoTempService.selectInitialSwitchInfoTempById(id));
}
/**
* 新增交换机监控信息
*/
@RequiresPermissions("rocketmq:temp:add")
@Log(title = "交换机监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchInfoTemp initialSwitchInfoTemp)
{
return toAjax(initialSwitchInfoTempService.insertInitialSwitchInfoTemp(initialSwitchInfoTemp));
}
/**
* 修改交换机监控信息
*/
@RequiresPermissions("rocketmq:temp:edit")
@Log(title = "交换机监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchInfoTemp initialSwitchInfoTemp)
{
return toAjax(initialSwitchInfoTempService.updateInitialSwitchInfoTemp(initialSwitchInfoTemp));
}
/**
* 删除交换机监控信息
*/
@RequiresPermissions("rocketmq:temp:remove")
@Log(title = "交换机监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchInfoTempService.deleteInitialSwitchInfoTempByIds(ids));
}
}
@@ -0,0 +1,155 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchMpuInfo;
import com.tongran.rocketmq.service.IInitialSwitchMpuInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* MPU信息Controller
*
* @author gyt
* @date 2025-09-22
*/
@RestController
@RequestMapping("/switchMpuInfo")
public class InitialSwitchMpuInfoController extends BaseController
{
@Autowired
private IInitialSwitchMpuInfoService initialSwitchMpuInfoService;
/**
* 查询MPU信息列表
*/
@RequiresPermissions("rocketmq:info:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchMpuInfo initialSwitchMpuInfo)
{
startPage();
List<InitialSwitchMpuInfo> list = initialSwitchMpuInfoService.selectInitialSwitchMpuInfoList(initialSwitchMpuInfo);
return getDataTable(list);
}
/**
* 导出MPU信息列表
*/
@RequiresPermissions("rocketmq:info:export")
@Log(title = "MPU信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchMpuInfo initialSwitchMpuInfo)
{
List<InitialSwitchMpuInfo> list = initialSwitchMpuInfoService.selectInitialSwitchMpuInfoList(initialSwitchMpuInfo);
ExcelUtil<InitialSwitchMpuInfo> util = new ExcelUtil<InitialSwitchMpuInfo>(InitialSwitchMpuInfo.class);
util.exportExcel(response, list, "MPU信息数据");
}
/**
* 获取MPU信息详细信息
*/
@RequiresPermissions("rocketmq:info:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchMpuInfoService.selectInitialSwitchMpuInfoById(id));
}
/**
* 新增MPU信息
*/
@RequiresPermissions("rocketmq:info:add")
@Log(title = "MPU信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo)
{
return toAjax(initialSwitchMpuInfoService.insertInitialSwitchMpuInfo(initialSwitchMpuInfo));
}
/**
* 修改MPU信息
*/
@RequiresPermissions("rocketmq:info:edit")
@Log(title = "MPU信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo)
{
return toAjax(initialSwitchMpuInfoService.updateInitialSwitchMpuInfo(initialSwitchMpuInfo));
}
/**
* 删除MPU信息
*/
@RequiresPermissions("rocketmq:info:remove")
@Log(title = "MPU信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchMpuInfoService.deleteInitialSwitchMpuInfoByIds(ids));
}
/**
* 获取所有mpu名称
* @param initialSwitchMpuInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getAllMpuName")
public AjaxResult getAllMpuName(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo){
List<Map> list = initialSwitchMpuInfoService.getAllMpuName(initialSwitchMpuInfo);
return success(list);
}
/**
* 获取mpu基础信息
* @param initialSwitchMpuInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getMpuMsg")
public AjaxResult getMpuMsg(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo){
List<InitialSwitchMpuInfo> list = initialSwitchMpuInfoService.getMpuMsg(initialSwitchMpuInfo);
return success(list);
}
/**
* 获取mpu的cpu使用率
* @param initialSwitchMpuInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getMpuCpuUse")
public AjaxResult getMpuCpuUse(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo){
Map<String, Object> echartsData = initialSwitchMpuInfoService.getMpuCpuUse(initialSwitchMpuInfo);
return success(echartsData);
}
/**
* 获取mpu的内存使用率
* @param initialSwitchMpuInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getMpuMemUse")
public AjaxResult getMpuMemUse(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo){
Map<String, Object> echartsData = initialSwitchMpuInfoService.getMpuMemUse(initialSwitchMpuInfo);
return success(echartsData);
}
/**
* 获取mpu的温度
* @param initialSwitchMpuInfo
* @return
*/
@RequiresPermissions("rocketmq:info:list")
@PostMapping("/getMpuTemperature")
public AjaxResult getMpuTemperature(@RequestBody InitialSwitchMpuInfo initialSwitchMpuInfo){
Map<String, Object> echartsData = initialSwitchMpuInfoService.getMpuTemperature(initialSwitchMpuInfo);
return success(echartsData);
}
}
@@ -0,0 +1,144 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchOpticalModule;
import com.tongran.rocketmq.service.IInitialSwitchOpticalModuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 光模块信息Controller
*
* @author gyt
* @date 2025-09-22
*/
@RestController
@RequestMapping("/switchOpticalModule")
public class InitialSwitchOpticalModuleController extends BaseController
{
@Autowired
private IInitialSwitchOpticalModuleService initialSwitchOpticalModuleService;
/**
* 查询光模块信息列表
*/
@RequiresPermissions("rocketmq:module:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchOpticalModule initialSwitchOpticalModule)
{
startPage();
List<InitialSwitchOpticalModule> list = initialSwitchOpticalModuleService.selectInitialSwitchOpticalModuleList(initialSwitchOpticalModule);
return getDataTable(list);
}
/**
* 导出光模块信息列表
*/
@RequiresPermissions("rocketmq:module:export")
@Log(title = "光模块信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchOpticalModule initialSwitchOpticalModule)
{
List<InitialSwitchOpticalModule> list = initialSwitchOpticalModuleService.selectInitialSwitchOpticalModuleList(initialSwitchOpticalModule);
ExcelUtil<InitialSwitchOpticalModule> util = new ExcelUtil<InitialSwitchOpticalModule>(InitialSwitchOpticalModule.class);
util.exportExcel(response, list, "光模块信息数据");
}
/**
* 获取光模块信息详细信息
*/
@RequiresPermissions("rocketmq:module:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchOpticalModuleService.selectInitialSwitchOpticalModuleById(id));
}
/**
* 新增光模块信息
*/
@RequiresPermissions("rocketmq:module:add")
@Log(title = "光模块信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule)
{
return toAjax(initialSwitchOpticalModuleService.insertInitialSwitchOpticalModule(initialSwitchOpticalModule));
}
/**
* 修改光模块信息
*/
@RequiresPermissions("rocketmq:module:edit")
@Log(title = "光模块信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule)
{
return toAjax(initialSwitchOpticalModuleService.updateInitialSwitchOpticalModule(initialSwitchOpticalModule));
}
/**
* 删除光模块信息
*/
@RequiresPermissions("rocketmq:module:remove")
@Log(title = "光模块信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchOpticalModuleService.deleteInitialSwitchOpticalModuleByIds(ids));
}
/**
* 获取该交换机的所有光模块名称
* @return
*/
@RequiresPermissions("rocketmq:module:list")
@PostMapping("/getAllModuleName")
public AjaxResult getAllModuleName(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule){
List<Map> list = initialSwitchOpticalModuleService.getAllModuleName(initialSwitchOpticalModule);
return success(list);
}
/**
* 获取光模块基础信息
* @param initialSwitchOpticalModule
* @return
*/
@RequiresPermissions("rocketmq:module:list")
@PostMapping("/switchOpticalModuleMsg")
public AjaxResult switchOpticalModuleMsg(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule){
List<InitialSwitchOpticalModule> list = initialSwitchOpticalModuleService.switchOpticalModuleMsg(initialSwitchOpticalModule);
return success(list);
}
/**
* 获取光模块的光衰阈值
* @param initialSwitchOpticalModule
* @return
*/
@RequiresPermissions("rocketmq:module:list")
@PostMapping("/opticalModuleLowThreshold")
public AjaxResult opticalModuleLowThreshold(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule){
Map<String, Object> echartsData = initialSwitchOpticalModuleService.opticalModuleLowThreshold(initialSwitchOpticalModule);
return success(echartsData);
}
/**
* 获取光模块的功率
* @param initialSwitchOpticalModule
* @return
*/
@RequiresPermissions("rocketmq:module:list")
@PostMapping("/opticalModulePower")
public AjaxResult opticalModulePower(@RequestBody InitialSwitchOpticalModule initialSwitchOpticalModule){
Map<String, Object> echartsData = initialSwitchOpticalModuleService.opticalModulePower(initialSwitchOpticalModule);
return success(echartsData);
}
}
@@ -0,0 +1,139 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchOtherCollectData;
import com.tongran.rocketmq.service.IInitialSwitchOtherCollectDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 交换机系统其他信息采集数据Controller
*
* @author gyt
* @date 2025-09-23
*/
@RestController
@RequestMapping("/switchOtherData")
public class InitialSwitchOtherCollectDataController extends BaseController
{
@Autowired
private IInitialSwitchOtherCollectDataService initialSwitchOtherCollectDataService;
/**
* 查询交换机系统其他信息采集数据列表
*/
@RequiresPermissions("rocketmq:switchOtherData:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
startPage();
List<InitialSwitchOtherCollectData> list = initialSwitchOtherCollectDataService.selectInitialSwitchOtherCollectDataList(initialSwitchOtherCollectData);
return getDataTable(list);
}
/**
* 导出交换机系统其他信息采集数据列表
*/
@RequiresPermissions("rocketmq:switchOtherData:export")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
List<InitialSwitchOtherCollectData> list = initialSwitchOtherCollectDataService.selectInitialSwitchOtherCollectDataList(initialSwitchOtherCollectData);
ExcelUtil<InitialSwitchOtherCollectData> util = new ExcelUtil<InitialSwitchOtherCollectData>(InitialSwitchOtherCollectData.class);
util.exportExcel(response, list, "交换机系统其他信息采集数据数据");
}
/**
* 获取交换机系统其他信息采集数据详细信息
*/
@RequiresPermissions("rocketmq:switchOtherData:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchOtherCollectDataService.selectInitialSwitchOtherCollectDataById(id));
}
/**
* 新增交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:switchOtherData:add")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
return toAjax(initialSwitchOtherCollectDataService.insertInitialSwitchOtherCollectData(initialSwitchOtherCollectData));
}
/**
* 修改交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:switchOtherData:edit")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
return toAjax(initialSwitchOtherCollectDataService.updateInitialSwitchOtherCollectData(initialSwitchOtherCollectData));
}
/**
* 删除交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:switchOtherData:remove")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchOtherCollectDataService.deleteInitialSwitchOtherCollectDataByIds(ids));
}
/**
* 图形监控交换机监控项基础信息
*/
@RequiresPermissions("rocketmq:switchOtherData:list")
@PostMapping("/getSwitchMonitorMsg")
public AjaxResult getSwitchMonitorMsg(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
Map list = initialSwitchOtherCollectDataService.getSwitchMonitorMsg(initialSwitchOtherCollectData);
return success(list);
}
/**
* 图形监控交换机设备CPU使用率
*/
@RequiresPermissions("rocketmq:switchOtherData:list")
@PostMapping("/getSwitchCpuUseMsg")
public AjaxResult getSwitchCpuUseMsg(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
Map<String, Object> echartsData = initialSwitchOtherCollectDataService.getSwitchCpuUseMsg(initialSwitchOtherCollectData);
return success(echartsData);
}
/**
* 图形监控交换机设备内存利用率
*/
@RequiresPermissions("rocketmq:switchOtherData:list")
@PostMapping("/getSwitchMemUseMsg")
public AjaxResult getSwitchMemUseMsg(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
Map<String, Object> echartsData = initialSwitchOtherCollectDataService.getSwitchMemUseMsg(initialSwitchOtherCollectData);
return success(echartsData);
}
/**
* 图形监控交换机设备系统功率
*/
@RequiresPermissions("rocketmq:switchOtherData:list")
@PostMapping("/getSwitchPowerMsg")
public AjaxResult getSwitchPowerMsg(@RequestBody InitialSwitchOtherCollectData initialSwitchOtherCollectData)
{
Map<String, Object> echartsData = initialSwitchOtherCollectDataService.getSwitchPowerMsg(initialSwitchOtherCollectData);
return success(echartsData);
}
}
@@ -0,0 +1,143 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSwitchPowerSupply;
import com.tongran.rocketmq.service.IInitialSwitchPowerSupplyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 电源信息Controller
*
* @author gyt
* @date 2025-09-22
*/
@RestController
@RequestMapping("/switchPowerSupply")
public class InitialSwitchPowerSupplyController extends BaseController
{
@Autowired
private IInitialSwitchPowerSupplyService initialSwitchPowerSupplyService;
/**
* 查询电源信息列表
*/
@RequiresPermissions("rocketmq:supply:list")
@GetMapping("/list")
public TableDataInfo list(InitialSwitchPowerSupply initialSwitchPowerSupply)
{
startPage();
List<InitialSwitchPowerSupply> list = initialSwitchPowerSupplyService.selectInitialSwitchPowerSupplyList(initialSwitchPowerSupply);
return getDataTable(list);
}
/**
* 导出电源信息列表
*/
@RequiresPermissions("rocketmq:supply:export")
@Log(title = "电源信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSwitchPowerSupply initialSwitchPowerSupply)
{
List<InitialSwitchPowerSupply> list = initialSwitchPowerSupplyService.selectInitialSwitchPowerSupplyList(initialSwitchPowerSupply);
ExcelUtil<InitialSwitchPowerSupply> util = new ExcelUtil<InitialSwitchPowerSupply>(InitialSwitchPowerSupply.class);
util.exportExcel(response, list, "电源信息数据");
}
/**
* 获取电源信息详细信息
*/
@RequiresPermissions("rocketmq:supply:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSwitchPowerSupplyService.selectInitialSwitchPowerSupplyById(id));
}
/**
* 新增电源信息
*/
@RequiresPermissions("rocketmq:supply:add")
@Log(title = "电源信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply)
{
return toAjax(initialSwitchPowerSupplyService.insertInitialSwitchPowerSupply(initialSwitchPowerSupply));
}
/**
* 修改电源信息
*/
@RequiresPermissions("rocketmq:supply:edit")
@Log(title = "电源信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply)
{
return toAjax(initialSwitchPowerSupplyService.updateInitialSwitchPowerSupply(initialSwitchPowerSupply));
}
/**
* 删除电源信息
*/
@RequiresPermissions("rocketmq:supply:remove")
@Log(title = "电源信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSwitchPowerSupplyService.deleteInitialSwitchPowerSupplyByIds(ids));
}
/**
* 获取指定交换机所有电源名称
* @param initialSwitchPowerSupply
* @return
*/
@RequiresPermissions("rocketmq:supply:list")
@PostMapping("/getAllPwrName")
public AjaxResult getAllPwrName(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply){
List<Map> list = initialSwitchPowerSupplyService.getAllPwrName(initialSwitchPowerSupply);
return success(list);
}
/**
* 获取电源基础信息
* @param initialSwitchPowerSupply
* @return
*/
@RequiresPermissions("rocketmq:supply:list")
@PostMapping("/getPwrMsg")
public AjaxResult getPwrMsg(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply){
List<Map> list = initialSwitchPowerSupplyService.getPwrMsg(initialSwitchPowerSupply);
return success(list);
}
/**
* 获取电源电流
* @param initialSwitchPowerSupply
* @return
*/
@RequiresPermissions("rocketmq:supply:list")
@PostMapping("/getPwrCurrent")
public AjaxResult getPwrCurrent(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply){
Map<String, Object> echartsData = initialSwitchPowerSupplyService.getPwrCurrent(initialSwitchPowerSupply);
return success(echartsData);
}
/**
* 获取电源电压
* @param initialSwitchPowerSupply
* @return
*/
@RequiresPermissions("rocketmq:supply:list")
@PostMapping("/getPwrVoltage")
public AjaxResult getPwrVoltage(@RequestBody InitialSwitchPowerSupply initialSwitchPowerSupply){
Map<String, Object> echartsData = initialSwitchPowerSupplyService.getPwrVoltage(initialSwitchPowerSupply);
return success(echartsData);
}
}
@@ -0,0 +1,139 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSystemInfo;
import com.tongran.rocketmq.domain.vo.SystemMsgVo;
import com.tongran.rocketmq.service.IInitialSystemInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 系统监控信息Controller
*
* @author gyt
* @date 2025-08-25
*/
@RestController
@RequestMapping("/systemInfo")
public class InitialSystemInfoController extends BaseController
{
@Autowired
private IInitialSystemInfoService initialSystemInfoService;
/**
* 查询系统监控信息列表
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody InitialSystemInfo initialSystemInfo)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(initialSystemInfo.getPageNum());
pageDomain.setPageSize(initialSystemInfo.getPageSize());
startPage(pageDomain);
List<InitialSystemInfo> list = initialSystemInfoService.selectInitialSystemInfoList(initialSystemInfo);
return getDataTable(list);
}
/**
* 导出系统监控信息列表
*/
@RequiresPermissions("rocketmq:systemInfo:export")
@Log(title = "系统监控信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSystemInfo initialSystemInfo)
{
List<InitialSystemInfo> list = initialSystemInfoService.selectInitialSystemInfoList(initialSystemInfo);
ExcelUtil<InitialSystemInfo> util = new ExcelUtil<InitialSystemInfo>(InitialSystemInfo.class);
util.exportExcel(response, list, "系统监控信息数据");
}
/**
* 获取系统监控信息详细信息
*/
@RequiresPermissions("rocketmq:systemInfo:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSystemInfoService.selectInitialSystemInfoById(id));
}
/**
* 新增系统监控信息
*/
@RequiresPermissions("rocketmq:systemInfo:add")
@Log(title = "系统监控信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSystemInfo initialSystemInfo)
{
return toAjax(initialSystemInfoService.insertInitialSystemInfo(initialSystemInfo));
}
/**
* 修改系统监控信息
*/
@RequiresPermissions("rocketmq:systemInfo:edit")
@Log(title = "系统监控信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSystemInfo initialSystemInfo)
{
return toAjax(initialSystemInfoService.updateInitialSystemInfo(initialSystemInfo));
}
/**
* 删除系统监控信息
*/
@RequiresPermissions("rocketmq:systemInfo:remove")
@Log(title = "系统监控信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSystemInfoService.deleteInitialSystemInfoByIds(ids));
}
/**
* 查询系统进程监控信息列表并封装为多折线ECharts图表数据
* @param initialSystemInfo
* @return
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/systemProcessEcharts")
public AjaxResult systemProcessEcharts(@RequestBody InitialSystemInfo initialSystemInfo) {
Map<String, Object> echartsData = initialSystemInfoService.systemProcessEcharts(initialSystemInfo);
return success(echartsData);
}
/**
* 查询系统登陆用户数(个)监控信息列表并封装为多折线ECharts图表数据
* @param initialSystemInfo
* @return
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/systemUserNumEcharts")
public AjaxResult systemUserNumEcharts(@RequestBody InitialSystemInfo initialSystemInfo) {
Map<String, Object> echartsData = initialSystemInfoService.systemUserNumEcharts(initialSystemInfo);
return success(echartsData);
}
/**
* 系统基础信息
* @param initialSystemInfo
* @return
*/
@RequiresPermissions("rocketmq:systemInfo:list")
@PostMapping("/systemDetailsMsg")
public AjaxResult systemDetailsMsg(@RequestBody InitialSystemInfo initialSystemInfo) {
SystemMsgVo systemDetailsMsg = initialSystemInfoService.getSystemDetailsMsg(initialSystemInfo);
return success(systemDetailsMsg);
}
}
@@ -0,0 +1,180 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.InitialSystemOtherCollectData;
import com.tongran.rocketmq.service.IInitialSystemOtherCollectDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 交换机系统其他信息采集数据Controller
*
* @author gyt
* @date 2025-09-23
*/
@RestController
@RequestMapping("/systemOtherCollectData")
public class InitialSystemOtherCollectDataController extends BaseController
{
@Autowired
private IInitialSystemOtherCollectDataService initialSystemOtherCollectDataService;
/**
* 查询交换机系统其他信息采集数据列表
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@GetMapping("/list")
public TableDataInfo list(InitialSystemOtherCollectData initialSystemOtherCollectData)
{
startPage();
List<InitialSystemOtherCollectData> list = initialSystemOtherCollectDataService.selectInitialSystemOtherCollectDataList(initialSystemOtherCollectData);
return getDataTable(list);
}
/**
* 导出交换机系统其他信息采集数据列表
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:export")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, InitialSystemOtherCollectData initialSystemOtherCollectData)
{
List<InitialSystemOtherCollectData> list = initialSystemOtherCollectDataService.selectInitialSystemOtherCollectDataList(initialSystemOtherCollectData);
ExcelUtil<InitialSystemOtherCollectData> util = new ExcelUtil<InitialSystemOtherCollectData>(InitialSystemOtherCollectData.class);
util.exportExcel(response, list, "交换机系统其他信息采集数据数据");
}
/**
* 获取交换机系统其他信息采集数据详细信息
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(initialSystemOtherCollectDataService.selectInitialSystemOtherCollectDataById(id));
}
/**
* 新增交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:add")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData)
{
return toAjax(initialSystemOtherCollectDataService.insertInitialSystemOtherCollectData(initialSystemOtherCollectData));
}
/**
* 修改交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:edit")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData)
{
return toAjax(initialSystemOtherCollectDataService.updateInitialSystemOtherCollectData(initialSystemOtherCollectData));
}
/**
* 删除交换机系统其他信息采集数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:remove")
@Log(title = "交换机系统其他信息采集数据", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(initialSystemOtherCollectDataService.deleteInitialSystemOtherCollectDataByIds(ids));
}
/**
* 查询系统其他信息基础数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/getMontiorMsg")
public AjaxResult getMontiorMsg(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData)
{
Map list = initialSystemOtherCollectDataService.getMonitorMsg(initialSystemOtherCollectData);
return success(list);
}
/**
* 查询系统登陆用户数(个)监控信息列表并封装为多折线ECharts图表数据
* @param initialSystemOtherCollectData
* @return
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/systemUserNumEcharts")
public AjaxResult systemUserNumEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.systemUserNumEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询交换卷文件的可用空间监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/systemSwapSizeFreeEcharts")
public AjaxResult systemSwapSizeFreeEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.systemSwapSizeFreeEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询内存利用率监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/memoryUtilizationEcharts")
public AjaxResult memoryUtilizationEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.memoryUtilizationEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询可用交换空间百分比监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/systemSwapSizePercentEcharts")
public AjaxResult systemSwapSizePercentEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.systemSwapSizePercentEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询可用内存监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/memorySizeAvailableEcharts")
public AjaxResult memorySizeAvailableEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.memorySizeAvailableEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询可用内存百分比监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/memorySizePercentEcharts")
public AjaxResult memorySizePercentEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.memorySizePercentEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
/**
* 查询进程数监控信息列表并封装为多折线ECharts图表数据
*/
@RequiresPermissions("rocketmq:systemOtherCollectData:list")
@PostMapping("/procNumEcharts")
public AjaxResult procNumEcharts(@RequestBody InitialSystemOtherCollectData initialSystemOtherCollectData) {
Map<String, Object> echartsData = initialSystemOtherCollectDataService.procNumEcharts(initialSystemOtherCollectData);
return success(echartsData);
}
}
@@ -0,0 +1,99 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAgentManagement;
import com.tongran.rocketmq.service.IRmAgentManagementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* Agent管理Controller
*
* @author gyt
* @date 2025-09-15
*/
@RestController
@RequestMapping("/agentManagement")
public class RmAgentManagementController extends BaseController
{
@Autowired
private IRmAgentManagementService rmAgentManagementService;
/**
* 查询Agent管理列表
*/
@RequiresPermissions("rocketmq:management:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmAgentManagement rmAgentManagement)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmAgentManagement.getPageNum());
pageDomain.setPageSize(rmAgentManagement.getPageSize());
startPage(pageDomain);
List<RmAgentManagement> list = rmAgentManagementService.selectRmAgentManagementList(rmAgentManagement);
return getDataTable(list);
}
/**
* 获取Agent管理详细信息
*/
@RequiresPermissions("rocketmq:management:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAgentManagementService.selectRmAgentManagementById(id));
}
/**
* 新增Agent管理
*/
@RequiresPermissions("rocketmq:management:add")
@Log(title = "Agent管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmAgentManagement rmAgentManagement)
{
return toAjax(rmAgentManagementService.addRmAgentManagement(rmAgentManagement));
}
/**
* 修改Agent管理
*/
@RequiresPermissions("rocketmq:management:edit")
@Log(title = "Agent管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmAgentManagement rmAgentManagement)
{
return toAjax(rmAgentManagementService.updateRmAgentManagement(rmAgentManagement));
}
/**
* 手动立即更新
* @param rmAgentManagement
* @return
*/
@RequiresPermissions("rocketmq:management:edit")
@PostMapping("/updateAgentNow")
public AjaxResult updateAgentNow(@RequestBody RmAgentManagement rmAgentManagement){
rmAgentManagementService.updateAgentNow(rmAgentManagement);
return success();
}
/**
* 配置更新策略
*/
@RequiresPermissions("rocketmq:management:add")
@Log(title = "Agent管理", businessType = BusinessType.INSERT)
@PostMapping("/addUpdatePolicy")
public AjaxResult addUpdatePolicy(@RequestBody RmAgentManagement rmAgentManagement)
{
return toAjax(rmAgentManagementService.addUpdatePolicy(rmAgentManagement));
}
}
@@ -0,0 +1,103 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmLog;
import com.tongran.rocketmq.service.IRmAlarmLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 客户端告警信息Controller
*
* @author gyt
* @date 2025-11-10
*/
@RestController
@RequestMapping("/alarmLog")
public class RmAlarmLogController extends BaseController
{
@Autowired
private IRmAlarmLogService rmAlarmLogService;
/**
* 查询客户端告警信息列表
*/
@RequiresPermissions("rocketmq:alarmLog:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmAlarmLog rmAlarmLog)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmAlarmLog.getPageNum());
pageDomain.setPageSize(rmAlarmLog.getPageSize());
startPage(pageDomain);
List<RmAlarmLog> list = rmAlarmLogService.selectRmAlarmLogList(rmAlarmLog);
return getDataTable(list);
}
/**
* 导出客户端告警信息列表
*/
@RequiresPermissions("rocketmq:alarmLog:export")
@Log(title = "客户端告警信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmAlarmLog rmAlarmLog)
{
List<RmAlarmLog> list = rmAlarmLogService.selectRmAlarmLogList(rmAlarmLog);
ExcelUtil<RmAlarmLog> util = new ExcelUtil<RmAlarmLog>(RmAlarmLog.class);
util.showColumn(rmAlarmLog.getProperties());
util.exportExcel(response, list, "客户端告警信息数据");
}
/**
* 获取客户端告警信息详细信息
*/
@RequiresPermissions("rocketmq:alarmLog:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAlarmLogService.selectRmAlarmLogById(id));
}
/**
* 新增客户端告警信息
*/
@RequiresPermissions("rocketmq:alarmLog:add")
@Log(title = "客户端告警信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmAlarmLog rmAlarmLog)
{
return toAjax(rmAlarmLogService.insertRmAlarmLog(rmAlarmLog));
}
/**
* 修改客户端告警信息
*/
@RequiresPermissions("rocketmq:alarmLog:edit")
@Log(title = "客户端告警信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmAlarmLog rmAlarmLog)
{
return toAjax(rmAlarmLogService.updateRmAlarmLog(rmAlarmLog));
}
/**
* 删除客户端告警信息
*/
@RequiresPermissions("rocketmq:alarmLog:remove")
@Log(title = "客户端告警信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmAlarmLogService.deleteRmAlarmLogByIds(ids));
}
}
@@ -0,0 +1,103 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmPolicy;
import com.tongran.rocketmq.service.IRmAlarmPolicyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 告警策略Controller
*
* @author gyt
* @date 2025-09-12
*/
@RestController
@RequestMapping("/alarmPolicy")
public class RmAlarmPolicyController extends BaseController
{
@Autowired
private IRmAlarmPolicyService rmAlarmPolicyService;
/**
* 查询告警策略列表
*/
@RequiresPermissions("rocketmq:policy:list")
@GetMapping("/list")
public TableDataInfo list(RmAlarmPolicy rmAlarmPolicy)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmAlarmPolicy.getPageNum());
pageDomain.setPageSize(rmAlarmPolicy.getPageSize());
startPage(pageDomain);
List<RmAlarmPolicy> list = rmAlarmPolicyService.selectRmAlarmPolicyList(rmAlarmPolicy);
return getDataTable(list);
}
/**
* 导出告警策略列表
*/
@RequiresPermissions("rocketmq:policy:export")
@Log(title = "告警策略", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmAlarmPolicy rmAlarmPolicy)
{
List<RmAlarmPolicy> list = rmAlarmPolicyService.selectRmAlarmPolicyList(rmAlarmPolicy);
ExcelUtil<RmAlarmPolicy> util = new ExcelUtil<RmAlarmPolicy>(RmAlarmPolicy.class);
util.exportExcel(response, list, "告警策略数据");
}
/**
* 获取告警策略详细信息
*/
@RequiresPermissions("rocketmq:policy:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAlarmPolicyService.getRmAlarmPolicyMsgById(id));
}
/**
* 新增告警策略
*/
@RequiresPermissions("rocketmq:policy:add")
@Log(title = "告警策略", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmAlarmPolicy rmAlarmPolicy)
{
return toAjax(rmAlarmPolicyService.addRmAlarmPolicy(rmAlarmPolicy));
}
/**
* 修改告警策略
*/
@RequiresPermissions("rocketmq:policy:edit")
@Log(title = "告警策略", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmAlarmPolicy rmAlarmPolicy)
{
return toAjax(rmAlarmPolicyService.updateRmAlarmPolicy(rmAlarmPolicy));
}
/**
* 下发告警策略
*/
@RequiresPermissions("rocketmq:policy:query")
@GetMapping(value = "/issueAlarmPolicy")
public AjaxResult issueAlarmPolicy(Long id)
{
return success(rmAlarmPolicyService.issueAlarmPolicy(id));
}
}
@@ -0,0 +1,103 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmPushConfig;
import com.tongran.rocketmq.service.IRmAlarmPushConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 告警推送配置Controller
*
* @author gyt
* @date 2025-11-11
*/
@RestController
@RequestMapping("/alarmPushConfig")
public class RmAlarmPushConfigController extends BaseController
{
@Autowired
private IRmAlarmPushConfigService rmAlarmPushConfigService;
/**
* 查询告警推送配置列表
*/
@RequiresPermissions("rocketmq:alarmPushConfig:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmAlarmPushConfig rmAlarmPushConfig)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmAlarmPushConfig.getPageNum());
pageDomain.setPageSize(rmAlarmPushConfig.getPageSize());
startPage(pageDomain);
List<RmAlarmPushConfig> list = rmAlarmPushConfigService.selectRmAlarmPushConfigList(rmAlarmPushConfig);
return getDataTable(list);
}
/**
* 导出告警推送配置列表
*/
@RequiresPermissions("rocketmq:alarmPushConfig:export")
@Log(title = "告警推送配置", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmAlarmPushConfig rmAlarmPushConfig)
{
List<RmAlarmPushConfig> list = rmAlarmPushConfigService.selectRmAlarmPushConfigList(rmAlarmPushConfig);
ExcelUtil<RmAlarmPushConfig> util = new ExcelUtil<RmAlarmPushConfig>(RmAlarmPushConfig.class);
util.showColumn(rmAlarmPushConfig.getProperties());
util.exportExcel(response, list, "告警推送配置数据");
}
/**
* 获取告警推送配置详细信息
*/
@RequiresPermissions("rocketmq:alarmPushConfig:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAlarmPushConfigService.selectRmAlarmPushConfigById(id));
}
/**
* 新增告警推送配置
*/
@RequiresPermissions("rocketmq:alarmPushConfig:add")
@Log(title = "告警推送配置", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmAlarmPushConfig rmAlarmPushConfig)
{
return toAjax(rmAlarmPushConfigService.insertRmAlarmPushConfig(rmAlarmPushConfig));
}
/**
* 修改告警推送配置
*/
@RequiresPermissions("rocketmq:alarmPushConfig:edit")
@Log(title = "告警推送配置", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmAlarmPushConfig rmAlarmPushConfig)
{
return toAjax(rmAlarmPushConfigService.updateRmAlarmPushConfig(rmAlarmPushConfig));
}
/**
* 删除告警推送配置
*/
@RequiresPermissions("rocketmq:alarmPushConfig:remove")
@Log(title = "告警推送配置", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmAlarmPushConfigService.deleteRmAlarmPushConfigByIds(ids));
}
}
@@ -0,0 +1,92 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.domain.R;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.InnerAuth;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmRecord;
import com.tongran.rocketmq.service.IRmAlarmRecordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 告警记录Controller
*
* @author gyt
* @date 2025-09-12
*/
@RestController
@RequestMapping("/alarmRecord")
public class RmAlarmRecordController extends BaseController
{
@Autowired
private IRmAlarmRecordService rmAlarmRecordService;
/**
* 查询告警记录列表
*/
@RequiresPermissions("rocketmq:record:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmAlarmRecord rmAlarmRecord)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmAlarmRecord.getPageNum());
pageDomain.setPageSize(rmAlarmRecord.getPageSize());
startPage(pageDomain);
List<RmAlarmRecord> list = rmAlarmRecordService.selectRmAlarmRecordList(rmAlarmRecord);
return getDataTable(list);
}
/**
* 查询告警记录列表
*/
@InnerAuth
@PostMapping("/getAlarmList")
public R<List<RmAlarmRecord>> getAlarmList(@RequestBody RmAlarmRecord rmAlarmRecord)
{
List<RmAlarmRecord> list = rmAlarmRecordService.selectRmAlarmRecordList(rmAlarmRecord);
return R.ok(list);
}
/**
* 导出告警记录列表
*/
@RequiresPermissions("rocketmq:record:export")
@Log(title = "告警记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmAlarmRecord rmAlarmRecord)
{
List<RmAlarmRecord> list = rmAlarmRecordService.selectRmAlarmRecordList(rmAlarmRecord);
ExcelUtil<RmAlarmRecord> util = new ExcelUtil<RmAlarmRecord>(RmAlarmRecord.class);
util.exportExcel(response, list, "告警记录数据");
}
/**
* 获取告警记录详细信息
*/
@RequiresPermissions("rocketmq:record:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAlarmRecordService.selectRmAlarmRecordById(id));
}
/**
* 资源告警处理情况
* @return
*/
@GetMapping(value = "/alarmHandlingStatus")
public R<Map> alarmHandlingStatus(){
Map alarmRecordMap = rmAlarmRecordService.alarmHandlingStatus();
return R.ok(alarmRecordMap);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmRule;
import com.tongran.rocketmq.service.IRmAlarmRuleService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 告警规则Controller
*
* @author gyt
* @date 2025-09-12
*/
@RestController
@RequestMapping("/rule")
public class RmAlarmRuleController extends BaseController
{
@Autowired
private IRmAlarmRuleService rmAlarmRuleService;
/**
* 查询告警规则列表
*/
@RequiresPermissions("rocketmq:rule:list")
@GetMapping("/list")
public TableDataInfo list(RmAlarmRule rmAlarmRule)
{
startPage();
List<RmAlarmRule> list = rmAlarmRuleService.selectRmAlarmRuleList(rmAlarmRule);
return getDataTable(list);
}
/**
* 导出告警规则列表
*/
@RequiresPermissions("rocketmq:rule:export")
@Log(title = "告警规则", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmAlarmRule rmAlarmRule)
{
List<RmAlarmRule> list = rmAlarmRuleService.selectRmAlarmRuleList(rmAlarmRule);
ExcelUtil<RmAlarmRule> util = new ExcelUtil<RmAlarmRule>(RmAlarmRule.class);
util.exportExcel(response, list, "告警规则数据");
}
/**
* 获取告警规则详细信息
*/
@RequiresPermissions("rocketmq:rule:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmAlarmRuleService.selectRmAlarmRuleById(id));
}
/**
* 新增告警规则
*/
@RequiresPermissions("rocketmq:rule:add")
@Log(title = "告警规则", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmAlarmRule rmAlarmRule)
{
return toAjax(rmAlarmRuleService.insertRmAlarmRule(rmAlarmRule));
}
/**
* 修改告警规则
*/
@RequiresPermissions("rocketmq:rule:edit")
@Log(title = "告警规则", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmAlarmRule rmAlarmRule)
{
return toAjax(rmAlarmRuleService.updateRmAlarmRule(rmAlarmRule));
}
/**
* 删除告警规则
*/
@RequiresPermissions("rocketmq:rule:remove")
@Log(title = "告警规则", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmAlarmRuleService.deleteRmAlarmRuleByIds(ids));
}
}
@@ -0,0 +1,39 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmAlarmRuleTemplate;
import com.tongran.rocketmq.service.IRmAlarmRuleTemplateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 告警规则模板Controller
*
* @author gyt
* @date 2025-09-12
*/
@RestController
@RequestMapping("/alarmTemplate")
public class RmAlarmRuleTemplateController extends BaseController
{
@Autowired
private IRmAlarmRuleTemplateService rmAlarmRuleTemplateService;
/**
* 查询告警规则模板列表
*/
@RequiresPermissions("rocketmq:template:list")
@PostMapping("/list")
public AjaxResult list(@RequestBody RmAlarmRuleTemplate rmAlarmRuleTemplate)
{
List<RmAlarmRuleTemplate> list = rmAlarmRuleTemplateService.selectRmAlarmRuleTemplateList(rmAlarmRuleTemplate);
return success(list);
}
}
@@ -0,0 +1,125 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.domain.R;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.InnerAuth;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmDeploymentPolicy;
import com.tongran.rocketmq.service.IRmDeploymentPolicyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 服务器脚本策略Controller
*
* @author gyt
* @date 2025-09-15
*/
@RestController
@RequestMapping("/policy")
public class RmDeploymentPolicyController extends BaseController
{
@Autowired
private IRmDeploymentPolicyService rmDeploymentPolicyService;
/**
* 查询服务器脚本策略列表
*/
@RequiresPermissions("rocketmq:policy:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmDeploymentPolicy rmDeploymentPolicy)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmDeploymentPolicy.getPageNum());
pageDomain.setPageSize(rmDeploymentPolicy.getPageSize());
startPage(pageDomain);
List<RmDeploymentPolicy> list = rmDeploymentPolicyService.selectRmDeploymentPolicyList(rmDeploymentPolicy);
return getDataTable(list);
}
/**
* 导出服务器脚本策略列表
*/
@RequiresPermissions("rocketmq:policy:export")
@Log(title = "服务器脚本策略", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, @RequestBody RmDeploymentPolicy rmDeploymentPolicy)
{
List<RmDeploymentPolicy> list = rmDeploymentPolicyService.selectRmDeploymentPolicyList(rmDeploymentPolicy);
ExcelUtil<RmDeploymentPolicy> util = new ExcelUtil<RmDeploymentPolicy>(RmDeploymentPolicy.class);
util.showColumn(rmDeploymentPolicy.getProperties());
util.exportExcel(response, list, "服务器脚本策略数据");
}
/**
* 获取服务器脚本策略详细信息
*/
@RequiresPermissions("rocketmq:policy:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmDeploymentPolicyService.selectRmDeploymentPolicyById(id));
}
/**
* 新增服务器脚本策略
*/
@RequiresPermissions("rocketmq:policy:add")
@Log(title = "服务器脚本策略", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmDeploymentPolicy rmDeploymentPolicy)
{
return toAjax(rmDeploymentPolicyService.insertRmDeploymentPolicy(rmDeploymentPolicy));
}
/**
* 修改服务器脚本策略
*/
@RequiresPermissions("rocketmq:policy:edit")
@Log(title = "服务器脚本策略", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmDeploymentPolicy rmDeploymentPolicy)
{
return toAjax(rmDeploymentPolicyService.updateRmDeploymentPolicy(rmDeploymentPolicy));
}
/**
* 删除服务器脚本策略
*/
@RequiresPermissions("rocketmq:policy:remove")
@Log(title = "服务器脚本策略", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmDeploymentPolicyService.deleteRmDeploymentPolicyByIds(ids));
}
/**
* 下发服务器脚本策略
*/
@RequiresPermissions("rocketmq:policy:list")
@GetMapping(value = "/issueDeploymentPolicy")
public AjaxResult issueDeploymentPolicy(Long id)
{
return success(rmDeploymentPolicyService.issueDeploymentPolicy(id));
}
/**
* 新增服务器脚本策略
*/
@InnerAuth
@PostMapping("/addDeployScript")
public R<Integer> addDeployScript(@RequestBody RmDeploymentPolicy rmDeploymentPolicy)
{
return R.ok(rmDeploymentPolicyService.insertRmDeploymentPolicy(rmDeploymentPolicy));
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmFileInfo;
import com.tongran.rocketmq.service.IRmFileInfoService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 文件信息Controller
*
* @author gyt
* @date 2025-09-15
*/
@RestController
@RequestMapping("/info")
public class RmFileInfoController extends BaseController
{
@Autowired
private IRmFileInfoService rmFileInfoService;
/**
* 查询文件信息列表
*/
@RequiresPermissions("rocketmq:info:list")
@GetMapping("/list")
public TableDataInfo list(RmFileInfo rmFileInfo)
{
startPage();
List<RmFileInfo> list = rmFileInfoService.selectRmFileInfoList(rmFileInfo);
return getDataTable(list);
}
/**
* 导出文件信息列表
*/
@RequiresPermissions("rocketmq:info:export")
@Log(title = "文件信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmFileInfo rmFileInfo)
{
List<RmFileInfo> list = rmFileInfoService.selectRmFileInfoList(rmFileInfo);
ExcelUtil<RmFileInfo> util = new ExcelUtil<RmFileInfo>(RmFileInfo.class);
util.exportExcel(response, list, "文件信息数据");
}
/**
* 获取文件信息详细信息
*/
@RequiresPermissions("rocketmq:info:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmFileInfoService.selectRmFileInfoById(id));
}
/**
* 新增文件信息
*/
@RequiresPermissions("rocketmq:info:add")
@Log(title = "文件信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmFileInfo rmFileInfo)
{
return toAjax(rmFileInfoService.insertRmFileInfo(rmFileInfo));
}
/**
* 修改文件信息
*/
@RequiresPermissions("rocketmq:info:edit")
@Log(title = "文件信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmFileInfo rmFileInfo)
{
return toAjax(rmFileInfoService.updateRmFileInfo(rmFileInfo));
}
/**
* 删除文件信息
*/
@RequiresPermissions("rocketmq:info:remove")
@Log(title = "文件信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmFileInfoService.deleteRmFileInfoByIds(ids));
}
}
@@ -0,0 +1,42 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmInitialMonitorItem;
import com.tongran.rocketmq.service.IRmInitialMonitorItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Map;
/**
* 基础监控项Controller
*
* @author gyt
* @date 2025-09-10
*/
@RestController
@RequestMapping("/initialMonitorItem")
public class RmInitialMonitorItemController extends BaseController
{
@Autowired
private IRmInitialMonitorItemService rmInitialMonitorItemService;
/**
* 查询监控项列表
*/
@RequiresPermissions("rocketmq:item:list")
@PostMapping("/list")
public AjaxResult list(@RequestBody RmInitialMonitorItem rmInitialMonitorItem)
{
Map<String, List<RmInitialMonitorItem>> map = rmInitialMonitorItemService.selectAllMsgList(rmInitialMonitorItem);
return success(map);
}
}
@@ -0,0 +1,201 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.domain.R;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.InnerAuth;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmMonitorPolicy;
import com.tongran.rocketmq.service.IRmMonitorPolicyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 资源监控策略Controller
*
* @author gyt
* @date 2025-09-10
*/
@RestController
@RequestMapping("/monitorPolicy")
public class RmMonitorPolicyController extends BaseController
{
@Autowired
private IRmMonitorPolicyService rmMonitorPolicyService;
/**
* 查询资源监控策略列表
*/
@RequiresPermissions("rocketmq:policy:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmMonitorPolicy.getPageNum());
pageDomain.setPageSize(rmMonitorPolicy.getPageSize());
startPage(pageDomain);
List<RmMonitorPolicy> list = rmMonitorPolicyService.selectRmMonitorPolicyList(rmMonitorPolicy);
return getDataTable(list);
}
/**
* 导出资源监控策略列表
*/
@RequiresPermissions("rocketmq:policy:export")
@Log(title = "资源监控策略", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, @RequestBody RmMonitorPolicy rmMonitorPolicy)
{
List<RmMonitorPolicy> list = rmMonitorPolicyService.selectRmMonitorPolicyList(rmMonitorPolicy);
ExcelUtil<RmMonitorPolicy> util = new ExcelUtil<RmMonitorPolicy>(RmMonitorPolicy.class);
util.showColumn(rmMonitorPolicy.getProperties());
util.exportExcel(response, list, "资源监控策略数据");
}
/**
* 获取资源监控策略详细信息
*/
@RequiresPermissions("rocketmq:policy:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmMonitorPolicyService.getRmMonitorPolicyMsgById(id));
}
/**
* 新增资源监控策略
*/
@RequiresPermissions("rocketmq:policy:add")
@Log(title = "资源监控策略", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
int rows = rmMonitorPolicyService.addRmMonitorPolicy(rmMonitorPolicy);
if(rows == -1){
return AjaxResult.error("资源监控策略新增失败,该资源组已绑定其他策略");
}
return toAjax(rows);
}
/**
* 修改资源监控策略
*/
@RequiresPermissions("rocketmq:policy:edit")
@Log(title = "资源监控策略", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
int rows = rmMonitorPolicyService.updateRmMonitorPolicy(rmMonitorPolicy);
if(rows == -1){
return AjaxResult.error("资源监控策略新增失败,该资源组已绑定其他策略");
}
return toAjax(rows);
}
/**
* 资源监控策略下发
*/
@RequiresPermissions("rocketmq:policy:edit")
@Log(title = "资源监控策略下发", businessType = BusinessType.UPDATE)
@GetMapping("/issuePolicy")
public AjaxResult issuePolicy(Long id)
{
return toAjax(rmMonitorPolicyService.issuePolicy(id));
}
/**
* 资源监控策略下发
*/
// @RequiresPermissions("rocketmq:policy:edit")
@Log(title = "issueSwitchPolicy", businessType = BusinessType.UPDATE)
@GetMapping("/issueSwitchPolicy")
public AjaxResult issueSwitchPolicy(Long id)
{
return toAjax(rmMonitorPolicyService.issueSwitchPolicy(id));
}
/**
* 删除监控模板
*/
@RequiresPermissions("rocketmq:policy:remove")
@Log(title = "资源监控策略", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmMonitorPolicyService.deleteRmMonitorPolicyByIds(ids));
}
/**
* 新增交换机监控策略
*/
@RequiresPermissions("rocketmq:policy:add")
@Log(title = "资源监控策略", businessType = BusinessType.INSERT)
@PostMapping("/addResourcePolicy")
public AjaxResult addResourcePolicy(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
int rows = rmMonitorPolicyService.addResourcePolicy(rmMonitorPolicy);
return toAjax(rows);
}
/**
* 修改交换机监控策略
*/
@RequiresPermissions("rocketmq:policy:update")
@Log(title = "资源监控策略", businessType = BusinessType.INSERT)
@PostMapping("/updateResourcePolicy")
public AjaxResult updateResourcePolicy(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
int rows = rmMonitorPolicyService.updateResourcePolicy(rmMonitorPolicy);
return toAjax(rows);
}
/**
* 策略下发,内部调用
* @param id
* @return
*/
@Log(title = "issueSwitchPolicy", businessType = BusinessType.UPDATE)
@GetMapping("/innerIssueSwitchPolicy")
@InnerAuth
public R<String> innerIssueSwitchPolicy(Long id)
{
rmMonitorPolicyService.issueSwitchPolicy(id);
return R.ok("优先级0策略下发成功");
}
/**
* 查询资源监控策略列表
*/
@PostMapping("/getPolicyMsgInner")
@InnerAuth
public R<List<RmMonitorPolicy>> getPolicyMsgInner(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
List<RmMonitorPolicy> list = rmMonitorPolicyService.selectRmMonitorPolicyList(rmMonitorPolicy);
return R.ok(list);
}
/**
* 修改资源监控策略
*/
@PostMapping("/updatePolicyMsgInner")
@InnerAuth
public R<Integer> updatePolicyMsgInner(@RequestBody RmMonitorPolicy rmMonitorPolicy)
{
int rows = rmMonitorPolicyService.updatePolicyMsgInner(rmMonitorPolicy);
return R.ok(rows);
}
/**
* 修改资源监控策略
*/
@GetMapping("/issueDefaultPolicyByClientId")
@InnerAuth
public R<Integer> issueDefaultPolicyByClientId(String clientId)
{
int rows = rmMonitorPolicyService.issueDefaultPolicyByClientId(clientId);
return R.ok(rows);
}
}
@@ -0,0 +1,115 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmMonitorTemplate;
import com.tongran.rocketmq.domain.vo.RmMonitorTemplateVo;
import com.tongran.rocketmq.service.IRmMonitorTemplateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
/**
* 监控模板Controller
*
* @author gyt
* @date 2025-09-09
*/
@RestController
@RequestMapping("/template")
public class RmMonitorTemplateController extends BaseController
{
@Autowired
private IRmMonitorTemplateService rmMonitorTemplateService;
/**
* 查询监控模板列表
*/
@RequiresPermissions("rocketmq:template:list")
@PostMapping("/list")
public TableDataInfo list(@RequestBody RmMonitorTemplate rmMonitorTemplate)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmMonitorTemplate.getPageNum());
pageDomain.setPageSize(rmMonitorTemplate.getPageSize());
startPage(pageDomain);
List<RmMonitorTemplate> list = rmMonitorTemplateService.selectRmMonitorTemplateList(rmMonitorTemplate);
return getDataTable(list);
}
/**
* 导出监控模板列表
*/
@RequiresPermissions("rocketmq:template:export")
@Log(title = "监控模板", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, @RequestBody RmMonitorTemplate rmMonitorTemplate)
{
List<RmMonitorTemplate> list = rmMonitorTemplateService.selectRmMonitorTemplateList(rmMonitorTemplate);
ExcelUtil<RmMonitorTemplate> util = new ExcelUtil<RmMonitorTemplate>(RmMonitorTemplate.class);
util.showColumn(rmMonitorTemplate.getProperties());
util.exportExcel(response, list, "监控模板数据");
}
/**
* 获取监控模板详细信息
*/
@RequiresPermissions("rocketmq:template:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmMonitorTemplateService.getTemplateMsgById(id));
}
/**
* 新增监控模板
*/
@RequiresPermissions("rocketmq:template:add")
@Log(title = "监控模板", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmMonitorTemplateVo rmMonitorTemplateVo)
{
return toAjax(rmMonitorTemplateService.addRmMonitorTemplate(rmMonitorTemplateVo));
}
/**
* 修改监控模板
*/
@RequiresPermissions("rocketmq:template:edit")
@Log(title = "监控模板", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmMonitorTemplateVo rmMonitorTemplateVo)
{
return toAjax(rmMonitorTemplateService.updateRmMonitorTemplate(rmMonitorTemplateVo));
}
/**
* 删除监控模板
*/
@RequiresPermissions("rocketmq:template:remove")
@Log(title = "监控模板", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmMonitorTemplateService.deleteRmMonitorTemplateByIds(ids));
}
/**
* 关联监控模板查询
*/
@RequiresPermissions("rocketmq:template:list")
@GetMapping("/getAllTemplate")
public AjaxResult getAllTemplate()
{
List<Map> list = rmMonitorTemplateService.getAllTemplate();
return success(list);
}
}
@@ -0,0 +1,119 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.domain.R;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.InnerAuth;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmNetworkInterface;
import com.tongran.rocketmq.service.IRmNetworkInterfaceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 客户端网络接口信息Controller
*
* @author gyt
* @date 2025-10-14
*/
@RestController
@RequestMapping("/networkInterface")
public class RmNetworkInterfaceController extends BaseController
{
@Autowired
private IRmNetworkInterfaceService rmNetworkInterfaceService;
/**
* 查询客户端网络接口信息列表
*/
@RequiresPermissions("rocketmq:networkInterface:list")
@PostMapping("/list")
public AjaxResult list(@RequestBody RmNetworkInterface rmNetworkInterface)
{
List<RmNetworkInterface> list = rmNetworkInterfaceService.selectRmNetworkInterfaceList(rmNetworkInterface);
return success(list);
}
/**
* 导出客户端网络接口信息列表
*/
@RequiresPermissions("rocketmq:networkInterface:export")
@Log(title = "客户端网络接口信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmNetworkInterface rmNetworkInterface)
{
List<RmNetworkInterface> list = rmNetworkInterfaceService.selectRmNetworkInterfaceList(rmNetworkInterface);
ExcelUtil<RmNetworkInterface> util = new ExcelUtil<RmNetworkInterface>(RmNetworkInterface.class);
util.exportExcel(response, list, "客户端网络接口信息数据");
}
/**
* 获取客户端网络接口信息详细信息
*/
@RequiresPermissions("rocketmq:networkInterface:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmNetworkInterfaceService.selectRmNetworkInterfaceById(id));
}
/**
* 新增客户端网络接口信息
*/
@RequiresPermissions("rocketmq:networkInterface:add")
@Log(title = "客户端网络接口信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmNetworkInterface rmNetworkInterface)
{
return toAjax(rmNetworkInterfaceService.insertRmNetworkInterface(rmNetworkInterface));
}
/**
* 修改客户端网络接口信息
*/
@RequiresPermissions("rocketmq:networkInterface:edit")
@Log(title = "客户端网络接口信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmNetworkInterface rmNetworkInterface)
{
return toAjax(rmNetworkInterfaceService.updateRmNetworkInterface(rmNetworkInterface));
}
/**
* 删除客户端网络接口信息
*/
@RequiresPermissions("rocketmq:networkInterface:remove")
@Log(title = "客户端网络接口信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmNetworkInterfaceService.deleteRmNetworkInterfaceByIds(ids));
}
/**
* 远程调用查询客户端网络接口信息列表
*/
@InnerAuth
@PostMapping("/getNetworkInterfaceList")
public R getNetworkInterfaceList(@RequestBody RmNetworkInterface rmNetworkInterface)
{
List<RmNetworkInterface> list = rmNetworkInterfaceService.selectRmNetworkInterfaceList(rmNetworkInterface);
return R.ok(list);
}
/**
* 远程调用修改客户端网络接口信息
*/
@InnerAuth
@PostMapping("/bindPublicIp")
public R<Integer> bindPublicIp(@RequestBody RmNetworkInterface rmNetworkInterface)
{
int rows = rmNetworkInterfaceService.bindPublicIp(rmNetworkInterface);
return R.ok(rows);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmPolicyDeviceDetails;
import com.tongran.rocketmq.service.IRmPolicyDeviceDetailsService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 客户端策略关联Controller
*
* @author gyt
* @date 2025-10-22
*/
@RestController
@RequestMapping("/policyDeviceDetails")
public class RmPolicyDeviceDetailsController extends BaseController
{
@Autowired
private IRmPolicyDeviceDetailsService rmPolicyDeviceDetailsService;
/**
* 查询客户端策略关联列表
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:list")
@GetMapping("/list")
public TableDataInfo list(RmPolicyDeviceDetails rmPolicyDeviceDetails)
{
startPage();
List<RmPolicyDeviceDetails> list = rmPolicyDeviceDetailsService.selectRmPolicyDeviceDetailsList(rmPolicyDeviceDetails);
return getDataTable(list);
}
/**
* 导出客户端策略关联列表
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:export")
@Log(title = "客户端策略关联", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmPolicyDeviceDetails rmPolicyDeviceDetails)
{
List<RmPolicyDeviceDetails> list = rmPolicyDeviceDetailsService.selectRmPolicyDeviceDetailsList(rmPolicyDeviceDetails);
ExcelUtil<RmPolicyDeviceDetails> util = new ExcelUtil<RmPolicyDeviceDetails>(RmPolicyDeviceDetails.class);
util.exportExcel(response, list, "客户端策略关联数据");
}
/**
* 获取客户端策略关联详细信息
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmPolicyDeviceDetailsService.selectRmPolicyDeviceDetailsById(id));
}
/**
* 新增客户端策略关联
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:add")
@Log(title = "客户端策略关联", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmPolicyDeviceDetails rmPolicyDeviceDetails)
{
return toAjax(rmPolicyDeviceDetailsService.insertRmPolicyDeviceDetails(rmPolicyDeviceDetails));
}
/**
* 修改客户端策略关联
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:edit")
@Log(title = "客户端策略关联", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmPolicyDeviceDetails rmPolicyDeviceDetails)
{
return toAjax(rmPolicyDeviceDetailsService.updateRmPolicyDeviceDetails(rmPolicyDeviceDetails));
}
/**
* 删除客户端策略关联
*/
@RequiresPermissions("rocketmq:policyDeviceDetails:remove")
@Log(title = "客户端策略关联", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmPolicyDeviceDetailsService.deleteRmPolicyDeviceDetailsByIds(ids));
}
}
@@ -0,0 +1,56 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.web.page.PageDomain;
import com.tongran.common.core.web.page.TableDataInfo;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmResourceRemote;
import com.tongran.rocketmq.service.IRmResourceRemoteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 资源远程管理Controller
*
* @author gyt
* @date 2025-09-15
*/
@RestController
@RequestMapping("/remote")
public class RmResourceRemoteController extends BaseController
{
@Autowired
private IRmResourceRemoteService rmResourceRemoteService;
/**
* 获取资源远程管理详细信息
*/
@RequiresPermissions("rocketmq:remote:query")
@PostMapping(value = "/getScriptResultBySn")
public AjaxResult getScriptResultBySn(@RequestBody RmResourceRemote rmResourceRemote)
{
return success(rmResourceRemoteService.getScriptResultBySn(rmResourceRemote));
}
/**
* 获取资源远程管理详细信息 -- 分页
*/
@RequiresPermissions("rocketmq:remote:query")
@PostMapping(value = "/getScriptResultByScriptId")
public TableDataInfo getScriptResultByScriptId(@RequestBody RmResourceRemote rmResourceRemote)
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(rmResourceRemote.getPageNum());
pageDomain.setPageSize(rmResourceRemote.getPageSize());
startPage(pageDomain);
List<Map<String, Object>> list = rmResourceRemoteService.getScriptResultByScriptId(rmResourceRemote);
return getDataTable(list);
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmTemplateLinux;
import com.tongran.rocketmq.service.IRmTemplateLinuxService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* Linux系统监控项Controller
*
* @author gyt
* @date 2025-09-09
*/
@RestController
@RequestMapping("/linux")
public class RmTemplateLinuxController extends BaseController
{
@Autowired
private IRmTemplateLinuxService rmTemplateLinuxService;
/**
* 查询Linux系统监控项列表
*/
@RequiresPermissions("rocketmq:linux:list")
@GetMapping("/list")
public TableDataInfo list(RmTemplateLinux rmTemplateLinux)
{
startPage();
List<RmTemplateLinux> list = rmTemplateLinuxService.selectRmTemplateLinuxList(rmTemplateLinux);
return getDataTable(list);
}
/**
* 导出Linux系统监控项列表
*/
@RequiresPermissions("rocketmq:linux:export")
@Log(title = "Linux系统监控项", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmTemplateLinux rmTemplateLinux)
{
List<RmTemplateLinux> list = rmTemplateLinuxService.selectRmTemplateLinuxList(rmTemplateLinux);
ExcelUtil<RmTemplateLinux> util = new ExcelUtil<RmTemplateLinux>(RmTemplateLinux.class);
util.exportExcel(response, list, "Linux系统监控项数据");
}
/**
* 获取Linux系统监控项详细信息
*/
@RequiresPermissions("rocketmq:linux:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmTemplateLinuxService.selectRmTemplateLinuxById(id));
}
/**
* 新增Linux系统监控项
*/
@RequiresPermissions("rocketmq:linux:add")
@Log(title = "Linux系统监控项", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmTemplateLinux rmTemplateLinux)
{
return toAjax(rmTemplateLinuxService.insertRmTemplateLinux(rmTemplateLinux));
}
/**
* 修改Linux系统监控项
*/
@RequiresPermissions("rocketmq:linux:edit")
@Log(title = "Linux系统监控项", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmTemplateLinux rmTemplateLinux)
{
return toAjax(rmTemplateLinuxService.updateRmTemplateLinux(rmTemplateLinux));
}
/**
* 删除Linux系统监控项
*/
@RequiresPermissions("rocketmq:linux:remove")
@Log(title = "Linux系统监控项", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmTemplateLinuxService.deleteRmTemplateLinuxByIds(ids));
}
}
@@ -0,0 +1,104 @@
package com.tongran.rocketmq.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tongran.common.log.annotation.Log;
import com.tongran.common.log.enums.BusinessType;
import com.tongran.common.security.annotation.RequiresPermissions;
import com.tongran.rocketmq.domain.RmTemplateSwitch;
import com.tongran.rocketmq.service.IRmTemplateSwitchService;
import com.tongran.common.core.web.controller.BaseController;
import com.tongran.common.core.web.domain.AjaxResult;
import com.tongran.common.core.utils.poi.ExcelUtil;
import com.tongran.common.core.web.page.TableDataInfo;
/**
* 交换机监控模板Controller
*
* @author gyt
* @date 2025-09-09
*/
@RestController
@RequestMapping("/switch")
public class RmTemplateSwitchController extends BaseController
{
@Autowired
private IRmTemplateSwitchService rmTemplateSwitchService;
/**
* 查询交换机监控模板列表
*/
@RequiresPermissions("rocketmq:switch:list")
@GetMapping("/list")
public TableDataInfo list(RmTemplateSwitch rmTemplateSwitch)
{
startPage();
List<RmTemplateSwitch> list = rmTemplateSwitchService.selectRmTemplateSwitchList(rmTemplateSwitch);
return getDataTable(list);
}
/**
* 导出交换机监控模板列表
*/
@RequiresPermissions("rocketmq:switch:export")
@Log(title = "交换机监控模板", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, RmTemplateSwitch rmTemplateSwitch)
{
List<RmTemplateSwitch> list = rmTemplateSwitchService.selectRmTemplateSwitchList(rmTemplateSwitch);
ExcelUtil<RmTemplateSwitch> util = new ExcelUtil<RmTemplateSwitch>(RmTemplateSwitch.class);
util.exportExcel(response, list, "交换机监控模板数据");
}
/**
* 获取交换机监控模板详细信息
*/
@RequiresPermissions("rocketmq:switch:query")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(rmTemplateSwitchService.selectRmTemplateSwitchById(id));
}
/**
* 新增交换机监控模板
*/
@RequiresPermissions("rocketmq:switch:add")
@Log(title = "交换机监控模板", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody RmTemplateSwitch rmTemplateSwitch)
{
return toAjax(rmTemplateSwitchService.insertRmTemplateSwitch(rmTemplateSwitch));
}
/**
* 修改交换机监控模板
*/
@RequiresPermissions("rocketmq:switch:edit")
@Log(title = "交换机监控模板", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody RmTemplateSwitch rmTemplateSwitch)
{
return toAjax(rmTemplateSwitchService.updateRmTemplateSwitch(rmTemplateSwitch));
}
/**
* 删除交换机监控模板
*/
@RequiresPermissions("rocketmq:switch:remove")
@Log(title = "交换机监控模板", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids)
{
return toAjax(rmTemplateSwitchService.deleteRmTemplateSwitchByIds(ids));
}
}
@@ -0,0 +1,139 @@
package com.tongran.rocketmq.controller;
import com.tongran.common.security.annotation.InnerAuth;
import com.tongran.rocketmq.producer.MessageProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 消息测试类Controller
*/
@RestController
@RequestMapping("/api/rocketMessage")
public class RocketMqController {
/**
* 发送同步消息
*/
@PostMapping("/sendSynchronizeMessage")
private Map sendSynchronizeMessage(){
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法
SendResult sendResult = messageProducer.sendSynchronizeMessage("order-message","order_message_tag","title","content");
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
/**
* 发送单向消息
*/
@PostMapping("/sendOnewayMessage")
private Map sendOnewayMessage(@RequestParam("topic") String topic,@RequestParam("tag") String tag,@RequestParam("key") String key,@RequestParam("value") String value){
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
messageProducer.sendOnewayMessage("order-message","order_timeout_tag","title","content");
Map<String,Object> result = new HashMap<>();
result.put("msg","发送成功");
result.put("code",200);
return result;
}
/**
* 批量发送消息
*/
@PostMapping("/sendBatchMessage")
private Map sendBatchMessage(){
// 根据实际需求创建消息列表并返回
List<Message> messages = new ArrayList<>();
// 添加消息到列表
messages.add(new Message("order-message", "order_timeout_tag", "Message 1".getBytes()));
messages.add(new Message("order-message", "order_timeout_tag", "Message 2".getBytes()));
messages.add(new Message("order-message", "order_timeout_tag", "Message 3".getBytes()));
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
SendResult sendResult = messageProducer.sendBatchMessage(messages);
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
/**
* 发送事物消息
*/
@PostMapping("/sendThingMessage")
private Map sendThingMessage(@RequestParam("topic") String topic,@RequestParam("tag") String tag,@RequestParam("key") String key,@RequestParam("value") String value){
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
SendResult sendResult = messageProducer.sendThingMessage("order-message","order_timeout_tag","title","content");
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
/**
* 发送有序的消息
*/
@PostMapping("/sendOrderlyMessage")
private Map sendOrderlyMessage(){
// 根据实际需求创建消息列表并返回
List<Message> messages = new ArrayList<>();
// 添加消息到列表
messages.add(new Message("order-message", "order_timeout_tag", "Message 1".getBytes()));
messages.add(new Message("order-message", "order_timeout_tag", "Message 2".getBytes()));
messages.add(new Message("order-message", "order_timeout_tag", "Message 3".getBytes()));
Integer messageQueueNumber = 3;
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
SendResult sendResult = messageProducer.sendOrderlyMessage(messages,messageQueueNumber);
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
/**
* 发送延迟消息
*/
@PostMapping("/sendDelayMessage")
private Map sendDelayMessage(@RequestParam("topic") String topic,@RequestParam("tag") String tag,@RequestParam("key") String key,@RequestParam("value") String value){
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
SendResult sendResult = messageProducer.sendDelayMessage("order-message","order_timeout_tag","title","content",4);
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
/**
* 发送异步的消息
*/
@InnerAuth
@PostMapping("/sendAsyncProducerMessage")
private Map sendAsyncProducerMessage(@RequestParam("topic") String topic,@RequestParam("tag") String tag,@RequestParam("key") String key,@RequestParam("value") String value){
MessageProducer messageProducer = new MessageProducer();
//调用MessageProducer配置好的消息方法 topic需要你根据你们业务定制相应的
SendResult sendResult = messageProducer.sendAsyncProducerMessage(topic,tag,key,value);
Map<String,Object> result = new HashMap<>();
result.put("data",sendResult);
return result;
}
}