package com.ruoyi.system.service.impl;
|
|
import java.net.Inet6Address;
|
import java.net.InetAddress;
|
import java.util.List;
|
import java.util.Locale;
|
import org.springframework.dao.DuplicateKeyException;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import com.ruoyi.common.constant.UserConstants;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.ip.IpUtils;
|
import com.ruoyi.system.domain.TDetectionCabinet;
|
import com.ruoyi.system.domain.vo.DiscoveredCabinetVo;
|
import com.ruoyi.system.mapper.TDetectionCabinetMapper;
|
import com.ruoyi.system.service.ITDetectionCabinetService;
|
|
/**
|
* 检测柜 Service 业务层处理
|
*
|
* @author ruoyi
|
*/
|
@Service
|
public class TDetectionCabinetServiceImpl implements ITDetectionCabinetService
|
{
|
private static final String NORMAL = "0";
|
private static final String DISABLED = "1";
|
private static final String TESTING = "1";
|
private static final String ACTIVE = "ACTIVE";
|
private static final String DISCOVERED = "DISCOVERED";
|
|
private final TDetectionCabinetMapper detectionCabinetMapper;
|
|
/**
|
* 构造检测柜业务服务。
|
*
|
* @param detectionCabinetMapper 检测柜数据访问对象
|
*/
|
public TDetectionCabinetServiceImpl(TDetectionCabinetMapper detectionCabinetMapper)
|
{
|
this.detectionCabinetMapper = detectionCabinetMapper;
|
}
|
|
/**
|
* 查询指定检测柜，并在记录不存在或已逻辑删除时统一抛出业务异常。
|
*
|
* @param cabinetId 检测柜主键
|
* @return 检测柜信息
|
*/
|
@Override
|
public TDetectionCabinet selectDetectionCabinetById(Long cabinetId)
|
{
|
TDetectionCabinet detectionCabinet = detectionCabinetMapper.selectDetectionCabinetById(cabinetId);
|
if (StringUtils.isNull(detectionCabinet))
|
{
|
throw new ServiceException("检测柜不存在或已删除");
|
}
|
return detectionCabinet;
|
}
|
|
/**
|
* 查询检测柜列表；查询 MAC 地址时先转换为统一格式，避免分隔符和大小写导致漏查。
|
*
|
* @param detectionCabinet 查询条件
|
* @return 检测柜列表
|
*/
|
@Override
|
public List<TDetectionCabinet> selectDetectionCabinetList(TDetectionCabinet detectionCabinet)
|
{
|
if (StringUtils.isNotBlank(detectionCabinet.getMacAddress()))
|
{
|
detectionCabinet.setMacAddress(normalizeMacAddress(detectionCabinet.getMacAddress()));
|
}
|
return detectionCabinetMapper.selectDetectionCabinetList(detectionCabinet);
|
}
|
|
/**
|
* 复用已持久化检测柜事实供原选择设备弹窗展示，不生成模拟设备。
|
* 测试占用状态由已持久化通道工作状态聚合；测试归属留待后续绑定闭环确认。
|
*
|
* @return 可供选择的检测柜设备摘要
|
*/
|
@Override
|
public List<DiscoveredCabinetVo> selectDiscoveredCabinetList()
|
{
|
return detectionCabinetMapper.selectDiscoveredCabinetList().stream()
|
.map(cabinet -> {
|
boolean active = ACTIVE.equals(cabinet.getObservedWorkStatus());
|
return new DiscoveredCabinetVo(
|
cabinet.getCabinetCode(),
|
cabinet.getIpAddress(),
|
cabinet.getMacAddress(),
|
cabinet.getCabinetName(),
|
cabinet.getManufacturer(),
|
cabinet.getModel(),
|
cabinet.getChannelCount(),
|
isOnline(cabinet.getOnlineStatus()) ? "在线" : "离线",
|
active ? "测试中" : "空闲",
|
active ? "待确认" : "-");
|
})
|
.toList();
|
}
|
|
private boolean isOnline(String onlineStatus)
|
{
|
return NORMAL.equals(onlineStatus) || "ONLINE".equalsIgnoreCase(onlineStatus);
|
}
|
|
/**
|
* 将操作员选择的发现候选设备登记为检测柜，并保留其适配器和通道身份。
|
*
|
* @param detectionCabinet 检测柜信息
|
* @return 影响行数
|
*/
|
@Override
|
public int insertDetectionCabinet(TDetectionCabinet detectionCabinet)
|
{
|
normalizeBasicFields(detectionCabinet);
|
validateIpAddress(detectionCabinet.getIpAddress());
|
TDetectionCabinet candidate = detectionCabinetMapper.selectByCabinetCode(detectionCabinet.getCabinetCode());
|
if (candidate == null)
|
{
|
throw new ServiceException("请先选择发现候选设备");
|
}
|
if (!DISCOVERED.equals(candidate.getRegistrationStatus()))
|
{
|
throw new ServiceException("设备编码已存在");
|
}
|
detectionCabinet.setCabinetId(candidate.getCabinetId());
|
validateUniqueFields(detectionCabinet);
|
detectionCabinet.setStatus(NORMAL);
|
try
|
{
|
int rows = detectionCabinetMapper.registerDiscoveredCabinet(detectionCabinet);
|
if (rows == 0) throw new ServiceException("发现候选设备状态已变化，请重新选择");
|
return rows;
|
}
|
catch (DuplicateKeyException exception)
|
{
|
throw buildDuplicateException(detectionCabinet, exception);
|
}
|
}
|
|
/**
|
* 修改检测柜基础信息；先确认目标记录存在，再执行字段规范化和唯一性校验。
|
*
|
* @param detectionCabinet 检测柜信息
|
* @return 影响行数
|
*/
|
@Override
|
public int updateDetectionCabinet(TDetectionCabinet detectionCabinet)
|
{
|
requireCabinetId(detectionCabinet.getCabinetId());
|
selectDetectionCabinetById(detectionCabinet.getCabinetId());
|
normalizeBasicFields(detectionCabinet);
|
validateIpAddress(detectionCabinet.getIpAddress());
|
validateUniqueFields(detectionCabinet);
|
try
|
{
|
return detectionCabinetMapper.updateDetectionCabinet(detectionCabinet);
|
}
|
catch (DuplicateKeyException exception)
|
{
|
throw buildDuplicateException(detectionCabinet, exception);
|
}
|
}
|
|
/**
|
* 修改检测柜启禁用状态；测试中的检测柜禁止被禁用，重复状态更新直接返回成功。
|
*
|
* @param detectionCabinet 检测柜主键、目标状态及更新人
|
* @return 影响行数
|
*/
|
@Override
|
public int updateDetectionCabinetStatus(TDetectionCabinet detectionCabinet)
|
{
|
requireCabinetId(detectionCabinet.getCabinetId());
|
if (!NORMAL.equals(detectionCabinet.getStatus()) && !DISABLED.equals(detectionCabinet.getStatus()))
|
{
|
throw new ServiceException("检测柜状态值不正确");
|
}
|
TDetectionCabinet current = selectDetectionCabinetById(detectionCabinet.getCabinetId());
|
if (DISABLED.equals(detectionCabinet.getStatus()))
|
{
|
validateCabinetNotTesting(current, "禁用");
|
}
|
if (detectionCabinet.getStatus().equals(current.getStatus()))
|
{
|
return 1;
|
}
|
return detectionCabinetMapper.updateDetectionCabinetStatus(detectionCabinet);
|
}
|
|
/**
|
* 批量逻辑删除检测柜；先完成全部目标记录校验，再执行删除，避免部分成功。
|
*
|
* @param cabinetIds 检测柜主键数组
|
* @param updateBy 更新人
|
* @return 影响行数
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int deleteDetectionCabinetByIds(Long[] cabinetIds, String updateBy)
|
{
|
if (StringUtils.isEmpty(cabinetIds))
|
{
|
throw new ServiceException("请选择要删除的检测柜");
|
}
|
for (Long cabinetId : cabinetIds)
|
{
|
TDetectionCabinet detectionCabinet = selectDetectionCabinetById(cabinetId);
|
validateCabinetNotTesting(detectionCabinet, "删除");
|
}
|
int rows = 0;
|
for (Long cabinetId : cabinetIds)
|
{
|
rows += detectionCabinetMapper.deleteDetectionCabinetById(cabinetId, updateBy);
|
}
|
return rows;
|
}
|
|
/**
|
* 校验设备编码唯一性，编辑当前记录时允许命中自身。
|
*
|
* @param detectionCabinet 待校验检测柜
|
* @return true 表示唯一
|
*/
|
@Override
|
public boolean checkCabinetCodeUnique(TDetectionCabinet detectionCabinet)
|
{
|
Long cabinetId = StringUtils.isNull(detectionCabinet.getCabinetId()) ? -1L : detectionCabinet.getCabinetId();
|
TDetectionCabinet info = detectionCabinetMapper.selectByCabinetCode(detectionCabinet.getCabinetCode());
|
if (StringUtils.isNotNull(info) && info.getCabinetId().longValue() != cabinetId.longValue())
|
{
|
return UserConstants.NOT_UNIQUE;
|
}
|
return UserConstants.UNIQUE;
|
}
|
|
/**
|
* 校验 MAC 地址唯一性，调用方应传入规范化后的地址。
|
*
|
* @param detectionCabinet 待校验检测柜
|
* @return true 表示唯一
|
*/
|
@Override
|
public boolean checkMacAddressUnique(TDetectionCabinet detectionCabinet)
|
{
|
if (StringUtils.isBlank(detectionCabinet.getMacAddress()))
|
{
|
return UserConstants.UNIQUE;
|
}
|
Long cabinetId = StringUtils.isNull(detectionCabinet.getCabinetId()) ? -1L : detectionCabinet.getCabinetId();
|
TDetectionCabinet info = detectionCabinetMapper.selectByMacAddress(detectionCabinet.getMacAddress());
|
if (StringUtils.isNotNull(info) && info.getCabinetId().longValue() != cabinetId.longValue())
|
{
|
return UserConstants.NOT_UNIQUE;
|
}
|
return UserConstants.UNIQUE;
|
}
|
|
private void validateUniqueFields(TDetectionCabinet detectionCabinet)
|
{
|
if (!checkCabinetCodeUnique(detectionCabinet))
|
{
|
throw new ServiceException("设备编码已存在");
|
}
|
if (!checkMacAddressUnique(detectionCabinet))
|
{
|
throw new ServiceException("MAC地址已存在");
|
}
|
}
|
|
private void normalizeBasicFields(TDetectionCabinet detectionCabinet)
|
{
|
detectionCabinet.setCabinetCode(StringUtils.trim(detectionCabinet.getCabinetCode()));
|
detectionCabinet.setCabinetName(StringUtils.trim(detectionCabinet.getCabinetName()));
|
detectionCabinet.setIpAddress(StringUtils.trim(detectionCabinet.getIpAddress()));
|
detectionCabinet.setMacAddress(normalizeMacAddress(detectionCabinet.getMacAddress()));
|
detectionCabinet.setManufacturer(StringUtils.trim(detectionCabinet.getManufacturer()));
|
detectionCabinet.setModel(StringUtils.trim(detectionCabinet.getModel()));
|
detectionCabinet.setRemark(StringUtils.trim(detectionCabinet.getRemark()));
|
}
|
|
private String normalizeMacAddress(String macAddress)
|
{
|
String normalized = StringUtils.trim(macAddress);
|
return StringUtils.isBlank(normalized) ? null : normalized.replace('-', ':').toUpperCase(Locale.ROOT);
|
}
|
|
private void validateIpAddress(String ipAddress)
|
{
|
if (IpUtils.isIP(ipAddress))
|
{
|
return;
|
}
|
try
|
{
|
InetAddress address = InetAddress.getByName(ipAddress);
|
if (ipAddress.contains(":") && address instanceof Inet6Address)
|
{
|
return;
|
}
|
}
|
catch (Exception ignored)
|
{
|
}
|
throw new ServiceException("IP地址格式不正确");
|
}
|
|
/**
|
* 校验检测柜是否处于可操作状态。
|
*
|
* @param detectionCabinet 检测柜当前数据
|
* @param operation 业务操作名称
|
*/
|
private void validateCabinetNotTesting(TDetectionCabinet detectionCabinet, String operation)
|
{
|
if (TESTING.equals(detectionCabinet.getTestStatus()))
|
{
|
throw new ServiceException("检测柜正在测试，不能" + operation);
|
}
|
}
|
|
private void requireCabinetId(Long cabinetId)
|
{
|
if (StringUtils.isNull(cabinetId))
|
{
|
throw new ServiceException("检测柜ID不能为空");
|
}
|
}
|
|
private ServiceException buildDuplicateException(TDetectionCabinet detectionCabinet, DuplicateKeyException cause)
|
{
|
String message = checkCabinetCodeUnique(detectionCabinet) ? "MAC地址已存在" : "设备编码已存在";
|
return new ServiceException(message).setDetailMessage(cause.getMessage());
|
}
|
}
|
