package cn.iocoder.yudao.module.mes.service.qc.indicator;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.ObjUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
|
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicator.vo.MesQcIndicatorPageReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicator.vo.MesQcIndicatorSaveReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.qc.indicator.MesQcIndicatorMapper;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcIndicatorItemTypeEnum;
|
import cn.iocoder.yudao.module.mes.enums.qc.MesQcResultValueTypeEnum;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertList;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
|
|
/**
|
* MES 质检指标 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class MesQcIndicatorServiceImpl implements MesQcIndicatorService {
|
|
@Resource
|
private MesQcIndicatorMapper indicatorMapper;
|
|
@Override
|
public Long createIndicator(MesQcIndicatorSaveReqVO createReqVO) {
|
// 校验相关参数
|
validateIndicatorSaveData(null, createReqVO);
|
|
// 插入
|
MesQcIndicatorDO indicator = BeanUtils.toBean(createReqVO, MesQcIndicatorDO.class);
|
normalizeHierarchy(indicator);
|
indicatorMapper.insert(indicator);
|
return indicator.getId();
|
}
|
|
@Override
|
public void updateIndicator(MesQcIndicatorSaveReqVO updateReqVO) {
|
// 校验存在
|
validateIndicatorExists(updateReqVO.getId());
|
// 校验相关参数
|
validateIndicatorSaveData(updateReqVO.getId(), updateReqVO);
|
|
// 更新
|
MesQcIndicatorDO updateObj = BeanUtils.toBean(updateReqVO, MesQcIndicatorDO.class);
|
normalizeHierarchy(updateObj);
|
indicatorMapper.updateById(updateObj);
|
}
|
|
@Override
|
public void deleteIndicator(Long id) {
|
// 校验存在
|
validateIndicatorExists(id);
|
// 级联删除子项：指标只支持两层，挂在它下面的都是它的明细项，父删了子无处可挂
|
List<MesQcIndicatorDO> children = indicatorMapper.selectListByParentId(id);
|
if (CollUtil.isNotEmpty(children)) {
|
indicatorMapper.deleteByIds(convertList(children, MesQcIndicatorDO::getId));
|
}
|
// 删除
|
indicatorMapper.deleteById(id);
|
}
|
|
private void validateIndicatorSaveData(Long id, MesQcIndicatorSaveReqVO saveReqVO) {
|
// 校验编码唯一
|
validateIndicatorCodeUnique(id, saveReqVO.getCode());
|
// 校验名称唯一
|
validateIndicatorNameUnique(id, saveReqVO.getName());
|
// 校验层级归属（只允许两层）
|
validateHierarchy(id, saveReqVO);
|
// 校验结果值属性
|
validateResultSpecification(saveReqVO.getItemType(), saveReqVO.getResultType(), saveReqVO.getResultSpecification());
|
}
|
|
/**
|
* 校验层级归属。只允许两层：分组项必须顶级，录入项可挂到分组项下。
|
* <p>
|
* 「父必须是分组项」这条本身就掐死了第三层，所以不再单独写一条「父必须顶级」的校验。
|
* 按业务优先级只抛第一处不满足，避免一次抛多条让用户抓不住重点。
|
*/
|
private void validateHierarchy(Long id, MesQcIndicatorSaveReqVO reqVO) {
|
Long parentId = ObjectUtils.defaultIfNull(reqVO.getParentId(), MesQcIndicatorDO.PARENT_ID_ROOT);
|
Integer itemType = ObjectUtils.defaultIfNull(reqVO.getItemType(), MesQcIndicatorItemTypeEnum.ENTRY.getType());
|
// 1. 分组项只能顶级
|
if (MesQcIndicatorItemTypeEnum.isGroup(itemType) && !MesQcIndicatorDO.PARENT_ID_ROOT.equals(parentId)) {
|
throw new ServiceException(QC_INDICATOR_GROUP_CANNOT_NEST.getCode(),
|
String.format("分组项[%s]必须作为顶级指标，不能挂到其它指标下（当前选择了父指标[%s]）。"
|
+ "如需调整层级，请把「条目类型」改为录入项后再选择所属分组。",
|
defaultStr(reqVO.getName()), nameOf(parentId)));
|
}
|
// 2. 父指标必须存在且是分组项
|
if (!MesQcIndicatorDO.PARENT_ID_ROOT.equals(parentId)) {
|
if (Objects.equals(id, parentId)) {
|
throw exception(QC_INDICATOR_PARENT_SELF);
|
}
|
MesQcIndicatorDO parent = indicatorMapper.selectById(parentId);
|
if (parent == null) {
|
throw new ServiceException(QC_INDICATOR_PARENT_NOT_EXISTS.getCode(),
|
String.format("所属分组不存在（指标编号 %d 查无此指标，可能已被删除）。请重新选择所属分组，或清空该项作为顶级指标。",
|
parentId));
|
}
|
if (!MesQcIndicatorItemTypeEnum.isGroup(parent.getItemType())) {
|
throw new ServiceException(QC_INDICATOR_PARENT_NOT_GROUP.getCode(),
|
String.format("所选父指标[%s]不是分组项（当前条目类型为[%s]），不能作为所属分组。"
|
+ "请改选一个分组项，或先在指标列表把[%s]的条目类型改为分组项。",
|
defaultStr(parent.getName()), itemTypeNameOf(parent.getItemType()), defaultStr(parent.getName())));
|
}
|
}
|
// 3. 录入项必须有结果值类型（分组项没有结果值，现网分组行 result_type 就是 NULL）
|
if (!MesQcIndicatorItemTypeEnum.isGroup(itemType) && reqVO.getResultType() == null) {
|
throw exception(QC_INDICATOR_RESULT_TYPE_REQUIRED);
|
}
|
// 4. 自己已经有子项时，不能再被别人收编、也不能反过来变成子项
|
if (id == null) {
|
return;
|
}
|
Long childCount = indicatorMapper.selectCountByParentId(id);
|
if (childCount <= 0) {
|
return;
|
}
|
if (!MesQcIndicatorDO.PARENT_ID_ROOT.equals(parentId)) {
|
throw new ServiceException(QC_INDICATOR_HAS_CHILDREN.getCode(),
|
String.format("指标[%s]下已挂有 %d 个录入项，不能再挂到其它分组下（指标只支持两层）。"
|
+ "请先删除或移走这 %d 个子项，再修改它的所属分组。",
|
defaultStr(reqVO.getName()), childCount, childCount));
|
}
|
if (!MesQcIndicatorItemTypeEnum.isGroup(itemType)) {
|
throw new ServiceException(QC_INDICATOR_HAS_CHILDREN.getCode(),
|
String.format("指标[%s]下已挂有 %d 个录入项，不能再把它的条目类型改为录入项，否则这些子项会失去所属分组。"
|
+ "请先删除或移走这 %d 个子项，再修改条目类型。",
|
defaultStr(reqVO.getName()), childCount, childCount));
|
}
|
}
|
|
/**
|
* 落库前补齐层级字段：分组项清空结果值（现网分组行没有结果值），排序号留空则排到同级末尾
|
*/
|
private void normalizeHierarchy(MesQcIndicatorDO indicator) {
|
indicator.setParentId(ObjectUtils.defaultIfNull(indicator.getParentId(), MesQcIndicatorDO.PARENT_ID_ROOT));
|
indicator.setItemType(ObjectUtils.defaultIfNull(indicator.getItemType(), MesQcIndicatorItemTypeEnum.ENTRY.getType()));
|
if (MesQcIndicatorItemTypeEnum.isGroup(indicator.getItemType())) {
|
indicator.setResultType(null);
|
indicator.setResultSpecification(null);
|
}
|
if (indicator.getSortOrder() == null) {
|
Integer max = indicatorMapper.selectMaxSortOrder(indicator.getParentId());
|
indicator.setSortOrder((max == null ? 0 : max) + (MesQcIndicatorDO.PARENT_ID_ROOT.equals(indicator.getParentId()) ? 10 : 1));
|
}
|
}
|
|
private String nameOf(Long id) {
|
MesQcIndicatorDO indicator = id == null ? null : indicatorMapper.selectById(id);
|
return indicator == null ? String.valueOf(id) : defaultStr(indicator.getName());
|
}
|
|
private static String itemTypeNameOf(Integer itemType) {
|
return MesQcIndicatorItemTypeEnum.isGroup(itemType)
|
? MesQcIndicatorItemTypeEnum.GROUP.getName() : MesQcIndicatorItemTypeEnum.ENTRY.getName();
|
}
|
|
private static String defaultStr(String value) {
|
return StrUtil.blankToDefault(value, "");
|
}
|
|
private void validateIndicatorExists(Long id) {
|
if (indicatorMapper.selectById(id) == null) {
|
throw exception(QC_INDICATOR_NOT_EXISTS);
|
}
|
}
|
|
private void validateIndicatorCodeUnique(Long id, String code) {
|
MesQcIndicatorDO indicator = indicatorMapper.selectByCode(code);
|
if (indicator == null) {
|
return;
|
}
|
if (ObjUtil.notEqual(indicator.getId(), id)) {
|
throw exception(QC_INDICATOR_CODE_DUPLICATE);
|
}
|
}
|
|
private void validateIndicatorNameUnique(Long id, String name) {
|
MesQcIndicatorDO indicator = indicatorMapper.selectByName(name);
|
if (indicator == null) {
|
return;
|
}
|
if (ObjUtil.notEqual(indicator.getId(), id)) {
|
throw exception(QC_INDICATOR_NAME_DUPLICATE);
|
}
|
}
|
|
private void validateResultSpecification(Integer itemType, Integer resultType, String resultSpecification) {
|
// 分组项没有结果值，落库前会被清空，这里不校验
|
if (MesQcIndicatorItemTypeEnum.isGroup(ObjectUtils.defaultIfNull(itemType, MesQcIndicatorItemTypeEnum.ENTRY.getType()))) {
|
return;
|
}
|
if (ObjectUtils.equalsAny(resultType, MesQcResultValueTypeEnum.FILE.getType(),
|
MesQcResultValueTypeEnum.DICT.getType())) {
|
if (StrUtil.isBlank(resultSpecification)) {
|
throw exception(QC_INDICATOR_RESULT_SPECIFICATION_REQUIRED);
|
}
|
}
|
}
|
|
@Override
|
public MesQcIndicatorDO getIndicator(Long id) {
|
return indicatorMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<MesQcIndicatorDO> getIndicatorPage(MesQcIndicatorPageReqVO pageReqVO) {
|
return indicatorMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public List<MesQcIndicatorDO> getIndicatorList() {
|
return indicatorMapper.selectList();
|
}
|
|
@Override
|
public List<MesQcIndicatorDO> getIndicatorGroupList() {
|
return indicatorMapper.selectListByItemType(MesQcIndicatorItemTypeEnum.GROUP.getType());
|
}
|
|
@Override
|
public List<MesQcIndicatorDO> getIndicatorList(Collection<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return Collections.emptyList();
|
}
|
return indicatorMapper.selectByIds(ids);
|
}
|
|
@Override
|
public Map<Long, MesQcIndicatorDO> validateIndicatorListExists(Collection<Long> ids) {
|
List<MesQcIndicatorDO> indicators = getIndicatorList(ids);
|
if (indicators.size() != ids.size()) {
|
throw exception(QC_INDICATOR_NOT_EXISTS);
|
}
|
return convertMap(indicators, MesQcIndicatorDO::getId);
|
}
|
|
}
|
