package org.jeecg.modules.iot.controller;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.aspect.annotation.AutoLog;
|
import org.jeecg.common.system.base.controller.JeecgController;
|
import org.jeecg.common.system.query.QueryGenerator;
|
import org.jeecg.modules.iot.entity.*;
|
import org.jeecg.modules.iot.entity.xmlEntity.*;
|
import org.jeecg.modules.iot.entity.xmlEntity.ControlSystem;
|
import org.jeecg.modules.iot.service.*;
|
import org.jeecg.modules.iot.util.HttpClientUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.util.*;
|
|
|
/**
|
* @Description: 设备
|
* @Author: cuikaidong
|
* @Date: 2024-12-23
|
* @Version: V1.0
|
*/
|
@Api(tags = "设备")
|
@RestController
|
@RequestMapping("/equipment")
|
@Slf4j
|
public class EquipmentController extends JeecgController<Equipment, IEquipmentService> {
|
|
@Autowired
|
private IEquipmentService equipmentService;
|
@Autowired
|
private IServerDeployService serverDeployService;
|
@Autowired
|
private IParameterGroupService parameterGroupService;
|
@Autowired
|
private IControlSystemService controlSystemService;
|
|
/**
|
* 分页列表查询
|
*
|
* @param equipment
|
* @param pageNo
|
* @param pageSize
|
* @param serverCode
|
* @return
|
*/
|
@ApiOperation(value = "设备-分页列表查询", notes = "设备-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<?> queryPageList(Equipment equipment,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
@RequestParam(name = "serverCode", required = false) String serverCode,
|
HttpServletRequest req) {
|
QueryWrapper<Equipment> queryWrapper = QueryGenerator.initQueryWrapper(equipment, req.getParameterMap());
|
Page<Equipment> page = new Page<>(pageNo, pageSize);
|
IPage<Equipment> pageList = equipmentService.page(page, queryWrapper);
|
List<Equipment> records = pageList.getRecords();
|
return Result.ok(pageList);
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
@GetMapping(value = "/queryById")
|
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
|
Equipment equipment = equipmentService.getById(id);
|
return Result.ok(equipment);
|
}
|
|
/**
|
* 添加
|
*
|
* @param equipment
|
* @return
|
*/
|
@AutoLog(value = "实设备-添加")
|
@ApiOperation(value = "实设备-添加", notes = "实设备-添加")
|
@PostMapping(value = "/add")
|
public Result<?> add(@RequestBody Equipment equipment) {
|
// 验证编码名称是否重复
|
if (equipmentService.findEquipmentByName(equipment,1)) {
|
return Result.error("设备名称已存在！");
|
}
|
if (equipmentService.findEquipmentByCode(equipment)) {
|
return Result.error("设备编号已存在！");
|
}
|
// 分类
|
equipment.setEquipmentType(1);
|
// 订阅主题
|
ServerDeploy serverDeploy = serverDeployService.getById(equipment.getServerId());
|
// 验证设备编号和设备名称
|
equipmentService.save(equipment);
|
equipment.setReadTopic("IOT/" + serverDeploy.getServerCode() + "/ActualDevices/" + equipment.getEqptCode() + "/Read");
|
equipment.setWriteTopic("IOT/" + serverDeploy.getServerCode() + "/ActualDevices/" + equipment.getEqptCode() + "/Write");
|
equipmentService.updateById(equipment);
|
return Result.ok("添加成功！");
|
}
|
|
/**
|
* 虚设备
|
*
|
* @param equipment
|
* @return
|
*/
|
@AutoLog(value = "虚设备-添加")
|
@ApiOperation(value = "虚设备-添加", notes = "虚设备-添加")
|
@PostMapping(value = "/add/empty")
|
public Result<?> addEmpty(@RequestBody Equipment equipment) {
|
return equipmentService.addEmpty(equipment);
|
}
|
|
/**
|
* 编辑
|
*
|
* @param equipment
|
* @return
|
*/
|
@AutoLog(value = "设备-编辑")
|
@ApiOperation(value = "设备-编辑", notes = "设备-编辑")
|
@PutMapping(value = "/edit")
|
public Result<?> edit(@RequestBody Equipment equipment) {
|
equipment.setCreateTime(new Date());
|
// 验证是否是虚设备
|
if (equipment.getEquipmentType() == 0) {
|
Equipment equipmentById = equipmentService.getById(equipment.getId());
|
// 验证是否编辑了虚设备名称
|
if (!equipment.getEqptName().equals(equipmentById.getEqptName())){
|
ServerDeploy serverDeploy = serverDeployService.getById(equipment.getServerId());
|
Map<String, String> param = new HashMap<>();
|
// 发送文件地址
|
param.put("path", "D:/iot/" + serverDeploy.getServerCode() + "/script");
|
HttpClientUtil.doGet("http://localhost:3002/ScriptCompiler/ProjectPath", param);
|
param.clear();
|
// 删除原来的文件
|
param.put("id", equipmentById.getEqptCode());
|
HttpClientUtil.doGet("http://localhost:3002/ScriptCompiler/DeleteDevicescript", param);
|
param.clear();
|
// 添加新文件
|
param.put("id", equipment.getEqptCode());
|
HttpClientUtil.doGet("http://localhost:3002/ScriptCompiler/AddDevicescript", param);
|
}
|
}
|
equipmentService.updateById(equipment);
|
return Result.ok("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "设备-通过id删除")
|
@ApiOperation(value = "设备-通过id删除", notes = "设备-通过id删除")
|
@DeleteMapping(value = "/delete")
|
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
|
List<ParameterGroup> parameterGroupList = parameterGroupService.findParameterGroupByServerId(id);
|
if (parameterGroupList.size() > 0) {
|
return Result.error("删除失败，请先删除参数组!");
|
}
|
Equipment equipment = equipmentService.getById(id);
|
if (equipment.getEquipmentType().equals(0)) {
|
ServerDeploy serverDeploy = serverDeployService.getById(equipment.getServerId());
|
//删除虚设备时调用
|
Map<String, String> param = new HashMap<>();
|
param.put("path", "D:/iot/" + serverDeploy.getServerCode() + "/script");
|
HttpClientUtil.doGet("http://localhost:3002/ScriptCompiler/ProjectPath", param);
|
param.clear();
|
param.put("id", equipment.getEqptCode());
|
HttpClientUtil.doGet("http://localhost:3002/ScriptCompiler/DeleteDevicescript", param);
|
}
|
equipmentService.removeById(id);
|
return Result.ok("删除成功!");
|
}
|
|
/**
|
* 根据服务器id查询设备订阅列表
|
*
|
* @return
|
*/
|
@ApiOperation(value = "根据服务器id查询设备订阅列表", notes = "根据服务器id查询设备订阅列表")
|
@GetMapping(value = "/subscribe")
|
public Result<?> queryEquipmentSubscribe(@RequestParam(name = "id") String id) {
|
Object[] subscribeList = equipmentService.queryEquipmentSubscribeList(id);
|
return Result.ok(subscribeList);
|
}
|
|
/**
|
* 查询系统类型
|
*
|
* @return
|
*/
|
@ApiOperation(value = "查询系统类型", notes = "查询系统类型")
|
@GetMapping(value = "/querySystemType")
|
public Result<?> querySystemType() {
|
List<SystemType> systemTypes = equipmentService.findProjectCode();
|
return Result.ok(systemTypes);
|
}
|
|
/**
|
* 根据系统类型查询控制系统列表
|
*
|
* @return
|
*/
|
@ApiOperation(value = "查询控制系统列表", notes = "查询控制系统列表")
|
@GetMapping(value = "/queryControlSystem")
|
public Result<?> queryControlSystem(@RequestParam(name = "type") String type) {
|
List<ControlSystem> controlSystems = equipmentService.findControlSystems(type);
|
return Result.ok(controlSystems);
|
}
|
|
/**
|
* 查询字节顺序列表
|
*
|
* @return
|
*/
|
@ApiOperation(value = "查询字节顺序列表", notes = "查询字节顺序列表")
|
@GetMapping(value = "/queryByteOrder")
|
public Result<?> queryByteOrder() {
|
List<ByteOrder> byteOrders = equipmentService.findByteOrder();
|
return Result.ok(byteOrders);
|
}
|
|
/**
|
* 查询参数类型列表
|
*
|
* @return
|
*/
|
@ApiOperation(value = "查询参数类型列表", notes = "查询参数类型列表")
|
@GetMapping(value = "/querySystemDataType")
|
public Result<?> querySystemDataType() {
|
List<SystemDataType> systemDataTypeList = equipmentService.findSystemDataTypeList();
|
return Result.ok(systemDataTypeList);
|
}
|
|
/**
|
* 根据参数组id查询设备采集参数
|
*
|
* @return
|
*/
|
@ApiOperation(value = "根据参数组id查询设备采集参数", notes = "根据参数组id查询设备采集参数")
|
@GetMapping(value = "/queryParameter")
|
public Result<?> queryParameter(@RequestParam(name = "id") String id) {
|
List<Parameter> controlSystems = equipmentService.findParameterById(id);
|
return Result.ok(controlSystems);
|
}
|
/**
|
* 根据参数组id查询设备自定义采集参数
|
*
|
* @return
|
*/
|
@ApiOperation(value = "根据参数组id查询设备自定义采集参数", notes = "根据参数组id查询设备自定义采集参数")
|
@GetMapping(value = "/customize/queryParameter")
|
public Result<?> queryParameterCustomize(@RequestParam(name = "id") String id) {
|
List<Parameter> controlSystems = equipmentService.findParameterCustomizeById(id);
|
return Result.ok(controlSystems);
|
}
|
|
/**
|
* 根据参数组id查询设备采集参数类型
|
*
|
* @return
|
*/
|
@ApiOperation(value = "根据参数组id查询设备采集参数类型", notes = "根据参数组id查询设备采集参数类型")
|
@GetMapping(value = "/queryDataType")
|
public Result<?> queryDataType(@RequestParam(name = "id") String id) {
|
List<Parameter> parameters = equipmentService.findDataTypeById(id);
|
return Result.ok(parameters);
|
}
|
|
/**
|
* 根据虚设备id查询设备分类树
|
*
|
* @return projectClassifyList
|
*/
|
@AutoLog(value = "根据虚设备id查询设备分类树")
|
@ApiOperation(value = "根据虚设备id查询设备分类树", notes = "查询项目分类树结构")
|
@GetMapping(value = "/tree")
|
public Result<?> queryPageList(@RequestParam(name = "id") String id) {
|
Equipment equipment = equipmentService.getById(id);
|
ServerDeploy serverDeploy = serverDeployService.getById(equipment.getServerId());
|
// 树图标
|
Map<String, String> iconIot = new HashMap<>();
|
iconIot.put("icon", "iot");
|
Map<String, String> iconProject = new HashMap<>();
|
iconProject.put("icon", "classify");
|
Map<String, String> iconProject1 = new HashMap<>();
|
iconProject1.put("icon", "project");
|
Map<String, String> iconEmpty = new HashMap<>();
|
iconEmpty.put("icon", "");
|
Map<String, String> iconSolid = new HashMap<>();
|
iconSolid.put("icon", "");
|
// 查询数据
|
List<Equipment> equipmentList = equipmentService.findEquipmentByServerId(serverDeploy.getId());
|
List<ParameterGroup> groupList = parameterGroupService.findParameterGroupByServerId(serverDeploy.getId());
|
// 树结构
|
List<IotTree> trees1 = new ArrayList<>();
|
List<IotTree> treeList = new ArrayList<>();
|
|
IotTree iotTree = new IotTree();
|
iotTree.setTitle(serverDeploy.getServerName());
|
iotTree.setKey("fwq_" + serverDeploy.getServerCode());
|
iotTree.setSlots(iconIot);
|
|
|
// 遍历设备信息
|
equipmentList.forEach(eq -> {
|
IotTree emptyEquipment = new IotTree();
|
emptyEquipment.setTitle(eq.getEqptName());
|
List<IotTree> treeList4 = new ArrayList<>();// 参数组
|
// 遍历参数组信息
|
groupList.forEach(g -> {
|
if (eq.getId().equals(g.getEquipmentId())) {
|
IotTree groupTree = new IotTree();
|
groupTree.setTitle(g.getName());
|
groupTree.setKey("ssb_" + g.getId());
|
groupTree.setSlots(iconSolid);
|
treeList4.add(groupTree);
|
}
|
});
|
if (serverDeploy.getId().equals(eq.getServerId()) && eq.getEquipmentType().equals(1)) {
|
emptyEquipment.setSlots(iconSolid);
|
emptyEquipment.setKey("group_" + eq.getId());
|
emptyEquipment.setChildren(treeList4);
|
trees1.add(emptyEquipment);
|
}
|
iotTree.setChildren(treeList4);
|
});
|
|
iotTree.setChildren(trees1);
|
treeList.add(iotTree);
|
return Result.ok(treeList);
|
}
|
|
/**
|
* 根据服务器id查询服务器下设备分类树
|
*
|
* @return projectClassifyList
|
*/
|
@AutoLog(value = "根据服务器id查询服务器下设备分类树")
|
@ApiOperation(value = "根据服务器id查询服务器下设备分类树", notes = "根据服务器id查询服务器下设备分类树")
|
@GetMapping(value = "/tree/collect")
|
public Result<?> queryCollectTree(@RequestParam(name = "id") String id) {
|
ServerDeploy serverDeploy = serverDeployService.getById(id);
|
// 树图标
|
Map<String, String> iconProject1 = new HashMap<>(); // 服务器图标
|
iconProject1.put("icon", "project");
|
Map<String, String> iconEmpty = new HashMap<>();
|
iconEmpty.put("icon", "empty");
|
Map<String, String> iconSolid = new HashMap<>();
|
iconSolid.put("icon", "solid");
|
Map<String, String> iconParameter = new HashMap<>();
|
iconParameter.put("icon", "");
|
// 查询数据
|
List<Equipment> equipmentList = equipmentService.findEquipmentByServerId(serverDeploy.getId());
|
List<ParameterGroup> groupList = parameterGroupService.findParameterGroupByServerId(serverDeploy.getId());
|
// 树结构
|
List<IotTree> trees2 = new ArrayList<>();
|
List<IotTree> treeList = new ArrayList<>();
|
|
IotTree iotTree = new IotTree();
|
iotTree.setTitle(serverDeploy.getServerName());
|
iotTree.setKey("fwq_" + serverDeploy.getServerCode());
|
iotTree.setSlots(iconProject1);
|
List<IotTree> treeList1 = new ArrayList<>();// 实设备
|
List<IotTree> treeList2 = new ArrayList<>(); //虚设备
|
// 实设备添加
|
IotTree empty = new IotTree();
|
empty.setTitle("实设备");
|
empty.setKey("solid_" + serverDeploy.getServerCode());
|
empty.setSlots(iconParameter);
|
// 虚设备添加
|
IotTree solid = new IotTree();
|
solid.setTitle("虚设备");
|
solid.setKey("empty_" + serverDeploy.getServerCode());
|
solid.setSlots(iconParameter);
|
// 遍历设备信息
|
equipmentList.forEach(eq -> {
|
IotTree emptyEquipment = new IotTree();
|
emptyEquipment.setTitle(eq.getEqptName());
|
List<IotTree> treeList4 = new ArrayList<>();// 参数组
|
// 遍历参数组信息
|
groupList.forEach(g -> {
|
if (eq.getId().equals(g.getEquipmentId())) {
|
IotTree groupTree = new IotTree();
|
groupTree.setTitle(g.getName());
|
groupTree.setKey("ssb_" + g.getId());
|
groupTree.setSlots(iconParameter);
|
treeList4.add(groupTree);
|
}
|
});
|
if (serverDeploy.getId().equals(eq.getServerId()) && eq.getEquipmentType().equals(1)) {
|
emptyEquipment.setSlots(iconSolid);
|
emptyEquipment.setKey("group_" + eq.getId());
|
emptyEquipment.setChildren(treeList4);
|
treeList1.add(emptyEquipment);
|
} else if (serverDeploy.getId().equals(eq.getServerId()) && eq.getEquipmentType().equals(0)) {
|
emptyEquipment.setKey("xxb_" + eq.getId());
|
emptyEquipment.setSlots(iconEmpty);
|
treeList2.add(emptyEquipment);
|
}
|
|
});
|
solid.setChildren(treeList2);
|
empty.setChildren(treeList1);
|
trees2.add(empty);
|
trees2.add(solid);
|
iotTree.setChildren(trees2);
|
treeList.add(iotTree);
|
return Result.ok(treeList);
|
}
|
|
/**
|
* 查询控制系统信息列表
|
*
|
* @return
|
*/
|
@ApiOperation(value = "查询控制系统信息列表", notes = "查询控制系统信息列表")
|
@GetMapping(value = "/findControlSystem")
|
public Result<?> findControlSystem() {
|
return Result.ok(controlSystemService.list());
|
}
|
}
|
