package cn.iocoder.yudao.module.mes.service.dc.device;
|
|
import cn.hutool.core.util.ObjUtil;
|
import cn.hutool.core.util.RandomUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.mes.controller.admin.dc.device.vo.MesDcDevicePageReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.dc.device.vo.MesDcDeviceSaveReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.dc.open.vo.MesDcHeartbeatReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.dc.open.vo.MesDcHeartbeatRespVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dc.device.MesDcDeviceDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dc.device.MesDcDeviceMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dc.record.MesDcRecordMapper;
|
import cn.iocoder.yudao.module.mes.enums.dc.MesDcDeviceStatusEnum;
|
import cn.iocoder.yudao.module.mes.enums.pro.MesProWorkOrderStatusEnum;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.nio.charset.StandardCharsets;
|
import java.security.MessageDigest;
|
import java.time.LocalDateTime;
|
import java.util.Arrays;
|
import java.util.List;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
|
|
/**
|
* MES 数据采集设备 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class MesDcDeviceServiceImpl implements MesDcDeviceService {
|
|
/**
|
* 采集令牌长度
|
*/
|
private static final int TOKEN_LENGTH = 40;
|
|
@Resource
|
private MesDcDeviceMapper deviceMapper;
|
@Resource
|
private MesDcRecordMapper recordMapper;
|
@Resource
|
private MesProWorkOrderService workOrderService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public MesDcDeviceDO createDevice(MesDcDeviceSaveReqVO createReqVO) {
|
validateDeviceCodeUnique(null, createReqVO.getCode());
|
MesDcDeviceDO device = BeanUtils.toBean(createReqVO, MesDcDeviceDO.class);
|
device.setId(null);
|
device.setToken(RandomUtil.randomString(TOKEN_LENGTH));
|
deviceMapper.insert(device);
|
return device;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateDevice(MesDcDeviceSaveReqVO updateReqVO) {
|
MesDcDeviceDO oldDevice = validateDeviceExists(updateReqVO.getId());
|
// 设备编号变化时校验唯一性(设备端需同步修改上报的 deviceCode)
|
if (StrUtil.isNotBlank(updateReqVO.getCode())
|
&& ObjUtil.notEqual(oldDevice.getCode(), updateReqVO.getCode())) {
|
validateDeviceCodeUnique(updateReqVO.getId(), updateReqVO.getCode());
|
}
|
MesDcDeviceDO updateObj = BeanUtils.toBean(updateReqVO, MesDcDeviceDO.class);
|
updateObj.setToken(null); // 令牌仅通过重置接口变更
|
deviceMapper.updateById(updateObj);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteDevice(Long id) {
|
MesDcDeviceDO device = validateDeviceExists(id);
|
Long recordCount = recordMapper.selectCountByDeviceId(id);
|
if (recordCount != null && recordCount > 0) {
|
throw exception(DC_DEVICE_DELETE_HAS_RECORD, device.getCode());
|
}
|
deviceMapper.deleteById(id);
|
}
|
|
@Override
|
public MesDcDeviceDO getDevice(Long id) {
|
return deviceMapper.selectById(id);
|
}
|
|
@Override
|
public MesDcDeviceDO validateDeviceExists(Long id) {
|
MesDcDeviceDO device = deviceMapper.selectById(id);
|
if (device == null) {
|
throw exception(DC_DEVICE_NOT_EXISTS);
|
}
|
return device;
|
}
|
|
@Override
|
public PageResult<MesDcDeviceDO> getDevicePage(MesDcDevicePageReqVO pageReqVO) {
|
return deviceMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public List<MesDcDeviceDO> getDeviceList() {
|
return deviceMapper.selectSimpleList();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public String resetToken(Long id) {
|
MesDcDeviceDO device = validateDeviceExists(id);
|
String token = RandomUtil.randomString(TOKEN_LENGTH);
|
MesDcDeviceDO updateObj = new MesDcDeviceDO();
|
updateObj.setId(device.getId());
|
updateObj.setToken(token);
|
deviceMapper.updateById(updateObj);
|
return token;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void bindWorkOrder(Long id, Long workOrderId) {
|
MesDcDeviceDO device = validateDeviceExists(id);
|
MesProWorkOrderDO workOrder = workOrderService.getWorkOrder(workOrderId);
|
if (workOrder == null) {
|
throw exception(DC_DEVICE_WORK_ORDER_NOT_EXISTS);
|
}
|
// 已完工、已取消的工单不能绑定
|
if (ObjUtil.equal(workOrder.getStatus(), MesProWorkOrderStatusEnum.FINISHED.getStatus())
|
|| ObjUtil.equal(workOrder.getStatus(), MesProWorkOrderStatusEnum.CANCELED.getStatus())) {
|
throw exception(DC_DEVICE_WORK_ORDER_BIND_INVALID, workOrder.getCode(),
|
resolveWorkOrderStatusName(workOrder.getStatus()));
|
}
|
MesDcDeviceDO updateObj = MesDcDeviceDO.builder()
|
.id(device.getId())
|
.workOrderId(workOrder.getId())
|
.workOrderCode(workOrder.getCode())
|
.bindTime(LocalDateTime.now())
|
.build();
|
deviceMapper.updateById(updateObj);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void unbindWorkOrder(Long id) {
|
MesDcDeviceDO device = validateDeviceExists(id);
|
deviceMapper.update(null, new LambdaUpdateWrapper<MesDcDeviceDO>()
|
.eq(MesDcDeviceDO::getId, device.getId())
|
.set(MesDcDeviceDO::getWorkOrderId, null)
|
.set(MesDcDeviceDO::getWorkOrderCode, null)
|
.set(MesDcDeviceDO::getBindTime, null));
|
}
|
|
@Override
|
public MesDcDeviceDO validateDeviceToken(String deviceCode, String token) {
|
if (StrUtil.isBlank(deviceCode)) {
|
throw exception(DC_DEVICE_CODE_MISSING);
|
}
|
if (StrUtil.isBlank(token)) {
|
throw exception(DC_DEVICE_TOKEN_REQUIRED);
|
}
|
MesDcDeviceDO device = deviceMapper.selectByCode(deviceCode);
|
if (device == null) {
|
throw exception(DC_DEVICE_CODE_NOT_EXISTS, deviceCode);
|
}
|
if (!isTokenMatch(token, device.getToken())) {
|
throw exception(DC_DEVICE_TOKEN_INVALID, device.getCode());
|
}
|
return device;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public MesDcHeartbeatRespVO heartbeat(MesDcHeartbeatReqVO heartbeatReqVO, String token) {
|
MesDcDeviceDO device = validateDeviceToken(heartbeatReqVO.getDeviceCode(), token);
|
MesDcDeviceDO updateObj = new MesDcDeviceDO();
|
updateObj.setId(device.getId());
|
updateObj.setLastHeartbeatTime(LocalDateTime.now());
|
if (StrUtil.isNotBlank(heartbeatReqVO.getFirmwareVersion())) {
|
updateObj.setFirmwareVersion(heartbeatReqVO.getFirmwareVersion());
|
}
|
if (StrUtil.isNotBlank(heartbeatReqVO.getIp())) {
|
updateObj.setDeviceIp(heartbeatReqVO.getIp());
|
}
|
deviceMapper.updateById(updateObj);
|
|
MesDcHeartbeatRespVO respVO = new MesDcHeartbeatRespVO();
|
respVO.setServerTime(LocalDateTime.now());
|
respVO.setDeviceName(device.getName());
|
respVO.setEnabled(ObjUtil.equal(device.getStatus(), MesDcDeviceStatusEnum.ENABLE.getStatus()));
|
respVO.setWorkOrderId(device.getWorkOrderId());
|
respVO.setWorkOrderCode(device.getWorkOrderCode());
|
return respVO;
|
}
|
|
// ==================== 私有方法 ====================
|
|
private void validateDeviceCodeUnique(Long id, String code) {
|
MesDcDeviceDO device = deviceMapper.selectByCode(code);
|
if (device != null && ObjUtil.notEqual(device.getId(), id)) {
|
throw exception(DC_DEVICE_CODE_DUPLICATE, code);
|
}
|
}
|
|
private static boolean isTokenMatch(String submittedToken, String storedToken) {
|
if (submittedToken == null || storedToken == null) {
|
return false;
|
}
|
return MessageDigest.isEqual(submittedToken.getBytes(StandardCharsets.UTF_8),
|
storedToken.getBytes(StandardCharsets.UTF_8));
|
}
|
|
private static String resolveWorkOrderStatusName(Integer status) {
|
return Arrays.stream(MesProWorkOrderStatusEnum.values())
|
.filter(item -> ObjUtil.equal(item.getStatus(), status))
|
.findFirst().map(MesProWorkOrderStatusEnum::getName)
|
.orElse("未知状态(" + status + ")");
|
}
|
|
}
|