package com.mes.device.controller;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.mes.device.entity.DeviceConfig;
|
import com.mes.device.request.DeviceConfigRequest;
|
import com.mes.device.service.DeviceConfigService;
|
import com.mes.device.vo.DeviceConfigVO;
|
import com.mes.device.vo.StatisticsVO;
|
import com.mes.vo.Result;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import io.swagger.annotations.ApiParam;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.validation.Valid;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 设备配置管理控制器
|
*
|
* @author mes
|
* @since 2024-10-30
|
*/
|
@Slf4j
|
@RestController
|
@RequestMapping("device/config")
|
@Api(tags = "设备配置管理")
|
public class DeviceConfigController {
|
|
@Autowired
|
private DeviceConfigService deviceConfigService;
|
|
@Autowired
|
private ObjectMapper objectMapper;
|
|
/**
|
* 创建设备配置
|
*/
|
@PostMapping("/devices")
|
@ApiOperation("创建设备配置")
|
public Result<DeviceConfig> createDevice(
|
@Valid @RequestBody DeviceConfig deviceConfig) {
|
try {
|
boolean success = deviceConfigService.createDevice(deviceConfig);
|
if (success) {
|
// 创建成功后，重新获取设备对象
|
DeviceConfig created = deviceConfigService.getDeviceByCode(deviceConfig.getDeviceCode());
|
return Result.success(created);
|
} else {
|
return Result.error("设备配置已存在");
|
}
|
} catch (Exception e) {
|
log.error("创建设备配置失败", e);
|
return Result.error("创建设备配置失败");
|
}
|
}
|
|
/**
|
* 更新设备配置
|
*/
|
@PostMapping("/devices/update")
|
@ApiOperation("更新设备配置")
|
public Result<DeviceConfig> updateDevice(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
DeviceConfig deviceConfig;
|
Object deviceConfigObj = request.getDeviceConfig();
|
|
// 如果 deviceConfig 是 Map 类型（JSON 反序列化后的 LinkedHashMap），需要转换为 DeviceConfig
|
if (deviceConfigObj instanceof Map) {
|
deviceConfig = objectMapper.convertValue(deviceConfigObj, DeviceConfig.class);
|
} else if (deviceConfigObj instanceof DeviceConfig) {
|
deviceConfig = (DeviceConfig) deviceConfigObj;
|
} else {
|
log.error("不支持的 deviceConfig 类型: {}", deviceConfigObj != null ? deviceConfigObj.getClass() : "null");
|
return Result.error("设备配置数据格式错误");
|
}
|
|
deviceConfig.setId(request.getDeviceId());
|
boolean success = deviceConfigService.updateDevice(deviceConfig);
|
if (success) {
|
// 更新成功后，重新获取设备对象
|
DeviceConfig updated = deviceConfigService.getDeviceById(request.getDeviceId());
|
return Result.success(updated);
|
} else {
|
return Result.error("设备配置不存在");
|
}
|
} catch (Exception e) {
|
log.error("更新设备配置失败", e);
|
return Result.error("更新设备配置失败: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 删除设备配置
|
*/
|
@PostMapping("/devices/delete")
|
@ApiOperation("删除设备配置")
|
public Result<Void> deleteDevice(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
deviceConfigService.deleteDevice(request.getDeviceId());
|
return Result.success(null);
|
} catch (Exception e) {
|
log.error("删除设备配置失败", e);
|
return Result.error("删除设备配置失败");
|
}
|
}
|
|
/**
|
* 根据ID获取设备配置
|
*/
|
@PostMapping("/devices/detail")
|
@ApiOperation("获取设备配置详情")
|
public Result<DeviceConfig> getDeviceById(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
DeviceConfig device = deviceConfigService.getDeviceById(request.getDeviceId());
|
return Result.success(device);
|
} catch (Exception e) {
|
log.error("获取设备配置失败", e);
|
return Result.error("获取设备配置失败");
|
}
|
}
|
|
/**
|
* 分页查询设备配置列表
|
*/
|
@PostMapping("/devices/list")
|
@ApiOperation("分页查询设备配置")
|
public Result<Page<DeviceConfigVO.DeviceInfo>> getDeviceList(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
Page<DeviceConfigVO.DeviceInfo> pageResult = deviceConfigService.getDeviceList(
|
request.getProjectId(),
|
request.getDeviceType(),
|
request.getDeviceStatus(),
|
request.getKeyword(),
|
request.getPage() != null ? request.getPage() : 1,
|
request.getSize() != null ? request.getSize() : 10);
|
return Result.success(pageResult);
|
} catch (Exception e) {
|
log.error("查询设备配置列表失败", e);
|
return Result.error("查询设备配置列表失败");
|
}
|
}
|
|
/**
|
* 启用设备
|
*/
|
@PostMapping("/devices/enable")
|
@ApiOperation("启用设备")
|
public Result<Void> enableDevice(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
deviceConfigService.enableDevice(request.getDeviceId());
|
return Result.success(null);
|
} catch (Exception e) {
|
log.error("启用设备失败", e);
|
return Result.error("启用设备失败");
|
}
|
}
|
|
/**
|
* 禁用设备
|
*/
|
@PostMapping("/devices/disable")
|
@ApiOperation("禁用设备")
|
public Result<Void> disableDevice(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
deviceConfigService.disableDevice(request.getDeviceId());
|
return Result.success(null);
|
} catch (Exception e) {
|
log.error("禁用设备失败", e);
|
return Result.error("禁用设备失败");
|
}
|
}
|
|
/**
|
* 批量启用设备
|
*/
|
@PostMapping("/devices/batch-enable")
|
@ApiOperation("批量启用设备")
|
public Result<Void> batchEnableDevices(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
deviceConfigService.batchEnableDevices(request.getDeviceIds());
|
return Result.success(null);
|
} catch (Exception e) {
|
log.error("批量启用设备失败", e);
|
return Result.error("批量启用设备失败");
|
}
|
}
|
|
/**
|
* 批量禁用设备
|
*/
|
@PostMapping("/devices/batch-disable")
|
@ApiOperation("批量禁用设备")
|
public Result<Void> batchDisableDevices(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
deviceConfigService.batchDisableDevices(request.getDeviceIds());
|
return Result.success(null);
|
} catch (Exception e) {
|
log.error("批量禁用设备失败", e);
|
return Result.error("批量禁用设备失败");
|
}
|
}
|
|
/**
|
* 获取设备统计信息
|
*/
|
@PostMapping("/statistics/devices")
|
@ApiOperation("获取设备统计信息")
|
public Result<StatisticsVO.DeviceStatistics> getDeviceStatistics(
|
@ApiParam("设备配置请求") @RequestBody(required = false) DeviceConfigRequest request) {
|
try {
|
StatisticsVO.DeviceStatistics statistics = deviceConfigService.getDeviceStatistics(request != null ? request.getProjectId() : null);
|
return Result.success(statistics);
|
} catch (Exception e) {
|
log.error("获取设备统计信息失败", e);
|
return Result.error("获取设备统计信息失败");
|
}
|
}
|
|
/**
|
* 检查设备编码是否已存在
|
*/
|
@PostMapping("/devices/check-code")
|
@ApiOperation("检查设备编码")
|
public Result<Boolean> checkDeviceCodeExists(
|
@ApiParam("设备配置请求") @RequestBody DeviceConfigRequest request) {
|
try {
|
boolean exists = deviceConfigService.isDeviceCodeExists(request.getDeviceCode(), request.getDeviceId());
|
return Result.success(exists);
|
} catch (Exception e) {
|
log.error("检查设备编码失败", e);
|
return Result.error("检查设备编码失败");
|
}
|
}
|
|
/**
|
* 获取设备类型列表
|
*/
|
@PostMapping("/devices/types")
|
@ApiOperation("获取设备类型列表")
|
public Result<List<String>> getDeviceTypes(@RequestBody(required = false) Map<String, Object> request) {
|
try {
|
List<String> deviceTypes = deviceConfigService.getAllDeviceTypes();
|
return Result.success(deviceTypes);
|
} catch (Exception e) {
|
log.error("获取设备类型列表失败", e);
|
return Result.error("获取设备类型列表失败");
|
}
|
}
|
|
/**
|
* 获取设备状态列表
|
*/
|
@PostMapping("/devices/statuses")
|
@ApiOperation("获取设备状态列表")
|
public Result<List<String>> getDeviceStatuses(@RequestBody(required = false) Map<String, Object> request) {
|
try {
|
List<String> deviceStatuses = deviceConfigService.getAllDeviceStatuses();
|
return Result.success(deviceStatuses);
|
} catch (Exception e) {
|
log.error("获取设备状态列表失败", e);
|
return Result.error("获取设备状态列表失败");
|
}
|
}
|
|
/**
|
* 获取设备配置树结构
|
*/
|
@PostMapping("/devices/tree")
|
@ApiOperation("获取设备配置树结构")
|
public Result<List<DeviceConfigVO.DeviceTreeNode>> getDeviceTree(
|
@ApiParam("设备配置请求") @RequestBody(required = false) DeviceConfigRequest request) {
|
try {
|
List<DeviceConfigVO.DeviceTreeNode> treeData = deviceConfigService.getDeviceTree(request != null ? request.getProjectId() : null);
|
return Result.success(treeData);
|
} catch (Exception e) {
|
log.error("获取设备配置树结构失败", e);
|
return Result.error("获取设备配置树结构失败");
|
}
|
}
|
|
/**
|
* 设备健康检查
|
*/
|
@PostMapping("/devices/health-check")
|
@ApiOperation("设备健康检查")
|
public Result<DeviceConfigVO.HealthCheckResult> performHealthCheck(
|
@Valid @RequestBody DeviceConfigRequest request) {
|
try {
|
DeviceConfigVO.HealthCheckResult result = deviceConfigService.performHealthCheck(request.getDeviceId());
|
return Result.success(result);
|
} catch (Exception e) {
|
log.error("设备健康检查失败", e);
|
return Result.error("设备健康检查失败");
|
}
|
}
|
|
/**
|
* 测试设备PLC连接
|
* 支持两种方式：
|
* 1. 传入 deviceId，根据已保存的设备配置测试
|
* 2. 直接传入 plcIp / plcPort / timeout 进行一次性测试
|
*/
|
@PostMapping("/devices/test-connection")
|
@ApiOperation("测试设备PLC连接")
|
public Result<String> testDeviceConnection(@RequestBody Map<String, Object> body) {
|
try {
|
String plcIp = null;
|
Integer plcPort = null;
|
Integer timeoutMs = null;
|
|
// 优先根据 deviceId 读取已保存配置
|
Object deviceIdObj = body.get("deviceId");
|
if (deviceIdObj != null) {
|
Long deviceId = deviceIdObj instanceof Number
|
? ((Number) deviceIdObj).longValue()
|
: Long.parseLong(deviceIdObj.toString());
|
DeviceConfig device = deviceConfigService.getDeviceById(deviceId);
|
if (device == null) {
|
return Result.error("设备不存在: " + deviceId);
|
}
|
plcIp = device.getPlcIp();
|
plcPort = device.getPlcPort();
|
timeoutMs = 3000;
|
} else {
|
// 直接从请求体中获取测试参数
|
Object ipObj = body.get("plcIp");
|
Object portObj = body.get("plcPort");
|
Object timeoutObj = body.get("timeout");
|
if (ipObj != null) {
|
plcIp = String.valueOf(ipObj);
|
}
|
if (portObj instanceof Number) {
|
plcPort = ((Number) portObj).intValue();
|
} else if (portObj != null) {
|
plcPort = Integer.parseInt(portObj.toString());
|
}
|
if (timeoutObj instanceof Number) {
|
timeoutMs = ((Number) timeoutObj).intValue() * 1000;
|
} else if (timeoutObj != null) {
|
timeoutMs = Integer.parseInt(timeoutObj.toString()) * 1000;
|
}
|
}
|
|
if (plcIp == null || plcIp.trim().isEmpty()) {
|
return Result.error("PLC IP不能为空");
|
}
|
if (plcPort == null || plcPort <= 0 || plcPort > 65535) {
|
plcPort = 102;
|
}
|
if (timeoutMs == null || timeoutMs <= 0) {
|
timeoutMs = 3000;
|
}
|
|
boolean ok = testTcpConnection(plcIp, plcPort, timeoutMs);
|
if (ok) {
|
String msg = String.format("连接测试成功：%s:%d", plcIp, plcPort);
|
log.info(msg);
|
return Result.success(msg);
|
} else {
|
String msg = String.format("连接测试失败：%s:%d", plcIp, plcPort);
|
log.warn(msg);
|
return Result.error(msg);
|
}
|
} catch (Exception e) {
|
log.error("设备PLC连接测试失败", e);
|
return Result.error("连接测试异常: " + e.getMessage());
|
}
|
}
|
|
private boolean testTcpConnection(String ip, int port, int timeoutMs) {
|
java.net.Socket socket = null;
|
try {
|
socket = new java.net.Socket();
|
socket.connect(new java.net.InetSocketAddress(ip, port), timeoutMs);
|
return true;
|
} catch (Exception e) {
|
log.warn("TCP连接测试失败: {}:{}, err={}", ip, port, e.getMessage());
|
return false;
|
} finally {
|
if (socket != null) {
|
try {
|
socket.close();
|
} catch (Exception ignore) {
|
}
|
}
|
}
|
}
|
}
|
