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<OrderProcessMapper, OrderProcess> 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<OrderProcessStartResultVO> 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<Long, OrderProcessStartWorkstationVO> workstationVoMap = orderProcessStartGeneralVO.getWorkstationVoList().stream().collect(Collectors.toMap(OrderProcessStartWorkstationVO::getWorkstationId, w -> w));
|
List<OrderReportRecord> orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVoMap, null, null);
|
Map<Long, OrderReportRecord> orderReportRecordMap = orderReportRecordList.stream().collect(Collectors.toMap(OrderReportRecord::getWorkstationId, w -> w));
|
|
/*
|
Map<Long, OrderProcessStartWorkstationVO> workstationVoMap = (Map) orderProcessStartGeneralVO.getWorkstationVoList().stream().collect(Collectors.toMap((v0) -> {
|
return v0.getWorkstationId();
|
}, w -> {
|
return w;
|
}));
|
List<OrderReportRecord> orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVoMap, null, null);
|
Map<Long, OrderReportRecord> 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<Long> orderProcessIdList, Date startTime) {
|
List<OrderProcess> 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<OrderProcessDetailVO> detail(Long orderId) {
|
List<OrderProcessDetailVO> 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<Integer> 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<OrderReportRecord> reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList());
|
|
|
List<OrderReportRecord> finishWorkRecords = reportRecords.stream().filter(s -> CoProductionEnum.RecordStatus.YES.getCode().equals(s.getRecordStatus())).collect(Collectors.toList());
|
/*
|
* List<OrderReportRecord> 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<Long> reportMainAndChildRecordIds = (List<Long>)reportRecords.stream().map(OrderReportRecord::getId).collect(Collectors.toList());
|
/*
|
List<Long> reportMainAndChildRecordIds = (List) reportRecords.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
*/
|
List<OrderWorkstation> reportWorkstationList = getReportWorkstationList(reportRecords);
|
List<OrderProcess> orderProcesses = currentOrderProcesses(order);
|
|
Map<Long, OrderReportRecord> recordMap = reportRecords.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity()));
|
/*
|
Map<Long, OrderReportRecord> recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, Function.identity()));*/
|
|
Map<String, OrderWorkstation> orderWorkstationMap = reportWorkstationList.stream().collect(Collectors.toMap(s -> s.getProcessId() + "-" + s.getWorkstationId(), Function.identity()));
|
/*
|
Map<String, OrderWorkstation> orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s2 -> {
|
return s2.getProcessId() + "-" + s2.getWorkstationId();
|
}, Function.identity()));
|
*/
|
Map<Long, OrderProcess> orderProcessMap = orderProcesses.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity()));
|
/*
|
Map<Long, OrderProcess> 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<OrderReportRecord> 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<OrderProcess> orderProcesses = currentOrderProcesses(planAndOrderDTO.getOrder());
|
List<OrderProcess> completeProcess = orderProcesses.stream().filter(s -> (s.isSubProcess().booleanValue() && OrderStatusEnum.COMPLETE.getCode().equals(s.getProcessStatus()))).collect(Collectors.toList());
|
/*
|
List<OrderProcess> completeProcess = (List) orderProcesses.stream().filter(s -> {
|
return s.isSubProcess().booleanValue() && OrderStatusEnum.COMPLETE.getCode().equals(s.getProcessStatus());
|
}).collect(Collectors.toList());
|
*/
|
if (Func.isNotEmpty(completeProcess)) {
|
List<Long> processIds = (List<Long>)completeProcess.stream().map(OrderProcess::getId).collect(Collectors.toList());
|
List<OrderReportRecord> startSurplusRecordList = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()).in(OrderReportRecord::getProcessId, processIds));
|
|
|
/*List<Long> processIds = (List) completeProcess.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<OrderReportRecord> 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<OrderReportRecord> childStartWorkList = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()).in(OrderReportRecord::getMainSequenceId, processIds));
|
/*
|
List<OrderReportRecord> 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<Long> startRecordIds = startSurplusRecordList.stream().map(OrderReportRecord::getId).collect(Collectors.toList());
|
List<OrderWorkstation> updateWorkstationStatusList = this.orderWorkstationService.list(Wrappers.<OrderWorkstation>lambdaQuery()
|
.eq(OrderWorkstation::getWorkstationStatus, WorkstationStatusEnum.started.getCode())
|
.in(OrderWorkstation::getCurrentRecordId, startRecordIds));
|
/*
|
List<Long> startRecordIds = (List) startSurplusRecordList.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<OrderWorkstation> 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<Long, OrderProcess> orderProcessMap, Date now, Order order, List<Long> 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<OrderProcess> 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<Long, OrderProcess> 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<Long> 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<OrderReportRecord> getReportRecords(List<OrderProcessReportWorkDTO> reportWorkDTOList) {
|
List<String> records = reportWorkDTOList.stream().map(OrderProcessReportWorkDTO::getRecordId).distinct().collect(Collectors.toList());
|
/*
|
List<String> records = (List) reportWorkDTOList.stream().map((v0) -> {
|
return v0.getRecordId();
|
}).distinct().collect(Collectors.toList());
|
*/
|
int reportRecordsSize = records.size();
|
List<OrderReportRecord> reportRecords = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getId, Func.toLongList(records)));
|
/*
|
List<OrderReportRecord> 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<OrderWorkstation> getReportWorkstationList(List<OrderReportRecord> reportRecords) {
|
List<Long> processIds = reportRecords.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList());
|
return this.orderWorkstationService.list(Wrappers.<OrderWorkstation>lambdaQuery().in(OrderWorkstation::getProcessId, processIds));
|
|
/*
|
List<Long> 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<Long, OrderProcess> orderProcessMap) {
|
int initialQualifyNum = 0;
|
int initialScrappedNum = 0;
|
nextProcess.setInputNum(nextInputNum);
|
updateById(nextProcess);
|
List<OrderProcess> 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<OrderReportRecord> startRecordsList) {
|
if (Func.isEmpty(startRecordsList))
|
throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0]));
|
Map<Long, OrderReportRecord> startRecordsMap = (Map<Long, OrderReportRecord>)startRecordsList.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity()));
|
List<Long> processIds = (List<Long>)startRecordsList.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList());
|
List<Long> planIds = (List<Long>)startRecordsList.stream().map(OrderReportRecord::getPlanId).distinct().collect(Collectors.toList());
|
List<Plan> planList = this.planService.list((Wrapper)Wrappers.<Plan>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<Long, Plan> planMap = (Map<Long, Plan>)planList.stream().collect(Collectors.toMap(Plan::getId, Function.identity()));
|
List<Order> orderList = this.orderService.list((Wrapper)Wrappers.<Order>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<Long, Order> orderMap = orderList.stream().collect(Collectors.toMap(Order::getId, Function.identity()));
|
List<OrderWorkstation> orderWorkstationList = this.orderWorkstationService.list(Wrappers.<OrderWorkstation>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<String, OrderWorkstation> orderWorkstationMap = (Map<String, OrderWorkstation>)orderWorkstationList.stream().collect(Collectors.toMap(s -> s.getProcessId() + "-" + s.getWorkstationId(), Function.identity()));
|
List<OrderProcess> orderProcesses = list(Wrappers.<OrderProcess>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<Long, OrderProcess> orderProcessMap = (Map<Long, OrderProcess>)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<Long, OrderProcess> 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<OrderProcess> updateWrapper = Wrappers.<OrderProcess>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<OrderProcess> list = list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getMainSequenceId, currentProcess.getId()));
|
List<Long> childProcessIds = (List<Long>)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.<OrderProcess>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<OrderProcess> list = list(Wrappers.<OrderProcess>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<OrderProcess> list = list(Wrappers.<OrderProcess>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<OrderProcess> getNextProcess(Long orderId, Integer nextSort) {
|
List<OrderProcess> list = list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getOrderId, orderId).eq(OrderProcess::getSort, nextSort).isNull(OrderProcess::getMainSequenceId));
|
if (Func.isNotEmpty(list))
|
return list;
|
return null;
|
}
|
|
private List<OrderProcess> getReportNextProcess(Order order, Integer nextSort) {
|
List<OrderProcess> orderProcesses = currentOrderProcesses(order);
|
List<OrderProcess> 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<OrderProcess> generateOrderProcess(OrderAssignVO orderAssignVO, Order order) {
|
List<PlanProcessWorkStationAssignVO> planProcessWorkStationAssignVOList = orderAssignVO.getPlanProcessWorkStationAssignVOList();
|
Map<Long, PlanProcessWorkStationAssignVO> processToWorkstation = (Map<Long, PlanProcessWorkStationAssignVO>)planProcessWorkStationAssignVOList.stream().collect(Collectors.toMap(PlanProcessWorkStationAssignVO::getPlanProcessId, v -> v));
|
List<PlanProcess> planProcessList = (List<PlanProcess>)this.planProcessService.list(Wrappers.<PlanProcess>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<Long, Long> planProcessToOrderProcess = new HashMap<>(planProcessList.size());
|
List<OrderProcess> 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<PlanProcess> 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<OrderProcessGeneralDetailVO> orderProcessGeneralDetailVOList = ((OrderProcessMapper) this.baseMapper).startDetailGeneralByParallel(orderProcessId);
|
result.setChildOrderProcessList(orderProcessGeneralDetailVOList);
|
return result;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderProcessService
|
public List<OrderProcessStartResultVO> startParallel(OrderProcessStartParallelVO orderProcessStartParallelVO) {
|
OrderProcess orderProcess = (OrderProcess) getById(orderProcessStartParallelVO.getOrderProcessId());
|
checkCanStartWork(orderProcess);
|
List<Long> workstationIdList = new ArrayList<>();
|
Set<Long> workstationIdSet = new HashSet<>();
|
Map<Long, OrderProcessStartWorkstationVO> map = new HashMap<>();
|
Set<String> 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<Long, OrderProcessStartWorkstationVO> workstationVOMap = (Map) resultByStartDTO.getWorkstationVOList().stream().collect(Collectors.toMap((v0) -> {
|
return v0.getWorkstationId();
|
}, w -> {
|
return w;
|
}));
|
List<OrderReportRecord> orderReportRecordList = this.orderReportRecordService.generateStartRecord(resultByStartDTO, planAndOrderDTO, now, workstationVOMap, orderProcessStartParallelVO.getOrderProcessId(), orderReportRecord.getId());
|
Map<Long, OrderReportRecord> 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<OrderProcessReportWorkDTO> 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<OrderProcessReportWorkDTO> reportWorkDTOList) {
|
List<String> processIds = (List<String>)reportWorkDTOList.stream().filter(s -> Func.isEmpty(s.getMainSequenceId())).map(OrderProcessReportWorkDTO::getProcessId).distinct().collect(Collectors.toList());
|
if (Func.isNotEmpty(processIds)) {
|
List<OrderProcess> list = list(Wrappers.<OrderProcess>lambdaQuery().in(OrderProcess::getId, processIds));
|
if (Func.isNotEmpty(list)) {
|
Map<Long, OrderProcess> orderProcessMap = (Map<Long, OrderProcess>)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<ReportParallelProcessDTO> parallelProcessDTO) {
|
List<ReportParallelProcessDTO> 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<ReportParallelProcessDTO> getChildProcessRecord(List<ReportParallelProcessDTO> parallelProcessDTO, String mainRecordId) {
|
List<ReportParallelProcessDTO> 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<ReportParallelProcessDTO> parallelProcessDTO, Boolean isEdit) {
|
Map<String, ParallelNumDTO> notReportMap = new HashMap<>(8);
|
Map<String, ParallelNumDTO> alreadyReportMap = new HashMap<>(8);
|
ReportParallelProcessDTO mainProcessRecord = getMainProcessRecord(parallelProcessDTO);
|
List<ReportParallelProcessDTO> childProcessRecords = getChildProcessRecord(parallelProcessDTO, mainProcessRecord.getRecordId());
|
if (Func.isNotEmpty(childProcessRecords)) {
|
Map<String, List<ReportParallelProcessDTO>> parallelChildProcessRecordMap = (Map<String, List<ReportParallelProcessDTO>>)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<String> recordIds = (List<String>)parallelProcessDTO.stream().map(OrderProcessReportWorkDTO::getRecordId).collect(Collectors.toList());
|
List<OrderReportRecord> list = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>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<Long> processIds = (List<Long>)list.stream().map(OrderReportRecord::getProcessId).distinct().collect(Collectors.toList());
|
List<OrderProcess> orderProcesses = listByIds(processIds);
|
Map<Long, OrderProcess> orderProcessMap = (Map<Long, OrderProcess>)orderProcesses.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity()));
|
List<OrderReportRecord> finishedRecords = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getProcessId, processIds).eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode()));
|
if (isEdit.booleanValue())
|
finishedRecords = (List<OrderReportRecord>)finishedRecords.stream().filter(s -> !recordIds.contains(Func.toStr(s.getId()))).collect(Collectors.toList());
|
Map<Long, List<OrderReportRecord>> finishedRecordsMap = (Map<Long, List<OrderReportRecord>>)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<OrderReportRecord> finishedRecords = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>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<ReportParallelProcessDTO> childProcessRecords, Map<String, ParallelNumDTO> notReportMap, Map<String, ParallelNumDTO> 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<Integer> 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<String> 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<WorkstationInGroupVO> treeWorkstation(Long planId, String processCode, Integer sort) {
|
List<PlanProcess> planProcessList = this.planProcessService.list(Wrappers.<PlanProcess>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.<Process>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<OrderProcessDetailVO> listDetailByOrderId(Long orderId) {
|
return ((OrderProcessMapper) this.baseMapper).listDetailByOrderId(orderId);
|
}
|
|
private Map<Long, List<OrderProcess>> getSpecialIdCollect(List<OrderProcess> parallelOrderProcessList) {
|
Map<Long, List<OrderProcess>> processMap = new HashMap<>(parallelOrderProcessList.size());
|
List<OrderProcess> 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<OrderProcessStartResultVO> result = new ArrayList<>();
|
List<OrderProcessStartWorkstationVO> workstationVoList = orderProcessStartGeneralVO.getWorkstationVoList();
|
Map<Long, OrderProcessStartWorkstationVO> map = (Map) workstationVoList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getWorkstationId();
|
}, w -> {
|
return w;
|
}));
|
Long orderProcessId = orderProcessStartGeneralVO.getOrderProcessId();
|
Set<Long> workstationIdList = (Set) workstationVoList.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toSet());
|
ResultByStartDTO resultByStartDTO = new ResultByStartDTO();
|
Set<String> orderProcessIdAndWorkstationIdSet = new HashSet<>();
|
orderProcessStartGeneralVO.getWorkstationVoList().forEach(i -> {
|
orderProcessIdAndWorkstationIdSet.add(String.valueOf(orderProcessStartGeneralVO.getOrderProcessId()).concat(String.valueOf(i.getWorkstationId())));
|
});
|
List<OrderWorkstation> list = this.orderWorkstationService.getWorkstationByProcessList(Arrays.asList(orderProcessStartGeneralVO.getOrderProcessId()));
|
Set<String> 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<WorkstationVO> workstationVoInMaintainOrRepairList = this.workstationService.getWorkstationListInMaintainOrRepairById(orderProcessId, workstationIdList);
|
if (Func.isNotEmpty(workstationVoInMaintainOrRepairList)) {
|
List<OrderProcessStartResultVO> maintainOrRepairList = generateResultForMaintainOrRepair(workstationVoInMaintainOrRepairList);
|
Set<Long> 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<OrderWorkstation> orderWorkstationList = this.orderWorkstationService.getWorkstationInProcess(workstationIdList);
|
Set<Long> orderWorkstationInProcessIdSet = (Set) orderWorkstationList.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toSet());
|
if (Func.isNotEmpty(orderWorkstationList)) {
|
List<OrderProcessStartResultVO> orderWorkstationInProcessIdList = generateResultForStarted(orderWorkstationList, map);
|
workstationIdList.removeAll(orderWorkstationInProcessIdSet);
|
result.addAll(orderWorkstationInProcessIdList);
|
}
|
if (Func.isEmpty(workstationIdList)) {
|
resultByStartDTO.setOrderProcessStartResultVOList(result);
|
return resultByStartDTO;
|
}
|
List<Long> canStartWorkstationIdList = new ArrayList<>();
|
Map<Long, Long> 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<Long> workstationIdSet, Map<Long, OrderProcessStartWorkstationVO> map, Set<String> orderProcessIdAndWorkstationIdSet) {
|
List<OrderProcessStartResultVO> result = new ArrayList<>();
|
ResultByStartDTO resultByStartDTO = new ResultByStartDTO();
|
List<Long> childOrderProcessIdList = (List) orderProcessStartParallelVO.getOrderProcessStartGeneralVoList().stream().map((v0) -> {
|
return v0.getOrderProcessId();
|
}).collect(Collectors.toList());
|
Map<Long, OrderProcess> orderProcessMap = (Map) listByIds(childOrderProcessIdList).stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, o -> {
|
return o;
|
}));
|
List<OrderWorkstation> list = this.orderWorkstationService.getWorkstationByProcessList(childOrderProcessIdList);
|
Set<String> 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<WorkstationVO> workstationVoInMaintainOrRepairList = this.workstationService.getWorkstationListInMaintainOrRepairByIdList(childOrderProcessIdList, workstationIdSet);
|
if (Func.isNotEmpty(workstationVoInMaintainOrRepairList)) {
|
List<OrderProcessStartResultVO> maintainOrRepairList = generateResultForMaintainOrRepair(workstationVoInMaintainOrRepairList);
|
Set<Long> 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<OrderWorkstation> orderWorkstationList = this.orderWorkstationService.getWorkstationInProcess(workstationIdSet);
|
Set<Long> orderWorkstationInProcessIdSet = (Set) orderWorkstationList.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toSet());
|
if (Func.isEmpty(orderWorkstationList)) {
|
List<OrderProcessStartResultVO> orderWorkstationInProcessIdList = generateResultForStarted(orderWorkstationList, map);
|
workstationIdSet.removeAll(orderWorkstationInProcessIdSet);
|
result.addAll(orderWorkstationInProcessIdList);
|
}
|
if (Func.isEmpty(workstationIdSet)) {
|
resultByStartDTO.setOrderProcessStartResultVOList(result);
|
return resultByStartDTO;
|
}
|
List<Long> canStartWorkstationIdList = new ArrayList<>();
|
List<OrderProcessStartWorkstationVO> workstationVOList = new ArrayList<>();
|
Map<Long, Long> workstationAndOrderProcessIdMap = new HashMap<>();
|
List<Long> 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<OrderProcessStartResultVO> generateResultForMaintainOrRepair(List<WorkstationVO> workstationVoInMaintainOrRepairList) {
|
List<OrderProcessStartResultVO> 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<OrderProcessStartResultVO> generateResultForStarted(List<OrderWorkstation> orderWorkstationList, Map<Long, OrderProcessStartWorkstationVO> map) {
|
List<OrderProcessStartResultVO> 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<OrderProcess> currentOrderProcesses(Order order) {
|
List<OrderProcess> orderProcesses = list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getOrderId, order.getId()));
|
List<OrderProcess> mainProcessList = (List<OrderProcess>)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<OrderReportRecord> reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList());
|
List<OrderWorkstation> reportWorkstationList = getReportWorkstationList(reportRecords);
|
List<OrderProcess> orderProcesses = currentOrderProcesses(order);
|
Map<Long, OrderReportRecord> recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, Function.identity()));
|
Map<String, OrderWorkstation> orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s -> {
|
return s.getProcessId() + "-" + s.getWorkstationId();
|
}, Function.identity()));
|
Map<Long, OrderProcess> 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<Long, OrderProcess> 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<OrderProcess> nextProcessList = getReportNextProcess(order, currentOrderProcess.getSort());
|
if (nextProcessList != null) {
|
nextProcessList.forEach(next -> {
|
editReportOrderProcess(next, 0, 0, orderProcessMap, now, order);
|
});
|
}
|
}
|
}
|
}
|
|
private Boolean editDealOrderProcessNum(OrderProcess currentOrderProcess, Map<Long, OrderProcess> 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<OrderReportRecord> reportRecords = getReportRecords(reportWorkDTO.getReportWorkDTOList());
|
List<Long> removeMainAndChildRecordIds = (List) reportRecords.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<Long> removeRecordIds = (List) reportRecords.stream().filter(s -> {
|
return Func.isNotEmpty(s.getMainSequenceId());
|
}).map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<OrderWorkstation> reportWorkstationList = getReportWorkstationList(reportRecords);
|
List<OrderProcess> orderProcesses = currentOrderProcesses(order);
|
Map<Long, OrderReportRecord> recordMap = (Map) reportRecords.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, Function.identity()));
|
Map<String, OrderWorkstation> orderWorkstationMap = (Map) reportWorkstationList.stream().collect(Collectors.toMap(s2 -> {
|
return s2.getProcessId() + "-" + s2.getWorkstationId();
|
}, Function.identity()));
|
Map<Long, OrderProcess> 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<Long, OrderProcess> orderProcessMap, Date now, Order order, List<Long> removeRecordIds, List<Long> 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<OrderProcess> 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<Long, OrderProcess> 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<Long> 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<Long> removeRecordIds) {
|
Date startTime = null;
|
if (Func.isEmpty(currentProcess.getMainSequenceId()) && CoProductionEnum.WhetherParallel.YES.getCode().equals(currentProcess.getWhetherParallel())) {
|
List<OrderProcess> list = list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getMainSequenceId, currentProcess.getId()));
|
List<Long> childProcessIds = (List<Long>)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);
|
}
|
}
|
