package com.ruoyi.system.service.impl;
|
|
import java.net.Inet6Address;
|
import java.net.InetAddress;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
import java.time.Instant;
|
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.TDetectionChannel;
|
import com.ruoyi.system.domain.vo.DiscoveredCabinetVo;
|
import com.ruoyi.system.mapper.TDetectionCabinetMapper;
|
import com.ruoyi.system.service.ITDetectionCabinetService;
|
import com.battery.device.discovery.DeviceDiscoveryCandidateStore;
|
import com.battery.device.discovery.DeviceDiscoveryCandidateStore.CabinetCandidate;
|
import com.battery.device.model.DeviceWorkStatus;
|
|
/**
|
* 检测柜 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 ONLINE = "0";
|
private static final String OFFLINE = "1";
|
private static final Set<DeviceWorkStatus> ACTIVE_WORK_STATUSES = Set.of(DeviceWorkStatus.WORKING,
|
DeviceWorkStatus.PAUSED, DeviceWorkStatus.PROTECTED, DeviceWorkStatus.SYNCHRONIZING,
|
DeviceWorkStatus.LIT, DeviceWorkStatus.WAITING_TIMEOUT, DeviceWorkStatus.WAITING_START,
|
DeviceWorkStatus.LOCKED);
|
|
private final TDetectionCabinetMapper detectionCabinetMapper;
|
private final DeviceDiscoveryCandidateStore candidateStore;
|
|
/**
|
* 构造检测柜业务服务。
|
*
|
* @param detectionCabinetMapper 检测柜数据访问对象
|
*/
|
public TDetectionCabinetServiceImpl(TDetectionCabinetMapper detectionCabinetMapper,
|
DeviceDiscoveryCandidateStore candidateStore)
|
{
|
this.detectionCabinetMapper = detectionCabinetMapper;
|
this.candidateStore = candidateStore;
|
}
|
|
/**
|
* 查询指定检测柜，并在记录不存在或已逻辑删除时统一抛出业务异常。
|
*
|
* @param cabinetId 检测柜主键
|
* @return 检测柜信息
|
*/
|
@Override
|
public TDetectionCabinet selectDetectionCabinetById(Long cabinetId)
|
{
|
TDetectionCabinet detectionCabinet = detectionCabinetMapper.selectDetectionCabinetById(cabinetId);
|
if (StringUtils.isNull(detectionCabinet))
|
{
|
throw new ServiceException("检测柜不存在或已删除");
|
}
|
return applyRealtimeState(detectionCabinet, candidatesByCode());
|
}
|
|
/**
|
* 查询检测柜列表；查询 MAC 地址时先转换为统一格式，避免分隔符和大小写导致漏查。
|
*
|
* @param detectionCabinet 查询条件
|
* @return 检测柜列表
|
*/
|
@Override
|
public List<TDetectionCabinet> selectDetectionCabinetList(TDetectionCabinet detectionCabinet)
|
{
|
String requestedOnlineStatus = detectionCabinet.getOnlineStatus();
|
String requestedTestStatus = detectionCabinet.getTestStatus();
|
if (StringUtils.isNotBlank(detectionCabinet.getMacAddress()))
|
{
|
detectionCabinet.setMacAddress(normalizeMacAddress(detectionCabinet.getMacAddress()));
|
}
|
detectionCabinet.setOnlineStatus(null);
|
detectionCabinet.setTestStatus(null);
|
Map<String, CabinetCandidate> candidates = candidatesByCode();
|
return detectionCabinetMapper.selectDetectionCabinetList(detectionCabinet).stream()
|
.map(item -> applyRealtimeState(item, candidates))
|
.filter(item -> StringUtils.isBlank(requestedOnlineStatus)
|
|| requestedOnlineStatus.equals(item.getOnlineStatus()))
|
.filter(item -> StringUtils.isBlank(requestedTestStatus)
|
|| requestedTestStatus.equals(item.getTestStatus()))
|
.toList();
|
}
|
|
/**
|
* 读取 Redis 在线候选供原选择设备弹窗展示，不生成模拟设备。
|
* 测试占用状态由实时通道工作状态聚合；测试归属留待后续绑定闭环确认。
|
*
|
* @return 可供选择的检测柜设备摘要
|
*/
|
@Override
|
public List<DiscoveredCabinetVo> selectDiscoveredCabinetList()
|
{
|
Set<String> registeredCodes = Set.copyOf(detectionCabinetMapper.selectRegisteredCabinetCodes());
|
return candidateStore.snapshot(Instant.now()).cabinets().stream()
|
.filter(CabinetCandidate::online)
|
.filter(candidate -> !registeredCodes.contains(candidate.deviceCode()))
|
.map(candidate -> {
|
boolean active = isActive(candidate);
|
return new DiscoveredCabinetVo(
|
candidate.deviceCode(), candidate.ip(), candidate.mac(), candidate.name(),
|
candidate.manufacturer(), candidate.model(), candidate.channels().size(), "在线",
|
active ? "测试中" : "空闲",
|
active ? "待确认" : "-");
|
})
|
.toList();
|
}
|
|
/**
|
* 将操作员选择的发现候选设备登记为检测柜，并保留其适配器和通道身份。
|
*
|
* @param detectionCabinet 检测柜信息
|
* @return 影响行数
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int insertDetectionCabinet(TDetectionCabinet detectionCabinet)
|
{
|
normalizeBasicFields(detectionCabinet);
|
CabinetCandidate candidate = candidateStore.findCabinet(detectionCabinet.getCabinetCode(), Instant.now())
|
.filter(CabinetCandidate::online)
|
.orElseThrow(() -> new ServiceException("请先选择在线的发现候选设备"));
|
detectionCabinet.setAdapterId(candidate.adapterId());
|
detectionCabinet.setAdapterCode(candidate.adapterCode());
|
detectionCabinet.setVendorDeviceType(candidate.devtype());
|
detectionCabinet.setVendorDeviceId(candidate.devid());
|
detectionCabinet.setIpAddress(candidate.ip());
|
detectionCabinet.setMacAddress(candidate.mac() == null ? detectionCabinet.getMacAddress() : candidate.mac());
|
detectionCabinet.setChannelCount(candidate.channels().size());
|
validateIpAddress(detectionCabinet.getIpAddress());
|
validateUniqueFields(detectionCabinet);
|
detectionCabinet.setOnlineStatus("OFFLINE");
|
detectionCabinet.setLastSeenAtUtc(null);
|
detectionCabinet.setStatus(NORMAL);
|
try
|
{
|
int rows = detectionCabinetMapper.insertDetectionCabinet(detectionCabinet);
|
for (var channel : candidate.channels())
|
{
|
TDetectionChannel value = new TDetectionChannel();
|
value.setAdapterId(candidate.adapterId());
|
value.setAdapterCode(candidate.adapterCode());
|
value.setCabinetId(detectionCabinet.getCabinetId());
|
value.setDevtype(channel.identity().devtype());
|
value.setDevid(channel.identity().devid());
|
value.setSubdevid(channel.identity().subdevid());
|
value.setChlid(channel.identity().chlid());
|
value.setDisplayNo(channel.identity().subdevid() + "-" + channel.identity().chlid());
|
value.setOnlineStatus("UNKNOWN");
|
value.setWorkStatus("UNKNOWN");
|
value.setLastSeenAtUtc(null);
|
detectionCabinetMapper.insertDetectionChannel(value);
|
}
|
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)
|
{
|
detectionCabinetMapper.deleteDetectionChannelsByCabinetId(cabinetId);
|
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 Map<String, CabinetCandidate> candidatesByCode()
|
{
|
return candidateStore.snapshot(Instant.now()).cabinets().stream()
|
.collect(java.util.stream.Collectors.toMap(CabinetCandidate::deviceCode, item -> item));
|
}
|
|
private TDetectionCabinet applyRealtimeState(TDetectionCabinet cabinet,
|
Map<String, CabinetCandidate> candidates)
|
{
|
CabinetCandidate candidate = candidates.get(cabinet.getCabinetCode());
|
cabinet.setOnlineStatus(candidate != null && candidate.online() ? ONLINE : OFFLINE);
|
return cabinet;
|
}
|
|
private boolean isActive(CabinetCandidate candidate)
|
{
|
return candidate.channels().stream().anyMatch(channel -> ACTIVE_WORK_STATUSES.contains(channel.workStatus()));
|
}
|
|
private ServiceException buildDuplicateException(TDetectionCabinet detectionCabinet, DuplicateKeyException cause)
|
{
|
String message = checkCabinetCodeUnique(detectionCabinet) ? "MAC地址已存在" : "设备编码已存在";
|
return new ServiceException(message).setDetailMessage(cause.getMessage());
|
}
|
}
|
