package cn.iocoder.yudao.module.mes.service.pro.task.schedule;
|
|
import cn.hutool.crypto.digest.DigestUtil;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.*;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.MesProBatchSchedulePreviewRespVO.*;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
|
import cn.iocoder.yudao.module.mes.enums.pro.*;
|
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import cn.iocoder.yudao.module.mes.service.pro.route.*;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderProcessService;
|
import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskService;
|
import cn.iocoder.yudao.module.mes.service.cal.holiday.MesCalHolidayService;
|
import jakarta.annotation.Resource;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Isolation;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.*;
|
import java.util.*;
|
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.*;
|
|
@Service
|
public class MesProBatchScheduleService {
|
@Resource private MesProTaskMapper taskMapper;
|
@Resource private MesProWorkOrderMapper workOrderMapper;
|
@Resource private MesDvMachineryMapper machineryMapper;
|
@Resource private MesMdWorkstationService workstationService;
|
@Resource private MesProWorkOrderProcessService workOrderProcessService;
|
@Resource private MesProRouteService routeService;
|
@Resource private MesProRouteProcessService routeProcessService;
|
@Resource private MesProRouteProductService routeProductService;
|
@Resource private MesProProcessService processService;
|
@Resource private MesMdItemService itemService;
|
@Resource private MesCalHolidayService holidayService;
|
@Resource @Lazy private cn.iocoder.yudao.module.mes.service.pd.processparamtemplate.MesPdProcessParamTemplateService paramTemplateService;
|
@Resource private MesProScheduleGuardService guard;
|
@Resource private CrmCustomerApi customerApi;
|
@Resource @Lazy private MesProTaskService taskService;
|
|
private LocalDateTime now() { return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).withNano(0); }
|
|
public MesProBatchSchedulePreviewRespVO preview(MesProBatchScheduleReqVO request) {
|
validateRequest(request);
|
return build(request);
|
}
|
|
@Transactional(rollbackFor = Exception.class, isolation = Isolation.SERIALIZABLE, timeout = 60)
|
public List<Long> execute(MesProBatchScheduleReqVO request) {
|
validateRequest(request);
|
if (request.getPreviewTime() == null || request.getPreviewHash() == null
|
|| request.getPreviewTime().isAfter(now()) || request.getPreviewTime().plusMinutes(15).isBefore(now())) {
|
throw exception(PRO_TASK_SCHEDULE_PREVIEW_CHANGED);
|
}
|
guard.lock();
|
workOrderMapper.lockScheduleOrders(request.getWorkOrderIds().stream().sorted().toList());
|
var preview = build(request);
|
if (!preview.isCanExecute()) {
|
throw exception(PRO_TASK_SCHEDULE_INVALID, preview.getOrders().stream()
|
.filter(order -> order.getError() != null).map(OrderPlan::getError).collect(Collectors.joining("；")));
|
}
|
if (!Objects.equals(request.getPreviewHash(), preview.getPreviewHash())) {
|
throw exception(PRO_TASK_SCHEDULE_PREVIEW_CHANGED);
|
}
|
if (preview.getTasks().stream().anyMatch(task -> task.getStartTime().isBefore(now()))) {
|
throw exception(PRO_TASK_SCHEDULE_PREVIEW_CHANGED);
|
}
|
if (!preview.getWarnings().isEmpty() && !Boolean.TRUE.equals(request.getAllowLate())) {
|
throw exception(PRO_TASK_SCHEDULE_INVALID, "请先确认预览中的交期延期风险");
|
}
|
List<Long> ids = new ArrayList<>();
|
for (var plan : preview.getTasks()) {
|
var task = new MesProTaskSaveReqVO();
|
task.setWorkOrderId(plan.getWorkOrderId());
|
task.setRouteId(plan.getRouteId());
|
task.setProcessId(plan.getProcessId());
|
task.setItemId(plan.getItemId());
|
task.setParamTemplateId(plan.getParamTemplateId());
|
task.setColorCode(plan.getColorCode());
|
task.setWorkstationId(plan.getWorkstationId());
|
task.setQuantity(plan.getQuantity());
|
task.setDuration(plan.getDuration());
|
task.setStartTime(plan.getStartTime());
|
task.setEndTime(plan.getEndTime());
|
task.setRemark("一键排产：09:00–18:00，排除周末及节假日");
|
ids.add(taskService.createTask(task));
|
}
|
// 每道工序均补齐后，工单的累计排产数量只记一次，不能按工序数累加。
|
for (var order : preview.getOrders()) {
|
workOrderMapper.updateById(new MesProWorkOrderDO().setId(order.getWorkOrderId())
|
.setQuantityScheduled(order.getQuantity()));
|
}
|
return ids;
|
}
|
|
private void validateRequest(MesProBatchScheduleReqVO request) {
|
var ids = request.getWorkOrderIds();
|
if (ids == null || ids.isEmpty() || ids.size() > 30 || ids.stream().anyMatch(id -> id == null || id <= 0)
|
|| new HashSet<>(ids).size() != ids.size()) {
|
throw exception(PRO_TASK_SCHEDULE_INVALID, "请选择1至30个不同的有效工单");
|
}
|
if (request.getStartTime() == null || request.getStartTime().isBefore(now().minusMinutes(15))
|
|| request.getStartTime().isAfter(now().plusDays(365))) {
|
throw exception(PRO_TASK_SCHEDULE_INVALID, "最早开工时间应为当前时间至未来一年以内，请重新选择");
|
}
|
}
|
|
private MesProBatchSchedulePreviewRespVO build(MesProBatchScheduleReqVO request) {
|
var result = new MesProBatchSchedulePreviewRespVO();
|
result.setPreviewTime(now());
|
var orders = workOrderMapper.selectByIds(request.getWorkOrderIds());
|
var orderMap = orders.stream().collect(Collectors.toMap(MesProWorkOrderDO::getId, order -> order));
|
List<Long> permitted = customerApi.getPermittedCustomerIds();
|
var stations = workstationService.getWorkstationListByStatus(0).stream()
|
.sorted(Comparator.comparing(MesMdWorkstationDO::getId)).toList();
|
var machineMap = machineryMapper.selectList().stream().collect(Collectors.toMap(MesDvMachineryDO::getId, machine -> machine));
|
var stationMachines = guard.machineIdsByStation();
|
Map<Long, MesProTaskDO> allRelevantTasks = new TreeMap<>();
|
taskMapper.selectSchedulingTasks().forEach(task -> allRelevantTasks.put(task.getId(), task));
|
taskMapper.selectListByWorkOrderIds(request.getWorkOrderIds()).stream()
|
.filter(task -> !Objects.equals(task.getStatus(), MesProTaskStatusEnum.CANCELED.getStatus()))
|
.forEach(task -> allRelevantTasks.put(task.getId(), task));
|
var existingTasks = new ArrayList<>(allRelevantTasks.values());
|
var holidays = holidayService.getHolidayList(request.getStartTime().toLocalDate().atStartOfDay(), request.getStartTime().plusYears(1));
|
Set<LocalDate> holidayDates = holidays.stream().filter(day -> Objects.equals(day.getType(), 2))
|
.map(day -> day.getDay().toLocalDate()).collect(Collectors.toSet());
|
var calendar = new MesProScheduleEngine.Calendar(holidayDates, request.getStartTime().toLocalDate().plusYears(1));
|
List<MesProScheduleEngine.Busy> busy = new ArrayList<>();
|
Set<Long> unknownStations = new HashSet<>();
|
for (var task : existingTasks) {
|
if (MesProTaskStatusEnum.isEndStatus(task.getStatus()) || task.getWorkstationId() == null) continue;
|
if (task.getStartTime() == null || task.getEndTime() == null || !task.getEndTime().isAfter(task.getStartTime())
|
|| task.getEndTime().isBefore(now())) {
|
unknownStations.add(task.getWorkstationId());
|
} else {
|
busy.add(new MesProScheduleEngine.Busy(task.getWorkstationId(),
|
stationMachines.getOrDefault(task.getWorkstationId(), Set.of()), task.getStartTime(), task.getEndTime()));
|
}
|
}
|
var sorted = orders.stream().sorted(Comparator.comparing(MesProWorkOrderDO::getRequestDate,
|
Comparator.nullsLast(Comparator.naturalOrder())).thenComparing(MesProWorkOrderDO::getId)).toList();
|
List<Long> orderSequence = new ArrayList<>();
|
Set<Long> visiting = new HashSet<>();
|
for (var order : sorted) addChildrenFirst(order.getId(), orderMap, orderSequence, visiting);
|
for (Long id : request.getWorkOrderIds()) if (!orderMap.containsKey(id)) orderSequence.add(id);
|
Map<Long, LocalDateTime> ends = new HashMap<>();
|
Map<Long, String> templateHashes = new TreeMap<>();
|
final List<MesProScheduleEngine.Busy> existingBusy = List.copyOf(busy);
|
for (Long id : orderSequence) {
|
var order = orderMap.get(id);
|
var orderPlan = new OrderPlan();
|
orderPlan.setWorkOrderId(id);
|
result.getOrders().add(orderPlan);
|
try {
|
if (order == null) throw new IllegalArgumentException("工单不存在或已删除");
|
if (permitted != null && order.getClientId() != null && !permitted.contains(order.getClientId())) {
|
throw new IllegalArgumentException("无权操作该客户的工单");
|
}
|
orderPlan.setWorkOrderCode(order.getCode());
|
orderPlan.setWorkOrderName(order.getName());
|
orderPlan.setQuantity(order.getQuantity());
|
orderPlan.setRequestDate(order.getRequestDate());
|
if (!Objects.equals(order.getStatus(), MesProWorkOrderStatusEnum.CONFIRMED.getStatus())
|
|| !Objects.equals(order.getType(), MesProWorkOrderTypeEnum.SELF.getType())) {
|
throw new IllegalArgumentException("仅支持已确认的自行生产工单");
|
}
|
if (order.getQuantity() == null || order.getQuantity().signum() <= 0
|
|| (order.getQuantityProduced() != null && order.getQuantityProduced().compareTo(order.getQuantity()) >= 0)) {
|
throw new IllegalArgumentException("工单数量无效或已生产完成");
|
}
|
LocalDateTime earliest = calendar.nextWorkingTime(request.getStartTime());
|
// 父工单必须等子工单；同一批次按依赖顺序排，未纳入的未完成子工单阻止排产。
|
for (var child : workOrderMapper.selectList(MesProWorkOrderDO::getParentId, id)) {
|
if (Objects.equals(child.getStatus(), MesProWorkOrderStatusEnum.FINISHED.getStatus())) continue;
|
if (!ends.containsKey(child.getId())) throw new IllegalArgumentException("请将未完成子工单" + child.getCode() + "一并选中并先完成排产");
|
if (ends.get(child.getId()).isAfter(earliest)) earliest = ends.get(child.getId());
|
}
|
Long routeId = order.getRouteId();
|
if (routeId == null) {
|
var relation = routeProductService.getRouteProductByItemId(order.getProductId());
|
if (relation != null) routeId = relation.getRouteId();
|
}
|
if (routeId == null) throw new IllegalArgumentException("未配置工艺路线，请先维护工单工序及产品路线");
|
var route = routeService.validateRouteExists(routeId);
|
if (!Objects.equals(route.getStatus(), 0)) throw new IllegalArgumentException("工艺路线已停用");
|
List<MesProRouteProcessDO> processes = processes(id, routeId);
|
if (processes.isEmpty()) throw new IllegalArgumentException("没有工序，请先维护工单工序");
|
Set<Long> processIds = new HashSet<>();
|
Set<Integer> sorts = new HashSet<>();
|
Map<Long, Integer> processSorts = processes.stream().filter(process -> process.getProcessId() != null && process.getSort() != null)
|
.collect(Collectors.toMap(MesProRouteProcessDO::getProcessId, MesProRouteProcessDO::getSort, (first, duplicate) -> first));
|
List<TaskPlan> plans = new ArrayList<>();
|
Map<Long, BigDecimal> targetQuantities = calcTargetQuantities(processes, order.getQuantity());
|
List<MesProScheduleEngine.Busy> trialBusy = new ArrayList<>(busy);
|
for (var process : processes) {
|
if (process.getProcessId() == null || process.getSort() == null || !processIds.add(process.getProcessId()) || !sorts.add(process.getSort())) {
|
throw new IllegalArgumentException("工序及顺序必须完整且不能重复，请先维护工单工序");
|
}
|
if (process.getNextProcessId() != null && (!processSorts.containsKey(process.getNextProcessId())
|
|| processSorts.get(process.getNextProcessId()) <= process.getSort())) {
|
throw new IllegalArgumentException("工序衔接与顺序不一致，请先维护工单工序");
|
}
|
int prepareMinutes = process.getPrepareTime() == null ? 0 : process.getPrepareTime();
|
int waitMinutes = process.getWaitTime() == null ? 0 : process.getWaitTime();
|
if (prepareMinutes < 0 || waitMinutes < 0) throw new IllegalArgumentException("工序准备时间和等待时间不能为负数");
|
if (process.getParamTemplateId() != null) {
|
paramTemplateService.validateProcessParamTemplateExists(process.getParamTemplateId());
|
var details = paramTemplateService.getProcessParamTemplateDetailListByTemplateId(process.getParamTemplateId());
|
if (details.isEmpty()) {
|
throw new IllegalArgumentException("工序参数模板没有明细，请先完善参数模板");
|
}
|
templateHashes.put(process.getParamTemplateId(), DigestUtil.sha256Hex(JsonUtils.toJsonString(details)));
|
}
|
processService.validateProcessExistsAndEnable(process.getProcessId());
|
var processData = processService.getProcess(process.getProcessId());
|
if (processData == null) throw new IllegalArgumentException("工序配置已变化，请重新维护后预览");
|
var ownTasks = existingTasks.stream().filter(task -> Objects.equals(task.getWorkOrderId(), id)
|
&& Objects.equals(task.getProcessId(), process.getProcessId())).toList();
|
if (ownTasks.stream().anyMatch(task -> task.getQuantity() == null || task.getQuantity().signum() <= 0)) {
|
throw new IllegalArgumentException("当前工序已有任务数量无效，请先修正历史任务数量");
|
}
|
var assigned = ownTasks.stream().map(task -> task.getQuantity() == null ? BigDecimal.ZERO : task.getQuantity()).reduce(BigDecimal.ZERO, BigDecimal::add);
|
// 各道工序按收率倒推的目标产出量：末道=订单量，前面各道逐级放大
|
var targetQuantity = targetQuantities.getOrDefault(process.getProcessId(), order.getQuantity());
|
var remaining = targetQuantity.subtract(assigned);
|
if (remaining.signum() < 0) throw new IllegalArgumentException("工序" + processData.getName() + "已有排产数量超限，请先核对");
|
for (var task : ownTasks) {
|
if (!MesProTaskStatusEnum.isEndStatus(task.getStatus()) && (task.getStartTime() == null
|
|| task.getEndTime() == null || !task.getEndTime().isAfter(task.getStartTime()) || task.getEndTime().isBefore(now()))) {
|
throw new IllegalArgumentException("工序" + processData.getName() + "已有任务时间不完整或已超时未完成，请先维护");
|
}
|
}
|
LocalDateTime existingEnd = ownTasks.stream().map(task -> task.getEndTime() != null ? task.getEndTime() : task.getFinishDate())
|
.filter(Objects::nonNull).max(Comparator.naturalOrder()).orElse(earliest);
|
if (remaining.signum() == 0) {
|
if (existingEnd.isAfter(earliest)) earliest = existingEnd;
|
earliest = earliest.plusMinutes(waitMinutes);
|
continue;
|
}
|
Long itemId = order.getProductId();
|
if (process.getOutputItemId() != null && !process.getOutputItemId().isBlank()) {
|
String[] output = process.getOutputItemId().split(",");
|
if (output.length != 1) throw new IllegalArgumentException("多产出工序请使用手工排产确认各产出数量");
|
itemId = Long.valueOf(output[0].trim());
|
}
|
var item = itemService.validateItemExists(itemId);
|
if (!Objects.equals(item.getStatus(), 0)) throw new IllegalArgumentException("工序产出产品已停用");
|
TaskPlan best = null;
|
for (var station : stations) {
|
if (!Objects.equals(station.getProcessId(), process.getProcessId())) continue;
|
Set<Long> machineIds = stationMachines.getOrDefault(station.getId(), Set.of());
|
if (unknownStations.contains(station.getId()) || machineIds.isEmpty()) continue;
|
if (unknownStations.stream().anyMatch(other -> !Collections.disjoint(machineIds, stationMachines.getOrDefault(other, Set.of())))) continue;
|
List<MesDvMachineryDO> machines = machineIds.stream().map(machineMap::get).filter(Objects::nonNull)
|
.filter(machine -> Objects.equals(machine.getStatus(), 1) || Objects.equals(machine.getStatus(), 2)).toList();
|
if (machines.isEmpty() || machines.stream().anyMatch(machine -> machine.getProductionEfficiency() == null || machine.getProductionEfficiency().signum() <= 0)) continue;
|
Set<Long> usableIds = machines.stream().map(MesDvMachineryDO::getId).collect(Collectors.toCollection(TreeSet::new));
|
if (machines.stream().anyMatch(machine -> Objects.equals(machine.getStatus(), 2) && existingBusy.stream().noneMatch(interval -> interval.machineryIds().contains(machine.getId())))) continue;
|
BigDecimal capacity = machines.stream().map(machine -> machine.getProductionEfficiency().multiply(BigDecimal.valueOf(
|
machine.getConveyorBelt() == null || machine.getConveyorBelt() <= 0 ? 1 : machine.getConveyorBelt())))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
MesProScheduleEngine.Slot slot;
|
try {
|
int hours = Math.addExact(MesProScheduleEngine.duration(remaining, capacity),
|
Math.toIntExact(((long) prepareMinutes + 59) / 60));
|
slot = MesProScheduleEngine.findSlotHours(station.getId(), machineIds, hours, earliest, trialBusy, calendar);
|
} catch (IllegalArgumentException | ArithmeticException unavailable) {
|
continue; // 一台低产能工作站超出排产窗口时，仍继续尝试其他工作站。
|
}
|
if (best == null || slot.end().isBefore(best.getEndTime())) {
|
best = new TaskPlan();
|
best.setWorkOrderId(id); best.setWorkOrderCode(order.getCode());
|
best.setRouteId(routeId); best.setRouteName(route.getName());
|
best.setProcessId(process.getProcessId()); best.setProcessName(processData.getName()); best.setSort(process.getSort());
|
best.setItemId(itemId); best.setItemName(item.getName()); best.setParamTemplateId(process.getParamTemplateId()); best.setColorCode(process.getColorCode());
|
best.setWorkstationId(station.getId()); best.setWorkstationName(station.getName());
|
best.setMachineryIds(new ArrayList<>(usableIds)); best.setMachineryNames(machines.stream().map(MesDvMachineryDO::getName).collect(Collectors.joining("、")));
|
best.setHourlyCapacity(capacity); best.setQuantity(remaining); best.setDuration(slot.hours()); best.setStartTime(slot.start()); best.setEndTime(slot.end());
|
}
|
}
|
if (best == null) throw new IllegalArgumentException("工序" + processData.getName() + "没有可用工作站及有效设备产能，或资源存在未知/超时任务，请先维护");
|
plans.add(best);
|
trialBusy.add(new MesProScheduleEngine.Busy(best.getWorkstationId(), stationMachines.getOrDefault(best.getWorkstationId(), Set.of()), best.getStartTime(), best.getEndTime()));
|
earliest = best.getEndTime().isAfter(existingEnd) ? best.getEndTime() : existingEnd;
|
earliest = earliest.plusMinutes(waitMinutes);
|
}
|
if (plans.isEmpty()) throw new IllegalArgumentException("所有工序已完成排产，不可重复提交");
|
if (result.getTasks().size() + plans.size() > 200) throw new IllegalArgumentException("一次最多生成200个任务，请拆分工单批次排产");
|
result.getTasks().addAll(plans); busy = trialBusy;
|
orderPlan.setTaskCount(plans.size()); orderPlan.setEndTime(earliest); ends.put(id, earliest);
|
if (order.getRequestDate() != null && earliest.toLocalDate().isAfter(order.getRequestDate().toLocalDate())) {
|
orderPlan.setLate(true); result.getWarnings().add("工单" + order.getCode() + "预计完成时间晚于交期");
|
}
|
} catch (ServiceException | IllegalArgumentException | ArithmeticException error) {
|
orderPlan.setError((orderPlan.getWorkOrderCode() == null ? "工单#" + id : orderPlan.getWorkOrderCode()) + "：" + error.getMessage());
|
}
|
}
|
result.setCanExecute(result.getOrders().stream().noneMatch(order -> order.getError() != null) && !result.getTasks().isEmpty());
|
// 不包含生成时间；同一输入与业务数据应得到稳定的预览指纹。
|
var fingerprint = new LinkedHashMap<String, Object>();
|
fingerprint.put("startTime", request.getStartTime()); fingerprint.put("orders", result.getOrders());
|
fingerprint.put("tasks", result.getTasks()); fingerprint.put("holidays", holidayDates.stream().sorted().toList());
|
fingerprint.put("workOrders", orders.stream().sorted(Comparator.comparing(MesProWorkOrderDO::getId)).toList());
|
fingerprint.put("paramTemplates", templateHashes);
|
result.setPreviewHash(DigestUtil.sha256Hex(JsonUtils.toJsonString(fingerprint)));
|
return result;
|
}
|
|
private List<MesProRouteProcessDO> processes(Long id, Long routeId) {
|
var saved = workOrderProcessService.getWorkOrderProcessListByWorkOrderId(id);
|
List<MesProRouteProcessDO> result = new ArrayList<>();
|
if (!saved.isEmpty()) {
|
for (var row : saved) result.add(new MesProRouteProcessDO().setProcessId(row.getProcessId()).setSort(row.getSort())
|
.setParamTemplateId(row.getParamTemplateId()).setYieldRate(row.getYieldRate()).setOutputItemId(row.getOutputItemId()).setColorCode(row.getColorCode())
|
.setPrepareTime(row.getPrepareTime()).setWaitTime(row.getWaitTime()).setNextProcessId(row.getNextProcessId()).setLinkType(row.getLinkType()));
|
} else result.addAll(routeProcessService.getRouteProcessListByRouteId(routeId));
|
result.sort(Comparator.comparing(MesProRouteProcessDO::getSort, Comparator.nullsLast(Comparator.naturalOrder())));
|
return result;
|
}
|
|
/**
|
* 按工序收率从末道往前倒推各道工序的目标产出数量：末道=订单量，前面各道除以后方工序的累计收率后向上取整；
|
* 收率为空按 1.0 处理。
|
*/
|
private Map<Long, BigDecimal> calcTargetQuantities(List<MesProRouteProcessDO> processes, BigDecimal orderQuantity) {
|
return MesProScheduleQuantityService.targetQuantities(processes, orderQuantity);
|
}
|
|
private void addChildrenFirst(Long id, Map<Long, MesProWorkOrderDO> orders, List<Long> sequence, Set<Long> visiting) {
|
if (sequence.contains(id)) return;
|
if (!visiting.add(id)) throw exception(PRO_TASK_SCHEDULE_INVALID, "工单父子关系存在循环，请先修复");
|
orders.values().stream().filter(order -> Objects.equals(order.getParentId(), id)).sorted(Comparator.comparing(MesProWorkOrderDO::getId))
|
.forEach(order -> addChildrenFirst(order.getId(), orders, sequence, visiting));
|
visiting.remove(id); sequence.add(id);
|
}
|
}
|
