package cn.iocoder.yudao.module.mes.service.pro.route;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.NumberUtil;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.process.MesProRouteProcessSaveReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessOutputDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProductBomDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProductDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.route.MesProRouteProcessMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.route.MesProRouteProcessOutputMapper;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import jakarta.annotation.Resource;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
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 MesProRouteProcessServiceImpl implements MesProRouteProcessService {
|
|
/**
|
* 产出排序：主产出优先，其次按 sort，最后按 id
|
*/
|
private static final Comparator<MesProRouteProcessOutputDO> OUTPUT_ORDER = Comparator
|
.comparing((MesProRouteProcessOutputDO o) -> Boolean.TRUE.equals(o.getMainFlag()),
|
Comparator.reverseOrder())
|
.thenComparing(MesProRouteProcessOutputDO::getSort, Comparator.nullsLast(Comparator.naturalOrder()))
|
.thenComparing(MesProRouteProcessOutputDO::getId, Comparator.nullsLast(Comparator.naturalOrder()));
|
|
@Resource
|
private MesProRouteProcessMapper routeProcessMapper;
|
@Resource
|
private MesProRouteProcessOutputMapper routeProcessOutputMapper;
|
|
@Resource
|
@Lazy
|
private MesProRouteProductService routeProductService;
|
@Resource
|
@Lazy
|
private MesProProcessService processService;
|
@Resource
|
@Lazy
|
private MesProRouteService routeService;
|
@Resource
|
@Lazy
|
private MesProRouteProductBomService routeProductBomService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createRouteProcess(MesProRouteProcessSaveReqVO createReqVO) {
|
// 1.0 已启用的工艺路线，不允许操作
|
routeService.validateRouteNotEnable(createReqVO.getRouteId());
|
// 1.1 校验工艺路线、工序存在
|
validateRouteAndProcessExists(createReqVO.getRouteId(), createReqVO.getProcessId());
|
// 1.2 校验唯一性
|
validateSortUnique(null, createReqVO.getRouteId(), createReqVO.getSort());
|
validateProcessUnique(null, createReqVO.getRouteId(), createReqVO.getProcessId());
|
validateKeyProcessUnique(null, createReqVO.getRouteId(), createReqVO.getKeyFlag());
|
|
// 2. 插入
|
MesProRouteProcessDO routeProcess = BeanUtils.toBean(createReqVO, MesProRouteProcessDO.class);
|
routeProcess.setOutputItemId(resolveOutputItemId(createReqVO));
|
routeProcessMapper.insert(routeProcess);
|
// 2.1 保存产出归属配置
|
saveRouteProcessOutputs(routeProcess, createReqVO);
|
|
// 3. 更新工序链
|
rebuildProcessChain(createReqVO.getRouteId());
|
return routeProcess.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateRouteProcess(MesProRouteProcessSaveReqVO updateReqVO) {
|
// 1.0 已启用的工艺路线，不允许操作
|
routeService.validateRouteNotEnable(updateReqVO.getRouteId());
|
// 1.1 校验存在
|
validateRouteProcessExists(updateReqVO.getId());
|
// 1.2 校验工艺路线、工序存在
|
validateRouteAndProcessExists(updateReqVO.getRouteId(), updateReqVO.getProcessId());
|
// 1.3 校验唯一性
|
validateSortUnique(updateReqVO.getId(), updateReqVO.getRouteId(), updateReqVO.getSort());
|
validateProcessUnique(updateReqVO.getId(), updateReqVO.getRouteId(), updateReqVO.getProcessId());
|
validateKeyProcessUnique(updateReqVO.getId(), updateReqVO.getRouteId(), updateReqVO.getKeyFlag());
|
|
// 2. 更新
|
MesProRouteProcessDO updateObj = BeanUtils.toBean(updateReqVO, MesProRouteProcessDO.class);
|
// 空数组也要显式写入空串，否则 MyBatis-Plus 默认忽略 null，用户清空产出品后旧配置仍会残留。
|
updateObj.setOutputItemId(resolveOutputItemId(updateReqVO));
|
routeProcessMapper.updateById(updateObj);
|
// 2.1 覆盖产出归属配置
|
saveRouteProcessOutputs(updateObj, updateReqVO);
|
|
// 3. 重建工序链
|
rebuildProcessChain(updateReqVO.getRouteId());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteRouteProcess(Long id) {
|
// 1.1 校验存在
|
MesProRouteProcessDO routeProcess = validateRouteProcessExists(id);
|
// 1.2 已启用的工艺路线，不允许操作
|
routeService.validateRouteNotEnable(routeProcess.getRouteId());
|
|
// 2. 删除（含产出归属配置）
|
routeProcessMapper.deleteById(id);
|
routeProcessOutputMapper.deleteByRouteProcessId(id);
|
|
// 3. 重建工序链
|
rebuildProcessChain(routeProcess.getRouteId());
|
}
|
|
/**
|
* 重建工序链（更新所有工序的 nextProcessId）
|
*/
|
private void rebuildProcessChain(Long routeId) {
|
List<MesProRouteProcessDO> list = routeProcessMapper.selectListByRouteId(routeId);
|
if (CollUtil.isEmpty(list)) {
|
return;
|
}
|
// 按 sort 排序
|
list.sort(Comparator.comparing(MesProRouteProcessDO::getSort));
|
for (int i = 0; i < list.size(); i++) {
|
MesProRouteProcessDO item = list.get(i);
|
if (i + 1 < list.size()) {
|
item.setNextProcessId(list.get(i + 1).getProcessId());
|
} else {
|
item.setNextProcessId(null);
|
}
|
routeProcessMapper.updateById(item);
|
}
|
}
|
|
private MesProRouteProcessDO validateRouteProcessExists(Long id) {
|
MesProRouteProcessDO routeProcess = routeProcessMapper.selectById(id);
|
if (routeProcess == null) {
|
throw exception(PRO_ROUTE_PROCESS_NOT_EXISTS);
|
}
|
return routeProcess;
|
}
|
|
private void validateRouteAndProcessExists(Long routeId, Long processId) {
|
if (routeService.getRoute(routeId) == null) {
|
throw exception(PRO_ROUTE_NOT_EXISTS);
|
}
|
if (processService.getProcess(processId) == null) {
|
throw exception(PRO_ROUTE_PROCESS_NOT_EXISTS);
|
}
|
}
|
|
private void validateSortUnique(Long id, Long routeId, Integer sort) {
|
MesProRouteProcessDO existing = routeProcessMapper.selectByRouteIdAndSort(routeId, sort);
|
if (existing != null && !existing.getId().equals(id)) {
|
throw exception(PRO_ROUTE_PROCESS_SORT_DUPLICATE);
|
}
|
}
|
|
private void validateProcessUnique(Long id, Long routeId, Long processId) {
|
MesProRouteProcessDO existing = routeProcessMapper.selectByRouteIdAndProcessId(routeId, processId);
|
if (existing != null && !existing.getId().equals(id)) {
|
throw exception(PRO_ROUTE_PROCESS_DUPLICATE);
|
}
|
}
|
|
private void validateKeyProcessUnique(Long id, Long routeId, Boolean keyFlag) {
|
if (!Boolean.TRUE.equals(keyFlag)) {
|
return;
|
}
|
MesProRouteProcessDO existing = routeProcessMapper.selectKeyProcessByRouteId(routeId);
|
if (existing != null && !existing.getId().equals(id)) {
|
throw exception(PRO_ROUTE_PROCESS_KEY_DUPLICATE);
|
}
|
}
|
|
@Override
|
public MesProRouteProcessDO getRouteProcess(Long id) {
|
return routeProcessMapper.selectById(id);
|
}
|
|
@Override
|
public List<MesProRouteProcessDO> getRouteProcessListByRouteId(Long routeId) {
|
return routeProcessMapper.selectListByRouteId(routeId);
|
}
|
|
@Override
|
public List<MesProRouteProcessDO> getRouteProcessListByRouteIds(Collection<Long> routeIds) {
|
if (CollUtil.isEmpty(routeIds)) {
|
return Collections.emptyList();
|
}
|
return routeProcessMapper.selectListByRouteIds(routeIds);
|
}
|
|
@Override
|
public MesProRouteProcessDO getRouteProcessByRouteIdAndProcessId(Long routeId, Long processId) {
|
return routeProcessMapper.selectByRouteIdAndProcessId(routeId, processId);
|
}
|
|
@Override
|
public List<MesProRouteProcessDO> getRouteProcessListByProductId(Long productId) {
|
// 1. 根据产品查找关联的工艺路线产品记录
|
MesProRouteProductDO routeProduct = routeProductService.getRouteProductByItemId(productId);
|
if (routeProduct == null) {
|
return Collections.emptyList();
|
}
|
// 2. 返回该工艺路线的工序列表
|
List<MesProRouteProcessDO> list = routeProcessMapper.selectListByRouteId(routeProduct.getRouteId());
|
// 3. 按产出归属过滤：通用产出 + 当前产品专属产出
|
Map<Long, List<MesProRouteProcessOutputDO>> outputMap = routeProcessOutputMapper
|
.selectListByRouteId(routeProduct.getRouteId()).stream()
|
.collect(Collectors.groupingBy(MesProRouteProcessOutputDO::getRouteProcessId));
|
for (MesProRouteProcessDO process : list) {
|
List<MesProRouteProcessOutputDO> outputs = outputMap.get(process.getId());
|
if (CollUtil.isEmpty(outputs)) {
|
// 存量数据未拆分归属时，退回旧的“剔除同路线其它产品”逻辑
|
filterOtherProductOutputs(Collections.singletonList(process), routeProduct);
|
continue;
|
}
|
String filtered = outputs.stream()
|
.filter(output -> output.getProductId() == null || output.getProductId().equals(productId))
|
.sorted(OUTPUT_ORDER)
|
.map(MesProRouteProcessOutputDO::getItemId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.map(String::valueOf)
|
.collect(Collectors.joining(","));
|
process.setOutputItemId(filtered.isEmpty() ? null : filtered);
|
}
|
return list;
|
}
|
|
@Override
|
public List<Long> getOutputItemIdsByRouteProcessId(Long routeProcessId, Long productId) {
|
List<MesProRouteProcessOutputDO> outputs = routeProcessOutputMapper.selectListByRouteProcessId(routeProcessId);
|
if (CollUtil.isEmpty(outputs)) {
|
// 未配置产出归属（存量数据）返回 null，便于调用方回退聚合产出
|
return null;
|
}
|
return outputs.stream()
|
.filter(output -> output.getProductId() == null || output.getProductId().equals(productId))
|
.sorted(OUTPUT_ORDER)
|
.map(MesProRouteProcessOutputDO::getItemId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.collect(Collectors.toList());
|
}
|
|
@Override
|
public List<MesProRouteProcessOutputDO> getProcessOutputs(Long routeProcessId, Long productId) {
|
if (routeProcessId == null) {
|
return Collections.emptyList();
|
}
|
List<MesProRouteProcessOutputDO> outputs = routeProcessOutputMapper.selectListByRouteProcessId(routeProcessId);
|
if (CollUtil.isEmpty(outputs)) {
|
return Collections.emptyList();
|
}
|
// 主产出优先排序，并按 itemId 去重
|
Map<Long, MesProRouteProcessOutputDO> distinct = new LinkedHashMap<>();
|
outputs.stream()
|
.filter(output -> output.getProductId() == null || output.getProductId().equals(productId))
|
.filter(output -> output.getItemId() != null)
|
.sorted(OUTPUT_ORDER)
|
.forEach(output -> distinct.putIfAbsent(output.getItemId(), output));
|
return new ArrayList<>(distinct.values());
|
}
|
|
@Override
|
public List<MesProRouteProcessOutputDO> getRouteProcessOutputListByRouteProcessIds(Collection<Long> routeProcessIds) {
|
if (CollUtil.isEmpty(routeProcessIds)) {
|
return Collections.emptyList();
|
}
|
return routeProcessOutputMapper.selectListByRouteProcessIds(routeProcessIds);
|
}
|
|
/**
|
* 计算工序产出物料的聚合串（逗号分隔，去重）
|
*
|
* 优先使用产出归属配置（outputs），未传时兼容 outputItemIds。
|
*/
|
private String resolveOutputItemId(MesProRouteProcessSaveReqVO reqVO) {
|
List<Long> itemIds;
|
if (CollUtil.isNotEmpty(reqVO.getOutputs())) {
|
itemIds = reqVO.getOutputs().stream()
|
.filter(Objects::nonNull)
|
.sorted(Comparator
|
.comparing((MesProRouteProcessSaveReqVO.OutputItem o) -> Boolean.TRUE.equals(o.getMainFlag()),
|
Comparator.reverseOrder())
|
.thenComparing(MesProRouteProcessSaveReqVO.OutputItem::getSort,
|
Comparator.nullsLast(Comparator.naturalOrder()))
|
.thenComparing(MesProRouteProcessSaveReqVO.OutputItem::getItemId,
|
Comparator.nullsLast(Comparator.naturalOrder())))
|
.map(MesProRouteProcessSaveReqVO.OutputItem::getItemId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.collect(Collectors.toList());
|
} else if (CollUtil.isNotEmpty(reqVO.getOutputItemIds())) {
|
itemIds = reqVO.getOutputItemIds().stream()
|
.filter(Objects::nonNull)
|
.distinct()
|
.collect(Collectors.toList());
|
} else {
|
itemIds = Collections.emptyList();
|
}
|
return itemIds.stream().map(String::valueOf).collect(Collectors.joining(","));
|
}
|
|
/**
|
* 覆盖保存工序产出归属配置
|
*/
|
private void saveRouteProcessOutputs(MesProRouteProcessDO routeProcess,
|
MesProRouteProcessSaveReqVO reqVO) {
|
routeProcessOutputMapper.deleteByRouteProcessId(routeProcess.getId());
|
if (CollUtil.isEmpty(reqVO.getOutputs()) && CollUtil.isEmpty(reqVO.getOutputItemIds())) {
|
return;
|
}
|
Set<Long> routeProductIds = routeProductService.getRouteProductListByRouteId(routeProcess.getRouteId())
|
.stream().map(MesProRouteProductDO::getItemId).filter(Objects::nonNull).collect(Collectors.toSet());
|
List<MesProRouteProcessOutputDO> outputs = new ArrayList<>();
|
Set<String> keys = new HashSet<>();
|
int index = 0;
|
if (CollUtil.isNotEmpty(reqVO.getOutputs())) {
|
List<MesProRouteProcessSaveReqVO.OutputItem> items = reqVO.getOutputs().stream()
|
.filter(Objects::nonNull)
|
.filter(output -> output.getItemId() != null)
|
.collect(Collectors.toList());
|
// 校验：同一归属产品分组内主产出唯一、配比合法
|
validateOutputs(items);
|
for (MesProRouteProcessSaveReqVO.OutputItem output : items) {
|
index++;
|
if (!keys.add(output.getProductId() + "_" + output.getItemId())) {
|
continue;
|
}
|
boolean main = Boolean.TRUE.equals(output.getMainFlag());
|
BigDecimal quantity = main ? BigDecimal.ONE : output.getQuantity();
|
outputs.add(buildOutput(routeProcess, output.getProductId(), output.getItemId(),
|
output.getSort() != null ? output.getSort() : index, quantity, main, output.getRemark()));
|
}
|
} else {
|
// 兼容只传 outputItemIds 的调用方：产出是路线产品时归属到自身，否则视为通用；
|
// 每个归属产品分组的第一条默认作为主产出
|
Set<Long> mainAssignedProducts = new HashSet<>();
|
for (Long itemId : reqVO.getOutputItemIds()) {
|
if (itemId == null) {
|
continue;
|
}
|
Long productId = routeProductIds.contains(itemId) ? itemId : null;
|
if (!keys.add(productId + "_" + itemId)) {
|
continue;
|
}
|
index++;
|
boolean main = mainAssignedProducts.add(productId);
|
outputs.add(buildOutput(routeProcess, productId, itemId, index, BigDecimal.ONE, main, null));
|
}
|
}
|
if (CollUtil.isNotEmpty(outputs)) {
|
routeProcessOutputMapper.insertBatch(outputs);
|
}
|
}
|
|
/**
|
* 校验工序产出配置：同一归属产品分组内最多一个主产出、多个产出时必须指定主产出，非主产出配比必须大于 0
|
*/
|
private void validateOutputs(List<MesProRouteProcessSaveReqVO.OutputItem> items) {
|
if (CollUtil.isEmpty(items)) {
|
return;
|
}
|
Map<Long, List<MesProRouteProcessSaveReqVO.OutputItem>> groupByProduct = new HashMap<>();
|
for (MesProRouteProcessSaveReqVO.OutputItem item : items) {
|
groupByProduct.computeIfAbsent(item.getProductId(), key -> new ArrayList<>()).add(item);
|
}
|
for (List<MesProRouteProcessSaveReqVO.OutputItem> group : groupByProduct.values()) {
|
long mainCount = group.stream().filter(item -> Boolean.TRUE.equals(item.getMainFlag())).count();
|
if (mainCount > 1) {
|
throw exception(PRO_ROUTE_PROCESS_OUTPUT_MAIN_DUPLICATE);
|
}
|
if (mainCount == 0 && group.size() > 1) {
|
throw exception(PRO_ROUTE_PROCESS_OUTPUT_MAIN_REQUIRED);
|
}
|
for (MesProRouteProcessSaveReqVO.OutputItem item : group) {
|
if (Boolean.TRUE.equals(item.getMainFlag())) {
|
continue;
|
}
|
// 未填配比默认按 1 处理，填了则必须大于 0
|
if (item.getQuantity() != null && item.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
|
throw exception(PRO_ROUTE_PROCESS_OUTPUT_RATIO_INVALID);
|
}
|
}
|
}
|
}
|
|
private MesProRouteProcessOutputDO buildOutput(MesProRouteProcessDO routeProcess, Long productId,
|
Long itemId, Integer sort, BigDecimal quantity,
|
Boolean mainFlag, String remark) {
|
return MesProRouteProcessOutputDO.builder()
|
.routeProcessId(routeProcess.getId())
|
.routeId(routeProcess.getRouteId())
|
.processId(routeProcess.getProcessId())
|
.productId(productId)
|
.itemId(itemId)
|
.quantity(mainFlag != null && mainFlag ? BigDecimal.ONE : quantity)
|
.mainFlag(Boolean.TRUE.equals(mainFlag))
|
.sort(sort)
|
.remark(remark)
|
.build();
|
}
|
|
/**
|
* 过滤产出物料：剔除同一工艺路线下其它产品的产出，只保留当前产品的产出和半成品产出
|
*/
|
private void filterOtherProductOutputs(List<MesProRouteProcessDO> list, MesProRouteProductDO routeProduct) {
|
if (CollUtil.isEmpty(list) || routeProduct.getItemId() == null) {
|
return;
|
}
|
Set<Long> otherProductIds = routeProductService.getRouteProductListByRouteId(routeProduct.getRouteId())
|
.stream()
|
.map(MesProRouteProductDO::getItemId)
|
.filter(itemId -> itemId != null && !itemId.equals(routeProduct.getItemId()))
|
.collect(Collectors.toSet());
|
if (otherProductIds.isEmpty()) {
|
return;
|
}
|
for (MesProRouteProcessDO process : list) {
|
String outputItemId = process.getOutputItemId();
|
if (outputItemId == null || outputItemId.isBlank()) {
|
continue;
|
}
|
String filtered = Arrays.stream(outputItemId.split(","))
|
.map(String::trim)
|
.filter(s -> !s.isEmpty())
|
.filter(s -> !otherProductIds.contains(NumberUtil.parseLong(s, -1L)))
|
.collect(Collectors.joining(","));
|
process.setOutputItemId(filtered.isEmpty() ? null : filtered);
|
}
|
}
|
|
@Override
|
public Map<Long, List<MesProRouteProductBomDO>> getRouteProcessBomMapByProductId(Long productId) {
|
MesProRouteProductDO routeProduct = routeProductService.getRouteProductByItemId(productId);
|
if (routeProduct == null) {
|
return Collections.emptyMap();
|
}
|
List<MesProRouteProductBomDO> bomList = routeProductBomService
|
.getRouteProductBomListByRouteIdAndProductId(routeProduct.getRouteId(), productId);
|
if (CollUtil.isEmpty(bomList)) {
|
return Collections.emptyMap();
|
}
|
return bomList.stream().collect(Collectors.groupingBy(MesProRouteProductBomDO::getProcessId));
|
}
|
|
@Override
|
public List<MesProRouteProcessDO> getRouteProcessListByProcessId(Long processId) {
|
return routeProcessMapper.selectListByProcessId(processId);
|
}
|
|
@Override
|
public void deleteRouteProcessByRouteId(Long routeId) {
|
routeProcessMapper.deleteByRouteId(routeId);
|
routeProcessOutputMapper.deleteByRouteId(routeId);
|
}
|
|
}
|
