package com.mes.device.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.mes.device.entity.DeviceGroupConfig;
|
import com.mes.device.entity.DeviceGroupRelation;
|
import com.mes.device.mapper.DeviceGroupConfigMapper;
|
import com.mes.device.mapper.DeviceGroupRelationMapper;
|
import com.mes.device.service.DeviceGroupConfigService;
|
import com.mes.device.vo.DeviceGroupConfigVO;
|
import com.mes.device.vo.DeviceGroupVO;
|
import com.mes.device.vo.StatisticsVO;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import java.io.IOException;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 设备组配置服务实现类
|
*/
|
@Slf4j
|
@Service
|
public class DeviceGroupConfigServiceImpl extends ServiceImpl<DeviceGroupConfigMapper, DeviceGroupConfig> implements DeviceGroupConfigService {
|
|
private final ObjectMapper objectMapper = new ObjectMapper();
|
private final DeviceGroupRelationMapper deviceGroupRelationMapper;
|
private static final TypeReference<Map<String, Object>> MAP_TYPE = new TypeReference<Map<String, Object>>() {};
|
|
public DeviceGroupConfigServiceImpl(DeviceGroupRelationMapper deviceGroupRelationMapper) {
|
this.deviceGroupRelationMapper = deviceGroupRelationMapper;
|
}
|
|
@Override
|
public boolean createDeviceGroup(DeviceGroupConfig groupConfig) {
|
try {
|
// 检查设备组编号是否已存在
|
if (isGroupCodeExists(groupConfig.getGroupCode(), null)) {
|
log.warn("设备组编号已存在: {}", groupConfig.getGroupCode());
|
return false;
|
}
|
|
// 初始化设备组状态为停用
|
if (groupConfig.getStatus() == null) {
|
groupConfig.setStatus(DeviceGroupConfig.Status.DISABLED);
|
}
|
|
// 设置默认配置
|
if (groupConfig.getMaxConcurrentDevices() == null) {
|
groupConfig.setMaxConcurrentDevices(3);
|
}
|
|
if (groupConfig.getHeartbeatInterval() == null) {
|
groupConfig.setHeartbeatInterval(30);
|
}
|
|
if (groupConfig.getCommunicationTimeout() == null) {
|
groupConfig.setCommunicationTimeout(5000);
|
}
|
|
boolean result = save(groupConfig);
|
if (result) {
|
log.info("创建设备组配置成功: {}", groupConfig.getGroupCode());
|
}
|
return result;
|
} catch (Exception e) {
|
log.error("创建设备组配置失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean updateDeviceGroup(DeviceGroupConfig groupConfig) {
|
try {
|
// 检查设备组编号是否已存在（排除当前设备组）
|
if (isGroupCodeExists(groupConfig.getGroupCode(), groupConfig.getId())) {
|
log.warn("设备组编号已存在: {}", groupConfig.getGroupCode());
|
return false;
|
}
|
|
boolean result = updateById(groupConfig);
|
if (result) {
|
log.info("更新设备组配置成功: {}", groupConfig.getGroupCode());
|
}
|
return result;
|
} catch (Exception e) {
|
log.error("更新设备组配置失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean deleteDeviceGroup(Long id) {
|
try {
|
// 先检查该设备组下是否有设备
|
int deviceCount = getDeviceCountByGroupId(id);
|
if (deviceCount > 0) {
|
log.warn("设备组下还有设备，无法删除: {}", id);
|
return false;
|
}
|
|
boolean result = removeById(id);
|
if (result) {
|
log.info("删除设备组配置成功: {}", id);
|
}
|
return result;
|
} catch (Exception e) {
|
log.error("删除设备组配置失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public DeviceGroupConfig getDeviceGroupById(Long id) {
|
return getById(id);
|
}
|
|
@Override
|
public DeviceGroupConfig getDeviceGroupByCode(String groupCode) {
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(DeviceGroupConfig::getGroupCode, groupCode);
|
wrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
return getOne(wrapper);
|
}
|
|
@Override
|
public List<DeviceGroupConfig> getDeviceGroupList(Long projectId, Integer groupType, Integer status) {
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
|
// 过滤未删除的设备组
|
wrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
|
if (groupType != null) {
|
wrapper.eq(DeviceGroupConfig::getGroupType, groupType);
|
}
|
|
if (status != null) {
|
wrapper.eq(DeviceGroupConfig::getStatus, status);
|
}
|
|
wrapper.orderByAsc(DeviceGroupConfig::getId);
|
|
return list(wrapper);
|
}
|
|
@Override
|
public Page<DeviceGroupVO.GroupInfo> getDeviceGroupList(Long projectId, String groupType, String groupStatus, String keyword, Integer page, Integer size) {
|
try {
|
// 创建分页对象
|
Page<DeviceGroupConfig> pageEntity = new Page<>(page, size);
|
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
|
// 过滤未删除的设备组
|
wrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
|
// 项目ID过滤
|
if (projectId != null) {
|
wrapper.eq(DeviceGroupConfig::getProjectId, projectId);
|
}
|
|
// 设备组类型过滤（字符串转换为枚举值）
|
if (groupType != null && !groupType.trim().isEmpty()) {
|
Integer typeEnum = convertGroupTypeFromString(groupType);
|
if (typeEnum != null) {
|
wrapper.eq(DeviceGroupConfig::getGroupType, typeEnum);
|
}
|
}
|
|
// 设备组状态过滤（字符串转换为枚举值）
|
if (groupStatus != null && !groupStatus.trim().isEmpty()) {
|
Integer statusEnum = convertStatusFromString(groupStatus);
|
if (statusEnum != null) {
|
wrapper.eq(DeviceGroupConfig::getStatus, statusEnum);
|
}
|
}
|
|
// 关键词搜索
|
if (keyword != null && !keyword.trim().isEmpty()) {
|
wrapper.and(w -> w
|
.like(DeviceGroupConfig::getGroupName, keyword)
|
.or().like(DeviceGroupConfig::getGroupCode, keyword)
|
.or().like(DeviceGroupConfig::getDescription, keyword));
|
}
|
|
wrapper.orderByDesc(DeviceGroupConfig::getUpdatedTime);
|
|
// 执行分页查询
|
pageEntity = page(pageEntity, wrapper);
|
|
// 转换为VO对象
|
List<DeviceGroupVO.GroupInfo> voList = pageEntity.getRecords().stream().map(group -> {
|
DeviceGroupVO.GroupInfo vo = new DeviceGroupVO.GroupInfo();
|
vo.setId(group.getId());
|
vo.setGroupCode(group.getGroupCode());
|
vo.setGroupName(group.getGroupName());
|
vo.setGroupType(getGroupTypeName(group.getGroupType()));
|
vo.setStatus(getStatusName(group.getStatus()));
|
vo.setDeviceCount(getDeviceCountByGroupId(group.getId()));
|
vo.setOnlineDeviceCount(getOnlineDeviceCountByGroupId(group.getId()));
|
vo.setCreateTime(group.getCreatedTime());
|
vo.setProjectId(group.getProjectId());
|
return vo;
|
}).collect(Collectors.toList());
|
|
// 创建分页结果
|
Page<DeviceGroupVO.GroupInfo> result = new Page<>(pageEntity.getCurrent(), pageEntity.getSize(), pageEntity.getTotal());
|
result.setRecords(voList);
|
|
return result;
|
} catch (Exception e) {
|
log.error("分页查询设备组配置列表失败", e);
|
throw new RuntimeException("分页查询设备组配置列表失败: " + e.getMessage(), e);
|
}
|
}
|
|
@Override
|
public List<DeviceGroupConfigVO.GroupInfo> getDeviceGroupVOList(Long projectId, Integer groupType, Integer status) {
|
List<DeviceGroupConfig> groupList = getDeviceGroupList(projectId, groupType, status);
|
|
return groupList.stream().map(group -> {
|
DeviceGroupConfigVO.GroupInfo vo = new DeviceGroupConfigVO.GroupInfo();
|
vo.setId(group.getId());
|
vo.setGroupName(group.getGroupName());
|
vo.setGroupCode(group.getGroupCode());
|
vo.setGroupType(getGroupTypeName(group.getGroupType()));
|
vo.setDescription(group.getDescription());
|
vo.setStatus(getStatusName(group.getStatus()));
|
vo.setDeviceCount(getDeviceCountByGroupId(group.getId()));
|
vo.setIsEnabled(group.getStatus() != null && group.getStatus() == DeviceGroupConfig.Status.ENABLED);
|
vo.setLocation(extractLocationFromExtraConfig(group));
|
vo.setSupervisor(extractSupervisorFromExtraConfig(group));
|
vo.setCreatedTime(new Date());
|
vo.setUpdatedTime(new Date());
|
vo.setProjectId(group.getProjectId());
|
return vo;
|
}).collect(Collectors.toList());
|
}
|
|
/**
|
* 获取设备组类型名称
|
*/
|
private String getGroupTypeName(Integer groupType) {
|
switch (groupType != null ? groupType : 0) {
|
case DeviceGroupConfig.GroupType.PRODUCTION_LINE:
|
return "生产线";
|
case DeviceGroupConfig.GroupType.TEST_LINE:
|
return "测试线";
|
case DeviceGroupConfig.GroupType.AUXILIARY_GROUP:
|
return "辅助设备组";
|
default:
|
return "未知类型";
|
}
|
}
|
|
/**
|
* 字符串转换为设备组类型枚举值
|
*/
|
private Integer convertGroupTypeFromString(String groupType) {
|
if (groupType == null || groupType.trim().isEmpty()) {
|
return null;
|
}
|
|
switch (groupType.trim()) {
|
case "生产线":
|
case "production_line":
|
case "PRODUCTION_LINE":
|
return DeviceGroupConfig.GroupType.PRODUCTION_LINE;
|
case "测试线":
|
case "test_line":
|
case "TEST_LINE":
|
return DeviceGroupConfig.GroupType.TEST_LINE;
|
case "辅助设备组":
|
case "auxiliary_group":
|
case "AUXILIARY_GROUP":
|
return DeviceGroupConfig.GroupType.AUXILIARY_GROUP;
|
default:
|
try {
|
// 尝试直接解析为整数
|
return Integer.parseInt(groupType.trim());
|
} catch (NumberFormatException e) {
|
log.warn("无法识别的设备组类型: {}", groupType);
|
return null;
|
}
|
}
|
}
|
|
/**
|
* 获取设备组状态名称
|
*/
|
private String getStatusName(Integer status) {
|
switch (status != null ? status : 0) {
|
case DeviceGroupConfig.Status.ENABLED:
|
return "启用";
|
case DeviceGroupConfig.Status.DISABLED:
|
return "停用";
|
case DeviceGroupConfig.Status.MAINTENANCE:
|
return "维护中";
|
default:
|
return "未知状态";
|
}
|
}
|
|
/**
|
* 字符串转换为设备组状态枚举值
|
*/
|
private Integer convertStatusFromString(String status) {
|
if (status == null || status.trim().isEmpty()) {
|
return null;
|
}
|
|
switch (status.trim()) {
|
case "启用":
|
case "enabled":
|
case "ENABLED":
|
return DeviceGroupConfig.Status.ENABLED;
|
case "停用":
|
case "disabled":
|
case "DISABLED":
|
return DeviceGroupConfig.Status.DISABLED;
|
case "维护中":
|
case "maintenance":
|
case "MAINTENANCE":
|
return DeviceGroupConfig.Status.MAINTENANCE;
|
default:
|
try {
|
// 尝试直接解析为整数
|
return Integer.parseInt(status.trim());
|
} catch (NumberFormatException e) {
|
log.warn("无法识别的设备组状态: {}", status);
|
return null;
|
}
|
}
|
}
|
|
@Override
|
public boolean isGroupCodeExists(String groupCode, Long excludeId) {
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(DeviceGroupConfig::getGroupCode, groupCode);
|
wrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
|
if (excludeId != null) {
|
wrapper.ne(DeviceGroupConfig::getId, excludeId);
|
}
|
|
return count(wrapper) > 0;
|
}
|
|
@Override
|
public boolean updateDeviceGroupStatus(Long id, Integer status) {
|
try {
|
DeviceGroupConfig group = getById(id);
|
if (group == null) {
|
log.warn("设备组不存在: {}", id);
|
return false;
|
}
|
|
group.setStatus(status);
|
boolean result = updateById(group);
|
if (result) {
|
log.info("更新设备组状态成功: {} -> {}", id, status);
|
}
|
return result;
|
} catch (Exception e) {
|
log.error("更新设备组状态失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean batchUpdateDeviceGroupStatus(List<Long> ids, Integer status) {
|
try {
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
wrapper.in(DeviceGroupConfig::getId, ids);
|
|
DeviceGroupConfig updateEntity = new DeviceGroupConfig();
|
updateEntity.setStatus(status);
|
|
boolean result = update(updateEntity, wrapper);
|
if (result) {
|
log.info("批量更新设备组状态成功: {} 个设备组 -> {}", ids.size(), status);
|
}
|
return result;
|
} catch (Exception e) {
|
log.error("批量更新设备组状态失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public Map<String, Object> getExtraConfig(Long id) {
|
try {
|
DeviceGroupConfig group = getById(id);
|
if (group == null || group.getExtraConfig() == null) {
|
return new HashMap<>();
|
}
|
|
return objectMapper.readValue(group.getExtraConfig(),
|
new TypeReference<Map<String, Object>>() {});
|
} catch (IOException e) {
|
log.error("解析设备组扩展配置失败", e);
|
return new HashMap<>();
|
}
|
}
|
|
@Override
|
public boolean updateExtraConfig(Long id, Map<String, Object> extraConfig) {
|
try {
|
DeviceGroupConfig group = getById(id);
|
if (group == null) {
|
log.warn("设备组不存在: {}", id);
|
return false;
|
}
|
|
String extraConfigJson = objectMapper.writeValueAsString(extraConfig);
|
group.setExtraConfig(extraConfigJson);
|
|
boolean result = updateById(group);
|
if (result) {
|
log.info("更新设备组扩展配置成功: {}", id);
|
}
|
return result;
|
} catch (IOException e) {
|
log.error("序列化设备组扩展配置失败", e);
|
return false;
|
}
|
}
|
|
@Override
|
public int getDeviceCountByGroupId(Long groupId) {
|
if (groupId == null) {
|
return 0;
|
}
|
try {
|
LambdaQueryWrapper<DeviceGroupRelation> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(DeviceGroupRelation::getGroupId, groupId)
|
.eq(DeviceGroupRelation::getIsDeleted, 0);
|
return (int) deviceGroupRelationMapper.selectCount(wrapper);
|
} catch (Exception e) {
|
log.error("获取设备组设备数量失败, groupId={}", groupId, e);
|
return 0;
|
}
|
}
|
|
/**
|
* 获取设备组下的在线设备数量
|
*
|
* @param groupId 设备组ID
|
* @return 在线设备数量
|
*/
|
private int getOnlineDeviceCountByGroupId(Long groupId) {
|
if (groupId == null) {
|
return 0;
|
}
|
try {
|
Integer count = deviceGroupRelationMapper.getOnlineDeviceCountByGroupId(groupId);
|
return count != null ? count : 0;
|
} catch (Exception e) {
|
log.error("获取设备组在线设备数量失败, groupId={}", groupId, e);
|
return 0;
|
}
|
}
|
|
/**
|
* 获取设备组类型统计数据
|
*/
|
private List<StatisticsVO.GroupTypeStatistics> getDeviceGroupTypeStatistics(Long projectId) {
|
try {
|
List<StatisticsVO.GroupTypeStatistics> groupTypeStats = new ArrayList<>();
|
|
// 获取所有设备组类型枚举值
|
// 注意：需要手动列出所有可能的设备组类型，因为枚举类结构与预期不符
|
List<Integer> groupTypes = Arrays.asList(DeviceGroupConfig.GroupType.PRODUCTION_LINE, DeviceGroupConfig.GroupType.TEST_LINE, DeviceGroupConfig.GroupType.AUXILIARY_GROUP);
|
|
for (Integer groupType : groupTypes) {
|
// 设备组总数
|
LambdaQueryWrapper<DeviceGroupConfig> totalWrapper = new LambdaQueryWrapper<>();
|
totalWrapper.eq(DeviceGroupConfig::getGroupType, groupType);
|
totalWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
long totalCount = count(totalWrapper);
|
|
// 在线数（启用的设备组数）
|
LambdaQueryWrapper<DeviceGroupConfig> onlineWrapper = new LambdaQueryWrapper<>();
|
onlineWrapper.eq(DeviceGroupConfig::getGroupType, groupType);
|
onlineWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.ENABLED);
|
onlineWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
long onlineCount = count(onlineWrapper);
|
|
// 离线数（停用的设备组数）
|
LambdaQueryWrapper<DeviceGroupConfig> offlineWrapper = new LambdaQueryWrapper<>();
|
offlineWrapper.eq(DeviceGroupConfig::getGroupType, groupType);
|
offlineWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.DISABLED);
|
offlineWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
long offlineCount = count(offlineWrapper);
|
|
// 维护中的设备组数
|
LambdaQueryWrapper<DeviceGroupConfig> maintenanceWrapper = new LambdaQueryWrapper<>();
|
maintenanceWrapper.eq(DeviceGroupConfig::getGroupType, groupType);
|
maintenanceWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.MAINTENANCE);
|
maintenanceWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
long maintenanceCount = count(maintenanceWrapper);
|
|
// 计算可用性
|
double availability = totalCount > 0 ? (onlineCount * 100.0 / totalCount) : 0.0;
|
|
// 创建设备组类型统计对象
|
StatisticsVO.GroupTypeStatistics groupTypeStat = new StatisticsVO.GroupTypeStatistics();
|
groupTypeStat.setGroupType(getGroupTypeName(groupType));
|
groupTypeStat.setTotalCount((int) totalCount);
|
// 注意：StatisticsVO.GroupTypeStatistics的字段与代码期望不符，这里做适当调整
|
// activeCount表示启用的设备组数
|
groupTypeStat.setActiveCount((int) onlineCount);
|
|
groupTypeStats.add(groupTypeStat);
|
}
|
|
return groupTypeStats;
|
} catch (Exception e) {
|
log.error("获取设备组类型统计数据失败", e);
|
return new ArrayList<>();
|
}
|
}
|
|
@Override
|
public int getOnlineDeviceGroupCount(Long projectId) {
|
// 简化实现，实际项目中可能需要根据项目ID过滤
|
LambdaQueryWrapper<DeviceGroupConfig> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.ENABLED);
|
wrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
|
return (int) count(wrapper);
|
}
|
|
@Override
|
public StatisticsVO.GroupStatistics getDeviceGroupStatistics(Long projectId) {
|
try {
|
// 设备组总数
|
LambdaQueryWrapper<DeviceGroupConfig> totalWrapper = new LambdaQueryWrapper<>();
|
totalWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
if (projectId != null) {
|
totalWrapper.eq(DeviceGroupConfig::getProjectId, projectId);
|
}
|
long totalGroups = count(totalWrapper);
|
|
// 启用的设备组数
|
LambdaQueryWrapper<DeviceGroupConfig> enabledWrapper = new LambdaQueryWrapper<>();
|
enabledWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.ENABLED);
|
enabledWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
if (projectId != null) {
|
enabledWrapper.eq(DeviceGroupConfig::getProjectId, projectId);
|
}
|
long enabledGroups = count(enabledWrapper);
|
|
// 停用的设备组数
|
LambdaQueryWrapper<DeviceGroupConfig> disabledWrapper = new LambdaQueryWrapper<>();
|
disabledWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.DISABLED);
|
disabledWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
if (projectId != null) {
|
disabledWrapper.eq(DeviceGroupConfig::getProjectId, projectId);
|
}
|
long disabledGroups = count(disabledWrapper);
|
|
// 维护中的设备组数
|
LambdaQueryWrapper<DeviceGroupConfig> maintenanceWrapper = new LambdaQueryWrapper<>();
|
maintenanceWrapper.eq(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.MAINTENANCE);
|
maintenanceWrapper.eq(DeviceGroupConfig::getIsDeleted, 0);
|
if (projectId != null) {
|
maintenanceWrapper.eq(DeviceGroupConfig::getProjectId, projectId);
|
}
|
long maintenanceGroups = count(maintenanceWrapper);
|
|
// 创建设备组统计对象
|
StatisticsVO.GroupStatistics groupStats = new StatisticsVO.GroupStatistics();
|
groupStats.setTotalGroups((int) totalGroups);
|
groupStats.setActiveGroups((int) enabledGroups);
|
groupStats.setInactiveGroups((int) disabledGroups);
|
// 注意：StatisticsVO.GroupStatistics没有直接的维护中设备组字段，这里忽略或调整
|
|
// 计算设备组可用性（启用设备组 / 总设备组 * 100%）
|
double availability = totalGroups > 0 ? (enabledGroups * 100.0 / totalGroups) : 0.0;
|
groupStats.setGroupAvailability(availability);
|
|
// 获取按设备组类型的统计数据
|
List<StatisticsVO.GroupTypeStatistics> groupTypeStats = getDeviceGroupTypeStatistics(projectId);
|
groupStats.setGroupTypeStats(groupTypeStats);
|
|
log.info("获取设备组统计信息成功: 总数={}, 启用={}, 停用={}, 维护中={}",
|
totalGroups, enabledGroups, disabledGroups, maintenanceGroups);
|
|
return groupStats;
|
} catch (Exception e) {
|
log.error("获取设备组统计信息失败", e);
|
// 返回默认统计对象
|
return new StatisticsVO.GroupStatistics();
|
}
|
}
|
|
@Override
|
public DeviceGroupVO.PerformanceStats getGroupPerformance(Long groupId) {
|
try {
|
// 检查设备组是否存在
|
DeviceGroupConfig group = getById(groupId);
|
if (group == null) {
|
log.warn("设备组不存在: {}", groupId);
|
return new DeviceGroupVO.PerformanceStats();
|
}
|
|
// 获取设备组下的设备数量
|
int totalDevices = getDeviceCountByGroupId(groupId);
|
|
// 获取在线设备数量（状态为正常的设备数）
|
int activeDevices = getActiveDeviceCountByGroupId(groupId);
|
|
// 计算平均性能指标（模拟数据）
|
double averageCpuUsage = 45.5; // CPU使用率百分比
|
double averageMemoryUsage = 65.2; // 内存使用率百分比
|
int totalTasksCompleted = 1000; // 总完成任务数
|
double successRate = 99.2; // 任务成功率百分比
|
|
// 创建设备组性能统计对象
|
DeviceGroupVO.PerformanceStats performanceStats = new DeviceGroupVO.PerformanceStats();
|
performanceStats.setTotalDevices(totalDevices);
|
performanceStats.setActiveDevices(activeDevices);
|
performanceStats.setAverageCpuUsage(averageCpuUsage);
|
performanceStats.setAverageMemoryUsage(averageMemoryUsage);
|
performanceStats.setTotalTasksCompleted(totalTasksCompleted);
|
performanceStats.setSuccessRate(successRate);
|
performanceStats.setStatsTime(new Date());
|
performanceStats.setDevicePerformances(new ArrayList<>());
|
|
log.info("获取设备组性能统计成功: groupId={}, totalDevices={}",
|
groupId, totalDevices);
|
|
return performanceStats;
|
} catch (Exception e) {
|
log.error("获取设备组性能统计失败", e);
|
// 返回默认性能统计对象
|
return new DeviceGroupVO.PerformanceStats();
|
}
|
}
|
|
@Override
|
public DeviceGroupVO.HealthCheckResult performGroupHealthCheck(Long groupId) {
|
try {
|
// 检查设备组是否存在
|
DeviceGroupConfig group = getById(groupId);
|
if (group == null) {
|
log.warn("设备组不存在: {}", groupId);
|
DeviceGroupVO.HealthCheckResult errorResult = new DeviceGroupVO.HealthCheckResult();
|
errorResult.setIsHealthy(false);
|
errorResult.setTotalDevices(0);
|
errorResult.setOnlineDevices(0);
|
errorResult.setOfflineDevices(0);
|
errorResult.setFailedDevices(new ArrayList<>());
|
errorResult.setCheckTime(new Date());
|
errorResult.setCheckSummary("设备组不存在");
|
return errorResult;
|
}
|
|
// 获取设备组下的设备信息
|
int totalDevices = getDeviceCountByGroupId(groupId);
|
int onlineDevices = getActiveDeviceCountByGroupId(groupId);
|
int offlineDevices = totalDevices - onlineDevices;
|
|
// 计算健康状态
|
boolean isHealthy = onlineDevices >= totalDevices * 0.9; // 90%以上在线则健康
|
|
// 创建健康检查结果
|
DeviceGroupVO.HealthCheckResult healthResult = new DeviceGroupVO.HealthCheckResult();
|
healthResult.setIsHealthy(isHealthy);
|
healthResult.setTotalDevices(totalDevices);
|
healthResult.setOnlineDevices(onlineDevices);
|
healthResult.setOfflineDevices(offlineDevices);
|
healthResult.setFailedDevices(new ArrayList<>()); // 设置为空列表
|
healthResult.setCheckTime(new Date());
|
healthResult.setCheckSummary(isHealthy ? "设备组健康" : "设备组存在问题");
|
|
log.info("设备组健康检查完成: groupId={}, isHealthy={}, totalDevices={}, onlineDevices={}",
|
groupId, isHealthy, totalDevices, onlineDevices);
|
|
return healthResult;
|
} catch (Exception e) {
|
log.error("执行设备组健康检查失败", e);
|
// 返回错误状态的结果
|
DeviceGroupVO.HealthCheckResult errorResult = new DeviceGroupVO.HealthCheckResult();
|
errorResult.setIsHealthy(false);
|
errorResult.setTotalDevices(0);
|
errorResult.setOnlineDevices(0);
|
errorResult.setOfflineDevices(0);
|
errorResult.setFailedDevices(new ArrayList<>());
|
errorResult.setCheckTime(new Date());
|
errorResult.setCheckSummary("健康检查执行失败: " + e.getMessage());
|
return errorResult;
|
}
|
}
|
|
@Override
|
public boolean enableDeviceGroup(Long id) {
|
try {
|
// 检查设备组是否存在
|
DeviceGroupConfig group = getById(id);
|
if (group == null) {
|
log.warn("设备组不存在: {}", id);
|
return false;
|
}
|
|
// 更新设备组状态为启用
|
group.setStatus(DeviceGroupConfig.Status.ENABLED);
|
boolean result = updateById(group);
|
|
if (result) {
|
log.info("启用设备组成功: {}", id);
|
} else {
|
log.error("启用设备组失败: {}", id);
|
}
|
|
return result;
|
} catch (Exception e) {
|
log.error("启用设备组异常", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean disableDeviceGroup(Long id) {
|
try {
|
// 检查设备组是否存在
|
DeviceGroupConfig group = getById(id);
|
if (group == null) {
|
log.warn("设备组不存在: {}", id);
|
return false;
|
}
|
|
// 更新设备组状态为禁用
|
group.setStatus(DeviceGroupConfig.Status.DISABLED);
|
boolean result = updateById(group);
|
|
if (result) {
|
log.info("禁用设备组成功: {}", id);
|
} else {
|
log.error("禁用设备组失败: {}", id);
|
}
|
|
return result;
|
} catch (Exception e) {
|
log.error("禁用设备组异常", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean batchEnableDeviceGroups(java.util.List<Long> groupIds) {
|
try {
|
if (groupIds == null || groupIds.isEmpty()) {
|
log.warn("批量启用设备组: 设备组ID列表为空");
|
return false;
|
}
|
|
// 批量更新设备组状态
|
LambdaUpdateWrapper<DeviceGroupConfig> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.in(DeviceGroupConfig::getId, groupIds)
|
.set(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.ENABLED);
|
|
boolean result = update(updateWrapper);
|
|
if (result) {
|
log.info("批量启用设备组成功: {} 个设备组", groupIds.size());
|
} else {
|
log.error("批量启用设备组失败");
|
}
|
|
return result;
|
} catch (Exception e) {
|
log.error("批量启用设备组异常", e);
|
return false;
|
}
|
}
|
|
@Override
|
public boolean batchDisableDeviceGroups(java.util.List<Long> groupIds) {
|
try {
|
if (groupIds == null || groupIds.isEmpty()) {
|
log.warn("批量禁用设备组: 设备组ID列表为空");
|
return false;
|
}
|
|
// 批量更新设备组状态
|
LambdaUpdateWrapper<DeviceGroupConfig> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.in(DeviceGroupConfig::getId, groupIds)
|
.set(DeviceGroupConfig::getStatus, DeviceGroupConfig.Status.DISABLED);
|
|
boolean result = update(updateWrapper);
|
|
if (result) {
|
log.info("批量禁用设备组成功: {} 个设备组", groupIds.size());
|
} else {
|
log.error("批量禁用设备组失败");
|
}
|
|
return result;
|
} catch (Exception e) {
|
log.error("批量禁用设备组异常", e);
|
return false;
|
}
|
}
|
|
@Override
|
public java.util.List<String> getAllGroupTypes() {
|
try {
|
// 返回预定义的设备组类型列表
|
java.util.List<String> groupTypes = new java.util.ArrayList<>();
|
groupTypes.add("PRODUCTION");
|
groupTypes.add("QUALITY_CONTROL");
|
groupTypes.add("LOGISTICS");
|
groupTypes.add("MAINTENANCE");
|
groupTypes.add("MONITORING");
|
|
log.debug("获取设备组类型列表: {} 个类型", groupTypes.size());
|
return groupTypes;
|
} catch (Exception e) {
|
log.error("获取设备组类型列表失败", e);
|
return new java.util.ArrayList<>();
|
}
|
}
|
|
/**
|
* 从扩展配置中提取位置信息
|
*/
|
private String extractLocationFromExtraConfig(DeviceGroupConfig group) {
|
if (group == null || group.getExtraConfig() == null) {
|
return "默认位置";
|
}
|
try {
|
Map<String, Object> extraConfig = objectMapper.readValue(group.getExtraConfig(), MAP_TYPE);
|
Object location = extraConfig.get("location");
|
return location != null ? String.valueOf(location) : "默认位置";
|
} catch (Exception e) {
|
log.warn("解析设备组位置信息失败, groupId={}", group.getId(), e);
|
return "默认位置";
|
}
|
}
|
|
/**
|
* 从扩展配置中提取管理员信息
|
*/
|
private String extractSupervisorFromExtraConfig(DeviceGroupConfig group) {
|
if (group == null || group.getExtraConfig() == null) {
|
return "默认管理员";
|
}
|
try {
|
Map<String, Object> extraConfig = objectMapper.readValue(group.getExtraConfig(), MAP_TYPE);
|
Object supervisor = extraConfig.get("supervisor");
|
return supervisor != null ? String.valueOf(supervisor) : "默认管理员";
|
} catch (Exception e) {
|
log.warn("解析设备组管理员信息失败, groupId={}", group.getId(), e);
|
return "默认管理员";
|
}
|
}
|
|
/**
|
* 获取设备组中活跃设备数量（状态为正常的设备）
|
*/
|
private int getActiveDeviceCountByGroupId(Long groupId) {
|
if (groupId == null) {
|
return 0;
|
}
|
try {
|
LambdaQueryWrapper<DeviceGroupRelation> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(DeviceGroupRelation::getGroupId, groupId)
|
.eq(DeviceGroupRelation::getStatus, DeviceGroupRelation.Status.NORMAL)
|
.eq(DeviceGroupRelation::getIsDeleted, 0);
|
return (int) deviceGroupRelationMapper.selectCount(wrapper);
|
} catch (Exception e) {
|
log.error("获取设备组活跃设备数量失败, groupId={}", groupId, e);
|
return 0;
|
}
|
}
|
|
@Override
|
public java.util.List<String> getAllGroupStatuses() {
|
try {
|
// 返回预定义的设备组状态列表
|
java.util.List<String> groupStatuses = new java.util.ArrayList<>();
|
groupStatuses.add("ENABLED");
|
groupStatuses.add("DISABLED");
|
groupStatuses.add("MAINTENANCE");
|
groupStatuses.add("OFFLINE");
|
|
log.debug("获取设备组状态列表: {} 个状态", groupStatuses.size());
|
return groupStatuses;
|
} catch (Exception e) {
|
log.error("获取设备组状态列表失败", e);
|
return new java.util.ArrayList<>();
|
}
|
}
|
}
|
