package cn.iocoder.yudao.module.mes.service.pro.route;
|
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.MesProRouteCompleteImportWorkbook;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.MesProRouteImportRespVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.route.vo.MesProRouteSaveReqVO;
|
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.process.MesProProcessDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.warehouse.MesWmWarehouseAreaDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.warehouse.MesWmWarehouseDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.warehouse.MesWmWarehouseLocationDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.process.MesProProcessMapper;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.wm.warehouse.MesWmWarehouseAreaService;
|
import cn.iocoder.yudao.module.mes.service.wm.warehouse.MesWmWarehouseLocationService;
|
import cn.iocoder.yudao.module.mes.service.wm.warehouse.MesWmWarehouseService;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.support.TransactionTemplate;
|
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
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.PRO_ROUTE_IMPORT_LIST_IS_EMPTY;
|
|
/** 按路线分事务批量导入完整配置；失败路线不会留下部分产品或工序。 */
|
@Service
|
public class MesProRouteCompleteImportService {
|
@Resource private TransactionTemplate transactionTemplate;
|
@Resource private MesProRouteService routeService;
|
@Resource private MesProRouteProductService productService;
|
@Resource private MesProRouteProcessService processService;
|
@Resource private MesProRouteProductBomService bomService;
|
@Resource private MesMdItemService itemService;
|
@Resource private MesProProcessMapper processMapper;
|
@Resource private MesWmWarehouseService warehouseService;
|
@Resource private MesWmWarehouseLocationService locationService;
|
@Resource private MesWmWarehouseAreaService areaService;
|
|
public MesProRouteImportRespVO importRoutes(MesProRouteCompleteImportWorkbook book) {
|
if (book.getRoutes() == null || book.getRoutes().isEmpty()) {
|
throw exception(PRO_ROUTE_IMPORT_LIST_IS_EMPTY);
|
}
|
MesProRouteImportRespVO result = MesProRouteImportRespVO.builder()
|
.createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
|
.failureCodes(new LinkedHashMap<>()).build();
|
Set<String> seen = new HashSet<>();
|
int rowNumber = 1;
|
for (MesProRouteCompleteImportWorkbook.RouteRow row : book.getRoutes()) {
|
rowNumber++;
|
String code = trim(row.getRouteCode());
|
String key = StrUtil.isBlank(code) ? "路线表第 " + rowNumber + " 行" : code;
|
if (StrUtil.isBlank(code) || StrUtil.isBlank(row.getName())) {
|
result.getFailureCodes().put(key, "路线编码和名称不能为空");
|
continue;
|
}
|
if (!seen.add(code)) {
|
result.getFailureCodes().put("路线表第 " + rowNumber + " 行（" + code + "）", "导入文件中路线编码重复");
|
continue;
|
}
|
try {
|
transactionTemplate.execute(status -> {
|
importOne(book, row, code);
|
return null;
|
});
|
result.getCreateCodes().add(code);
|
} catch (RuntimeException ex) {
|
result.getFailureCodes().put(key, ex.getMessage());
|
}
|
}
|
Set<String> known = book.getRoutes().stream().map(r -> trim(r.getRouteCode()))
|
.collect(Collectors.toSet());
|
collectUnknownRoutes(result.getFailureCodes(), known, "产品", book.getProducts() == null ? List.of() :
|
book.getProducts().stream().map(MesProRouteCompleteImportWorkbook.ProductRow::getRouteCode).toList());
|
collectUnknownRoutes(result.getFailureCodes(), known, "工序", book.getProcesses() == null ? List.of() :
|
book.getProcesses().stream().map(MesProRouteCompleteImportWorkbook.ProcessRow::getRouteCode).toList());
|
collectUnknownRoutes(result.getFailureCodes(), known, "工序产出", book.getOutputs() == null ? List.of() :
|
book.getOutputs().stream().map(MesProRouteCompleteImportWorkbook.OutputRow::getRouteCode).toList());
|
collectUnknownRoutes(result.getFailureCodes(), known, "工序投料", book.getInputs() == null ? List.of() :
|
book.getInputs().stream().map(MesProRouteCompleteImportWorkbook.InputRow::getRouteCode).toList());
|
return result;
|
}
|
|
private void importOne(MesProRouteCompleteImportWorkbook book,
|
MesProRouteCompleteImportWorkbook.RouteRow row, String code) {
|
List<MesProRouteCompleteImportWorkbook.ProductRow> products = rows(book.getProducts()).stream()
|
.filter(r -> code.equals(trim(r.getRouteCode()))).toList();
|
List<MesProRouteCompleteImportWorkbook.ProcessRow> processes = rows(book.getProcesses()).stream()
|
.filter(r -> code.equals(trim(r.getRouteCode())))
|
.sorted(Comparator.comparing(MesProRouteCompleteImportWorkbook.ProcessRow::getSort,
|
Comparator.nullsLast(Comparator.naturalOrder()))).toList();
|
if (products.isEmpty() || processes.isEmpty()) {
|
throw new IllegalArgumentException("至少需要一条产品和一道工序");
|
}
|
MesProRouteSaveReqVO route = new MesProRouteSaveReqVO();
|
route.setCode(code);
|
route.setName(trim(row.getName()));
|
route.setDescription(row.getDescription());
|
route.setRemark(row.getRemark());
|
Long routeId = routeService.createRoute(route);
|
Set<String> productCodes = new HashSet<>();
|
for (MesProRouteCompleteImportWorkbook.ProductRow product : products) {
|
String itemCode = trim(product.getItemCode());
|
if (!productCodes.add(itemCode)) {
|
throw new IllegalArgumentException("产品编码重复：" + itemCode);
|
}
|
MesProRouteProductSaveReqVO request = new MesProRouteProductSaveReqVO();
|
request.setRouteId(routeId);
|
request.setItemId(itemId(itemCode));
|
MesWmWarehouseDO warehouse = warehouseService.getWarehouseByCode(trim(product.getWarehouseCode()));
|
MesWmWarehouseLocationDO location = locationService.getWarehouseLocationByCode(trim(product.getLocationCode()));
|
MesWmWarehouseAreaDO area = areaService.getWarehouseAreaByCode(trim(product.getAreaCode()));
|
if (warehouse == null || location == null || area == null) {
|
throw new IllegalArgumentException("产品 " + itemCode + " 的仓库、库区或库位编码不存在");
|
}
|
request.setWarehouseId(warehouse.getId());
|
request.setLocationId(location.getId());
|
request.setAreaId(area.getId());
|
request.setQuantity(product.getQuantity());
|
request.setProductionTime(product.getProductionTime());
|
request.setTimeUnitType(product.getTimeUnitType());
|
request.setRemark(product.getRemark());
|
productService.createRouteProduct(request);
|
}
|
Set<String> processCodes = new HashSet<>();
|
Set<Integer> sorts = new HashSet<>();
|
for (MesProRouteCompleteImportWorkbook.ProcessRow process : processes) {
|
String processCode = trim(process.getProcessCode());
|
if (!processCodes.add(processCode) || process.getSort() == null || !sorts.add(process.getSort())) {
|
throw new IllegalArgumentException("工序编码或排序重复/为空：" + processCode);
|
}
|
MesProProcessDO processDO = processMapper.selectByCode(processCode);
|
if (processDO == null) {
|
throw new IllegalArgumentException("工序编码不存在：" + processCode);
|
}
|
MesProRouteProcessSaveReqVO request = new MesProRouteProcessSaveReqVO();
|
request.setRouteId(routeId);
|
request.setProcessId(processDO.getId());
|
request.setSort(process.getSort());
|
request.setParamTemplateId(process.getParamTemplateId());
|
request.setYieldRate(process.getYieldRate());
|
request.setLinkType(process.getLinkType());
|
request.setPrepareTime(process.getPrepareTime());
|
request.setWaitTime(process.getWaitTime());
|
request.setColorCode(process.getColorCode());
|
request.setKeyFlag(flag(process.getKeyFlag(), processCode, "关键工序"));
|
request.setCheckFlag(flag(process.getCheckFlag(), processCode, "质检工序"));
|
request.setBackflushFlag(flag(process.getBackflushFlag(), processCode, "倒冲"));
|
request.setRemark(process.getRemark());
|
List<MesProRouteProcessSaveReqVO.OutputItem> outputs = new ArrayList<>();
|
for (MesProRouteCompleteImportWorkbook.OutputRow output : rows(book.getOutputs())) {
|
if (!code.equals(trim(output.getRouteCode())) || !processCode.equals(trim(output.getProcessCode()))) {
|
continue;
|
}
|
MesProRouteProcessSaveReqVO.OutputItem value = new MesProRouteProcessSaveReqVO.OutputItem();
|
value.setItemId(itemId(output.getItemCode()));
|
if (StrUtil.isNotBlank(output.getProductCode())) {
|
String ownerCode = trim(output.getProductCode());
|
if (!productCodes.contains(ownerCode)) {
|
throw new IllegalArgumentException("产出归属产品未关联路线：" + ownerCode);
|
}
|
value.setProductId(itemId(ownerCode));
|
}
|
value.setSort(output.getSort());
|
value.setRemark(output.getRemark());
|
outputs.add(value);
|
}
|
request.setOutputs(outputs);
|
processService.createRouteProcess(request);
|
}
|
for (MesProRouteCompleteImportWorkbook.OutputRow output : rows(book.getOutputs())) {
|
if (code.equals(trim(output.getRouteCode())) && !processCodes.contains(trim(output.getProcessCode()))) {
|
throw new IllegalArgumentException("产出引用了未配置的工序：" + output.getProcessCode());
|
}
|
}
|
for (MesProRouteCompleteImportWorkbook.InputRow input : rows(book.getInputs())) {
|
if (!code.equals(trim(input.getRouteCode()))) {
|
continue;
|
}
|
String processCode = trim(input.getProcessCode());
|
String productCode = trim(input.getProductCode());
|
if (!processCodes.contains(processCode) || !productCodes.contains(productCode)) {
|
throw new IllegalArgumentException("投料引用了未配置的工序或产品：" + processCode + "/" + productCode);
|
}
|
MesProRouteProductBomSaveReqVO request = new MesProRouteProductBomSaveReqVO();
|
request.setRouteId(routeId);
|
request.setProcessId(processMapper.selectByCode(processCode).getId());
|
request.setProductId(itemId(productCode));
|
request.setItemId(itemId(input.getItemCode()));
|
request.setQuantity(input.getQuantity());
|
request.setRemark(input.getRemark());
|
bomService.createRouteProductBom(request);
|
}
|
}
|
|
private Long itemId(String code) {
|
String normalized = trim(code);
|
MesMdItemDO item = StrUtil.isBlank(normalized) ? null : itemService.getItemByCode(normalized);
|
if (item == null) {
|
throw new IllegalArgumentException("物料编码不存在：" + normalized);
|
}
|
return item.getId();
|
}
|
|
private static boolean flag(String value, String processCode, String field) {
|
String normalized = trim(value);
|
if (StrUtil.isBlank(normalized) || "否".equals(normalized)
|
|| "false".equalsIgnoreCase(normalized) || "0".equals(normalized)) {
|
return false;
|
}
|
if ("是".equals(normalized) || "true".equalsIgnoreCase(normalized) || "1".equals(normalized)) {
|
return true;
|
}
|
throw new IllegalArgumentException("工序 " + processCode + " 的" + field + "只能填写是或否");
|
}
|
|
private static String trim(String value) {
|
return StrUtil.trim(value);
|
}
|
|
private static <T> List<T> rows(List<T> values) {
|
return values == null ? List.of() : values;
|
}
|
|
private static void collectUnknownRoutes(Map<String, String> failures, Set<String> known,
|
String sheet, List<String> codes) {
|
for (String code : codes) {
|
if (!known.contains(trim(code))) {
|
failures.put(sheet + "表路线 " + code, "路线表中不存在此路线编码");
|
}
|
}
|
}
|
}
|
