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.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.google.common.collect.Lists;
|
import java.lang.invoke.SerializedLambda;
|
import java.time.LocalDate;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
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.ExcelConstant;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.common.utils.TimeUtils;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.mp.support.Condition;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.coproduction.convert.OrderReportRecordConvert;
|
import com.qianwen.smartman.modules.coproduction.convert.ReportConvert;
|
import com.qianwen.smartman.modules.coproduction.dto.JuxtapositionReportDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.OrderProcessReportWorkDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.OrderReportDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanAndOrderDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.ReportWorkDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.ReportWorkDetailDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.ResultByStartDTO;
|
import com.qianwen.smartman.modules.coproduction.entity.OrderProcess;
|
import com.qianwen.smartman.modules.coproduction.entity.OrderReportRecord;
|
import com.qianwen.smartman.modules.coproduction.enums.CoProductionEnum;
|
import com.qianwen.smartman.modules.coproduction.enums.OrderReportRecordStatusEnum;
|
import com.qianwen.smartman.modules.coproduction.excel.OrderReportRecordExport;
|
import com.qianwen.smartman.modules.coproduction.mapper.OrderReportRecordMapper;
|
import com.qianwen.smartman.modules.coproduction.service.IOrderProcessService;
|
import com.qianwen.smartman.modules.coproduction.service.IOrderReportRecordService;
|
import com.qianwen.smartman.modules.coproduction.service.IPlanService;
|
import com.qianwen.smartman.modules.coproduction.vo.OpRecordExportVO;
|
import com.qianwen.smartman.modules.coproduction.vo.OrderChildRecordVO;
|
import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartWorkstationVO;
|
import com.qianwen.smartman.modules.coproduction.vo.OrderReportRecordResVO;
|
import com.qianwen.smartman.modules.coproduction.vo.OrderReportRecordSearchVO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/coproduction/service/impl/OrderReportRecordServiceImpl.class */
|
public class OrderReportRecordServiceImpl extends BaseServiceImpl<OrderReportRecordMapper, OrderReportRecord> implements IOrderReportRecordService {
|
private final IOrderProcessService orderProcessService;
|
private final IPlanService planService;
|
private final OssBuilder ossBuilder;
|
|
|
public OrderReportRecordServiceImpl(IOrderProcessService orderProcessService, IPlanService planService, OssBuilder ossBuilder) {
|
this.orderProcessService = orderProcessService;
|
this.planService = planService;
|
this.ossBuilder = ossBuilder;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public List<OrderReportRecord> generateStartRecord(ResultByStartDTO resultByStartDTO, PlanAndOrderDTO planAndOrderDTO, Date startTime, Map<Long, OrderProcessStartWorkstationVO> workstationVoMap, Long mainSequenceId, Long openSequenceId) {
|
List<OrderReportRecord> orderReportRecordList = new ArrayList<>();
|
resultByStartDTO.getCanStartWorkstationIdList().forEach(i -> {
|
OrderReportRecord orderReportRecord = new OrderReportRecord();
|
orderReportRecord.setPlanId(planAndOrderDTO.getPlan().getId());
|
orderReportRecord.setOrderId(planAndOrderDTO.getOrder().getId());
|
orderReportRecord.setProcessId(resultByStartDTO.getWorkstationAndOrderProcessIdMap().get(i));
|
orderReportRecord.setWorkstationId(i);
|
orderReportRecord.setWorkstationName(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getWorkstationName());
|
orderReportRecord.setProducerUserId(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerId());
|
orderReportRecord.setProducerUserCode(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerCode());
|
orderReportRecord.setProducerUserName(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerName());
|
orderReportRecord.setStartTime(startTime);
|
orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.STARTED.getCode());
|
orderReportRecord.setMainSequenceId(mainSequenceId);
|
orderReportRecord.setOpenSequenceId(openSequenceId);
|
orderReportRecordList.add(orderReportRecord);
|
});
|
saveBatch(orderReportRecordList);
|
return orderReportRecordList;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public ReportWorkDetailDTO getReportWorkDetail(Long processId) {
|
OrderProcess orderProcess = (OrderProcess)this.orderProcessService.getById(processId);
|
if (orderProcess == null)
|
throw new ServiceException(MessageUtils.message("production.loading.report.detail.fail.process.is.not.exist", new Object[0]));
|
Integer whetherParallel = orderProcess.getWhetherParallel();
|
ReportWorkDetailDTO reportWorkDetailDTO = new ReportWorkDetailDTO();
|
OrderReportDTO orderHead = ((OrderReportRecordMapper)this.baseMapper).getOrderHead(processId);
|
reportWorkDetailDTO.setReportDTO(orderHead);
|
List<JuxtapositionReportDTO> juxtapositionReportList = new LinkedList<>();
|
if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
|
List<OrderProcess> childProcess = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getMainSequenceId, processId));
|
Map<Long, OrderProcess> childProcessMap = (Map<Long, OrderProcess>)childProcess.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity()));
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(OrderReportRecord::getProcessId, processId)
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
|
if (Func.isNotEmpty(list)) {
|
int size = list.size();
|
if (size > 1)
|
throw new ServiceException(MessageUtils.message("production.loading.report.detail.fail.parallel.main.process.only.one.record", new Object[0]));
|
OrderReportRecord mainOrderReportRecord = list.get(0);
|
JuxtapositionReportDTO mainJuxtapositionReport = assembleReportData(mainOrderReportRecord, orderProcess.getProcessName(), orderProcess.getProcessCode());
|
juxtapositionReportList.add(mainJuxtapositionReport);
|
Long mainId = mainOrderReportRecord.getId();
|
List<OrderReportRecord> suborderList = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, mainId));
|
if (Func.isNotEmpty(suborderList)) {
|
List<JuxtapositionReportDTO> whetherParallelProcessRecord = (List<JuxtapositionReportDTO>)suborderList.stream().map(s -> {
|
OrderProcess child = (OrderProcess)childProcessMap.get(s.getProcessId());
|
return assembleReportData(s, child.getProcessName(), child.getProcessCode());
|
}).collect(Collectors.toList());
|
juxtapositionReportList.addAll(whetherParallelProcessRecord);
|
}
|
}
|
} else {
|
List<OrderReportRecord> commonlyList = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(OrderReportRecord::getProcessId, processId)
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
|
if (Func.isNotEmpty(commonlyList)) {
|
List<JuxtapositionReportDTO> whetherParallelProcessRecord = (List<JuxtapositionReportDTO>)commonlyList.stream().map(commonlyProcess -> assembleReportData(commonlyProcess, orderProcess.getProcessName(), orderProcess.getProcessCode())).collect(Collectors.toList());
|
juxtapositionReportList.addAll(whetherParallelProcessRecord);
|
}
|
}
|
if (Func.isNotEmpty(juxtapositionReportList)) {
|
reportWorkDetailDTO.setJuxtapositionReports(juxtapositionReportList);
|
String workstationNames = juxtapositionReportList.stream().map(JuxtapositionReportDTO::getWorkstationName).filter(Func::isNotBlank).distinct().collect(Collectors.joining(","));
|
reportWorkDetailDTO.setWorkstationNames(workstationNames);
|
}
|
return reportWorkDetailDTO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public OrderReportRecord generateStartMainRecord(PlanAndOrderDTO planAndOrderDTO, Long orderProcessId, Date startTime) {
|
OrderReportRecord orderReportRecord = new OrderReportRecord();
|
orderReportRecord.setPlanId(planAndOrderDTO.getPlan().getId());
|
orderReportRecord.setOrderId(planAndOrderDTO.getOrder().getId());
|
orderReportRecord.setProcessId(orderProcessId);
|
orderReportRecord.setStartTime(startTime);
|
orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.STARTED.getCode());
|
save(orderReportRecord);
|
return orderReportRecord;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean updateRecord(OrderProcessReportWorkDTO workDTO, OrderReportRecord orderReportRecord, OrderProcess orderProcess) {
|
int qualifyNum = workDTO.getQualifyNum().intValue() + ((orderReportRecord.getQualifyNum() == null) ? 0 : orderReportRecord.getQualifyNum().intValue());
|
int scrappedNum = workDTO.getScrappedNum().intValue() + ((orderReportRecord.getScrappedNum() == null) ? 0 : orderReportRecord.getScrappedNum().intValue());
|
Integer whetherParallel = orderProcess.getWhetherParallel();
|
if (Func.isEmpty(orderReportRecord.getMainSequenceId()) && qualifyNum == 0 && scrappedNum == 0)
|
throw new ServiceException(MessageUtils.message("production.report.fail.is.not.parallel.qualifyNum.and.scrappedNum.is.not.zero", new Object[0]));
|
return Boolean.valueOf(update(Wrappers.<OrderReportRecord>lambdaUpdate()
|
.eq(OrderReportRecord::getId, orderReportRecord.getId())
|
.set(OrderReportRecord::getQualifyNum, Integer.valueOf(qualifyNum))
|
.set(OrderReportRecord::getScrappedNum, Integer.valueOf(scrappedNum))
|
.set(OrderReportRecord::getWorkshopUserId, workDTO.getWorkshopUserId())
|
.set(OrderReportRecord::getWorkshopUserCode, workDTO.getWorkshopUserCode())
|
.set(OrderReportRecord::getWorkshopUserName, workDTO.getWorkshopUserName())
|
.set(OrderReportRecord::getQualityUserId, workDTO.getQualityUserId())
|
.set(OrderReportRecord::getQualityUserCode, workDTO.getQualityUserCode())
|
.set(OrderReportRecord::getQualityUserName, workDTO.getQualityUserName())
|
.set(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
|
.set(OrderReportRecord::getRemark, workDTO.getRemark())));
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public OrderReportRecord buildReportRecord(OrderProcessReportWorkDTO reportWorkDTO, OrderReportRecord orderReportRecord) {
|
orderReportRecord.setQualifyNum(Integer.valueOf(reportWorkDTO.getQualifyNum().intValue() + orderReportRecord.getQualifyNum().intValue())).setScrappedNum(Integer.valueOf(reportWorkDTO.getScrappedNum().intValue() + orderReportRecord.getScrappedNum().intValue())).setWorkshopUserId(Long.valueOf(Func.toLong(reportWorkDTO.getWorkshopUserId()))).setWorkshopUserName(reportWorkDTO.getWorkshopUserName()).setWorkshopUserCode(reportWorkDTO.getWorkshopUserCode()).setQualityUserId(Long.valueOf(Func.toLong(reportWorkDTO.getQualityUserId()))).setQualityUserName(reportWorkDTO.getQualityUserName()).setQualityUserCode(reportWorkDTO.getQualityUserCode()).setRemark(reportWorkDTO.getRemark()).setRecordStatus(CoProductionEnum.RecordStatus.YES.getCode()).setQualityTime(DateUtil.now()).setWorkshopTime(DateUtil.now());
|
return orderReportRecord;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public OrderReportRecord getLatestRecord(Long planId, Long orderId, Long orderProcessId) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(Func.isNotEmpty(planId), OrderReportRecord::getPlanId, planId)
|
.eq(Func.isNotEmpty(orderId), OrderReportRecord::getOrderId, orderId)
|
.eq(Func.isNotEmpty(orderProcessId), OrderReportRecord::getProcessId, orderProcessId)
|
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
|
.orderByDesc(OrderReportRecord::getWorkshopTime));
|
|
if (Func.isNotEmpty(list)) {
|
return (OrderReportRecord) list().get(0);
|
}
|
return null;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public OrderReportRecord getLatestChildProcessRecord(List<Long> processIds) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.in(OrderReportRecord::getProcessId, processIds)
|
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
|
.orderByDesc(OrderReportRecord::getWorkshopTime));
|
|
if (Func.isNotEmpty(list)) {
|
return (OrderReportRecord) list().get(0);
|
}
|
return null;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public OrderReportRecord getEarliestChildProcessRecord(List<Long> processIds, List<Long> removeRecordIds) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.in(OrderReportRecord::getProcessId, processIds)
|
.orderByDesc(OrderReportRecord::getStartTime));
|
if (Func.isNotEmpty(list)) {
|
List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> (Func.isNotEmpty(removeRecordIds) && !removeRecordIds.contains(s.getId()))).collect(Collectors.toList());
|
if (Func.isNotEmpty(reportRecords))
|
return reportRecords.get(0);
|
}
|
return null;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public OrderReportRecord getEarliestRecord(Long planId, Long orderId, Long orderProcessId, List<Long> removeRecordIds) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(Func.isNotEmpty(planId), OrderReportRecord::getPlanId, planId)
|
.eq(Func.isNotEmpty(orderId), OrderReportRecord::getOrderId, orderId)
|
.eq(Func.isNotEmpty(orderProcessId), OrderReportRecord::getProcessId, orderProcessId)
|
|
.orderByAsc(OrderReportRecord::getStartTime));
|
if (Func.isNotEmpty(list)) {
|
List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> (removeRecordIds != null && !removeRecordIds.contains(s.getId()))).collect(Collectors.toList());
|
if (Func.isNotEmpty(reportRecords))
|
return reportRecords.get(0);
|
}
|
return null;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public Integer countOpenRecord(Long processId) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(OrderReportRecord::getProcessId, processId)
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
|
if (Func.isNotEmpty(list))
|
return Integer.valueOf(list.size());
|
return CommonConstant.ZERO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public Integer countDelRecord(Long processId, List<Long> removeRecordIds) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
|
.eq(OrderReportRecord::getProcessId, processId)
|
.eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
|
if (Func.isNotEmpty(list)) {
|
List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> !removeRecordIds.contains(s.getId())).collect(Collectors.toList());
|
if (Func.isNotEmpty(reportRecords))
|
return Integer.valueOf(reportRecords.size());
|
}
|
return CommonConstant.ZERO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean removeReportRecord(Long recordId) {
|
OrderReportRecord delOrderReportRecord = (OrderReportRecord) getById(recordId);
|
if (delOrderReportRecord == null) {
|
throw new ServiceException(MessageUtils.message("production.del.record.fail.report.is.not.exist", new Object[0]));
|
}
|
Long mainSequenceId = delOrderReportRecord.getMainSequenceId();
|
Long processId = delOrderReportRecord.getProcessId();
|
if (Func.isNotEmpty(mainSequenceId)) {
|
throw new ServiceException(MessageUtils.message("production.del.record.fail.is.not.del.child.process.report.record", new Object[0]));
|
}
|
OrderProcess orderProcess = (OrderProcess) this.orderProcessService.getById(processId);
|
if (orderProcess == null) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0]));
|
}
|
Boolean checkPlan = this.planService.checkPlanStatus(delOrderReportRecord.getPlanId());
|
if (checkPlan.booleanValue()) {
|
throw new ServiceException(MessageUtils.message("production.del.report.fail.plan.suspend.or.close", new Object[0]));
|
}
|
Integer whetherParallel = orderProcess.getWhetherParallel();
|
List<OrderProcessReportWorkDTO> reportWorkDTOList = new ArrayList<>();
|
ReportWorkDTO reportWorkDTO = new ReportWorkDTO();
|
reportWorkDTO.setPlanId(Func.toStr(delOrderReportRecord.getPlanId()));
|
reportWorkDTO.setOrderId(Func.toStr(delOrderReportRecord.getOrderId()));
|
reportWorkDTOList.add(buildDelData(delOrderReportRecord.getId(), delOrderReportRecord.getProcessId(), delOrderReportRecord.getMainSequenceId(), delOrderReportRecord.getOpenSequenceId(), delOrderReportRecord.getQualifyNum(), delOrderReportRecord.getScrappedNum()));
|
reportWorkDTO.setReportWorkDTOList(reportWorkDTOList);
|
|
if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
|
List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, recordId));
|
if (Func.isNotEmpty(list)) {
|
for (OrderReportRecord delRecord : list) {
|
reportWorkDTOList.add(buildDelData(delRecord.getId(), delRecord.getProcessId(), delRecord.getMainSequenceId(), delRecord.getOpenSequenceId(), delRecord.getQualifyNum(), delRecord.getScrappedNum()));
|
}
|
}
|
}
|
|
|
Boolean result = this.orderProcessService.delReportWork(reportWorkDTO);
|
if (!result.booleanValue()) {
|
throw new ServiceException(MessageUtils.message("production.del.report.fail.reduce.num.fail", new Object[0]));
|
}
|
return true;
|
}
|
|
private OrderProcessReportWorkDTO buildDelData(Long recordId, Long processId, Long mainSequenceId, Long openSequenceId, Integer qualifyNum, Integer scrappedNum) {
|
OrderProcessReportWorkDTO orderProcessReportWorkDTO = new OrderProcessReportWorkDTO();
|
orderProcessReportWorkDTO.setRecordId(Func.toStr(recordId)).setMainSequenceId(mainSequenceId).setOpenSequenceId(openSequenceId).setProcessId(Func.toStr(processId)).setQualifyNum(Integer.valueOf(-qualifyNum.intValue())).setScrappedNum(Integer.valueOf(-scrappedNum.intValue()));
|
return orderProcessReportWorkDTO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public IPage<OrderReportRecordResVO> pageQuery(OrderReportRecordSearchVO vo) {
|
Query query = vo.getQuery();
|
Long productId = vo.getProductId();
|
Long orderId = vo.getOrderId();
|
List<Long> reportEmployeeIds = vo.getReportEmployeeIds();
|
List<Long> workEmployeeIds = vo.getWorkEmployeeIds();
|
LocalDate startDate = vo.getStartDate();
|
String startTime = Func.notNull(startDate) ? TimeUtils.getStartTime(startDate) : "";
|
LocalDate endDate = vo.getEndDate();
|
String endTime = Func.notNull(endDate) ? TimeUtils.getEndTime(endDate) : "";
|
IPage<OrderReportRecordResVO> page = ((OrderReportRecordMapper) this.baseMapper).pageQuery(Condition.getPage(query), getWrapper(orderId, productId, reportEmployeeIds, workEmployeeIds, startTime, endTime));
|
List<OrderReportRecordResVO> records = page.getRecords();
|
if (Func.isEmpty(records)) {
|
return new Page();
|
}
|
List<Long> recordIds = (List) records.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<OrderReportRecord> recordList = list(Lambda.in((v0) -> {
|
return v0.getOpenSequenceId();
|
}, recordIds));
|
if (Func.isEmpty(recordList)) {
|
page.setRecords((List) records.stream().peek(r -> {
|
if (Func.notNull(r.getStartTime()) && Func.notNull(r.getEndTime())) {
|
r.setReportTime(Long.valueOf(DateUtil.between(r.getStartTime(), r.getEndTime()).getSeconds()));
|
}
|
}).collect(Collectors.toList()));
|
return page;
|
}
|
Map<Long, List<OrderReportRecord>> recordMap = (Map) recordList.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getOpenSequenceId();
|
}));
|
List<OrderReportRecordResVO> vos = completeData(records, recordMap);
|
page.setRecords(vos);
|
return page;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public BladeFile recordExport(OpRecordExportVO vo) {
|
Long productId = vo.getProductId();
|
List<Long> reportEmployeeIds = vo.getReportEmployeeIds();
|
List<Long> workEmployeeIds = vo.getWorkEmployeeIds();
|
LocalDate startDate = vo.getStartDate();
|
LocalDate endDate = vo.getEndDate();
|
String startTime = Func.notNull(startDate) ? TimeUtils.getStartTime(startDate) : "";
|
String endTime = Func.notNull(endDate) ? TimeUtils.getEndTime(endDate) : "";
|
List<OrderReportRecordResVO> records = ((OrderReportRecordMapper) this.baseMapper).recordExport(getWrapper(vo.getOrderId(), productId, reportEmployeeIds, workEmployeeIds, startTime, endTime));
|
if (Func.isEmpty(records)) {
|
return exportRecord(Lists.newArrayList());
|
}
|
List<Long> recordIds = (List) records.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<OrderReportRecord> recordList = list(Lambda.in((v0) -> {
|
return v0.getOpenSequenceId();
|
}, recordIds));
|
if (Func.isEmpty(recordList)) {
|
return exportNoChildRecord(records);
|
}
|
return exportHasChildRecord(records, recordList);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public List<OrderChildRecordVO> queryChildRecord(String mainRecordId) {
|
List<OrderReportRecord> records = list(Lambda.eq((v0) -> {
|
return v0.getOpenSequenceId();
|
}, mainRecordId));
|
List<Long> opIds = (List) records.stream().map((v0) -> {
|
return v0.getProcessId();
|
}).collect(Collectors.toList());
|
List<OrderProcess> orderProcessList = this.orderProcessService.listByIds(opIds);
|
Map<Long, OrderProcess> map = (Map) orderProcessList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, v -> {
|
return v;
|
}));
|
return (List) records.stream().map(c -> {
|
return convertVO(c, map);
|
}).collect(Collectors.toList());
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
public List<JuxtapositionReportDTO> reportRecordsDetail(Long recordId) {
|
OrderReportRecord orderReportRecord = (OrderReportRecord) getById(recordId);
|
List<JuxtapositionReportDTO> juxtapositionReportDTOList = new ArrayList<>();
|
if (Func.isEmpty(orderReportRecord)) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0]));
|
}
|
OrderProcess orderProcess = (OrderProcess) this.orderProcessService.getById(orderReportRecord.getProcessId());
|
if (Func.isEmpty(orderProcess)) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0]));
|
}
|
JuxtapositionReportDTO mainProcessRecord = assembleReportData(orderReportRecord, orderProcess.getProcessName(), orderProcess.getProcessCode());
|
juxtapositionReportDTOList.add(mainProcessRecord);
|
Integer whetherParallel = orderProcess.getWhetherParallel();
|
if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
|
List<OrderReportRecord> childRecordList = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, recordId));
|
if (Func.isNotEmpty(childRecordList)) {
|
childRecordList.forEach(record -> {
|
JuxtapositionReportDTO juxtapositionReportDTO = assembleReportData(record, orderProcess.getProcessName(), orderProcess.getProcessCode());
|
juxtapositionReportDTOList.add(juxtapositionReportDTO);
|
});
|
}
|
}
|
return juxtapositionReportDTOList;
|
}
|
|
private BladeFile exportNoChildRecord(List<OrderReportRecordResVO> records) {
|
List<OrderReportRecordExport> result = (List) records.stream().map(OrderReportRecordServiceImpl::getExport).collect(Collectors.toList());
|
return exportRecord(result);
|
}
|
|
private BladeFile exportHasChildRecord(List<OrderReportRecordResVO> records, List<OrderReportRecord> recordList) {
|
Map<Long, List<OrderReportRecord>> recordMap = (Map) recordList.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getOpenSequenceId();
|
}));
|
List<OrderReportRecordExport> result = Lists.newArrayList();
|
List<OrderProcess> orderProcessList = this.orderProcessService.list();
|
Map<Long, OrderProcess> orderProcessMap = (Map) orderProcessList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, v -> {
|
return v;
|
}));
|
records.forEach(rd -> {
|
OrderReportRecordExport convert = getExport(rd);
|
List<OrderReportRecord> childRecords = (List) recordMap.get(rd.getId());
|
if (Func.isNotEmpty(childRecords)) {
|
String workstationNames = (String) childRecords.stream().map((v0) -> {
|
return v0.getWorkstationName();
|
}).filter((v0) -> {
|
return Func.notNull(v0);
|
}).collect(Collectors.joining(","));
|
String workstationName = convert.getWorkstationName();
|
convert.setWorkstationName(workstationName == null ? workstationNames : String.join(",", workstationName, workstationNames));
|
result.add(convert);
|
childRecords.forEach(crd -> {
|
result.add(convertExport(crd, rd, orderProcessMap));
|
});
|
return;
|
}
|
result.add(convert);
|
});
|
return exportRecord(result);
|
}
|
|
private static OrderReportRecordExport convertExport(OrderReportRecord crd, OrderReportRecordResVO rd, Map<Long, OrderProcess> orderProcessMap) {
|
OrderReportRecordExport res = OrderReportRecordExport.builder().productName(rd.getProductName()).standardModel(rd.getStandardModel()).workstationName(crd.getWorkstationName()).workEmployeeName(crd.getProducerUserName()).reportEmployeeName(crd.getWorkshopUserName()).assignNum(rd.getAssignNum()).reportNum(Integer.valueOf(convertNum(crd.getQualifyNum()).intValue() + convertNum(crd.getScrappedNum()).intValue())).qualifNum(convertNum(crd.getQualifyNum())).scrappedNum(convertNum(crd.getScrappedNum())).remark(crd.getRemark()).build();
|
OrderProcess orderProcess = orderProcessMap.get(crd.getProcessId());
|
if (Func.notNull(orderProcess)) {
|
res.setProcessName(orderProcess.getProcessName());
|
}
|
completeTime(crd.getStartTime(), crd.getWorkshopTime(), res);
|
return res;
|
}
|
|
private static OrderReportRecordExport getExport(OrderReportRecordResVO rd) {
|
OrderReportRecordExport convert = OrderReportRecordConvert.INSTANCE.convert(rd);
|
completeTime(rd.getStartTime(), rd.getEndTime(), convert);
|
return convert;
|
}
|
|
private static void completeTime(Date startTime, Date endTime, OrderReportRecordExport res) {
|
if (Func.notNull(startTime) && Func.notNull(endTime)) {
|
res.setStartTime(DateUtil.formatDateTime(startTime));
|
res.setEndTime(DateUtil.formatDateTime(endTime));
|
long seconds = DateUtil.between(startTime, endTime).getSeconds();
|
res.setReportTime(TimeUtils.getUseTime(seconds));
|
} else if (Func.notNull(startTime)) {
|
res.setStartTime(DateUtil.formatDateTime(startTime));
|
} else {
|
res.setEndTime(DateUtil.formatDateTime(endTime));
|
}
|
}
|
|
private BladeFile exportRecord(List<OrderReportRecordExport> result) {
|
String fileName = String.format("%s-%s.xlsx", ExcelConstant.ORDER_REPORT_RECORD, DateUtil.time());
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, ExcelConstant.ORDER_REPORT_RECORD, result, OrderReportRecordExport.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
private <T> QueryWrapper<T> getWrapper(Long orderId, Long productId, List<Long> reportEmployeeIds, List<Long> workEmployeeIds, String startTime, String endTime) {
|
QueryWrapper<T> wrapper = Wrappers.<T>query().eq(Func.notNull(productId), "bp.product_id", productId).eq(Func.notNull(orderId), "borr.order_id", orderId).in(Func.isNotEmpty(reportEmployeeIds), "borr.workshop_user_id", reportEmployeeIds).in(Func.isNotEmpty(workEmployeeIds), "borr.producer_user_id", workEmployeeIds);
|
if (Func.isNotBlank(startTime) && Func.isNotBlank(endTime)) {
|
wrapper.nested(nt -> {
|
QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt.between("borr.start_time", startTime, endTime)).or()).between("borr.workshop_time", startTime, endTime);
|
});
|
} else if (Func.isNotBlank(startTime)) {
|
wrapper.nested(nt2 -> {
|
QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt2.gt("borr.start_time", startTime)).or()).gt("borr.start_time", startTime);
|
});
|
} else if (Func.isNotBlank(endTime)) {
|
wrapper.nested(nt3 -> {
|
QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt3.le("borr.workshop_time", endTime)).or()).le("borr.workshop_time", endTime);
|
});
|
}
|
if (Func.isNotBlank(wrapper.getSqlSegment())) {
|
return wrapper;
|
}
|
return null;
|
}
|
|
private List<OrderReportRecordResVO> completeData(List<OrderReportRecordResVO> records, Map<Long, List<OrderReportRecord>> recordMap) {
|
return (List) records.stream().peek(r -> {
|
if (Func.notNull(r.getStartTime()) && Func.notNull(r.getEndTime())) {
|
r.setReportTime(Long.valueOf(DateUtil.between(r.getStartTime(), r.getEndTime()).getSeconds()));
|
}
|
List<OrderReportRecord> childRecords = (List) recordMap.get(r.getId());
|
if (Func.isNotEmpty(childRecords)) {
|
String workstationIds = (String) childRecords.stream().map(c -> {
|
Long workstationId = c.getWorkstationId();
|
if (workstationId == null) {
|
return null;
|
}
|
return String.valueOf(workstationId);
|
}).filter((v0) -> {
|
return Func.notNull(v0);
|
}).collect(Collectors.joining(","));
|
Long workstationId = r.getWorkstationId();
|
r.setWorkstationIds(workstationId == null ? workstationIds : String.join(",", String.valueOf(workstationId), workstationIds));
|
String workstationNames = (String) childRecords.stream().map((v0) -> {
|
return v0.getWorkstationName();
|
}).filter((v0) -> {
|
return Func.notNull(v0);
|
}).collect(Collectors.joining(","));
|
String workstationName = r.getWorkstationName();
|
r.setWorkstationName(workstationName == null ? workstationNames : String.join(",", workstationName, workstationNames));
|
r.setHasChildProcess(1);
|
}
|
}).collect(Collectors.toList());
|
}
|
|
private static Integer convertNum(Integer num) {
|
return Integer.valueOf(num == null ? 0 : num.intValue());
|
}
|
|
private JuxtapositionReportDTO assembleReportData(OrderReportRecord reportRecord, String processName, String processCode) {
|
JuxtapositionReportDTO juxtapositionReportDTO = new JuxtapositionReportDTO();
|
juxtapositionReportDTO.setRecordId(reportRecord.getId()).setProcessId(reportRecord.getProcessId()).setProcessCode(processCode).setProcessName(processName).setQualifyNum(reportRecord.getQualifyNum()).setScrappedNum(reportRecord.getScrappedNum()).setWorkstationId(reportRecord.getWorkstationId()).setWorkstationName(reportRecord.getWorkstationName()).setMainSequenceId(reportRecord.getMainSequenceId()).setOpenSequenceId(reportRecord.getOpenSequenceId());
|
return juxtapositionReportDTO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean editOrderProcessRecord(ReportWorkDTO reportWorkDTO) {
|
List<OrderProcessReportWorkDTO> reportWorkDTOList = reportWorkDTO.getReportWorkDTOList();
|
if (Func.isEmpty(reportWorkDTOList)) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.data.empty", new Object[0]));
|
}
|
List<String> recordIds = (List) reportWorkDTOList.stream().map((v0) -> {
|
return v0.getRecordId();
|
}).collect(Collectors.toList());
|
Map<Long, OrderReportRecord> recordMap = getRecordMap(recordIds);
|
for (OrderProcessReportWorkDTO upRecord : reportWorkDTOList) {
|
OrderReportRecord oldOrderReportRecord = recordMap.get(Long.valueOf(Func.toLong(upRecord.getRecordId())));
|
Integer agoQualifyNum = oldOrderReportRecord.getQualifyNum();
|
Integer agoScrappedNum = oldOrderReportRecord.getScrappedNum();
|
Integer upQualifyNum = upRecord.getQualifyNum();
|
Integer upScrappedNum = upRecord.getScrappedNum();
|
Integer newQualifyNum = Integer.valueOf(upQualifyNum.intValue() - agoQualifyNum.intValue());
|
Integer newScrappedNum = Integer.valueOf(upScrappedNum.intValue() - agoScrappedNum.intValue());
|
upRecord.setQualifyNum(newQualifyNum);
|
upRecord.setScrappedNum(newScrappedNum);
|
}
|
return this.orderProcessService.editReportWork(reportWorkDTO);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean editParallelProcessRecord(ReportWorkDTO reportWorkDTO) {
|
List<OrderProcessReportWorkDTO> reportWorkDTOList = reportWorkDTO.getReportWorkDTOList();
|
if (Func.isEmpty(reportWorkDTOList)) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.data.empty", new Object[0]));
|
}
|
this.orderProcessService.parallelProcessAround(ReportConvert.INSTANCE.convertParallel(reportWorkDTOList), Boolean.TRUE);
|
List<String> recordIds = (List) reportWorkDTOList.stream().map((v0) -> {
|
return v0.getRecordId();
|
}).distinct().collect(Collectors.toList());
|
Map<Long, OrderReportRecord> recordMap = getRecordMap(recordIds);
|
reportWorkDTOList.forEach(parallelRecord -> {
|
OrderReportRecord record = (OrderReportRecord) recordMap.get(Long.valueOf(Func.toLong(parallelRecord.getRecordId())));
|
Integer agoQualifyNum = record.getQualifyNum();
|
Integer agoScrappedNum = record.getScrappedNum();
|
Integer upQualifyNum = parallelRecord.getQualifyNum();
|
Integer upScrappedNum = parallelRecord.getScrappedNum();
|
Integer newQualifyNum = Integer.valueOf(upQualifyNum.intValue() - agoQualifyNum.intValue());
|
Integer newScrappedNum = Integer.valueOf(upScrappedNum.intValue() - agoScrappedNum.intValue());
|
parallelRecord.setQualifyNum(newQualifyNum);
|
parallelRecord.setScrappedNum(newScrappedNum);
|
});
|
Boolean result = this.orderProcessService.editReportWork(reportWorkDTO);
|
this.orderProcessService.dealChildProcess(reportWorkDTOList);
|
this.orderProcessService.dealCompleteProcessSurplusRecords(reportWorkDTO.getOrderId());
|
return result;
|
}
|
|
private Map<Long, OrderReportRecord> getRecordMap(List<String> recordIds) {
|
List<OrderReportRecord> list = 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]));
|
}
|
return (Map<Long, OrderReportRecord>)list.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity()));
|
}
|
|
private OrderChildRecordVO convertVO(OrderReportRecord rd, Map<Long, OrderProcess> map) {
|
OrderChildRecordVO vo = new OrderChildRecordVO();
|
vo.setId(rd.getId());
|
vo.setPlanId(rd.getPlanId());
|
vo.setOrderId(rd.getOrderId());
|
vo.setOrderProcessId(rd.getProcessId());
|
vo.setWorkstationId(rd.getWorkstationId());
|
vo.setWorkstationName(rd.getWorkstationName());
|
vo.setWorkEmployeeId(rd.getProducerUserId());
|
vo.setWorkEmployeeName(rd.getProducerUserName());
|
vo.setStartTime(rd.getStartTime());
|
vo.setEndTime(rd.getWorkshopTime());
|
vo.setReportEmployeeId(rd.getWorkshopUserId());
|
vo.setReportEmployeeName(rd.getWorkshopUserName());
|
vo.setReportNum(Integer.valueOf(convertNum(rd.getQualifyNum()).intValue() + convertNum(rd.getScrappedNum()).intValue()));
|
vo.setQualifNum(convertNum(rd.getQualifyNum()));
|
vo.setRecordStatus(rd.getRecordStatus());
|
vo.setRemark(rd.getRemark());
|
vo.setScrappedNum(rd.getScrappedNum());
|
OrderProcess orderProcess = map.get(rd.getProcessId());
|
if (Func.notNull(orderProcess)) {
|
vo.setProductCode(orderProcess.getProcessCode());
|
vo.setProductName(orderProcess.getProcessName());
|
}
|
if (Func.notNull(vo.getStartTime()) && Func.notNull(vo.getEndTime())) {
|
vo.setReportTime(Long.valueOf(DateUtil.between(vo.getStartTime(), vo.getEndTime()).getSeconds()));
|
}
|
return vo;
|
}
|
}
|
