package com.qianwen.smartman.modules.coproduction.service.impl; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.toolkit.IdWorker; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import java.lang.invoke.SerializedLambda; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; import com.qianwen.smartman.common.cache.RegionCache; import com.qianwen.smartman.common.constant.CommonConstant; import com.qianwen.smartman.common.constant.CommonGroupConstant; import com.qianwen.smartman.common.enums.CommonGroupTypeEnum; import com.qianwen.smartman.common.utils.MessageUtils; import com.qianwen.core.log.exception.ServiceException; import com.qianwen.core.mp.base.BaseServiceImpl; import com.qianwen.core.tool.node.ForestNodeMerger; import com.qianwen.core.tool.utils.DateUtil; import com.qianwen.core.tool.utils.Func; import com.qianwen.smartman.modules.coproduction.convert.OrderProcessConvert; import com.qianwen.smartman.modules.coproduction.convert.ReportConvert; import com.qianwen.smartman.modules.coproduction.dto.OrderProcessReportWorkDTO; import com.qianwen.smartman.modules.coproduction.dto.ParallelNumDTO; import com.qianwen.smartman.modules.coproduction.dto.PlanAndOrderDTO; import com.qianwen.smartman.modules.coproduction.dto.ReportParallelProcessDTO; import com.qianwen.smartman.modules.coproduction.dto.ReportSourceDTO; import com.qianwen.smartman.modules.coproduction.dto.ReportWorkDTO; import com.qianwen.smartman.modules.coproduction.dto.ResultByStartDTO; import com.qianwen.smartman.modules.coproduction.entity.Order; import com.qianwen.smartman.modules.coproduction.entity.OrderProcess; import com.qianwen.smartman.modules.coproduction.entity.OrderReportRecord; import com.qianwen.smartman.modules.coproduction.entity.OrderWorkstation; import com.qianwen.smartman.modules.coproduction.entity.Plan; import com.qianwen.smartman.modules.coproduction.entity.PlanProcess; import com.qianwen.smartman.modules.coproduction.enums.CoProductionEnum; import com.qianwen.smartman.modules.coproduction.enums.OrderProcessStatusEnum; import com.qianwen.smartman.modules.coproduction.enums.OrderStatusEnum; import com.qianwen.smartman.modules.coproduction.enums.WorkstationStatusEnum; import com.qianwen.smartman.modules.coproduction.mapper.OrderProcessMapper; import com.qianwen.smartman.modules.coproduction.service.IOrderProcessService; import com.qianwen.smartman.modules.coproduction.service.IOrderReportRecordService; import com.qianwen.smartman.modules.coproduction.service.IOrderService; import com.qianwen.smartman.modules.coproduction.service.IOrderWorkstationService; import com.qianwen.smartman.modules.coproduction.service.IPlanProcessService; import com.qianwen.smartman.modules.coproduction.service.IPlanService; import com.qianwen.smartman.modules.coproduction.vo.OrderAssignVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessDetailVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessGeneralDetailVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessParallelDetailVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessRelationQueryVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessRelationVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartGeneralVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartParallelVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartResultVO; import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartWorkstationVO; import com.qianwen.smartman.modules.coproduction.vo.PlanProcessWorkStationAssignVO; import com.qianwen.smartman.modules.cps.entity.Process; import com.qianwen.smartman.modules.cps.service.ICommonGroupService; import com.qianwen.smartman.modules.cps.service.IProcessService; import com.qianwen.smartman.modules.cps.service.IWorkstationService; import com.qianwen.smartman.modules.cps.vo.CommonGroupTypeVO; import com.qianwen.smartman.modules.cps.vo.WorkstationInGroupVO; import com.qianwen.smartman.modules.cps.vo.WorkstationVO; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class OrderProcessServiceImpl extends BaseServiceImpl implements IOrderProcessService { @Autowired private IWorkstationService workstationService; @Autowired private IOrderWorkstationService orderWorkstationService; @Autowired @Lazy private IPlanService planService; @Autowired private IOrderService orderService; @Autowired @Lazy private IOrderReportRecordService orderReportRecordService; @Autowired private IPlanProcessService planProcessService; @Autowired private IProcessService processService; @Autowired private ICommonGroupService commonGroupService; @Override // org.springblade.modules.coproduction.service.IOrderProcessService public OrderProcessGeneralDetailVO startDetailGeneral(Long orderProcessId) { OrderProcess orderProcess = getById(orderProcessId); checkCanStartWork(orderProcess); return this.baseMapper.startDetailGeneral(orderProcessId); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService @Transactional(rollbackFor = {Exception.class}) public List startGeneral(OrderProcessStartGeneralVO orderProcessStartGeneralVO) { OrderProcess orderProcess = getById(orderProcessStartGeneralVO.getOrderProcessId()); checkCanStartWork(orderProcess); ResultByStartDTO resultByStartDTO = generateResultByGeneral(orderProcessStartGeneralVO, orderProcess); if (Func.isEmpty(resultByStartDTO.getCanStartWorkstationIdList())) { return resultByStartDTO.getOrderProcessStartResultVOList(); } PlanAndOrderDTO planAndOrderDTO = this.orderService.getPlanAndOrderByOrderId(orderProcess.getOrderId()); Date now = DateUtil.now(); Map workstationVoMap = orderProcessStartGeneralVO.getWorkstationVoList().stream().collect(Collectors.toMap(OrderProcessStartWorkstationVO::getWorkstationId, w -> w)); List orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVoMap, null, null); Map orderReportRecordMap = orderReportRecordList.stream().collect(Collectors.toMap(OrderReportRecord::getWorkstationId, w -> w)); /* Map workstationVoMap = (Map) orderProcessStartGeneralVO.getWorkstationVoList().stream().collect(Collectors.toMap((v0) -> { return v0.getWorkstationId(); }, w -> { return w; })); List orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVoMap, null, null); Map orderReportRecordMap = (Map) orderReportRecordList.stream().collect(Collectors.toMap((v0) -> { return v0.getWorkstationId(); }, w2 -> { return w2; })); */ updateOrderProcess(orderProcess, now); this.orderWorkstationService.updateOrderWorkstationForStart(orderReportRecordMap, resultByStartDTO, workstationVoMap); this.orderService.updateOrderByStart(planAndOrderDTO.getOrder(), now); this.planService.updatePlanByStart(planAndOrderDTO.getPlan(), now); return resultByStartDTO.getOrderProcessStartResultVOList(); } private void updateOrderProcess(OrderProcess orderProcess, Date startTime) { if (OrderProcessStatusEnum.TO_BE_PROCESSED.getCode().equals(orderProcess.getProcessStatus())) { orderProcess.setProcessStatus(OrderProcessStatusEnum.IN_PROCESS.getCode()); if (Func.isEmpty(orderProcess.getStartTime())) { orderProcess.setStartTime(startTime); } updateById(orderProcess); } } private void updateOrderProcessBatch(List orderProcessIdList, Date startTime) { List list = listByIds(orderProcessIdList); list.forEach(i -> { if (OrderProcessStatusEnum.TO_BE_PROCESSED.getCode().equals(i.getProcessStatus())) { i.setProcessStatus(OrderProcessStatusEnum.IN_PROCESS.getCode()); if (Func.isEmpty(i.getStartTime())) { i.setStartTime(startTime); } } }); updateBatchById(list); } private OrderProcessStartResultVO generateOrderProcessStartResultVO(OrderProcessStartWorkstationVO orderProcessStartWorkstationVO) { OrderProcessStartResultVO orderProcessStartResultVO = new OrderProcessStartResultVO(); orderProcessStartResultVO.setResultFlag(Boolean.FALSE); orderProcessStartResultVO.setWorkstationId(orderProcessStartWorkstationVO.getWorkstationId()); orderProcessStartResultVO.setWorkstationName(orderProcessStartWorkstationVO.getWorkstationName()); orderProcessStartResultVO.setWorkstationCode(orderProcessStartWorkstationVO.getWorkstationCode()); orderProcessStartResultVO.setResultFlag(Boolean.TRUE); return orderProcessStartResultVO; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public List detail(Long orderId) { List items = ((OrderProcessMapper) this.baseMapper).listByOrderId(orderId); items.forEach(orderProcessRelateDetailVO -> { if (Func.isEmpty(orderProcessRelateDetailVO.getParentId())) { orderProcessRelateDetailVO.setParentId(0L); } }); return ForestNodeMerger.merge(items); } private void checkCanStartWork(OrderProcess orderProcess) { if (orderProcess == null) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.is.not.exist", new Object[0])); } List processStatus = Arrays.asList(OrderProcessStatusEnum.TO_BE_PROCESSED.getCode(), OrderProcessStatusEnum.IN_PROCESS.getCode()); if (!processStatus.contains(orderProcess.getProcessStatus())) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.can.not.start.work", new Object[0])); } if (!this.orderWorkstationService.checkProcessHaveAssign(orderProcess.getId()).booleanValue()) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.has.no.workstation.can.not.start.work", new Object[0])); } } @Override // org.springblade.modules.coproduction.service.IOrderProcessService @Transactional(rollbackFor = {Exception.class}) public Boolean reportWork(ReportWorkDTO reportWorkDTO) { long orderId = Func.toLong(reportWorkDTO.getOrderId()); PlanAndOrderDTO planAndOrderDTO = checkPlanAndOrder(Long.valueOf(orderId)); Order order = planAndOrderDTO.getOrder(); Plan plan = planAndOrderDTO.getPlan(); List reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList()); List finishWorkRecords = reportRecords.stream().filter(s -> CoProductionEnum.RecordStatus.YES.getCode().equals(s.getRecordStatus())).collect(Collectors.toList()); /* * List finishWorkRecords = (List) reportRecords.stream().filter(s -> { return CoProductionEnum.RecordStatus.YES.getCode().equals(s.getRecordStatus()); }).collect(Collectors.toList()); */ if (Func.isNotEmpty(finishWorkRecords)) { throw new ServiceException(MessageUtils.message("production.report.fail.record.is.has.finish.records", new Object[0])); } List reportMainAndChildRecordIds = (List)reportRecords.stream().map(OrderReportRecord::getId).collect(Collectors.toList()); /* List reportMainAndChildRecordIds = (List) reportRecords.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); */ List reportWorkstationList = getReportWorkstationList(reportRecords); List orderProcesses = currentOrderProcesses(order); Map recordMap = reportRecords.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity())); /* Map recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity()));*/ Map orderWorkstationMap = reportWorkstationList.stream().collect(Collectors.toMap(s -> s.getProcessId() + "-" + s.getWorkstationId(), Function.identity())); /* Map orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s2 -> { return s2.getProcessId() + "-" + s2.getWorkstationId(); }, Function.identity())); */ Map orderProcessMap = orderProcesses.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity())); /* Map orderProcessMap = (Map) orderProcesses.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity())); */ Date now = DateUtil.now(); reportWorkDTO.getReportWorkDTOList().forEach(report -> { Long recordId = Long.valueOf(Func.toLong(report.getRecordId())); Integer reportQualifyNum = report.getQualifyNum(); Integer reportScrappedNum = report.getScrappedNum(); OrderReportRecord orderReportRecord = (OrderReportRecord) recordMap.get(recordId); this.orderReportRecordService.buildReportRecord(report, orderReportRecord); OrderWorkstation orderWorkstation = (OrderWorkstation) orderWorkstationMap.get(orderReportRecord.getProcessId() + "-" + orderReportRecord.getWorkstationId()); this.orderWorkstationService.buildWorkstation(report, orderWorkstation); OrderProcess currentOrderProcess = (OrderProcess) orderProcessMap.get(orderReportRecord.getProcessId()); reportOrderProcess(currentOrderProcess, reportQualifyNum, reportScrappedNum, orderProcessMap, now, order, reportMainAndChildRecordIds); }); triggerOptimisticLock(reportRecords); this.orderWorkstationService.updateBatchById(reportWorkstationList); updateBatchById(orderProcesses); this.orderService.updateById(this.orderService.reportOrderData(order)); this.planService.updateById(this.planService.reportCurrentPlan(reportWorkDTO.getReportWorkDTOList(), plan, order.getDelOrderNum())); return true; } private void triggerOptimisticLock(List finishWorkRecords) { finishWorkRecords.forEach(record -> { boolean result = this.orderReportRecordService.updateById(record); System.out.println("报工结果：" + result); if (!result) { throw new ServiceException(MessageUtils.message("production.order.process.report.fail", new Object[0])); } }); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public void dealCompleteProcessSurplusRecords(String orderId) { PlanAndOrderDTO planAndOrderDTO = checkPlanAndOrder(Long.valueOf(Func.toLong(orderId))); List orderProcesses = currentOrderProcesses(planAndOrderDTO.getOrder()); List completeProcess = orderProcesses.stream().filter(s -> (s.isSubProcess().booleanValue() && OrderStatusEnum.COMPLETE.getCode().equals(s.getProcessStatus()))).collect(Collectors.toList()); /* List completeProcess = (List) orderProcesses.stream().filter(s -> { return s.isSubProcess().booleanValue() && OrderStatusEnum.COMPLETE.getCode().equals(s.getProcessStatus()); }).collect(Collectors.toList()); */ if (Func.isNotEmpty(completeProcess)) { List processIds = (List)completeProcess.stream().map(OrderProcess::getId).collect(Collectors.toList()); List startSurplusRecordList = this.orderReportRecordService.list(Wrappers.lambdaQuery().eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()).in(OrderReportRecord::getProcessId, processIds)); /*List processIds = (List) completeProcess.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List startSurplusRecordList = this.orderReportRecordService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getRecordStatus(); }, CoProductionEnum.RecordStatus.NO.getCode())).in((v0) -> { return v0.getProcessId(); }, processIds)); */ if (Func.isNotEmpty(startSurplusRecordList)) { List childStartWorkList = this.orderReportRecordService.list(Wrappers.lambdaQuery().eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()).in(OrderReportRecord::getMainSequenceId, processIds)); /* List childStartWorkList = this.orderReportRecordService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getRecordStatus(); }, CoProductionEnum.RecordStatus.NO.getCode())).in((v0) -> { return v0.getMainSequenceId(); }, processIds));*/ if (Func.isNotEmpty(childStartWorkList)) { startSurplusRecordList.addAll(childStartWorkList); } startSurplusRecordList.forEach(record -> { record.setQualifyNum(0); record.setScrappedNum(0); record.setRecordStatus(CoProductionEnum.RecordStatus.YES.getCode()); }); this.orderReportRecordService.updateBatchById(startSurplusRecordList); List startRecordIds = startSurplusRecordList.stream().map(OrderReportRecord::getId).collect(Collectors.toList()); List updateWorkstationStatusList = this.orderWorkstationService.list(Wrappers.lambdaQuery() .eq(OrderWorkstation::getWorkstationStatus, WorkstationStatusEnum.started.getCode()) .in(OrderWorkstation::getCurrentRecordId, startRecordIds)); /* List startRecordIds = (List) startSurplusRecordList.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List updateWorkstationStatusList = this.orderWorkstationService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> { return v0.getWorkstationStatus(); }, WorkstationStatusEnum.started.getCode())).in((v0) -> { return v0.getCurrentRecordId(); }, startRecordIds));*/ if (Func.isNotEmpty(updateWorkstationStatusList)) { updateWorkstationStatusList.forEach(workstation -> { workstation.setWorkstationStatus(WorkstationStatusEnum.UNDRESSED.getCode()); workstation.setCurrentRecordId(null); }); this.orderWorkstationService.updateBatchById(updateWorkstationStatusList); } } } } private void reportOrderProcess(OrderProcess currentOrderProcess, Integer addQualifyNum, Integer addScrappedNum, Map orderProcessMap, Date now, Order order, List reportMainAndChildRecordIds) { boolean isChild = !currentOrderProcess.isSubProcess().booleanValue(); boolean numsResult = dealOrderProcessNum(currentOrderProcess, orderProcessMap, addQualifyNum, addScrappedNum, Boolean.valueOf(isChild)).booleanValue(); dealReportProcessStatus(currentOrderProcess, Boolean.valueOf(isChild), Boolean.valueOf(numsResult), now, reportMainAndChildRecordIds); if (!isChild) { if (currentOrderProcess.isLastProcess().booleanValue()) { order.setQualifyNum(currentOrderProcess.getQualifyNum()); order.setDelOrderNum(addQualifyNum); } OrderProcess nextProcess = currentOrderProcess.getNextProcess(); if (nextProcess != null) { dealNextProcessInputNum(nextProcess, addQualifyNum); List nextProcessList = getReportNextProcess(order, currentOrderProcess.getSort()); if (nextProcessList != null) { nextProcessList.forEach(next -> { reportOrderProcess(next, 0, 0, orderProcessMap, now, order, reportMainAndChildRecordIds); }); } } } } private Boolean dealOrderProcessNum(OrderProcess currentOrderProcess, Map orderProcessMap, Integer addQualifyNum, Integer addScrappedNum, Boolean isChild) { Integer inputNum; if (isChild.booleanValue()) { OrderProcess mainProcess = orderProcessMap.get(currentOrderProcess.getMainSequenceId()); inputNum = mainProcess.getInputNum(); } else { inputNum = currentOrderProcess.getInputNum(); } Integer oldQualifyNum = currentOrderProcess.getQualifyNum(); Integer oldScrappedNum = currentOrderProcess.getScrappedNum(); Integer newQualifyNum = Integer.valueOf(addQualifyNum.intValue() + oldQualifyNum.intValue()); Integer newScrappedNum = Integer.valueOf(addScrappedNum.intValue() + oldScrappedNum.intValue()); Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue()); if (inputNum.intValue() < newReportNum.intValue()) { throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.local.process.inputNum", new Object[0])); } currentOrderProcess.setQualifyNum(newQualifyNum); currentOrderProcess.setScrappedNum(newScrappedNum); return Boolean.valueOf(inputNum.equals(newReportNum)); } private void dealNextProcessInputNum(OrderProcess nextProcess, Integer addQualifyNum) { if (nextProcess != null) { int nextInputNum = nextProcess.getInputNum().intValue() + addQualifyNum.intValue(); int nextReportNum = nextProcess.getQualifyNum().intValue() + nextProcess.getScrappedNum().intValue(); if (nextInputNum < nextReportNum) { throw new ServiceException(MessageUtils.message("production.report.fail.update.next.process", new Object[0])); } nextProcess.setInputNum(Integer.valueOf(nextInputNum)); } } private void dealReportProcessStatus(OrderProcess currentOrderProcess, Boolean isChild, Boolean numsResult, Date now, List reportMainAndChildRecordIds) { Integer startWorkRecordNum = this.orderReportRecordService.countDelRecord(currentOrderProcess.getId(), reportMainAndChildRecordIds); OrderProcess prevProcess = currentOrderProcess.getPrevProcess(); if (currentOrderProcess.isFirstProcess().booleanValue()) { if (!numsResult.booleanValue() && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); } if (numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); currentOrderProcess.setEndTime(now); return; } return; } Integer preProcessStatus = prevProcess.getProcessStatus(); boolean resultPre = OrderStatusEnum.COMPLETE.getCode().equals(preProcessStatus); if ((!resultPre || !numsResult.booleanValue()) && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); } if (resultPre && numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); currentOrderProcess.setEndTime(now); } } private List getReportRecords(List reportWorkDTOList) { List records = reportWorkDTOList.stream().map(OrderProcessReportWorkDTO::getRecordId).distinct().collect(Collectors.toList()); /* List records = (List) reportWorkDTOList.stream().map((v0) -> { return v0.getRecordId(); }).distinct().collect(Collectors.toList()); */ int reportRecordsSize = records.size(); List reportRecords = this.orderReportRecordService.list(Wrappers.lambdaQuery().in(OrderReportRecord::getId, Func.toLongList(records))); /* List reportRecords = this.orderReportRecordService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> { return v0.getId(); }, Func.toLongList(records))); */ if (Func.isEmpty(reportRecords)) { throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0])); } int size = reportRecords.size(); if (reportRecordsSize != size) { throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.data.inconsistency", new Object[0])); } return reportRecords; } private List getReportWorkstationList(List reportRecords) { List processIds = reportRecords.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList()); return this.orderWorkstationService.list(Wrappers.lambdaQuery().in(OrderWorkstation::getProcessId, processIds)); /* List processIds = (List) reportRecords.stream().map((v0) -> { return v0.getProcessId(); }).distinct().collect(Collectors.toList()); return this.orderWorkstationService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> { return v0.getProcessId(); }, processIds));*/ } private void dealNextProcess(OrderProcess nextProcess, Integer nextInputNum, OrderProcess orderProcess, Map orderProcessMap) { int initialQualifyNum = 0; int initialScrappedNum = 0; nextProcess.setInputNum(nextInputNum); updateById(nextProcess); List nextProcessList = getNextProcess(orderProcess.getOrderId(), orderProcess.getSort()); if (nextProcessList != null) nextProcessList.forEach(next -> handleOrderReport(Integer.valueOf(initialQualifyNum), Integer.valueOf(initialScrappedNum), next, Boolean.FALSE, orderProcessMap)); } private ReportSourceDTO assembleData(List startRecordsList) { if (Func.isEmpty(startRecordsList)) throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0])); Map startRecordsMap = (Map)startRecordsList.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity())); List processIds = (List)startRecordsList.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList()); List planIds = (List)startRecordsList.stream().map(OrderReportRecord::getPlanId).distinct().collect(Collectors.toList()); List planList = this.planService.list((Wrapper)Wrappers.lambdaQuery().in(Plan::getId, planIds)); if (Func.isEmpty(planList)) throw new ServiceException(MessageUtils.message("production.report.fail.plan.is.not.exist", new Object[0])); Map planMap = (Map)planList.stream().collect(Collectors.toMap(Plan::getId, Function.identity())); List orderList = this.orderService.list((Wrapper)Wrappers.lambdaQuery().in(Order::getPlanId, planIds)); if (Func.isEmpty(orderList)) throw new ServiceException(MessageUtils.message("production.report.fail.order.is.not.exist", new Object[0])); Map orderMap = orderList.stream().collect(Collectors.toMap(Order::getId, Function.identity())); List orderWorkstationList = this.orderWorkstationService.list(Wrappers.lambdaQuery().in(OrderWorkstation::getProcessId, processIds)); if (Func.isEmpty(orderWorkstationList)) throw new ServiceException(MessageUtils.message("production.report.fail.order.process.workstation.is.not.exist", new Object[0])); Map orderWorkstationMap = (Map)orderWorkstationList.stream().collect(Collectors.toMap(s -> s.getProcessId() + "-" + s.getWorkstationId(), Function.identity())); List orderProcesses = list(Wrappers.lambdaQuery().in(OrderProcess::getId, processIds)); if (Func.isEmpty(orderProcesses)) throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0])); Map orderProcessMap = (Map)orderProcesses.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity())); return ReportSourceDTO.builder().planMap(planMap) .orderMap(orderMap) .orderProcessMap(orderProcessMap) .orderWorkstationMap(orderWorkstationMap) .startRecordsMap(startRecordsMap) .build(); } private void handleOrderReport(Integer addQualifyNum, Integer addScrappedNum, OrderProcess currentOrderProcess, Boolean isDel, Map orderProcessMap) { Integer inputNum; boolean isChild = Func.isNotEmpty(currentOrderProcess.getMainSequenceId()); Date now = DateUtil.now(); if (isChild) { OrderProcess mainProcess = orderProcessMap.get(currentOrderProcess.getMainSequenceId()); inputNum = mainProcess.getInputNum(); } else { inputNum = currentOrderProcess.getInputNum(); } Integer oldQualifyNum = currentOrderProcess.getQualifyNum(); Integer oldScrappedNum = currentOrderProcess.getScrappedNum(); Integer newQualifyNum = Integer.valueOf((addQualifyNum == null ? 0 : addQualifyNum.intValue()) + oldQualifyNum.intValue()); Integer newScrappedNum = Integer.valueOf((addScrappedNum == null ? 0 : addScrappedNum.intValue()) + oldScrappedNum.intValue()); Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue()); if (inputNum.intValue() < newReportNum.intValue()) { throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.local.process.inputNum", new Object[0])); } currentOrderProcess.setQualifyNum(newQualifyNum); currentOrderProcess.setScrappedNum(newScrappedNum); LambdaUpdateWrapper updateWrapper = Wrappers.lambdaUpdate().eq(OrderProcess::getId, currentOrderProcess.getId()); boolean numsResult = inputNum.equals(newReportNum); OrderProcess preProcess = getPreProcess(currentOrderProcess); Integer startWorkRecordNum = this.orderReportRecordService.countOpenRecord(currentOrderProcess.getId()); if (preProcess != null) { Integer preProcessStatus = preProcess.getProcessStatus(); boolean resultPre = OrderStatusEnum.COMPLETE.getCode().equals(preProcessStatus); if (!numsResult && startWorkRecordNum.intValue() == 0) updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.NOT_STARTED.getCode()); if (!resultPre && startWorkRecordNum.intValue() > 0) updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.IN_EXECUTION.getCode()); if (resultPre && numsResult && !isChild) { updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.COMPLETE.getCode()).set(OrderProcess::getEndTime, now); updateProcessEndTime(currentOrderProcess); } } else { if (!numsResult) updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.IN_EXECUTION.getCode()); if (startWorkRecordNum.intValue() == 0 && !numsResult) updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.NOT_STARTED.getCode()); if (numsResult && !isChild) { updateWrapper.set(OrderProcess::getProcessStatus, OrderStatusEnum.COMPLETE.getCode()).set(OrderProcess::getEndTime, now); updateProcessEndTime(currentOrderProcess); } } if (isDel.booleanValue()) { } boolean reportResult = update(currentOrderProcess, updateWrapper); if (!reportResult) throw new ServiceException(MessageUtils.message("production.order.process.report.fail", new Object[0])); } private void updateProcessEndTime(OrderProcess currentProcess) { Date endTime = null; if (Func.isNotEmpty(currentProcess.getMainSequenceId())) { List list = list(Wrappers.lambdaQuery().eq(OrderProcess::getMainSequenceId, currentProcess.getId())); List childProcessIds = (List)list.stream().map(OrderProcess::getId).collect(Collectors.toList()); OrderReportRecord latestChildProcessRecord = this.orderReportRecordService.getLatestChildProcessRecord(childProcessIds); if (latestChildProcessRecord != null) { endTime = latestChildProcessRecord.getWorkshopTime(); } } else { OrderReportRecord latestRecord = this.orderReportRecordService.getLatestRecord(null, null, currentProcess.getId()); if (latestRecord != null) { endTime = latestRecord.getWorkshopTime(); } } if (endTime == null) { endTime = DateUtil.now(); } currentProcess.setEndTime(endTime); } private void finishChildAllProcess(OrderProcess currentOrderProcess) { if (Func.isEmpty(currentOrderProcess.getMainSequenceId())) { Long mainProcessId = currentOrderProcess.getId(); update(Wrappers.lambdaUpdate() .eq(OrderProcess::getMainSequenceId, mainProcessId) .set(OrderProcess::getProcessStatus, OrderStatusEnum.COMPLETE.getCode()) .set(OrderProcess::getEndTime, DateUtil.now())); } /*( if (Func.isEmpty(currentOrderProcess.getMainSequenceId())) { Long mainProcessId = currentOrderProcess.getId(); update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().eq((v0) -> { return v0.getMainSequenceId(); }, mainProcessId)).set((v0) -> { return v0.getProcessStatus(); }, OrderStatusEnum.COMPLETE.getCode())).set((v0) -> { return v0.getEndTime(); }, DateUtil.now())); }*/ } private OrderProcess getPreProcess(OrderProcess orderProcess) { Integer currentSort = orderProcess.getSort(); List list = list(Wrappers.lambdaQuery() .eq(OrderProcess::getOrderId, orderProcess.getOrderId()) .lt(OrderProcess::getSort, currentSort) .isNull(OrderProcess::getMainSequenceId) .orderByDesc(OrderProcess::getSort)); if (Func.isNotEmpty(list)) return list.get(0); return null; } private OrderProcess getNextProcess(OrderProcess orderProcess) { Integer currentSort = orderProcess.getSort(); List list = list(Wrappers.lambdaQuery() .eq(OrderProcess::getOrderId, orderProcess.getOrderId()) .gt(OrderProcess::getSort, currentSort) .isNull(OrderProcess::getMainSequenceId) .orderByAsc(OrderProcess::getSort)); if (Func.isNotEmpty(list)) return list.get(0); return null; } private List getNextProcess(Long orderId, Integer nextSort) { List list = list(Wrappers.lambdaQuery().eq(OrderProcess::getOrderId, orderId).eq(OrderProcess::getSort, nextSort).isNull(OrderProcess::getMainSequenceId)); if (Func.isNotEmpty(list)) return list; return null; } private List getReportNextProcess(Order order, Integer nextSort) { List orderProcesses = currentOrderProcesses(order); List nextList = (List) orderProcesses.stream().filter((v0) -> { return v0.isSubProcess(); }).filter(s -> { return s.getSort().intValue() > nextSort.intValue(); }).collect(Collectors.toList()); if (Func.isNotEmpty(nextList)) { return nextList; } return null; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public List generateOrderProcess(OrderAssignVO orderAssignVO, Order order) { List planProcessWorkStationAssignVOList = orderAssignVO.getPlanProcessWorkStationAssignVOList(); Map processToWorkstation = (Map)planProcessWorkStationAssignVOList.stream().collect(Collectors.toMap(PlanProcessWorkStationAssignVO::getPlanProcessId, v -> v)); List planProcessList = (List)this.planProcessService.list(Wrappers.lambdaQuery().eq(PlanProcess::getPlanId, orderAssignVO.getPlanId())).stream().sorted(Comparator.comparing(PlanProcess::getSort).thenComparing(PlanProcess::getMainSequenceId, Comparator.nullsFirst(Long::compareTo))).collect(Collectors.toList()); PlanProcess firstProcess = getFirstProcess(planProcessList); Map planProcessToOrderProcess = new HashMap<>(planProcessList.size()); List orderProcessList = new ArrayList<>(); for (PlanProcess planProcess : planProcessList) { OrderProcess orderProcess = OrderProcessConvert.INSTANCE.convertPlanProcess(planProcess); orderProcess.setId(Long.valueOf(IdWorker.getId())); orderProcess.setOrderId(order.getId()); orderProcess.setProcessStatus(OrderProcessStatusEnum.TO_BE_PROCESSED.getCode()); orderProcess.setMainSequenceId(planProcessToOrderProcess.get(planProcess.getMainSequenceId())); PlanProcessWorkStationAssignVO planProcessWorkStationAssignVO = processToWorkstation.get(planProcess.getId()); if (Func.isNotEmpty(planProcessWorkStationAssignVO)) { String workstationId = planProcessWorkStationAssignVO.getWorkstationId(); if (Func.isNotEmpty(workstationId)) { orderProcess.setWorkstationId(workstationId); orderProcess.setWorkstationName(((PlanProcessWorkStationAssignVO)processToWorkstation.get(planProcess.getId())).getWorkstationName()); } } if (planProcess.getId().equals(firstProcess.getId())) orderProcess.setInputNum(orderAssignVO.getAssignNum()); orderProcessList.add(orderProcess); planProcessToOrderProcess.put(planProcess.getId(), orderProcess.getId()); } saveBatch(orderProcessList); return orderProcessList; } private PlanProcess getFirstProcess(List planProcessList) { return planProcessList.stream().filter(p -> { return Func.isEmpty(p.getMainSequenceId()); }).min(Comparator.comparing((v0) -> { return v0.getSort(); })).get(); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public OrderProcessParallelDetailVO startDetailParallel(Long orderProcessId) { OrderProcessParallelDetailVO result = new OrderProcessParallelDetailVO(); OrderProcess orderProcess = (OrderProcess) getById(orderProcessId); checkCanStartWork(orderProcess); OrderProcessGeneralDetailVO orderProcessGeneralDetailVO = ((OrderProcessMapper) this.baseMapper).startDetailGeneral(orderProcessId); result.setOrderProcessGeneralDetailVO(orderProcessGeneralDetailVO); List orderProcessGeneralDetailVOList = ((OrderProcessMapper) this.baseMapper).startDetailGeneralByParallel(orderProcessId); result.setChildOrderProcessList(orderProcessGeneralDetailVOList); return result; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public List startParallel(OrderProcessStartParallelVO orderProcessStartParallelVO) { OrderProcess orderProcess = (OrderProcess) getById(orderProcessStartParallelVO.getOrderProcessId()); checkCanStartWork(orderProcess); List workstationIdList = new ArrayList<>(); Set workstationIdSet = new HashSet<>(); Map map = new HashMap<>(); Set orderProcessIdAndWorkstationIdSet = new HashSet<>(); orderProcessStartParallelVO.getOrderProcessStartGeneralVoList().forEach(i -> { i.getWorkstationVoList().forEach(w -> { workstationIdList.add(w.getWorkstationId()); workstationIdSet.add(w.getWorkstationId()); map.put(w.getWorkstationId(), w); orderProcessIdAndWorkstationIdSet.add(String.valueOf(i.getOrderProcessId()).concat(String.valueOf(w.getWorkstationId()))); }); }); if (workstationIdList.size() != workstationIdSet.size()) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.workstation.is.repeat", new Object[0])); } ResultByStartDTO resultByStartDTO = generateResultByParallel(orderProcessStartParallelVO, workstationIdSet, map, orderProcessIdAndWorkstationIdSet); if (Func.isEmpty(resultByStartDTO.getCanStartWorkstationIdList())) { return resultByStartDTO.getOrderProcessStartResultVOList(); } PlanAndOrderDTO planAndOrderDTO = this.orderService.getPlanAndOrderByOrderId(orderProcess.getOrderId()); Date now = DateUtil.now(); OrderReportRecord orderReportRecord = this.orderReportRecordService.generateStartMainRecord(planAndOrderDTO, orderProcessStartParallelVO.getOrderProcessId(), now); this.orderWorkstationService.updateOrderWorkstationForStartMain(orderProcessStartParallelVO.getOrderProcessId(), orderReportRecord.getId()); updateOrderProcess(orderProcess, now); Map workstationVOMap = (Map) resultByStartDTO.getWorkstationVOList().stream().collect(Collectors.toMap((v0) -> { return v0.getWorkstationId(); }, w -> { return w; })); List orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVOMap, orderProcessStartParallelVO.getOrderProcessId(), orderReportRecord.getId()); Map orderReportRecordMap = (Map) orderReportRecordList.stream().collect(Collectors.toMap((v0) -> { return v0.getWorkstationId(); }, w2 -> { return w2; })); updateOrderProcessBatch(resultByStartDTO.getCanStartOrderProcessIdList(), now); this.orderWorkstationService.updateOrderWorkstationForStart(orderReportRecordMap, resultByStartDTO, workstationVOMap); this.orderService.updateOrderByStart(planAndOrderDTO.getOrder(), now); this.planService.updatePlanByStart(planAndOrderDTO.getPlan(), now); return resultByStartDTO.getOrderProcessStartResultVOList(); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public OrderProcessRelationVO getRelation(OrderProcessRelationQueryVO orderProcessRelationQueryVO) { return ((OrderProcessMapper) this.baseMapper).getRelation(orderProcessRelationQueryVO); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService @Transactional(rollbackFor = {Exception.class}) public Boolean reportParallel(ReportWorkDTO reportWorkDTO) { List reportWorkDTOList = reportWorkDTO.getReportWorkDTOList(); if (Func.isEmpty(reportWorkDTO.getReportWorkDTOList())) { throw new ServiceException(MessageUtils.message("production.report.fail.data.empty", new Object[0])); } parallelProcessAround(ReportConvert.INSTANCE.convertParallel(reportWorkDTOList), Boolean.FALSE); Boolean result = reportWork(reportWorkDTO); dealChildProcess(reportWorkDTOList); dealCompleteProcessSurplusRecords(reportWorkDTO.getOrderId()); return result; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public void dealChildProcess(List reportWorkDTOList) { List processIds = (List)reportWorkDTOList.stream().filter(s -> Func.isEmpty(s.getMainSequenceId())).map(OrderProcessReportWorkDTO::getProcessId).distinct().collect(Collectors.toList()); if (Func.isNotEmpty(processIds)) { List list = list(Wrappers.lambdaQuery().in(OrderProcess::getId, processIds)); if (Func.isNotEmpty(list)) { Map orderProcessMap = (Map)list.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity())); for (String processId : processIds) { OrderProcess currentOrderProcess = orderProcessMap.get(Long.valueOf(Func.toLong(processId))); if (CoProductionEnum.WhetherParallel.YES.getCode().equals(currentOrderProcess.getWhetherParallel()) && OrderStatusEnum.COMPLETE.getCode().equals(currentOrderProcess.getProcessStatus())) finishChildAllProcess(currentOrderProcess); } } } } private ReportParallelProcessDTO getMainProcessRecord(List parallelProcessDTO) { List mainParallelProcesses = (List) parallelProcessDTO.stream().filter(s -> { return Func.isEmpty(s.getMainSequenceId()); }).collect(Collectors.toList()); if (Func.isEmpty(mainParallelProcesses)) { throw new ServiceException(MessageUtils.message("production.report.fail.main.process.message", new Object[0])); } return mainParallelProcesses.get(0); } private List getChildProcessRecord(List parallelProcessDTO, String mainRecordId) { List childProcesses = (List) parallelProcessDTO.stream().filter(s -> { return !mainRecordId.equals(s.getRecordId()); }).collect(Collectors.toList()); if (Func.isEmpty(childProcesses)) { throw new ServiceException(MessageUtils.message("production.report.fail.main.process.message", new Object[0])); } return childProcesses; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public Integer parallelProcessAround(List parallelProcessDTO, Boolean isEdit) { Map notReportMap = new HashMap<>(8); Map alreadyReportMap = new HashMap<>(8); ReportParallelProcessDTO mainProcessRecord = getMainProcessRecord(parallelProcessDTO); List childProcessRecords = getChildProcessRecord(parallelProcessDTO, mainProcessRecord.getRecordId()); if (Func.isNotEmpty(childProcessRecords)) { Map> parallelChildProcessRecordMap = (Map>)childProcessRecords.stream().collect(Collectors.groupingBy(OrderProcessReportWorkDTO::getProcessId)); parallelChildProcessRecordMap.forEach((k, v) -> { int qualifyNumSum = v.stream().mapToInt(OrderProcessReportWorkDTO::getQualifyNum).sum(); int scrappedNumSum = v.stream().mapToInt(OrderProcessReportWorkDTO::getScrappedNum).sum(); int reportNum = qualifyNumSum + scrappedNumSum; notReportMap.put(k, saveNum(Integer.valueOf(reportNum), Integer.valueOf(qualifyNumSum), Integer.valueOf(scrappedNumSum))); }); } List recordIds = (List)parallelProcessDTO.stream().map(OrderProcessReportWorkDTO::getRecordId).collect(Collectors.toList()); List list = this.orderReportRecordService.list(Wrappers.lambdaQuery().in(OrderReportRecord::getId, Func.toLongList(recordIds))); if (Func.isEmpty(list)) throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0])); List processIds = (List)list.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList()); List orderProcesses = listByIds(processIds); Map orderProcessMap = (Map)orderProcesses.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity())); List finishedRecords = this.orderReportRecordService.list(Wrappers.lambdaQuery().in(OrderReportRecord::getProcessId, processIds).eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())); if (isEdit.booleanValue()) finishedRecords = (List)finishedRecords.stream().filter(s -> !recordIds.contains(Func.toStr(s.getId()))).collect(Collectors.toList()); Map> finishedRecordsMap = (Map>)finishedRecords.stream().collect(Collectors.groupingBy(OrderReportRecord::getProcessId)); finishedRecordsMap.forEach((k, v) -> { int qualifyNumSum = v.stream().mapToInt(OrderReportRecord::getQualifyNum).sum(); int scrappedNumSum = v.stream().mapToInt(OrderReportRecord::getScrappedNum).sum(); int reportNum = qualifyNumSum + scrappedNumSum; alreadyReportMap.put(Func.toStr(k), saveNum(Integer.valueOf(reportNum), Integer.valueOf(qualifyNumSum), Integer.valueOf(scrappedNumSum))); }); OrderProcess mainOrderProcess = orderProcessMap.get(Long.valueOf(Func.toLong(mainProcessRecord.getProcessId()))); if (mainOrderProcess == null) throw new ServiceException(MessageUtils.message("production.report.fail.main.process.is.not.exist", new Object[0])); return checkMainProcess(mainProcessRecord, mainOrderProcess, childProcessRecords, notReportMap, alreadyReportMap, isEdit); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public Integer getChildReportNum(Long orderProcessId) { OrderProcess orderProcess = (OrderProcess)getById(orderProcessId); Long mainSequenceId = orderProcess.getMainSequenceId(); if (Func.isNotEmpty(mainSequenceId)) { OrderProcess mainProcess = (OrderProcess)getById(mainSequenceId); int inputNum = mainProcess.getInputNum().intValue(); List finishedRecords = this.orderReportRecordService.list(Wrappers.lambdaQuery().in(OrderReportRecord::getProcessId, new Object[] { orderProcessId }).eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())); if (Func.isNotEmpty(finishedRecords)) { int alReportScrappedNum = finishedRecords.stream().mapToInt(OrderReportRecord::getScrappedNum).sum(); int alReportNum = finishedRecords.stream().mapToInt(s -> s.getQualifyNum().intValue() + s.getScrappedNum().intValue()).sum(); boolean result = (alReportScrappedNum > 0); int stayReportNum = inputNum - mainProcess.getScrappedNum().intValue() - alReportNum + (result ? mainProcess.getScrappedNum().intValue() : 0); if (stayReportNum < 0) throw new ServiceException(MessageUtils.message("production.child.process.message.exception", new Object[0])); return Integer.valueOf(stayReportNum); } return Integer.valueOf(inputNum); } return CommonConstant.ZERO; } private Integer checkMainProcess(ReportParallelProcessDTO mainProcessRecord, OrderProcess mainOrderProcess, List childProcessRecords, Map notReportMap, Map alreadyReportMap, Boolean isEdit) { Integer mainScrappedNum; Integer mainQualifyNum; int inputNum = mainOrderProcess.getInputNum().intValue(); if (isEdit.booleanValue()) { OrderReportRecord orderReportRecord = mainRecord(Long.valueOf(Func.toLong(mainProcessRecord.getRecordId()))); mainScrappedNum = Integer.valueOf(mainOrderProcess.getScrappedNum().intValue() - orderReportRecord.getScrappedNum().intValue()); mainQualifyNum = Integer.valueOf(mainOrderProcess.getQualifyNum().intValue() - orderReportRecord.getQualifyNum().intValue()); } else { mainScrappedNum = mainOrderProcess.getScrappedNum(); mainQualifyNum = mainOrderProcess.getQualifyNum(); } Integer newScrappedNum = Integer.valueOf(mainScrappedNum.intValue() + mainProcessRecord.getScrappedNum().intValue()); Integer newQualifyNum = Integer.valueOf(mainQualifyNum.intValue() + mainProcessRecord.getQualifyNum().intValue()); List qualifyNumRange = new LinkedList<>(); int newReportNum = newScrappedNum.intValue() + newQualifyNum.intValue(); if (inputNum < newReportNum) { throw new ServiceException(MessageUtils.message("production.report.fail.main.process.cumulative.exceed.process.inputNum", new Object[0])); } Integer num = mainScrappedNum; childProcessRecords.forEach(s -> { String processId = s.getProcessId(); Integer addQualifyNum = s.getQualifyNum(); Integer addScrappedNum = s.getScrappedNum(); Integer addReportNum = Integer.valueOf(addQualifyNum.intValue() + addScrappedNum.intValue()); Integer reportNum = CommonConstant.ZERO; Integer reportScrappedNum = CommonConstant.ZERO; if (!alreadyReportMap.isEmpty()) { ParallelNumDTO parallelNumDTO = (ParallelNumDTO) alreadyReportMap.get(processId); if (parallelNumDTO == null) { throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0])); } reportNum = parallelNumDTO.getReportNum(); reportScrappedNum = parallelNumDTO.getNoScrappedNum(); } int cumulativeReportNum = (addReportNum.intValue() + reportNum.intValue()) - reportScrappedNum.intValue(); if (inputNum - num.intValue() < cumulativeReportNum) { throw new ServiceException(MessageUtils.message("production.report.fail.child.process.cumulative.exceed.process.inputNum", new Object[0])); } }); List processIds = (List) childProcessRecords.stream().map((v0) -> { return v0.getProcessId(); }).distinct().collect(Collectors.toList()); processIds.forEach(id -> { ParallelNumDTO parallelNumDTO; Integer alYield = CommonConstant.ZERO; Integer notYield = CommonConstant.ZERO; if (!alreadyReportMap.isEmpty()) { ParallelNumDTO parallelNumDTO2 = (ParallelNumDTO) alreadyReportMap.get(id); if (parallelNumDTO2 == null) { throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0])); } alYield = parallelNumDTO2.getYield(); } if (!notReportMap.isEmpty() && (parallelNumDTO = (ParallelNumDTO) notReportMap.get(id)) != null) { notYield = parallelNumDTO.getYield(); } Integer qualifyRange = Integer.valueOf(alYield.intValue() + notYield.intValue()); qualifyNumRange.add(qualifyRange); }); if (Func.isNotEmpty(qualifyNumRange)) { int minQualifyNum = qualifyNumRange.stream().mapToInt(s2 -> { return s2.intValue(); }).min().orElse(0); int qualifyNum = mainQualifyNum.intValue(); int qualifyRange = minQualifyNum - qualifyNum; if (qualifyRange < 0) { throw new ServiceException(MessageUtils.message("production.report.fail.qualifyNum.less.than.zero", new Object[0])); } if (mainProcessRecord.getQualifyNum().intValue() > qualifyRange) { throw new ServiceException(MessageUtils.message("production.report.fail.main.fill.in.num.exceed.range", new Object[0])); } return Integer.valueOf(qualifyRange); } return CommonConstant.ZERO; } private OrderReportRecord mainRecord(Long mainRecordId) { return (OrderReportRecord) this.orderReportRecordService.getById(mainRecordId); } private ParallelNumDTO saveNum(Integer reportNum, Integer yield, Integer noScrappedNum) { return new ParallelNumDTO().setReportNum(reportNum).setYield(yield).setNoScrappedNum(noScrappedNum); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public List treeWorkstation(Long planId, String processCode, Integer sort) { List planProcessList = this.planProcessService.list(Wrappers.lambdaQuery() .eq(PlanProcess::getPlanId, planId) .eq(PlanProcess::getCode, processCode) .eq(PlanProcess::getSort, sort)); CommonGroupTypeVO commonGroupTypeVO = new CommonGroupTypeVO(); commonGroupTypeVO.setGroupType(CommonGroupTypeEnum.WORKSTATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY); if (Func.isEmpty(planProcessList)) throw new ServiceException(MessageUtils.message("production.plan.process.not.exists", new Object[0])); PlanProcess planProcess = planProcessList.get(0); if (Func.isEmpty(planProcess.getWorkstationId())) { Process process = this.processService.getOne(Wrappers.lambdaQuery().eq(Process::getCode, planProcess.getCode())); if (Func.isEmpty(process)) throw new ServiceException(MessageUtils.message("production.process.not.exists", new Object[0])); commonGroupTypeVO.setWorkType(process.getType()); } else { commonGroupTypeVO.setWorkstationIdList(Func.toLongList(planProcess.getWorkstationId())); } return this.commonGroupService.groupWorkstationList(commonGroupTypeVO); } @Override // org.springblade.modules.coproduction.service.IOrderProcessService public List listDetailByOrderId(Long orderId) { return ((OrderProcessMapper) this.baseMapper).listDetailByOrderId(orderId); } private Map> getSpecialIdCollect(List parallelOrderProcessList) { Map> processMap = new HashMap<>(parallelOrderProcessList.size()); List processList = new ArrayList<>(); for (int i = 0; i < parallelOrderProcessList.size(); i++) { OrderProcess currentProcess = parallelOrderProcessList.get(i); Long key = currentProcess.getId(); processList.add(currentProcess); if (i + 1 < parallelOrderProcessList.size()) { OrderProcess nextProcess = parallelOrderProcessList.get(i + 1); if (currentProcess.getSort().intValue() + 1 == nextProcess.getSort().intValue()) { processMap.remove(key); Long key2 = nextProcess.getId(); processList.add(nextProcess); processMap.put(key2, processList); } else { processMap.put(key, processList); processList = new ArrayList<>(); } } else { processMap.put(key, processList); } } return processMap; } private ResultByStartDTO generateResultByGeneral(OrderProcessStartGeneralVO orderProcessStartGeneralVO, OrderProcess orderProcess) { List result = new ArrayList<>(); List workstationVoList = orderProcessStartGeneralVO.getWorkstationVoList(); Map map = (Map) workstationVoList.stream().collect(Collectors.toMap((v0) -> { return v0.getWorkstationId(); }, w -> { return w; })); Long orderProcessId = orderProcessStartGeneralVO.getOrderProcessId(); Set workstationIdList = (Set) workstationVoList.stream().map((v0) -> { return v0.getWorkstationId(); }).collect(Collectors.toSet()); ResultByStartDTO resultByStartDTO = new ResultByStartDTO(); Set orderProcessIdAndWorkstationIdSet = new HashSet<>(); orderProcessStartGeneralVO.getWorkstationVoList().forEach(i -> { orderProcessIdAndWorkstationIdSet.add(String.valueOf(orderProcessStartGeneralVO.getOrderProcessId()).concat(String.valueOf(i.getWorkstationId()))); }); List list = this.orderWorkstationService.getWorkstationByProcessList(Arrays.asList(orderProcessStartGeneralVO.getOrderProcessId())); Set allOrderProcessIdAndWorkstationIdSet = new HashSet<>(); list.forEach(i2 -> { allOrderProcessIdAndWorkstationIdSet.add(String.valueOf(i2.getProcessId()).concat(String.valueOf(i2.getWorkstationId()))); }); if (!allOrderProcessIdAndWorkstationIdSet.containsAll(orderProcessIdAndWorkstationIdSet)) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.workstation.is.delete", new Object[0])); } List workstationVoInMaintainOrRepairList = this.workstationService.getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList); if (Func.isNotEmpty(workstationVoInMaintainOrRepairList)) { List maintainOrRepairList = generateResultForMaintainOrRepair(workstationVoInMaintainOrRepairList); Set workstationIdInMaintainOrRepairList = (Set) workstationVoInMaintainOrRepairList.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toSet()); workstationIdList.removeAll(workstationIdInMaintainOrRepairList); result.addAll(maintainOrRepairList); } if (Func.isEmpty(workstationIdList)) { resultByStartDTO.setOrderProcessStartResultVOList(result); return resultByStartDTO; } List orderWorkstationList = this.orderWorkstationService.getWorkstationInProcess(workstationIdList); Set orderWorkstationInProcessIdSet = (Set) orderWorkstationList.stream().map((v0) -> { return v0.getWorkstationId(); }).collect(Collectors.toSet()); if (Func.isNotEmpty(orderWorkstationList)) { List orderWorkstationInProcessIdList = generateResultForStarted(orderWorkstationList, map); workstationIdList.removeAll(orderWorkstationInProcessIdSet); result.addAll(orderWorkstationInProcessIdList); } if (Func.isEmpty(workstationIdList)) { resultByStartDTO.setOrderProcessStartResultVOList(result); return resultByStartDTO; } List canStartWorkstationIdList = new ArrayList<>(); Map workstationAndOrderProcessIdMap = new HashMap<>(); for (OrderProcessStartWorkstationVO i3 : workstationVoList) { if (workstationIdList.contains(i3.getWorkstationId())) { OrderProcessStartResultVO orderProcessStartResultVO = new OrderProcessStartResultVO(); orderProcessStartResultVO.setResultFlag(Boolean.FALSE); orderProcessStartResultVO.setWorkstationId(i3.getWorkstationId()); orderProcessStartResultVO.setWorkstationName(i3.getWorkstationName()); orderProcessStartResultVO.setWorkstationCode(i3.getWorkstationCode()); orderProcessStartResultVO.setResultFlag(Boolean.TRUE); orderProcessStartResultVO.setCurrentProcessId(orderProcessId); orderProcessStartResultVO.setCurrentProcessCode(orderProcess.getProcessCode()); orderProcessStartResultVO.setCurrentProcessName(orderProcess.getProcessName()); orderWorkstationInProcessIdSet.add(i3.getWorkstationId()); canStartWorkstationIdList.add(i3.getWorkstationId()); result.add(orderProcessStartResultVO); workstationAndOrderProcessIdMap.put(i3.getWorkstationId(), orderProcessId); } } resultByStartDTO.setCanStartWorkstationIdList(canStartWorkstationIdList); resultByStartDTO.setOrderProcessStartResultVOList(result); resultByStartDTO.setWorkstationAndOrderProcessIdMap(workstationAndOrderProcessIdMap); return resultByStartDTO; } private ResultByStartDTO generateResultByParallel(OrderProcessStartParallelVO orderProcessStartParallelVO, Set workstationIdSet, Map map, Set orderProcessIdAndWorkstationIdSet) { List result = new ArrayList<>(); ResultByStartDTO resultByStartDTO = new ResultByStartDTO(); List childOrderProcessIdList = (List) orderProcessStartParallelVO.getOrderProcessStartGeneralVoList().stream().map((v0) -> { return v0.getOrderProcessId(); }).collect(Collectors.toList()); Map orderProcessMap = (Map) listByIds(childOrderProcessIdList).stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, o -> { return o; })); List list = this.orderWorkstationService.getWorkstationByProcessList(childOrderProcessIdList); Set allOrderProcessIdAndWorkstationIdSet = new HashSet<>(); list.forEach(i -> { allOrderProcessIdAndWorkstationIdSet.add(String.valueOf(i.getProcessId()).concat(String.valueOf(i.getWorkstationId()))); }); if (!allOrderProcessIdAndWorkstationIdSet.containsAll(orderProcessIdAndWorkstationIdSet)) { throw new ServiceException(MessageUtils.message("cps.coproduction.order.process.workstation.is.delete", new Object[0])); } List workstationVoInMaintainOrRepairList = this.workstationService.getWorkstationListInMaintainOrRepairByIdList(childOrderProcessIdList, workstationIdSet); if (Func.isNotEmpty(workstationVoInMaintainOrRepairList)) { List maintainOrRepairList = generateResultForMaintainOrRepair(workstationVoInMaintainOrRepairList); Set workstationIdInMaintainOrRepairList = (Set) workstationVoInMaintainOrRepairList.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toSet()); workstationIdSet.removeAll(workstationIdInMaintainOrRepairList); result.addAll(maintainOrRepairList); } if (Func.isEmpty(workstationIdSet)) { resultByStartDTO.setOrderProcessStartResultVOList(result); return resultByStartDTO; } List orderWorkstationList = this.orderWorkstationService.getWorkstationInProcess(workstationIdSet); Set orderWorkstationInProcessIdSet = (Set) orderWorkstationList.stream().map((v0) -> { return v0.getWorkstationId(); }).collect(Collectors.toSet()); if (Func.isEmpty(orderWorkstationList)) { List orderWorkstationInProcessIdList = generateResultForStarted(orderWorkstationList, map); workstationIdSet.removeAll(orderWorkstationInProcessIdSet); result.addAll(orderWorkstationInProcessIdList); } if (Func.isEmpty(workstationIdSet)) { resultByStartDTO.setOrderProcessStartResultVOList(result); return resultByStartDTO; } List canStartWorkstationIdList = new ArrayList<>(); List workstationVOList = new ArrayList<>(); Map workstationAndOrderProcessIdMap = new HashMap<>(); List canStartOrderProcessIdList = new ArrayList<>(); for (OrderProcessStartGeneralVO orderProcessStartGeneralVO : orderProcessStartParallelVO.getOrderProcessStartGeneralVoList()) { for (OrderProcessStartWorkstationVO i2 : orderProcessStartGeneralVO.getWorkstationVoList()) { if (workstationIdSet.contains(i2.getWorkstationId())) { OrderProcessStartResultVO orderProcessStartResultVO = new OrderProcessStartResultVO(); orderProcessStartResultVO.setResultFlag(Boolean.FALSE); orderProcessStartResultVO.setWorkstationId(i2.getWorkstationId()); orderProcessStartResultVO.setWorkstationName(i2.getWorkstationName()); orderProcessStartResultVO.setWorkstationCode(i2.getWorkstationCode()); orderProcessStartResultVO.setResultFlag(Boolean.TRUE); orderProcessStartResultVO.setCurrentProcessId(orderProcessStartGeneralVO.getOrderProcessId()); orderProcessStartResultVO.setCurrentProcessCode(orderProcessMap.get(orderProcessStartGeneralVO.getOrderProcessId()).getProcessCode()); orderProcessStartResultVO.setCurrentProcessName(orderProcessMap.get(orderProcessStartGeneralVO.getOrderProcessId()).getProcessName()); orderWorkstationInProcessIdSet.add(i2.getWorkstationId()); canStartWorkstationIdList.add(i2.getWorkstationId()); result.add(orderProcessStartResultVO); workstationAndOrderProcessIdMap.put(i2.getWorkstationId(), orderProcessStartGeneralVO.getOrderProcessId()); canStartOrderProcessIdList.add(orderProcessStartGeneralVO.getOrderProcessId()); workstationVOList.add(i2); } } } resultByStartDTO.setCanStartWorkstationIdList(canStartWorkstationIdList); resultByStartDTO.setOrderProcessStartResultVOList(result); resultByStartDTO.setWorkstationAndOrderProcessIdMap(workstationAndOrderProcessIdMap); resultByStartDTO.setWorkstationVOList(workstationVOList); resultByStartDTO.setCanStartOrderProcessIdList(canStartOrderProcessIdList); return resultByStartDTO; } private List generateResultForMaintainOrRepair(List workstationVoInMaintainOrRepairList) { List list = new ArrayList<>(); workstationVoInMaintainOrRepairList.forEach(i -> { OrderProcessStartResultVO orderProcessStartResultVO = new OrderProcessStartResultVO(); orderProcessStartResultVO.setResultFlag(Boolean.FALSE); orderProcessStartResultVO.setWorkstationId(i.getId()); orderProcessStartResultVO.setWorkstationName(i.getName()); orderProcessStartResultVO.setWorkstationCode(i.getCode()); orderProcessStartResultVO.setMsg(MessageUtils.message("cps.coproduction.order.process.workstation.can.not.use", new Object[0])); list.add(orderProcessStartResultVO); }); return list; } private List generateResultForStarted(List orderWorkstationList, Map map) { List list = new ArrayList<>(); orderWorkstationList.forEach(i -> { OrderProcessStartResultVO orderProcessStartResultVO = new OrderProcessStartResultVO(); orderProcessStartResultVO.setResultFlag(Boolean.FALSE); orderProcessStartResultVO.setWorkstationId(i.getWorkstationId()); orderProcessStartResultVO.setWorkstationName(i.getWorkstationName()); orderProcessStartResultVO.setWorkstationCode(((OrderProcessStartWorkstationVO) map.get(i.getWorkstationId())).getWorkstationCode()); orderProcessStartResultVO.setCurrentProcessId(i.getProcessId()); orderProcessStartResultVO.setCurrentProcessCode(i.getProcessCode()); orderProcessStartResultVO.setCurrentProcessName(i.getProcessName()); orderProcessStartResultVO.setMsg(MessageUtils.message("cps.coproduction.order.process.workstation.is.in.process", new Object[0])); orderProcessStartResultVO.setOrderCode(i.getOrderCode()); list.add(orderProcessStartResultVO); }); return list; } private PlanAndOrderDTO checkPlanAndOrder(Long orderId) { PlanAndOrderDTO planAndOrderDTO = this.orderService.getPlanAndOrderByOrderId(orderId); Boolean checkPlanStatus = this.planService.checkPlanStatus(planAndOrderDTO.getPlan().getId()); if (checkPlanStatus.booleanValue()) { throw new ServiceException(MessageUtils.message("production.report.fail.plan.suspend.or.close.is.not.report", new Object[0])); } return planAndOrderDTO; } private List currentOrderProcesses(Order order) { List orderProcesses = list(Wrappers.lambdaQuery().eq(OrderProcess::getOrderId, order.getId())); List mainProcessList = (List)orderProcesses.stream().filter(OrderProcess::isSubProcess).collect(Collectors.toList()); int processCount = mainProcessList.size(); for (int i = 0; i < processCount; i++) { ((OrderProcess)mainProcessList.get(i)).setPrevProcess((i - 1 >= 0) ? mainProcessList.get(i - 1) : null); if (i < processCount - 1) ((OrderProcess)mainProcessList.get(i)).setNextProcess(mainProcessList.get(i + 1)); } order.setOrderProcessList(orderProcesses); return orderProcesses; } @Override // org.springblade.modules.coproduction.service.IOrderProcessService @Transactional(rollbackFor = {Exception.class}) public Boolean editReportWork(ReportWorkDTO reportWorkDTO) { long orderId = Func.toLong(reportWorkDTO.getOrderId()); PlanAndOrderDTO planAndOrderDTO = checkPlanAndOrder(Long.valueOf(orderId)); Order order = planAndOrderDTO.getOrder(); Plan plan = planAndOrderDTO.getPlan(); List reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList()); List reportWorkstationList = getReportWorkstationList(reportRecords); List orderProcesses = currentOrderProcesses(order); Map recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity())); Map orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s -> { return s.getProcessId() + "-" + s.getWorkstationId(); }, Function.identity())); Map orderProcessMap = (Map) orderProcesses.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity())); Date now = DateUtil.now(); reportWorkDTO.getReportWorkDTOList().forEach(report -> { Long recordId = Long.valueOf(Func.toLong(report.getRecordId())); Integer reportQualifyNum = report.getQualifyNum(); Integer reportScrappedNum = report.getScrappedNum(); OrderReportRecord orderReportRecord = (OrderReportRecord) recordMap.get(recordId); this.orderReportRecordService.buildReportRecord(report, orderReportRecord); OrderWorkstation orderWorkstation = (OrderWorkstation) orderWorkstationMap.get(orderReportRecord.getProcessId() + "-" + orderReportRecord.getWorkstationId()); this.orderWorkstationService.buildWorkstation(report, orderWorkstation); OrderProcess currentOrderProcess = (OrderProcess) orderProcessMap.get(orderReportRecord.getProcessId()); editReportOrderProcess(currentOrderProcess, reportQualifyNum, reportScrappedNum, orderProcessMap, now, order); }); triggerOptimisticLock(reportRecords); this.orderWorkstationService.updateBatchById(reportWorkstationList); updateBatchById(orderProcesses); this.orderService.updateById(this.orderService.reportOrderData(order)); this.planService.updateById(this.planService.reportCurrentPlan(reportWorkDTO.getReportWorkDTOList(), plan, order.getDelOrderNum())); return true; } private void editReportOrderProcess(OrderProcess currentOrderProcess, Integer addQualifyNum, Integer addScrappedNum, Map orderProcessMap, Date now, Order order) { boolean isChild = !currentOrderProcess.isSubProcess().booleanValue(); boolean numsResult = editDealOrderProcessNum(currentOrderProcess, orderProcessMap, addQualifyNum, addScrappedNum, Boolean.valueOf(isChild)).booleanValue(); editDealReportProcessStatus(currentOrderProcess, Boolean.valueOf(isChild), Boolean.valueOf(numsResult), now); if (!isChild) { if (currentOrderProcess.isLastProcess().booleanValue()) { order.setQualifyNum(currentOrderProcess.getQualifyNum()); order.setDelOrderNum(addQualifyNum); } OrderProcess nextProcess = currentOrderProcess.getNextProcess(); if (nextProcess != null) { dealNextProcessInputNum(nextProcess, addQualifyNum); List nextProcessList = getReportNextProcess(order, currentOrderProcess.getSort()); if (nextProcessList != null) { nextProcessList.forEach(next -> { editReportOrderProcess(next, 0, 0, orderProcessMap, now, order); }); } } } } private Boolean editDealOrderProcessNum(OrderProcess currentOrderProcess, Map orderProcessMap, Integer addQualifyNum, Integer addScrappedNum, Boolean isChild) { Integer inputNum; if (isChild.booleanValue()) { OrderProcess mainProcess = orderProcessMap.get(currentOrderProcess.getMainSequenceId()); inputNum = mainProcess.getInputNum(); } else { inputNum = currentOrderProcess.getInputNum(); } Integer oldQualifyNum = currentOrderProcess.getQualifyNum(); Integer oldScrappedNum = currentOrderProcess.getScrappedNum(); Integer newQualifyNum = Integer.valueOf(addQualifyNum.intValue() + oldQualifyNum.intValue()); Integer newScrappedNum = Integer.valueOf(addScrappedNum.intValue() + oldScrappedNum.intValue()); Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue()); if (inputNum.intValue() < newReportNum.intValue()) { throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.local.process.inputNum", new Object[0])); } currentOrderProcess.setQualifyNum(newQualifyNum); currentOrderProcess.setScrappedNum(newScrappedNum); return Boolean.valueOf(inputNum.equals(newReportNum)); } private void editDealReportProcessStatus(OrderProcess currentOrderProcess, Boolean isChild, Boolean numsResult, Date now) { Integer startWorkRecordNum = this.orderReportRecordService.countOpenRecord(currentOrderProcess.getId()); OrderProcess prevProcess = currentOrderProcess.getPrevProcess(); boolean notEmptyEndTime = Func.isNotEmpty(currentOrderProcess.getEndTime()); if (currentOrderProcess.isFirstProcess().booleanValue()) { if (!numsResult.booleanValue() && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (!numsResult.booleanValue() && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (numsResult.booleanValue() && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (numsResult.booleanValue() && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); currentOrderProcess.setEndTime(now); return; } return; } Integer preProcessStatus = prevProcess.getProcessStatus(); boolean resultPre = OrderStatusEnum.COMPLETE.getCode().equals(preProcessStatus); if (!resultPre && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); } if (!resultPre && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); } if (resultPre && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); } if (resultPre && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); } if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } if (resultPre && numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); currentOrderProcess.setEndTime(now); } } @Override // org.springblade.modules.coproduction.service.IOrderProcessService @Transactional(rollbackFor = {Exception.class}) public Boolean delReportWork(ReportWorkDTO reportWorkDTO) { long orderId = Func.toLong(reportWorkDTO.getOrderId()); PlanAndOrderDTO planAndOrderDTO = checkPlanAndOrder(Long.valueOf(orderId)); Order order = planAndOrderDTO.getOrder(); Plan plan = planAndOrderDTO.getPlan(); List reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList()); List removeMainAndChildRecordIds = (List) reportRecords.stream().map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List removeRecordIds = (List) reportRecords.stream().filter(s -> { return Func.isNotEmpty(s.getMainSequenceId()); }).map((v0) -> { return v0.getId(); }).collect(Collectors.toList()); List reportWorkstationList = getReportWorkstationList(reportRecords); List orderProcesses = currentOrderProcesses(order); Map recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity())); Map orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s2 -> { return s2.getProcessId() + "-" + s2.getWorkstationId(); }, Function.identity())); Map orderProcessMap = (Map) orderProcesses.stream().collect(Collectors.toMap((v0) -> { return v0.getId(); }, Function.identity())); Date now = DateUtil.now(); reportWorkDTO.getReportWorkDTOList().forEach(report -> { OrderWorkstation orderWorkstation; Long recordId = Long.valueOf(Func.toLong(report.getRecordId())); Integer reportQualifyNum = report.getQualifyNum(); Integer reportScrappedNum = report.getScrappedNum(); OrderReportRecord orderReportRecord = (OrderReportRecord) recordMap.get(recordId); if (orderReportRecord.getSystemOrOrdinary() != null && CoProductionEnum.SystemOrOrdinaryStatus.ORDINARY.getCode().equals(orderReportRecord.getSystemOrOrdinary()) && (orderWorkstation = (OrderWorkstation) orderWorkstationMap.get(report.getProcessId() + "-" + orderReportRecord.getWorkstationId())) != null) { this.orderWorkstationService.buildWorkstation(report, orderWorkstation); } OrderProcess currentOrderProcess = (OrderProcess) orderProcessMap.get(orderReportRecord.getProcessId()); delReportOrderProcess(currentOrderProcess, reportQualifyNum, reportScrappedNum, orderProcessMap, now, order, removeRecordIds, removeMainAndChildRecordIds); }); this.orderReportRecordService.removeBatchByIds(reportRecords); this.orderWorkstationService.updateBatchById(reportWorkstationList); updateBatchById(orderProcesses); this.orderService.updateById(this.orderService.delReportOrderData(order, removeMainAndChildRecordIds)); this.planService.updateById(this.planService.delReportRecordCurrentPlan(reportWorkDTO.getReportWorkDTOList(), plan, order, removeMainAndChildRecordIds)); return true; } private void delReportOrderProcess(OrderProcess currentOrderProcess, Integer addQualifyNum, Integer addScrappedNum, Map orderProcessMap, Date now, Order order, List removeRecordIds, List removeMainAndChildRecordIds) { boolean isChild = !currentOrderProcess.isSubProcess().booleanValue(); boolean numsResult = delDealOrderProcessNum(currentOrderProcess, orderProcessMap, addQualifyNum, addScrappedNum, Boolean.valueOf(isChild)).booleanValue(); delDealReportProcessStatus(currentOrderProcess, Boolean.valueOf(isChild), Boolean.valueOf(numsResult), now, removeMainAndChildRecordIds); updateDelProcessStartTime(currentOrderProcess, removeMainAndChildRecordIds); if (!isChild) { if (currentOrderProcess.isLastProcess().booleanValue()) { order.setQualifyNum(order.getQualifyNum()); order.setDelOrderNum(addQualifyNum); } OrderProcess nextProcess = currentOrderProcess.getNextProcess(); if (nextProcess != null) { dealNextProcessInputNum(nextProcess, addQualifyNum); List nextProcessList = getReportNextProcess(order, currentOrderProcess.getSort()); if (nextProcessList != null) { nextProcessList.forEach(next -> { delReportOrderProcess(next, 0, 0, orderProcessMap, now, order, removeRecordIds, removeMainAndChildRecordIds); }); } } } } private Boolean delDealOrderProcessNum(OrderProcess currentOrderProcess, Map orderProcessMap, Integer addQualifyNum, Integer addScrappedNum, Boolean isChild) { Integer inputNum; if (isChild.booleanValue()) { OrderProcess mainProcess = orderProcessMap.get(currentOrderProcess.getMainSequenceId()); inputNum = mainProcess.getInputNum(); } else { inputNum = currentOrderProcess.getInputNum(); } Integer oldQualifyNum = currentOrderProcess.getQualifyNum(); Integer oldScrappedNum = currentOrderProcess.getScrappedNum(); Integer newQualifyNum = Integer.valueOf(addQualifyNum.intValue() + oldQualifyNum.intValue()); Integer newScrappedNum = Integer.valueOf(addScrappedNum.intValue() + oldScrappedNum.intValue()); Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue()); if (inputNum.intValue() < newReportNum.intValue()) { throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.local.process.inputNum", new Object[0])); } currentOrderProcess.setQualifyNum(newQualifyNum); currentOrderProcess.setScrappedNum(newScrappedNum); return Boolean.valueOf(inputNum.equals(newReportNum)); } private void delDealReportProcessStatus(OrderProcess currentOrderProcess, Boolean isChild, Boolean numsResult, Date now, List removeRecordIds) { Integer startWorkRecordNum = this.orderReportRecordService.countDelRecord(currentOrderProcess.getId(), removeRecordIds); OrderProcess prevProcess = currentOrderProcess.getPrevProcess(); boolean notEmptyEndTime = Func.isNotEmpty(currentOrderProcess.getEndTime()); if (currentOrderProcess.isFirstProcess().booleanValue()) { if (!numsResult.booleanValue() && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (!numsResult.booleanValue() && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); updateProcessEndTime(currentOrderProcess); return; } return; } Integer preProcessStatus = prevProcess.getProcessStatus(); boolean resultPre = OrderStatusEnum.COMPLETE.getCode().equals(preProcessStatus); if ((!resultPre || !numsResult.booleanValue()) && startWorkRecordNum.intValue() == 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.NOT_STARTED.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (!resultPre && startWorkRecordNum.intValue() > 0) { currentOrderProcess.setProcessStatus(OrderStatusEnum.IN_EXECUTION.getCode()); if (notEmptyEndTime) { currentOrderProcess.setEndTime(null); } } if (resultPre && numsResult.booleanValue() && !isChild.booleanValue()) { currentOrderProcess.setProcessStatus(OrderStatusEnum.COMPLETE.getCode()); currentOrderProcess.setEndTime(now); updateProcessEndTime(currentOrderProcess); } } private void updateDelProcessStartTime(OrderProcess currentProcess, List removeRecordIds) { Date startTime = null; if (Func.isEmpty(currentProcess.getMainSequenceId()) && CoProductionEnum.WhetherParallel.YES.getCode().equals(currentProcess.getWhetherParallel())) { List list = list(Wrappers.lambdaQuery().eq(OrderProcess::getMainSequenceId, currentProcess.getId())); List childProcessIds = (List)list.stream().map(OrderProcess::getId).collect(Collectors.toList()); OrderReportRecord earliestChildProcessRecord = this.orderReportRecordService.getEarliestChildProcessRecord(childProcessIds, removeRecordIds); if (earliestChildProcessRecord != null) startTime = earliestChildProcessRecord.getStartTime(); } else { OrderReportRecord earliestRecord = this.orderReportRecordService.getEarliestRecord(null, null, currentProcess.getId(), removeRecordIds); if (earliestRecord != null) startTime = earliestRecord.getStartTime(); } Date currentProcessStartTime = currentProcess.getStartTime(); if (startTime != null && currentProcessStartTime != null && !currentProcessStartTime.equals(startTime)) currentProcess.setStartTime(startTime); if (startTime == null) currentProcess.setStartTime(null); } }