package cn.iocoder.yudao.module.mes.service.pro.route;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.hutool.extra.spring.SpringUtil;
|
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.*;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.process.MesProRouteProcessSaveReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.product.MesProRouteProductSaveReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.productbom.MesProRouteProductBomSaveReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.*;
|
import cn.iocoder.yudao.module.mes.dal.mysql.md.item.MesMdItemMapper;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemTypeService;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.process.MesProProcessMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.route.*;
|
import cn.iocoder.yudao.module.mes.dal.mysql.wm.warehouse.*;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import java.util.*;
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
|
|
/** 完整模板按路线分组逐组事务导入，不删除表格中未出现的其他产品或投料。 */
|
@Service
|
@Slf4j
|
public class MesProRouteFullImportService {
|
@Resource private MesProRouteMapper routeMapper;
|
@Resource private MesProRouteProductMapper productMapper;
|
@Resource private MesProRouteProcessMapper processMapper;
|
@Resource private MesProRouteProcessOutputMapper outputMapper;
|
@Resource private MesProRouteProductBomMapper bomMapper;
|
@Resource private MesMdItemMapper itemMapper;
|
@Resource private MesMdItemTypeService itemTypeService;
|
@Resource private MesProProcessMapper operationMapper;
|
@Resource private MesProProcessService operationService;
|
@Resource private MesWmWarehouseMapper warehouseMapper;
|
@Resource private MesWmWarehouseLocationMapper locationMapper;
|
@Resource private MesWmWarehouseAreaMapper areaMapper;
|
@Resource private MesProRouteService routeService;
|
@Resource private MesProRouteProductService productService;
|
@Resource private MesProRouteProcessService processService;
|
@Resource private MesProRouteProductBomService bomService;
|
|
public MesProRouteImportRespVO importRows(List<MesProRouteFullExcelVO> rows, boolean updateSupport) {
|
if (CollUtil.isEmpty(rows)) throw exception(PRO_ROUTE_IMPORT_LIST_IS_EMPTY);
|
var response = MesProRouteImportRespVO.builder().createCodes(new ArrayList<>())
|
.updateCodes(new ArrayList<>()).failureCodes(new LinkedHashMap<>()).build();
|
Map<String, List<MesProRouteFullExcelVO>> groups = new LinkedHashMap<>();
|
for (int i = 0; i < rows.size(); i++) {
|
var row = rows.get(i);
|
if (row == null) continue;
|
if (StrUtil.isBlank(row.getRecordType()) && StrUtil.isBlank(row.getRouteCode())) {
|
boolean hasContent = cn.hutool.core.bean.BeanUtil.beanToMap(row).values().stream()
|
.anyMatch(v -> v != null && (!(v instanceof String) || StrUtil.isNotBlank((String) v)));
|
if (hasContent) response.getFailureCodes().put("第 " + (i + 2) + " 行", "记录类型和路线编码不能为空");
|
continue;
|
}
|
if (StrUtil.isBlank(row.getRouteCode())) {
|
response.getFailureCodes().put("第 " + (i + 2) + " 行", "路线编码不能为空"); continue;
|
}
|
groups.computeIfAbsent(row.getRouteCode().trim(), k -> new ArrayList<>()).add(row);
|
}
|
// 缺失路线编码的行无法归组，拒绝整个文件以避免关联明细被悄悄遗漏。
|
if (!response.getFailureCodes().isEmpty()) return response;
|
if (groups.isEmpty()) throw exception(PRO_ROUTE_IMPORT_LIST_IS_EMPTY);
|
for (var entry : groups.entrySet()) {
|
try {
|
boolean created = SpringUtil.getBean(MesProRouteFullImportService.class)
|
.importGroup(entry.getKey(), entry.getValue(), updateSupport);
|
(created ? response.getCreateCodes() : response.getUpdateCodes()).add(entry.getKey());
|
} catch (ServiceException ex) {
|
response.getFailureCodes().put(entry.getKey(), ex.getMessage());
|
} catch (Exception ex) {
|
log.error("[importRows] 工艺路线完整模板导入失败，路线={}", entry.getKey(), ex);
|
response.getFailureCodes().put(entry.getKey(), "导入失败，请检查模板内容或联系管理员");
|
}
|
}
|
return response;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public boolean importGroup(String code, List<MesProRouteFullExcelVO> rows, boolean updateSupport) {
|
Map<String, List<MesProRouteFullExcelVO>> types = new LinkedHashMap<>();
|
for (var row : rows) {
|
String type = StrUtil.trimToEmpty(row.getRecordType());
|
if (!Set.of("路线", "产品", "工序", "产出", "投料").contains(type)) fail("记录类型必须为路线、产品、工序、产出或投料");
|
types.computeIfAbsent(type, k -> new ArrayList<>()).add(row);
|
}
|
var headers = types.getOrDefault("路线", List.of());
|
if (headers.size() != 1 || StrUtil.isBlank(headers.get(0).getRouteName())) fail("每条路线须有且仅有一条路线记录并填写名称");
|
var products = types.getOrDefault("产品", List.of());
|
List<MesProRouteFullExcelVO> references = products.stream().filter(p -> yes(p.getTemplateReference(), "模板引用")).toList();
|
if (references.size() != 1 || StrUtil.isBlank(references.get(0).getProductCode())) fail("每条路线须有且仅有一个模板引用产品");
|
String referenceCode = references.get(0).getProductCode().trim();
|
if (MesProRouteFullExcelService.REFERENCE.equals(referenceCode)) fail("产品行须填写实际产品编码，不能填写 @模板产品");
|
var steps = types.getOrDefault("工序", List.of());
|
if (steps.isEmpty()) fail("至少需要一条工序记录");
|
if (steps.stream().anyMatch(p -> StrUtil.isBlank(p.getProcessCode()) || p.getProcessSort() == null))
|
fail("工序记录须填写工序编码和工序顺序");
|
if (steps.stream().noneMatch(p -> yes(p.getKeyFlag(), "关键工序"))) fail("至少需要一个关键工序");
|
var lastStep = steps.stream().max(Comparator.comparing(MesProRouteFullExcelVO::getProcessSort)).orElseThrow();
|
boolean hasFinalOutput = types.getOrDefault("产出", List.of()).stream().anyMatch(out ->
|
StrUtil.equals(StrUtil.trimToEmpty(out.getProcessCode()), StrUtil.trimToEmpty(lastStep.getProcessCode()))
|
&& isReference(out.getProductCode(), referenceCode) && isReference(out.getItemCode(), referenceCode));
|
if (!hasFinalOutput) fail("末道工序必须有归属到模板产品自身的产出记录");
|
if (types.getOrDefault("投料", List.of()).stream().noneMatch(bom -> isReference(bom.getProductCode(), referenceCode)))
|
fail("模板产品至少需要一条工序投料记录");
|
for (var row : products) if (StrUtil.isBlank(row.getProductCode()) || StrUtil.isBlank(row.getWarehouseCode())
|
|| StrUtil.isBlank(row.getLocationCode()) || StrUtil.isBlank(row.getAreaCode())) fail("产品记录须填写产品、仓库、库区和库位编码");
|
|
MesProRouteDO route = routeMapper.selectByCode(code);
|
boolean created = route == null;
|
if (!created) {
|
if (!updateSupport) fail("路线编码已存在，请勾选更新已有数据");
|
route = routeMapper.selectOne(new LambdaQueryWrapperX<MesProRouteDO>().eq(MesProRouteDO::getId, route.getId()).last("FOR UPDATE"));
|
if (route == null) fail("路线不存在");
|
if (CommonStatusEnum.ENABLE.getStatus().equals(route.getStatus())) fail("路线已启用，请先停用后再导入更新");
|
}
|
MesProRouteSaveReqVO routeReq = new MesProRouteSaveReqVO();
|
routeReq.setCode(code); routeReq.setName(headers.get(0).getRouteName().trim());
|
routeReq.setDescription(headers.get(0).getRouteDescription()); routeReq.setRemark(headers.get(0).getRouteRemark());
|
Long routeId;
|
if (created) routeId = routeService.createRoute(routeReq);
|
else { routeId = route.getId(); routeReq.setId(routeId); routeService.updateRoute(routeReq); }
|
|
Set<Long> proposedProductIds = new HashSet<>();
|
for (var row : products) proposedProductIds.add(item(row.getProductCode(), referenceCode).getId());
|
boolean hasOtherProducts = productMapper.selectListByRouteId(routeId).stream()
|
.anyMatch(p -> !proposedProductIds.contains(p.getItemId()));
|
if (!created && hasOtherProducts && (!Objects.equals(route.getName(), routeReq.getName())
|
|| !Objects.equals(StrUtil.nullToEmpty(route.getDescription()), StrUtil.nullToEmpty(routeReq.getDescription()))
|
|| !Objects.equals(StrUtil.nullToEmpty(route.getRemark()), StrUtil.nullToEmpty(routeReq.getRemark()))))
|
fail("路线包含其他产品，不能通过单产品模板修改路线基本信息");
|
Set<Long> productIds = new HashSet<>(); Long refProductId = null;
|
for (var row : products) {
|
MesMdItemDO item = item(row.getProductCode(), referenceCode);
|
if (!productIds.add(item.getId())) fail("产品重复：" + row.getProductCode());
|
var wh = warehouseMapper.selectByCode(row.getWarehouseCode().trim());
|
if (wh == null) fail("仓库不存在：" + row.getWarehouseCode());
|
var loc = locationMapper.selectByCode(wh.getId(), row.getLocationCode().trim());
|
if (loc == null) fail("库区不存在：" + row.getLocationCode());
|
var area = areaMapper.selectByCode(loc.getId(), row.getAreaCode().trim());
|
if (area == null) fail("库位不存在：" + row.getAreaCode());
|
if (row.getQuantity() != null && row.getQuantity() <= 0) fail("生产数量必须大于零");
|
if (row.getProductionTime() != null && row.getProductionTime().signum() < 0) fail("生产用时不能为负数");
|
MesProRouteProductSaveReqVO req = new MesProRouteProductSaveReqVO();
|
req.setRouteId(routeId); req.setItemId(item.getId()); req.setWarehouseId(wh.getId());
|
req.setLocationId(loc.getId()); req.setAreaId(area.getId()); req.setQuantity(row.getQuantity());
|
req.setProductionTime(row.getProductionTime()); req.setTimeUnitType(timeUnit(row.getTimeUnitType())); req.setRemark(row.getProductRemark());
|
MesProRouteProductDO existing = productMapper.selectByItemId(item.getId());
|
Long id;
|
if (existing == null) id = productService.createRouteProduct(req);
|
else {
|
if (!existing.getRouteId().equals(routeId)) fail("产品已绑定其他路线：" + item.getCode());
|
if (hasOtherProducts && !item.getCode().equals(referenceCode)
|
&& (!Objects.equals(existing.getWarehouseId(), req.getWarehouseId())
|
|| !Objects.equals(existing.getLocationId(), req.getLocationId())
|
|| !Objects.equals(existing.getAreaId(), req.getAreaId())
|
|| !Objects.equals(existing.getQuantity(), req.getQuantity())
|
|| (existing.getProductionTime() == null ? req.getProductionTime() != null
|
: req.getProductionTime() == null || existing.getProductionTime().compareTo(req.getProductionTime()) != 0)
|
|| !Objects.equals(StrUtil.nullToEmpty(existing.getTimeUnitType()), StrUtil.nullToEmpty(req.getTimeUnitType()))
|
|| !Objects.equals(StrUtil.nullToEmpty(existing.getRemark()), StrUtil.nullToEmpty(req.getRemark()))))
|
fail("路线包含其他产品，不能通过单产品模板修改共用产出产品：" + item.getCode());
|
req.setId(existing.getId()); productService.updateRouteProduct(req); id = existing.getId();
|
}
|
if (yes(row.getTemplateReference(), "模板引用")) refProductId = id;
|
}
|
productService.setTemplateReference(refProductId);
|
Map<String, MesProRouteProcessDO> existingProcesses = new HashMap<>();
|
for (var process : processMapper.selectListByRouteId(routeId)) {
|
var op = operationMapper.selectById(process.getProcessId());
|
if (op != null) existingProcesses.put(op.getCode(), process);
|
}
|
Set<String> stepCodes = new HashSet<>(); Set<Integer> sorts = new HashSet<>();
|
for (var row : steps) {
|
if (StrUtil.isBlank(row.getProcessCode()) || row.getProcessSort() == null) fail("工序记录须填写工序编码和工序顺序");
|
String processCode = row.getProcessCode().trim();
|
if (row.getProcessSort() < 0 || (row.getPrepareTime() != null && row.getPrepareTime() < 0)
|
|| (row.getWaitTime() != null && row.getWaitTime() < 0))
|
fail("工序顺序、准备时间和等待时间不能为负数：" + processCode);
|
if (row.getLinkType() != null && (row.getLinkType() < 0 || row.getLinkType() > 3))
|
fail("工序关系只能填写 0、1、2 或 3：" + processCode);
|
if (!stepCodes.add(processCode) || !sorts.add(row.getProcessSort())) fail("工序编码和工序顺序不能重复");
|
var operation = operationMapper.selectByCode(processCode);
|
if (operation == null) fail("工序不存在：" + processCode);
|
operationService.validateProcessExistsAndEnable(operation.getId());
|
MesProRouteProcessDO existing = existingProcesses.get(processCode);
|
if (existing == null && hasOtherProducts) fail("路线包含其他产品，不能通过单产品模板新增共用工序：" + processCode);
|
MesProRouteProcessSaveReqVO req = new MesProRouteProcessSaveReqVO();
|
req.setRouteId(routeId); req.setProcessId(operation.getId()); req.setSort(row.getProcessSort());
|
req.setLinkType(row.getLinkType()); req.setPrepareTime(row.getPrepareTime()); req.setWaitTime(row.getWaitTime());
|
req.setColorCode(row.getColorCode()); req.setKeyFlag(yes(row.getKeyFlag(), "关键工序"));
|
req.setCheckFlag(yes(row.getCheckFlag(), "质检工序")); req.setBackflushFlag(yes(row.getBackflushFlag(), "倒冲"));
|
req.setRemark(row.getProcessRemark());
|
if (existing != null && hasOtherProducts
|
&& (!Objects.equals(existing.getSort(), req.getSort())
|
|| !Objects.equals(existing.getLinkType(), req.getLinkType())
|
|| !Objects.equals(existing.getPrepareTime(), req.getPrepareTime())
|
|| !Objects.equals(existing.getWaitTime(), req.getWaitTime())
|
|| !Objects.equals(existing.getColorCode(), req.getColorCode())
|
|| !Objects.equals(Boolean.TRUE.equals(existing.getKeyFlag()), req.getKeyFlag())
|
|| !Objects.equals(Boolean.TRUE.equals(existing.getCheckFlag()), req.getCheckFlag())
|
|| !Objects.equals(Boolean.TRUE.equals(existing.getBackflushFlag()), req.getBackflushFlag())
|
|| !Objects.equals(StrUtil.nullToEmpty(existing.getRemark()), StrUtil.nullToEmpty(req.getRemark())))) {
|
fail("路线包含其他产品，不能通过单产品模板修改共用工序：" + processCode);
|
}
|
// 保留其他产品的既有产出，避免一次导入删除整条路线的产出。
|
Map<String, MesProRouteProcessSaveReqVO.OutputItem> merged = new LinkedHashMap<>();
|
if (existing != null) {
|
for (var out : outputMapper.selectListByRouteProcessId(existing.getId())) {
|
var v = new MesProRouteProcessSaveReqVO.OutputItem();
|
v.setItemId(out.getItemId()); v.setProductId(out.getProductId()); v.setSort(out.getSort()); v.setRemark(out.getRemark());
|
merged.put(out.getProductId() + ":" + out.getItemId(), v);
|
}
|
// 旧数据只有 outputItemId 时也必须保留，不能因导入而清空。
|
if (merged.isEmpty() && StrUtil.isNotBlank(existing.getOutputItemId())) {
|
for (String text : existing.getOutputItemId().split(",")) if (StrUtil.isNotBlank(text)) {
|
Long id = Long.valueOf(text.trim()); var v = new MesProRouteProcessSaveReqVO.OutputItem();
|
Long owner = isFinished(id) && productMapper.selectListByRouteId(routeId).stream().anyMatch(p -> id.equals(p.getItemId())) ? id : null;
|
v.setItemId(id); v.setProductId(owner); merged.put(owner + ":" + id, v);
|
}
|
}
|
}
|
Set<String> importedOutputKeys = new HashSet<>();
|
for (var out : types.getOrDefault("产出", List.of())) {
|
if (!processCode.equals(StrUtil.trimToEmpty(out.getProcessCode()))) continue;
|
MesMdItemDO outputItem = item(out.getItemCode(), referenceCode);
|
Long ownerId = StrUtil.isBlank(out.getProductCode()) ? null : item(out.getProductCode(), referenceCode).getId();
|
if (!productIds.contains(outputItem.getId())) fail("产出物料未出现在产品记录：" + outputItem.getCode());
|
if (ownerId != null && !productIds.contains(ownerId)) fail("产出归属产品未出现在产品记录");
|
var v = new MesProRouteProcessSaveReqVO.OutputItem();
|
v.setItemId(outputItem.getId()); v.setProductId(ownerId); v.setSort(out.getOutputSort()); v.setRemark(out.getDetailRemark());
|
String outputKey = ownerId + ":" + outputItem.getId();
|
if (!importedOutputKeys.add(outputKey)) fail("工序产出记录重复：" + processCode + " / " + outputItem.getCode());
|
if (hasOtherProducts && ownerId == null) {
|
var old = merged.get(outputKey);
|
if (old == null || !Objects.equals(old.getSort(), v.getSort())
|
|| !Objects.equals(StrUtil.nullToEmpty(old.getRemark()), StrUtil.nullToEmpty(v.getRemark())))
|
fail("路线包含其他产品，不能通过单产品模板修改共用产出：" + outputItem.getCode());
|
}
|
merged.put(outputKey, v);
|
}
|
req.setOutputs(new ArrayList<>(merged.values()));
|
if (existing == null) processService.createRouteProcess(req);
|
else { req.setId(existing.getId()); processService.updateRouteProcess(req); }
|
}
|
for (var row : types.getOrDefault("产出", List.of()))
|
if (!stepCodes.contains(StrUtil.trimToEmpty(row.getProcessCode()))) fail("产出记录找不到对应的工序记录：" + row.getProcessCode());
|
Set<String> bomKeys = new HashSet<>();
|
for (var row : types.getOrDefault("投料", List.of())) {
|
String operationCode = StrUtil.trimToEmpty(row.getProcessCode());
|
if (!stepCodes.contains(operationCode)) fail("投料记录找不到对应的工序记录：" + operationCode);
|
var op = operationMapper.selectByCode(operationCode);
|
MesMdItemDO product = item(row.getProductCode(), referenceCode), material = item(row.getItemCode(), referenceCode);
|
if (!productIds.contains(product.getId())) fail("投料产品未出现在产品记录：" + product.getCode());
|
if (row.getBomQuantity() == null || row.getBomQuantity().signum() <= 0) fail("投料比例必须大于零");
|
if (!bomKeys.add(op.getId() + ":" + product.getId() + ":" + material.getId())) fail("投料记录重复：" + material.getCode());
|
MesProRouteProductBomSaveReqVO req = new MesProRouteProductBomSaveReqVO();
|
req.setRouteId(routeId); req.setProcessId(op.getId()); req.setProductId(product.getId()); req.setItemId(material.getId());
|
req.setQuantity(row.getBomQuantity()); req.setRemark(row.getDetailRemark());
|
var existing = bomMapper.selectByUnique(material.getId(), op.getId(), product.getId());
|
if (hasOtherProducts && !product.getCode().equals(referenceCode)
|
&& (existing == null || existing.getQuantity() == null
|
|| existing.getQuantity().compareTo(req.getQuantity()) != 0
|
|| !Objects.equals(StrUtil.nullToEmpty(existing.getRemark()), StrUtil.nullToEmpty(req.getRemark()))))
|
fail("路线包含其他产品，不能通过单产品模板修改共用产品投料：" + product.getCode());
|
if (existing == null) bomService.createRouteProductBom(req);
|
else { if (!existing.getRouteId().equals(routeId)) fail("投料记录属于其他路线"); req.setId(existing.getId()); bomService.updateRouteProductBom(req); }
|
}
|
return created;
|
}
|
|
private MesMdItemDO item(String code, String referenceCode) {
|
if (StrUtil.isBlank(code)) { fail("物料编码不能为空"); return null; }
|
String resolved = MesProRouteFullExcelService.REFERENCE.equals(code.trim()) ? referenceCode : code.trim();
|
MesMdItemDO item = itemMapper.selectByCode(resolved);
|
if (item == null) fail("物料不存在：" + resolved);
|
return item;
|
}
|
private boolean isReference(String value, String referenceCode) {
|
return StrUtil.isNotBlank(value) && (MesProRouteFullExcelService.REFERENCE.equals(value.trim()) || referenceCode.equals(value.trim()));
|
}
|
private boolean isFinished(Long itemId) {
|
MesMdItemDO source = itemMapper.selectById(itemId);
|
if (source == null) fail("原工序的产出物料不存在：" + itemId);
|
var type = itemTypeService.getItemType(source.getItemTypeId());
|
Set<Long> seen = new HashSet<>();
|
while (type != null && seen.add(type.getId())) {
|
if ("FG".equals(type.getCode())) return true;
|
if (type.getParentId() == null || type.getParentId() == 0L) break;
|
type = itemTypeService.getItemType(type.getParentId());
|
}
|
return false;
|
}
|
private String timeUnit(String value) {
|
if (StrUtil.isBlank(value)) return null;
|
return switch (value.trim()) {
|
case "分钟", "MINUTE" -> "MINUTE";
|
case "小时", "HOUR" -> "HOUR";
|
case "天", "DAY" -> "DAY";
|
// 保留历史数据中的旧单位编码，不推测其含义。
|
case "1", "2", "3" -> value.trim();
|
default -> throw exception(PRO_ROUTE_FULL_EXCEL_INVALID, "生产时间单位只能填写分钟、小时或天");
|
};
|
}
|
private boolean yes(String value, String field) {
|
if (StrUtil.isBlank(value) || "否".equals(value.trim())) return false;
|
if ("是".equals(value.trim())) return true;
|
fail(field + "只能填写是或否"); return false;
|
}
|
private void fail(String message) { throw exception(PRO_ROUTE_FULL_EXCEL_INVALID, message); }
|
}
|
