package cn.iocoder.yudao.module.mes.service.dv.machinery;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.ObjUtil;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeListReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeSaveReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryTypeMapper;
|
import jakarta.annotation.Resource;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.util.*;
|
|
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 MesDvMachineryTypeServiceImpl implements MesDvMachineryTypeService {
|
|
@Resource
|
private MesDvMachineryTypeMapper machineryTypeMapper;
|
|
@Resource
|
@Lazy // 延迟加载，避免循环依赖
|
private MesDvMachineryService machineryService;
|
|
@Override
|
public Long createMachineryType(MesDvMachineryTypeSaveReqVO createReqVO) {
|
// 校验
|
validateMachineryTypeSaveData(createReqVO);
|
|
// 插入
|
MesDvMachineryTypeDO machineryType = BeanUtils.toBean(createReqVO, MesDvMachineryTypeDO.class);
|
machineryTypeMapper.insert(machineryType);
|
return machineryType.getId();
|
}
|
|
@Override
|
public void updateMachineryType(MesDvMachineryTypeSaveReqVO updateReqVO) {
|
// 校验
|
validateMachineryTypeSaveData(updateReqVO);
|
|
// 更新
|
MesDvMachineryTypeDO updateObj = BeanUtils.toBean(updateReqVO, MesDvMachineryTypeDO.class);
|
machineryTypeMapper.updateById(updateObj);
|
}
|
|
@Override
|
public void deleteMachineryType(Long id) {
|
// 1.1 校验存在
|
validateMachineryTypeExists(id);
|
// 1.2 校验是否有子类型
|
if (machineryTypeMapper.selectCountByParentId(id) > 0) {
|
throw exception(DV_MACHINERY_TYPE_EXITS_CHILDREN);
|
}
|
// 1.3 校验是否有设备
|
if (machineryService.getMachineryCountByMachineryTypeId(id) > 0) {
|
throw exception(DV_MACHINERY_TYPE_HAS_MACHINERY);
|
}
|
|
// 2. 删除
|
machineryTypeMapper.deleteById(id);
|
}
|
|
private void validateMachineryTypeSaveData(MesDvMachineryTypeSaveReqVO saveReqVO) {
|
if (saveReqVO.getId() != null) {
|
validateMachineryTypeExists(saveReqVO.getId());
|
}
|
// 校验父级节点有效性
|
validateParentMachineryType(saveReqVO.getId(), saveReqVO.getParentId());
|
// 校验类型名称唯一性
|
validateMachineryTypeNameUnique(saveReqVO.getId(), saveReqVO.getParentId(), saveReqVO.getName());
|
// 校验类型编码唯一性
|
validateMachineryTypeCodeUnique(saveReqVO.getId(), saveReqVO.getParentId(), saveReqVO.getCode());
|
}
|
|
private void validateMachineryTypeExists(Long id) {
|
if (machineryTypeMapper.selectById(id) == null) {
|
throw exception(DV_MACHINERY_TYPE_NOT_EXISTS);
|
}
|
}
|
|
private void validateParentMachineryType(Long id, Long parentId) {
|
if (parentId == null || MesDvMachineryTypeDO.PARENT_ID_ROOT.equals(parentId)) {
|
return;
|
}
|
// 1. 不能设置自己为父类型
|
if (Objects.equals(id, parentId)) {
|
throw exception(DV_MACHINERY_TYPE_PARENT_ERROR);
|
}
|
// 2. 父类型不存在
|
MesDvMachineryTypeDO parentType = machineryTypeMapper.selectById(parentId);
|
if (parentType == null) {
|
throw exception(DV_MACHINERY_TYPE_PARENT_NOT_EXITS);
|
}
|
// 3. 递归校验父类型，如果父类型是自己的子类型，则报错，避免形成环路
|
if (id == null) { // id 为空，说明新增，不需要考虑环路
|
return;
|
}
|
for (int i = 0; i < Short.MAX_VALUE; i++) {
|
// 3.1 校验环路
|
parentId = parentType.getParentId();
|
if (Objects.equals(id, parentId)) {
|
throw exception(DV_MACHINERY_TYPE_PARENT_IS_CHILD);
|
}
|
// 3.2 继续递归下一级父类型
|
if (parentId == null || MesDvMachineryTypeDO.PARENT_ID_ROOT.equals(parentId)) {
|
break;
|
}
|
parentType = machineryTypeMapper.selectById(parentId);
|
if (parentType == null) {
|
break;
|
}
|
}
|
}
|
|
private void validateMachineryTypeNameUnique(Long id, Long parentId, String name) {
|
MesDvMachineryTypeDO machineryType = machineryTypeMapper.selectByParentIdAndName(parentId, name);
|
if (machineryType == null) {
|
return;
|
}
|
if (ObjUtil.notEqual(machineryType.getId(), id)) {
|
throw exception(DV_MACHINERY_TYPE_NAME_DUPLICATE);
|
}
|
}
|
|
private void validateMachineryTypeCodeUnique(Long id, Long parentId, String code) {
|
MesDvMachineryTypeDO machineryType = machineryTypeMapper.selectByCode(code);
|
if (machineryType == null) {
|
return;
|
}
|
if (ObjUtil.notEqual(machineryType.getId(), id)) {
|
throw exception(DV_MACHINERY_TYPE_CODE_DUPLICATE);
|
}
|
}
|
|
@Override
|
public MesDvMachineryTypeDO getMachineryType(Long id) {
|
return machineryTypeMapper.selectById(id);
|
}
|
|
@Override
|
public List<MesDvMachineryTypeDO> getMachineryTypeList(MesDvMachineryTypeListReqVO listReqVO) {
|
return machineryTypeMapper.selectList(listReqVO);
|
}
|
|
@Override
|
public List<MesDvMachineryTypeDO> getMachineryTypeList(Collection<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return Collections.emptyList();
|
}
|
return machineryTypeMapper.selectByIds(ids);
|
}
|
|
@Override
|
public List<MesDvMachineryTypeDO> getMachineryTypeChildrenList(Long parentId) {
|
List<MesDvMachineryTypeDO> allList = machineryTypeMapper.selectList(); // 类型总量小，全量查
|
// 1. 构建 parentId -> children 的 Map（类似 menu 的 treeNodeMap 思路）
|
Map<Long, List<MesDvMachineryTypeDO>> parentChildrenMap = new LinkedHashMap<>();
|
allList.forEach(type -> parentChildrenMap
|
.computeIfAbsent(type.getParentId(), k -> new ArrayList<>()).add(type));
|
// 2. 收集所有后代节点
|
List<MesDvMachineryTypeDO> result = new ArrayList<>();
|
List<Long> parentIds = new ArrayList<>();
|
parentIds.add(parentId);
|
for (int i = 0; i < Short.MAX_VALUE; i++) {
|
if (i >= parentIds.size()) {
|
break;
|
}
|
List<MesDvMachineryTypeDO> children = parentChildrenMap.get(parentIds.get(i));
|
if (children == null) {
|
continue;
|
}
|
for (MesDvMachineryTypeDO child : children) {
|
result.add(child);
|
parentIds.add(child.getId());
|
}
|
}
|
return result;
|
}
|
|
}
|
