package com.qianwen.smartman.modules.coproduction.service.impl;
|
|
import cn.hutool.core.map.MapUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.hutool.json.JSONObject;
|
import cn.hutool.json.JSONUtil;
|
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.core.toolkit.support.SFunction;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.lang.invoke.SerializedLambda;
|
import java.lang.reflect.Field;
|
import java.text.ParseException;
|
import java.time.LocalDate;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Optional;
|
import java.util.Set;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.jetbrains.annotations.NotNull;
|
import com.qianwen.smartman.common.cache.CodeRuleCache;
|
import com.qianwen.smartman.common.cache.RegionCache;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.DateConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.utils.ExcelUtils;
|
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.oss.model.BladeFile;
|
import com.qianwen.core.tool.utils.CollectionUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.core.tool.utils.StringUtil;
|
import com.qianwen.smartman.modules.coproduction.convert.PlanConvert;
|
import com.qianwen.smartman.modules.coproduction.convert.PlanProcessConvert;
|
import com.qianwen.smartman.modules.coproduction.dto.CheckParamDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.CheckResultDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.OrderProcessReportWorkDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanCraftDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanImportCheckMapDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanProcessDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanProcessInfoDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.PlanProductTypeDTO;
|
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.OrderReportRecordStatusEnum;
|
import com.qianwen.smartman.modules.coproduction.enums.OrderStatusEnum;
|
import com.qianwen.smartman.modules.coproduction.enums.PlanCategoryEnum;
|
import com.qianwen.smartman.modules.coproduction.enums.PlanStatusEnum;
|
import com.qianwen.smartman.modules.coproduction.enums.WorkstationStatusEnum;
|
import com.qianwen.smartman.modules.coproduction.mapper.OrderReportRecordMapper;
|
import com.qianwen.smartman.modules.coproduction.mapper.PlanMapper;
|
import com.qianwen.smartman.modules.coproduction.mapper.PlanProcessMapper;
|
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.OrderEditWorkstationVO;
|
import com.qianwen.smartman.modules.coproduction.vo.OrderProcessEditWorkStationVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanAppendVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanBomVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanCraftVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanCraftVersionVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanExportVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanImportVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanModifyVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanQueryVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanStatusCountVO;
|
import com.qianwen.smartman.modules.coproduction.vo.PlanSubmitVO;
|
import com.qianwen.smartman.modules.cps.entity.BomVersion;
|
import com.qianwen.smartman.modules.cps.entity.CraftRouting;
|
import com.qianwen.smartman.modules.cps.entity.Product;
|
import com.qianwen.smartman.modules.cps.entity.ProductionCraftVersion;
|
import com.qianwen.smartman.modules.cps.service.IBomVersionService;
|
import com.qianwen.smartman.modules.cps.service.ICraftRoutingService;
|
import com.qianwen.smartman.modules.cps.service.IProductService;
|
import com.qianwen.smartman.modules.cps.service.IProductionCraftVersionService;
|
import com.qianwen.smartman.modules.cps.vo.CraftRoutingDetailVO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.system.constant.FieldConstant;
|
import com.qianwen.smartman.modules.system.constant.SystemFieldConstant;
|
import com.qianwen.smartman.modules.system.dto.CustomTemplateFieldRelationDTO;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplate;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplateBusiness;
|
import com.qianwen.smartman.modules.system.enums.BusinessTypeEnums;
|
import com.qianwen.smartman.modules.system.enums.ConfigTypeEnum;
|
import com.qianwen.smartman.modules.system.handler.field.HandlerFieldSqlParse;
|
import com.qianwen.smartman.modules.system.mapper.CustomTemplateFieldRelationMapper;
|
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateBusinessService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateFieldService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateService;
|
import com.qianwen.smartman.modules.system.vo.CustomTemplateFieldColumnVO;
|
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
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/PlanServiceImpl.class */
|
public class PlanServiceImpl extends BaseServiceImpl<PlanMapper, Plan> implements IPlanService {
|
@Autowired
|
private ICodeGeneratorService codeGeneratorService;
|
@Autowired
|
@Lazy
|
private IOrderService orderService;
|
@Autowired
|
private IOrderProcessService orderProcessService;
|
@Autowired
|
private ICustomTemplateFieldService customTemplateFieldService;
|
@Autowired
|
private ICustomTemplateBusinessService customTemplateBusinessService;
|
@Autowired
|
private OssBuilder ossBuilder;
|
@Autowired
|
@Lazy
|
private IOrderReportRecordService orderReportRecordService;
|
@Autowired
|
private IOrderWorkstationService orderWorkstationService;
|
@Autowired
|
private ICustomTemplateService templateService;
|
@Autowired
|
private PlanProcessMapper planProcessMapper;
|
@Autowired
|
private IPlanProcessService planProcessService;
|
@Autowired
|
private HandlerFieldSqlParse handlerFieldSqlParse;
|
@Autowired
|
private IProductService productService;
|
@Autowired
|
private IProductionCraftVersionService productionCraftVersionService;
|
@Autowired
|
private OrderReportRecordMapper orderReportRecordMapper;
|
@Autowired
|
private PlanMapper planMapper;
|
@Autowired
|
private ICraftRoutingService craftRoutingService;
|
@Autowired
|
private IBomVersionService bomVersionService;
|
@Autowired
|
private CustomTemplateFieldRelationMapper customTemplateFieldRelationMapper;
|
private static final String CODE_RULE = "CoPlan";
|
private static final String PLAN_TYPE_CODE = "typeId";
|
static final List<Integer> CHECK_STATUS_LIST = Arrays.asList(PlanStatusEnum.WAIT_MACHINE.getCode(), PlanStatusEnum.PAUSE.getCode(), PlanStatusEnum.MACH_ING.getCode());
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean remove(Long id) {
|
Plan plan = (Plan) getById(id);
|
Integer planStatus = plan.getPlanStatus();
|
if (!Func.equals(planStatus, PlanStatusEnum.WAIT_PUBLISH.getCode())) {
|
|
List<Order> list = this.orderService.list(
|
Wrappers.<Order>lambdaQuery()
|
.eq(Order::getPlanId, id)
|
.eq(Order::getStatus, CommonConstant.ENABLE));
|
List<Long> orderIds = (List<Long>)list.stream().map(Order::getId).collect(Collectors.toList());
|
Long num = this.orderReportRecordMapper.selectCount(Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getOrderId, orderIds)
|
.eq(OrderReportRecord::getRecordStatus, CommonConstant.DEACTIVATE));
|
if (Func.isNotEmpty(num) && num.longValue() > 0L) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.remove", new Object[0]));
|
}
|
this.orderService.remove(orderIds, plan.getId());
|
}
|
return removeById(id);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public void pause(Long planId) {
|
Plan plan = (Plan) getById(planId);
|
List<Order> orders = this.orderService.list(Wrappers.<Order>lambdaQuery().eq(Order::getStatus, CommonConstant.ENABLE).eq(Order::getPlanId, planId));
|
/*
|
List<Order> orders = this.orderService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getPlanId();
|
}, planId));*/
|
checkPause(plan, orders);
|
plan.setPlanStatusBefore(plan.getPlanStatus());
|
plan.setPlanStatus(PlanStatusEnum.PAUSE.getCode());
|
updateById(plan);
|
|
List<OrderProcess> orderProcesses = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getStatus, CommonConstant.ENABLE).eq(OrderProcess::getPlanId, planId));
|
/*
|
List<OrderProcess> orderProcesses = this.orderProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getPlanId();
|
}, planId));*/
|
pauseOrderAndProcesses(orders, orderProcesses);
|
}
|
|
private void pauseOrderAndProcesses(List<Order> orders, List<OrderProcess> orderProcesses) {
|
orders.forEach(item -> {
|
item.setOrderStatusBefore(item.getOrderStatus());
|
});
|
orderProcesses.forEach(item2 -> {
|
item2.setProcessStatusBefore(item2.getProcessStatus());
|
});
|
orders.forEach(item3 -> {
|
item3.setOrderStatus(OrderProcessStatusEnum.SUSPEND.getCode());
|
});
|
orderProcesses.forEach(item4 -> {
|
item4.setProcessStatus(OrderProcessStatusEnum.SUSPEND.getCode());
|
});
|
this.orderService.updateBatchById(orders);
|
this.orderProcessService.updateBatchById(orderProcesses);
|
}
|
|
private void checkPause(Plan plan, List<Order> orders) {
|
List<Integer> status = new ArrayList<>();
|
status.add(PlanStatusEnum.MACH_ING.getCode());
|
status.add(PlanStatusEnum.WAIT_MACHINE.getCode());
|
status.add(PlanStatusEnum.WAIT_PUBLISH.getCode());
|
Integer planStatus = plan.getPlanStatus();
|
if (!status.contains(planStatus)) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.pause", new Object[0]));
|
}
|
if (Func.equals(planStatus, PlanStatusEnum.MACH_ING.getCode())) {
|
List<Order> list = orders.stream().filter(item -> Func.equals(item.getOrderStatus(), OrderStatusEnum.IN_EXECUTION.getCode())).collect(Collectors.toList());
|
List<Long> orderIds = list.stream().map(Order::getId).collect(Collectors.toList());
|
if (Func.isNotEmpty(list)) {
|
List<OrderReportRecord> orderReportRecords = this.orderReportRecordMapper.selectList(
|
Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getOrderId, orderIds)
|
.eq(OrderReportRecord::getRecordStatus, CommonConstant.DEACTIVATE));
|
if (Func.isNotEmpty(orderReportRecords)) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.pause", new Object[0]));
|
}
|
}
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public void reboot(Long planId) {
|
Plan plan = (Plan) getById(planId);
|
checkReboot(plan);
|
|
List<Order> orders = this.orderService.list(
|
Wrappers.<Order>lambdaQuery()
|
.eq(Order::getStatus, CommonConstant.ENABLE)
|
.eq(Order::getPlanId, planId));
|
/*
|
List<Order> orders = this.orderService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getPlanId();
|
}, planId));*/
|
|
List<OrderProcess> orderProcesses = this.orderProcessService.list(
|
Wrappers.<OrderProcess>lambdaQuery()
|
.eq(OrderProcess::getStatus, CommonConstant.ENABLE)
|
.eq(OrderProcess::getPlanId, planId));
|
/*
|
List<OrderProcess> orderProcesses = this.orderProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getPlanId();
|
}, planId));*/
|
plan.setPlanStatus(plan.getPlanStatusBefore());
|
orders.forEach(item -> {
|
item.setOrderStatus(item.getOrderStatusBefore());
|
});
|
orderProcesses.forEach(item2 -> {
|
item2.setProcessStatus(item2.getProcessStatusBefore());
|
});
|
updateById(plan);
|
this.orderService.updateBatchById(orders);
|
this.orderProcessService.updateBatchById(orderProcesses);
|
}
|
|
private void checkReboot(Plan plan) {
|
Integer planStatus = plan.getPlanStatus();
|
if (!Func.equals(planStatus, PlanStatusEnum.PAUSE.getCode())) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.reboot", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public void append(PlanAppendVO planAppendVO) {
|
Long planId = planAppendVO.getPlanId();
|
Plan sourcePlan = (Plan) getById(planId);
|
if (!Func.equals(sourcePlan.getPlanStatus(), PlanStatusEnum.CLOSE.getCode()) && !Func.equals(sourcePlan.getPlanStatus(), PlanStatusEnum.FINISHED.getCode())) {
|
throw new ServiceException(MessageUtils.message(MessageUtils.message("cps.plan.can.not.append", new Object[0]), new Object[0]));
|
}
|
Integer num = planAppendVO.getNum();
|
if (num.intValue() <= 0) {
|
throw new ServiceException(MessageUtils.message("plan.num.must.greater.than.zero", new Object[0]));
|
}
|
checkPlanTime(planAppendVO.getPlanStartTime(), planAppendVO.getPlanEndTime());
|
Plan plan = PlanConvert.INSTANCE.copyNewPlan(sourcePlan, planAppendVO);
|
if (CodeRuleCache.existCodeRule(CODE_RULE)) {
|
plan.setCode(planCodeGenerator(new PlanSubmitVO()));
|
} else {
|
String planCode = planAppendVO.getPlanCode();
|
if (Func.isEmpty(planCode)) {
|
throw new ServiceException(MessageUtils.message("cps.plan.code.can.not.null", new Object[0]));
|
}
|
plan.setCode(planAppendVO.getPlanCode());
|
}
|
save(plan);
|
appendProcesses(planAppendVO, plan);
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
private void appendProcesses(PlanAppendVO planAppendVO, Plan plan) {
|
List<PlanProcessDTO> planProcess = planAppendVO.getPlanProcess();
|
if (Func.isEmpty(planProcess)) {
|
throw new ServiceException(MessageUtils.message("cps.plan.process.can.not.null", new Object[0]));
|
}
|
List<Long> processIds = new ArrayList<>();
|
planProcess.forEach(item -> {
|
processIds.add(item.getPlanProcessId());
|
});
|
|
Map<Long, PlanProcessDTO> map = (Map<Long, PlanProcessDTO>)planProcess.stream().collect(Collectors.toMap(PlanProcessDTO::getPlanProcessId, item -> item));
|
|
List<PlanProcess> planProcesses = this.planProcessService.list(Wrappers.<PlanProcess>lambdaQuery().in(PlanProcess::getId, processIds).orderByAsc(PlanProcess::getSort));
|
/*
|
List<PlanProcess> planProcesses = this.planProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getId();
|
}, processIds)).orderByAsc((v0) -> {
|
return v0.getSort();
|
}));
|
*/
|
if (Func.isEmpty(planProcesses)) {
|
throw new ServiceException(MessageUtils.message("production.plan.process.not.exists", new Object[0]));
|
}
|
Set<Long> mainProcessesIds = planProcesses.stream().map(PlanProcess::getMainSequenceId).collect(Collectors.toSet());
|
/*
|
Set<Long> mainProcessesIds = (Set) planProcesses.stream().map((v0) -> {
|
return v0.getMainSequenceId();
|
}).collect(Collectors.toSet());
|
*/
|
|
Map<Long, PlanProcess> mainMap = MapUtil.newHashMap();
|
Map<String, Long> newMainMap = MapUtil.newHashMap();
|
if (Func.isNotEmpty(mainProcessesIds)) {
|
List<PlanProcess> mainProcessesList = this.planProcessService.listByIds(mainProcessesIds);
|
if (Func.isNotEmpty(mainProcessesList)) {
|
/*
|
mainMap = (Map) mainProcessesList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, item3 -> {
|
return item3;
|
}));*/
|
mainMap = mainProcessesList.stream().collect(Collectors.toMap(PlanProcess::getId, item -> item));
|
}
|
mainProcessesList.forEach(item4 -> {
|
PlanProcessDTO planProcessDTO = (PlanProcessDTO) map.get(item4.getId());
|
item4.setId(null);
|
item4.setPlanId(plan.getId());
|
if (Func.isNotEmpty(planProcessDTO)) {
|
item4.setWorkstationId(planProcessDTO.getWorkstationIds());
|
item4.setWorkstationName(planProcessDTO.getWorkstationNames());
|
}
|
});
|
this.planProcessService.saveBatch(mainProcessesList);
|
if (Func.isNotEmpty(mainProcessesList)) {
|
newMainMap = mainProcessesList.stream().collect(Collectors.toMap(this::getProcessKey, PlanProcess::getId));
|
/*
|
newMainMap = (Map) mainProcessesList.stream().collect(Collectors.toMap(this::getProcessKey, (v0) -> {
|
return v0.getId();
|
}));*/
|
}
|
}
|
Map<Long, PlanProcess> finalMainMap = mainMap;
|
Map<String, Long> finalNewMainMap = newMainMap;
|
planProcesses.forEach(item5 -> {
|
PlanProcessDTO planProcessDTO = (PlanProcessDTO) map.get(item5.getId());
|
item5.setId(null);
|
item5.setPlanId(plan.getId());
|
item5.setWorkstationId(planProcessDTO.getWorkstationIds());
|
item5.setWorkstationName(planProcessDTO.getWorkstationNames());
|
if (Func.isEmpty(item5.getMainSequenceId())) {
|
return;
|
}
|
Long mainSequenceId = item5.getMainSequenceId();
|
if (finalMainMap.containsKey(mainSequenceId)) {
|
PlanProcess process = (PlanProcess) finalMainMap.get(mainSequenceId);
|
if (finalNewMainMap.containsKey(getProcessKey(process))) {
|
Long mainId = (Long) finalNewMainMap.get(getProcessKey(process));
|
item5.setMainSequenceId(mainId);
|
}
|
}
|
});
|
this.planProcessService.saveBatch(planProcesses);
|
}
|
|
private String getProcessKey(PlanProcess process) {
|
return process.getCode() + "-" + process.getSort();
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public BladeFile planImport(Long templateId, MultipartFile file) {
|
try {
|
ExcelUtils.ExcelDataDTO excelDataDTO = ExcelUtils.readExcel(file.getInputStream());
|
List<Map<String, String>> data = excelDataDTO.getData();
|
List<Map<String, String>> sysData = new ArrayList<>();
|
List<CheckResultDTO> checkResultDTOS = this.templateService.checkImport(getCheckFunction(sysData), BusinessTypeEnums.PLAN_ORDER.getCode(), data);
|
if (Func.isEmpty(checkResultDTOS)) {
|
throw new ServiceException("cps.plan.table.data.error");
|
}
|
List<PlanImportVO> cover = cover(sysData);
|
List<Plan> plans = checkAndHandleSysPlan(checkResultDTOS, cover);
|
BladeFile bladeFile = putImportFail(excelDataDTO, checkResultDTOS);
|
if (Func.isNotEmpty(bladeFile)) {
|
return bladeFile;
|
}
|
saveList(plans);
|
return new BladeFile();
|
} catch (Exception e) {
|
throw new ServiceException(MessageUtils.message("cps.plan.table.data.error", new Object[0]));
|
}
|
}
|
|
private void saveList(List<Plan> plans) {
|
plans.forEach(plan -> {
|
plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
|
});
|
saveBatch(plans);
|
plans.forEach(this::saveProcessBatch);
|
}
|
|
private BladeFile putImportFail(ExcelUtils.ExcelDataDTO excelDataDTO, List<CheckResultDTO> checkResultDTOS) {
|
int pass = CommonConstant.ENABLE.intValue();
|
Iterator<CheckResultDTO> it = checkResultDTOS.iterator();
|
while (true) {
|
if (it.hasNext()) {
|
if (Func.equals(it.next().getCode(), CommonConstant.DEACTIVATE)) {
|
pass = CommonConstant.DEACTIVATE.intValue();
|
break;
|
}
|
} else {
|
break;
|
}
|
}
|
if (Func.equals(Integer.valueOf(pass), CommonConstant.ENABLE)) {
|
return null;
|
}
|
List<Map<String, String>> data = excelDataDTO.getData();
|
for (int i = 0; i < data.size(); i++) {
|
Map<String, String> map = data.get(i);
|
CheckResultDTO checkResultDTO = checkResultDTOS.get(i);
|
if (Func.equals(checkResultDTO.getCode(), CommonConstant.DEACTIVATE)) {
|
map.put(ExcelConstant.FAIL_REASON, checkResultDTO.getError());
|
}
|
}
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
Workbook workbook = ExcelUtils.generateFail(excelDataDTO);
|
try {
|
workbook.write(bos);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
InputStream is = new ByteArrayInputStream(bos.toByteArray());
|
return this.ossBuilder.systemTemplate().putFile("计划导入模板错误.xlsx", is);
|
}
|
|
List<PlanImportVO> cover(List<Map<String, String>> sysData) {
|
List<PlanImportVO> planImportVOS = new ArrayList<>();
|
sysData.forEach(item -> {
|
PlanImportVO planImportVO = new PlanImportVO();
|
planImportVOS.add(planImportVO);
|
item.forEach((k, v) -> {
|
Field[] declaredFields = PlanImportVO.class.getDeclaredFields();
|
for (Field field : declaredFields) {
|
try {
|
if (Func.equals(field.getName(), k)) {
|
field.setAccessible(true);
|
field.set(planImportVO, v);
|
}
|
} catch (IllegalAccessException e) {
|
e.printStackTrace();
|
}
|
}
|
});
|
});
|
return planImportVOS;
|
}
|
|
private Function<List<Map<String, String>>, List<CheckParamDTO>> getCheckFunction(List<Map<String, String>> map) {
|
return dto -> {
|
CustomTemplate customTemplate;
|
map.addAll(dto);
|
List<CheckParamDTO> checkParamDTOS = new ArrayList<>();
|
List<String> types = new ArrayList<>();
|
map.forEach(item -> {
|
if (item.containsKey(PLAN_TYPE_CODE)) {
|
String typeId = (String) item.get(PLAN_TYPE_CODE);
|
if (Func.isNotBlank(typeId)) {
|
types.add(typeId);
|
}
|
}
|
});
|
LambdaQueryWrapper<CustomTemplate> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode());
|
|
|
lambdaQueryWrapper.and(wrapper -> {
|
(wrapper.in(types.size() > 0, (v0) -> {
|
return v0.getTemplateName();
|
}, types).or()).eq((v0) -> {
|
return v0.getDefaultTemplate();
|
}, CommonConstant.ENABLE);
|
});
|
List<CustomTemplate> templates = this.templateService.list(lambdaQueryWrapper);
|
Optional<CustomTemplate> customTemplateOptional = templates.stream().filter(item2 -> {
|
return Func.equals(item2.getDefaultTemplate(), CommonConstant.ENABLE);
|
}).findFirst();
|
CustomTemplate defaultTemplate = null;
|
if (customTemplateOptional.isPresent()) {
|
defaultTemplate = customTemplateOptional.get();
|
}
|
|
Map<String, CustomTemplate> templateMap = templates.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getTemplateName();
|
}, item3 -> {
|
return item3;
|
}));
|
List<Long> templateIds = templates.stream().map(CustomTemplate::getId).collect(Collectors.toList());
|
|
List<CustomTemplateFieldRelationDTO> customTemplateFieldRelationDTOS = this.customTemplateFieldRelationMapper.getImportFields(templateIds);
|
Map<Long, List<CustomTemplateFieldRelationDTO>> relation = (Map) customTemplateFieldRelationDTOS.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getTemplateId();
|
}));
|
for (int i = 0; i < dto.size(); i++) {
|
CheckParamDTO checkParamDTO = new CheckParamDTO();
|
checkParamDTOS.add(checkParamDTO);
|
Map<String, String> specialData = MapUtil.newHashMap();
|
Map<String, String> item4 = (Map) dto.get(i);
|
if (item4.containsKey(PLAN_TYPE_CODE)) {
|
String typeId = item4.get(PLAN_TYPE_CODE);
|
if (Func.isBlank(typeId)) {
|
customTemplate = defaultTemplate;
|
specialData.put(PLAN_TYPE_CODE, customTemplate.getTemplateName());
|
} else if (!templateMap.containsKey(typeId)) {
|
break;
|
} else {
|
customTemplate = templateMap.get(typeId);
|
}
|
} else {
|
customTemplate = defaultTemplate;
|
}
|
List<CustomTemplateFieldRelationDTO> relations = relation.get(customTemplate.getId());
|
Map<String, CustomTemplateFieldRelationDTO> relationDTOMap = (Map) relations.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getFieldCode();
|
}, j -> {
|
return j;
|
}));
|
checkParamDTO.setRelationMap(relationDTOMap);
|
checkParamDTO.setCustomTemplate(customTemplate);
|
checkParamDTO.setSpecialData(specialData);
|
}
|
return checkParamDTOS;
|
};
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
private List<Plan> checkAndHandleSysPlan(List<CheckResultDTO> checkResultDTOS, List<PlanImportVO> planExcels) {
|
PlanImportCheckMapDTO mapDTO = getCraftVersionMap(planExcels);
|
Map<String, CraftRouting> craftMap = mapDTO.getCraftMap();
|
Map<String, BomVersion> bomVersionMap = mapDTO.getBomVersionMap();
|
Map<String, Product> productMap = mapDTO.getProductMap();
|
Map<Long, List<Long>> planTypeProductMap = mapDTO.getPlanTypeProductMap();
|
Map<String, CustomTemplate> planTypeMap = mapDTO.getPlanTypeMap();
|
Map<Long, Map<String, Long>> craftVersionMap = mapDTO.getCraftVersionMap();
|
List<String> codes = new ArrayList<>();
|
List<Plan> list = list(Wrappers.<Plan>lambdaQuery().select(Plan::getCode));
|
/*
|
List<Plan> list = list(Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
|
return v0.getCode();
|
}}));*/
|
if (Func.isNotEmpty(list)) {
|
codes = list.stream().map(Plan::getCode).collect(Collectors.toList());
|
/*
|
codes = (List) list.stream().map((v0) -> {
|
return v0.getCode();
|
}).collect(Collectors.toList());
|
*/
|
}
|
List<Plan> plans = new ArrayList<>();
|
for (int i = 0; i < planExcels.size(); i++) {
|
CheckResultDTO checkResultDTO = checkResultDTOS.get(i);
|
if (!Func.equals(CommonConstant.DEACTIVATE, checkResultDTO.getCode())) {
|
String extendField = checkResultDTO.getJson();
|
Plan plan = new Plan();
|
plan.setExtendField(extendField);
|
PlanImportVO excelVO = planExcels.get(i);
|
plan.setCode(excelVO.getCode());
|
if (Func.isNotEmpty(plan.getCode()) && codes.contains(plan.getCode())) {
|
checkResultDTO.error(MessageUtils.message("plan.code.already.exist", new Object[0]));
|
} else {
|
try {
|
plan.setPlanStartTime(DateUtils.parseDate(excelVO.getPlanStartTime(), new String[]{DateConstant.PATTERN_DATE_TIME, DateConstant.PATTERN_DATE}));
|
plan.setPlanEndTime(DateUtils.parseDate(excelVO.getPlanEndTime(), new String[]{DateConstant.PATTERN_DATE_TIME, DateConstant.PATTERN_DATE}));
|
checkPlanTime(plan.getPlanStartTime(), plan.getPlanEndTime());
|
String categoryLabel = excelVO.getCategoryLabel();
|
plan.setCategory(PlanCategoryEnum.of(categoryLabel));
|
if (Func.isEmpty(plan.getCategory())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.category.data.error", new Object[0]));
|
} else if (!craftMap.containsKey(excelVO.getCraftId())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.non-existent", new Object[0]));
|
} else {
|
CraftRouting craftRouting = craftMap.get(excelVO.getCraftId());
|
plan.setCraftId(craftRouting.getId());
|
plan.setCraftName(craftRouting.getName());
|
if (!craftVersionMap.containsKey(craftRouting.getId())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.craft.version.non-existent", new Object[0]));
|
} else {
|
Map<String, Long> versionMap = craftVersionMap.get(craftRouting.getId());
|
if (!versionMap.containsKey(excelVO.getCraftVersion())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.and.craft.version.mismatch", new Object[0]));
|
} else {
|
Long craftVersionId = versionMap.get(excelVO.getCraftVersion());
|
plan.setCraftVersion(craftVersionId);
|
plan.setCraftVersionName(excelVO.getCraftVersion());
|
CustomTemplate customTemplate = null;
|
if (Func.isNotBlank(excelVO.getTypeId())) {
|
if (!planTypeMap.containsKey(excelVO.getTypeId())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.type.not.exist", new Object[0]));
|
} else {
|
customTemplate = planTypeMap.get(excelVO.getTypeId());
|
plan.setTypeId(customTemplate.getId());
|
}
|
} else {
|
Collection<CustomTemplate> customTemplates = planTypeMap.values();
|
customTemplates.forEach(item -> {
|
if (Func.equals(item.getDefaultTemplate(), CommonConstant.ENABLE)) {
|
plan.setTypeId(item.getId());
|
}
|
});
|
}
|
if (Func.equals(plan.getCategory(), PlanCategoryEnum.PRODUCTION.getCode())) {
|
if (Func.isEmpty(excelVO.getProductId())) {
|
checkResultDTO.error(MessageUtils.message("cps.product.code.can.not.be.empty", new Object[0]));
|
} else if (!productMap.containsKey(excelVO.getProductId())) {
|
checkResultDTO.error(MessageUtils.message("cps.product.code.not.exist", new Object[0]));
|
} else {
|
Product product = productMap.get(excelVO.getProductId());
|
plan.setProductId(product.getId());
|
plan.setProductName(product.getName());
|
plan.setProductCode(product.getCode());
|
if (Func.isNotEmpty(customTemplate) && Func.equals(customTemplate.getDefaultTemplate(), CommonConstant.DEACTIVATE) && Func.isNotEmpty(planTypeProductMap) && planTypeProductMap.containsKey(customTemplate.getId())) {
|
List<Long> itemIds = planTypeProductMap.get(customTemplate.getId());
|
if (!itemIds.contains(product.getTypeId())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.type.and.product.mismatch", new Object[0]));
|
}
|
}
|
if (!Func.equals(craftRouting.getProductId(), plan.getProductId())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.and.product.mismatch", new Object[0]));
|
} else if (Func.isNotBlank(excelVO.getBomVersion())) {
|
if (!bomVersionMap.containsKey(craftRouting.getId() + "-" + excelVO.getCraftVersion())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
|
} else {
|
BomVersion bomVersion = bomVersionMap.get(craftRouting.getId() + "-" + excelVO.getCraftVersion());
|
if (!Func.equals(bomVersion.getVersion(), excelVO.getBomVersion())) {
|
checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
|
} else {
|
plan.setBomId(bomVersion.getId());
|
plan.setBomVersion(bomVersion.getVersion());
|
}
|
}
|
}
|
}
|
}
|
String planNum = excelVO.getPlanNum();
|
if (Func.isNumeric(excelVO.getPlanNum()) && Integer.parseInt(planNum) > 0) {
|
plan.setPlanNum(Integer.valueOf(Integer.parseInt(planNum)));
|
plan.setStandardModel(excelVO.getStandardModel());
|
plan.setIndentCode(excelVO.getIndentCode());
|
plan.setUnassignedNum(plan.getPlanNum());
|
plans.add(plan);
|
} else {
|
checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
|
}
|
}
|
}
|
}
|
} catch (ParseException e) {
|
e.printStackTrace();
|
checkResultDTO.error(MessageUtils.message("excel.import.machine.time.error", new Object[0]));
|
}
|
}
|
}
|
}
|
return plans;
|
}
|
|
private PlanImportCheckMapDTO getCraftVersionMap(List<PlanImportVO> planExcels) {
|
List<CustomTemplate> customTemplates;
|
PlanImportCheckMapDTO craftRoutingDTO = new PlanImportCheckMapDTO();
|
List<String> productCodes = new ArrayList<>();
|
List<String> craftNames = new ArrayList<>();
|
List<String> bomVersions = new ArrayList<>();
|
List<String> craftVersions = new ArrayList<>();
|
List<String> planTypes = new ArrayList<>();
|
planExcels.forEach(item -> {
|
if (Func.isNotEmpty(item.getProductId())) {
|
productCodes.add(item.getProductId());
|
}
|
if (Func.isNotEmpty(item.getCraftId())) {
|
craftNames.add(item.getCraftId());
|
}
|
if (Func.isNotEmpty(item.getCraftVersion())) {
|
craftVersions.add(item.getCraftVersion());
|
}
|
if (Func.isNotEmpty(item.getBomVersion())) {
|
bomVersions.add(item.getBomVersion());
|
}
|
if (Func.isNotEmpty(item.getTypeId())) {
|
planTypes.add(item.getTypeId());
|
}
|
});
|
if (Func.isNotEmpty(productCodes)) {
|
List<Product> products = this.productService.list(Wrappers.<Product>lambdaQuery().in(Product::getCode, productCodes));
|
/*
|
List<Product> products = this.productService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getCode();
|
}, productCodes));*/
|
|
craftRoutingDTO.setProductMap(products.stream().collect(Collectors.toMap(Product::getCode, item -> item)));
|
/*
|
craftRoutingDTO.setProductMap((Map) products.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getCode();
|
}, item2 -> {
|
return item2;
|
})));*/
|
}
|
if (Func.isNotEmpty(planTypes)) {
|
customTemplates = this.templateService.list(
|
Wrappers.<CustomTemplate>lambdaQuery()
|
.eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
|
.in(CustomTemplate::getTemplateName, planTypes));
|
/*
|
customTemplates = this.templateService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getBusinessType();
|
}, BusinessTypeEnums.PLAN_ORDER.getCode())).in((v0) -> {
|
return v0.getTemplateName();
|
}, planTypes));
|
*/
|
} else {
|
customTemplates = this.templateService.list(
|
Wrappers.<CustomTemplate>lambdaQuery()
|
.eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
|
.eq(CustomTemplate::getDefaultTemplate, CommonConstant.ENABLE));
|
/*
|
customTemplates = this.templateService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getBusinessType();
|
}, BusinessTypeEnums.PLAN_ORDER.getCode())).eq((v0) -> {
|
return v0.getDefaultTemplate();
|
}, CommonConstant.ENABLE));
|
*/
|
}
|
if (Func.isNotEmpty(customTemplates)) {
|
craftRoutingDTO.setPlanTypeMap(customTemplates.stream().collect(Collectors.toMap(CustomTemplate::getTemplateName, item -> item)));
|
|
List<Long> templateIds = (List<Long>)customTemplates.stream().map(CustomTemplate::getId).collect(Collectors.toList());
|
|
List<CustomTemplateBusiness> businesses = this.customTemplateBusinessService.list(Wrappers.<CustomTemplateBusiness>lambdaQuery()
|
.select(CustomTemplateBusiness::getTemplateId, CustomTemplateBusiness::getRelationId).eq(CustomTemplateBusiness::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
|
.in(CustomTemplateBusiness::getTemplateId, templateIds));
|
craftRoutingDTO.setPlanTypeProductMap(businesses.stream().collect(Collectors.groupingBy(CustomTemplateBusiness::getTemplateId, Collectors.mapping(CustomTemplateBusiness::getRelationId, Collectors.toList()))));
|
/*
|
List<CustomTemplateBusiness> businesses = this.customTemplateBusinessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
|
return v0.getTemplateId();
|
}, (v0) -> {
|
return v0.getRelationId();
|
}}).eq((v0) -> {
|
return v0.getBusinessType();
|
}, BusinessTypeEnums.PLAN_ORDER.getCode())).in((v0) -> {
|
return v0.getTemplateId();
|
}, templateIds));
|
|
craftRoutingDTO.setPlanTypeProductMap((Map) businesses.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getTemplateId();
|
}, Collectors.mapping((v0) -> {
|
return v0.getRelationId();
|
}, Collectors.toList()))));
|
*/
|
}
|
if (Func.isEmpty(craftNames)) {
|
return craftRoutingDTO;
|
}
|
List<CraftRouting> craftRoutingList = this.craftRoutingService.list(Wrappers.<CraftRouting>lambdaQuery().in(CraftRouting::getName, craftNames));
|
if (Func.isEmpty(craftRoutingList)) {
|
return craftRoutingDTO;
|
}
|
|
craftRoutingDTO.setCraftMap(craftRoutingList.stream().collect(Collectors.toMap(CraftRouting::getName, item -> item)));
|
|
Set<Long> craftIds = craftRoutingList.stream().map(CraftRouting::getId).collect(Collectors.toSet());
|
if (Func.isEmpty(craftVersions)) {
|
return craftRoutingDTO;
|
}
|
List<ProductionCraftVersion> versions = this.productionCraftVersionService.list(Wrappers.<ProductionCraftVersion>lambdaQuery().in(ProductionCraftVersion::getCraftId, craftIds));
|
/*
|
List<ProductionCraftVersion> versions = this.productionCraftVersionService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getCraftId();
|
}, craftIds));*/
|
if (Func.isEmpty(versions)) {
|
return craftRoutingDTO;
|
}
|
craftRoutingDTO.setCraftVersionMap(versions.stream().collect(Collectors.groupingBy(ProductionCraftVersion::getCraftId, Collectors.toMap(ProductionCraftVersion::getName, ProductionCraftVersion::getId))));
|
|
List<String> craftVersionNames = versions.stream().map(ProductionCraftVersion::getName).collect(Collectors.toList());
|
if (Func.isNotEmpty(bomVersions)) {
|
List<BomVersion> bomVersionList = this.bomVersionService.list(Wrappers.<BomVersion>lambdaQuery().in(BomVersion::getCraftId, craftIds).in(BomVersion::getCraftVersion, craftVersionNames));
|
craftRoutingDTO.setBomVersionMap(bomVersionList.stream().collect(Collectors.toMap(item -> item.getCraftId() + "-" + item.getCraftVersion(), item -> item)));
|
}
|
return craftRoutingDTO;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public BladeFile planExport(PlanQueryVO planQueryVO) {
|
Long planTypeId = planQueryVO.getTypeId();
|
List<CustomTemplateFieldColumnVO> columns = this.customTemplateFieldService.getColumns(planTypeId, ConfigTypeEnum.VIEW_PAGE.getCode());
|
Map<String, CustomTemplateFieldColumnVO> fieldCodeMap = (Map) columns.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getFieldCode();
|
}, item -> {
|
return item;
|
}));
|
IPage<Plan> planPage = listPage(Page.of(1L, -1L), planQueryVO);
|
List<Plan> plans = planPage.getRecords();
|
ExcelUtils.ExcelExportDTO excelExportDTO = ExcelUtils.buildExcelExportDTO();
|
columns.forEach(item2 -> {
|
if (Func.equals(item2.getSystemField(), CommonConstant.ENABLE)) {
|
if (Func.equals(item2.getSupportExport(), CommonConstant.ENABLE)) {
|
excelExportDTO.addTableHead(item2.getFieldName(), Func.equals(item2.getMustField(), CommonConstant.ENABLE));
|
return;
|
}
|
return;
|
}
|
excelExportDTO.addTableHead(item2.getFieldName(), Func.equals(item2.getMustField(), CommonConstant.ENABLE));
|
});
|
List<PlanExportVO> planExports = (List) plans.stream().map(item3 -> {
|
PlanExportVO planExportVO = new PlanExportVO();
|
planExportVO.setCategoryLabel(PlanCategoryEnum.of(item3.getCategory()));
|
planExportVO.setProductTypeLabel(item3.getProductTypeLabel());
|
if (Func.isNotEmpty(item3.getPlanStartTime())) {
|
planExportVO.setPlanStartTime(DateUtil.DATE_FORMAT.format(item3.getPlanStartTime()));
|
}
|
if (Func.isNotEmpty(item3.getPlanEndTime())) {
|
planExportVO.setPlanEndTime(DateUtil.DATE_FORMAT.format(item3.getPlanEndTime()));
|
}
|
planExportVO.setReportSituation(item3.getReportSituation());
|
if (Func.isNotEmpty(item3.getReportNum())) {
|
planExportVO.setReportNum(String.valueOf(item3.getReportNum()));
|
}
|
if (Func.isNotEmpty(item3.getQualifyNum())) {
|
planExportVO.setQualifyNum(String.valueOf(item3.getQualifyNum()));
|
}
|
if (Func.isNotEmpty(item3.getStartTime())) {
|
planExportVO.setStartTime(DateUtil.format(item3.getStartTime(), DateConstant.PATTERN_DATE_TIME1));
|
}
|
if (Func.isNotEmpty(item3.getEndTime())) {
|
planExportVO.setEndTime(DateUtil.format(item3.getEndTime(), DateConstant.PATTERN_DATE_TIME1));
|
}
|
planExportVO.setCode(item3.getCode());
|
planExportVO.setIndentCode(item3.getIndentCode());
|
planExportVO.setPlanStatusLabel(PlanStatusEnum.of(item3.getPlanStatus()).getName());
|
if (Func.isNotEmpty(item3.getPlanProgress())) {
|
planExportVO.setPlanProgress(Double.valueOf(item3.getPlanProgress()) + "%");
|
}
|
planExportVO.setProductCode(item3.getProductCode());
|
planExportVO.setStandardModel(item3.getStandardModel());
|
planExportVO.setPlanNum("" + item3.getPlanNum());
|
planExportVO.setExtendField(item3.getExtendField());
|
return planExportVO;
|
}).collect(Collectors.toList());
|
Field[] fields = PlanExportVO.class.getDeclaredFields();
|
for (PlanExportVO plan : planExports) {
|
Map<String, String> item4 = MapUtil.newHashMap();
|
excelExportDTO.addData(item4);
|
for (Field field : fields) {
|
field.setAccessible(true);
|
try {
|
if (fieldCodeMap.containsKey(field.getName())) {
|
CustomTemplateFieldColumnVO customTemplateFieldColumnVO = fieldCodeMap.get(field.getName());
|
if (!Func.equals(customTemplateFieldColumnVO.getSystemField(), CommonConstant.ENABLE) || !Func.equals(customTemplateFieldColumnVO.getSupportExport(), CommonConstant.ENABLE)) {
|
break;
|
}
|
Object o = field.get(plan);
|
if (Func.isNotEmpty(o)) {
|
item4.put(customTemplateFieldColumnVO.getFieldName(), String.valueOf(o));
|
} else {
|
item4.put(customTemplateFieldColumnVO.getFieldName(), "");
|
}
|
}
|
} catch (IllegalAccessException e) {
|
e.printStackTrace();
|
}
|
}
|
String extendField = plan.getExtendField();
|
JSONObject jsonObject = JSONUtil.parseObj(extendField);
|
jsonObject.forEach((key, value) -> {
|
if (!fieldCodeMap.containsKey(key)) {
|
return;
|
}
|
CustomTemplateFieldColumnVO customTemplateFieldColumnVO2 = (CustomTemplateFieldColumnVO) fieldCodeMap.get(key);
|
String fieldName = customTemplateFieldColumnVO2.getFieldName();
|
String v = value.toString();
|
if (JSONUtil.isJsonArray(value.toString())) {
|
List<String> vs = JSONUtil.toList(JSONUtil.parseArray(value.toString()), String.class);
|
v = StringUtil.join(vs, ",");
|
}
|
item4.put(fieldName, v);
|
});
|
}
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
Workbook workbook = ExcelUtils.generateExport(excelExportDTO);
|
try {
|
workbook.write(bos);
|
} catch (IOException e2) {
|
e2.printStackTrace();
|
}
|
InputStream is = new ByteArrayInputStream(bos.toByteArray());
|
return this.ossBuilder.systemTemplate().putFile("计划数据.xlsx", is);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public BladeFile planTemplate(Long templateId) {
|
return this.templateService.getTemplate(BusinessTypeEnums.PLAN_ORDER.getCode());
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public void create(PlanSubmitVO planVO) {
|
checkPlanIsCreate(planVO);
|
Plan plan = PlanConvert.INSTANCE.convert(PlanConvert.INSTANCE.convert(planVO));
|
plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
|
plan.setUnassignedNum(plan.getPlanNum());
|
CustomTemplate customTemplate = (CustomTemplate) this.templateService.getById(plan.getTypeId());
|
plan.setName(!Objects.isNull(customTemplate) ? customTemplate.getTemplateName() : "");
|
save(plan);
|
saveProcessBatch(plan);
|
}
|
|
private void saveProcessBatch(Plan plan) {
|
List<PlanProcessInfoDTO> planProcesses = this.planProcessMapper.getProcessByCraftIdAndVersionId(plan.getCraftId(), plan.getCraftVersion());
|
if (Func.isEmpty(planProcesses)) {
|
return;
|
}
|
Map<Long, PlanProcessInfoDTO> dtoMap = planProcesses.stream().collect(Collectors.toMap(PlanProcessInfoDTO::getCraftProcessId, p -> p, (old, newVal) -> old));
|
planProcesses.forEach(planProcess -> {
|
planProcess.setPlanId(plan.getId());
|
planProcess.setTypeName(plan.getName());
|
if (Func.isEmpty(planProcess.getMainSequenceId())) {
|
return;
|
}
|
PlanProcessInfoDTO planProcessInfoDTO = (PlanProcessInfoDTO) dtoMap.get(planProcess.getMainSequenceId());
|
if (Func.isEmpty(planProcessInfoDTO)) {
|
return;
|
}
|
planProcess.setMainSequenceId(planProcessInfoDTO.getId());
|
});
|
this.planProcessService.saveBatch(PlanProcessConvert.INSTANCE.convertDTO(planProcesses));
|
}
|
|
private void checkPlanIsCreate(PlanSubmitVO planVO) {
|
planBaseCheck(planVO.getPlanNum(), planVO.getPlanStartTime(), planVO.getPlanEndTime(), planVO.getExtendField());
|
if (Func.isEmpty(planVO.getCode())) {
|
planVO.setCode(planCodeGenerator(planVO));
|
}
|
if (planCodeIsDuplicate(planVO).booleanValue()) {
|
throw new ServiceException(MessageUtils.message("plan.code.already.exist", new Object[0]));
|
}
|
}
|
|
private void checkPlanTime(Date planStartTime, Date planEndTime) {
|
if (planStartTime.after(planEndTime) || DateUtil.toDate(LocalDate.now()).after(planEndTime)) {
|
throw new ServiceException(MessageUtils.message("cps.plan.start.time.cannot.be.greater.than.the.end.time", new Object[0]));
|
}
|
}
|
|
private Boolean planCodeIsDuplicate(PlanSubmitVO planSubmitVO) {
|
long count = count(Wrappers.<Plan>lambdaQuery().eq(Plan::getCode, planSubmitVO.getCode()).ne(Func.isNotEmpty(planSubmitVO.getId()), Plan::getId, planSubmitVO.getId()));
|
return Boolean.valueOf(count > 0);
|
}
|
|
private String planCodeGenerator(PlanSubmitVO planSubmitVO) {
|
String code = this.codeGeneratorService.getGeneratorCode(planSubmitVO, MetaTypeEnum.PLAN.getCode());
|
if (StrUtil.isEmpty(code)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.maintain.coding.rules", new Object[0]));
|
}
|
return code;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean finish(Long planId) {
|
Plan plan = checkFinishConditionBefore(planId);
|
List<OrderReportRecord> insertRecordList = new ArrayList<>();
|
List<OrderProcess> updateProcessList = new ArrayList<>();
|
List<Order> planOrderList = this.orderService.list(Wrappers.<Order>lambdaQuery().eq(Order::getPlanId, planId).ne(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode()));
|
List<OrderProcess> planOrderProcessList = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getPlanId, planId).isNull(OrderProcess::getMainSequenceId));
|
if (Func.isNotEmpty(planOrderProcessList)) {
|
Map<Long, List<OrderProcess>> orderProcessListMap = planOrderProcessList.stream().collect(Collectors.groupingBy(OrderProcess::getOrderId));
|
|
Date now = DateUtil.now();
|
for (Order order : planOrderList) {
|
List<OrderProcess> currentProcessList = orderProcessListMap.get(order.getId());
|
if (!Func.isEmpty(currentProcessList)) {
|
currentProcessList.sort(Comparator.comparing((v0) -> {
|
return v0.getSort();
|
}));
|
Integer currentInputNum = order.getAssignNum();
|
for (OrderProcess orderProcess : currentProcessList) {
|
if (!currentInputNum.equals(0) && currentInputNum.intValue() > orderProcess.getQualifyNum().intValue() + orderProcess.getScrappedNum().intValue()) {
|
insertRecordList.add(packageRecord(order.getPlanId(), order, Integer.valueOf(currentInputNum.intValue() - (orderProcess.getQualifyNum().intValue() + orderProcess.getScrappedNum().intValue())), orderProcess, now));
|
}
|
orderProcess.setProcessStatus(OrderProcessStatusEnum.TO_BE_FINISHED.getCode());
|
orderProcess.setEndTime(Func.isEmpty(orderProcess.getEndTime()) ? now : orderProcess.getEndTime());
|
orderProcess.setStartTime(Func.isEmpty(orderProcess.getStartTime()) ? now : orderProcess.getStartTime());
|
orderProcess.setInputNum(currentInputNum);
|
orderProcess.setScrappedNum(Integer.valueOf(currentInputNum.intValue() - orderProcess.getQualifyNum().intValue()));
|
updateProcessList.add(orderProcess);
|
currentInputNum = orderProcess.getQualifyNum();
|
}
|
}
|
}
|
}
|
if (Func.isNotEmpty(insertRecordList)) {
|
this.orderReportRecordService.saveBatch(insertRecordList);
|
}
|
if (Func.isNotEmpty(updateProcessList)) {
|
this.orderProcessService.updateBatchById(updateProcessList);
|
}
|
this.orderService.update(Wrappers.<Order>lambdaUpdate().eq(Order::getPlanId, planId).ne(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode())
|
.set(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode()).set(Order::getEndTime, new Date())
|
.setSql("scrapped_num = assign_num - qualify_num"));
|
/*
|
this.orderService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().eq((v0) -> {
|
return v0.getPlanId();
|
}, planId)).ne((v0) -> {
|
return v0.getOrderStatus();
|
}, OrderStatusEnum.COMPLETE.getCode())).set((v0) -> {
|
return v0.getOrderStatus();
|
}, OrderStatusEnum.COMPLETE.getCode())).set((v0) -> {
|
return v0.getEndTime();
|
}, new Date())).setSql("scrapped_num = assign_num - qualify_num"));
|
*/
|
return Boolean.valueOf(update(Wrappers.<Plan>lambdaUpdate().eq(Plan::getId, planId).set(Plan::getPlanStatus, PlanStatusEnum.FINISHED.getCode()).set(Plan::getReportNum, plan.getPlanNum())
|
.set(Plan::getEndTime, new Date()).setSql("scrapped_num = scrapped_num + (plan_num - " + plan.getReportNum() + ")")));
|
}
|
|
@NotNull
|
private Plan checkFinishConditionBefore(Long planId) {
|
Plan plan = getOne(Wrappers.<Plan>lambdaQuery().eq(Plan::getId, planId));
|
long count = this.orderReportRecordService.count(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId).eq(OrderReportRecord::getRecordStatus, CommonConstant.DISABLE));
|
if (Func.isEmpty(plan) || !CHECK_STATUS_LIST.contains(plan.getPlanStatus()) || count > 0) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.finish", new Object[0]));
|
}
|
if (plan.getUnassignedNum().intValue() > 0) {
|
throw new ServiceException(MessageUtils.message("cps.plan.distributed.before.finish", new Object[0]));
|
}
|
|
List<OrderReportRecord> planOrderRecordList = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId));
|
|
if (Func.isNotEmpty(planOrderRecordList) && planOrderRecordList.stream().anyMatch(record -> {
|
return record.getRecordStatus().equals(OrderReportRecordStatusEnum.STARTED.getCode());
|
})) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.finish", new Object[0]));
|
}
|
return plan;
|
}
|
|
private OrderReportRecord packageRecord(Long planId, Order order, Integer scrappedNum, OrderProcess orderProcess, Date now) {
|
OrderReportRecord orderReportRecord = new OrderReportRecord();
|
orderReportRecord.setSystemOrOrdinary(CoProductionEnum.SystemOrOrdinaryStatus.SYSTEM.getCode());
|
orderReportRecord.setPlanId(planId);
|
orderReportRecord.setOrderId(order.getId());
|
orderReportRecord.setProcessId(orderProcess.getId());
|
orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.FINISHED.getCode());
|
orderReportRecord.setWorkshopTime(now);
|
orderReportRecord.setStartTime(now);
|
orderReportRecord.setQualifyNum(0);
|
orderReportRecord.setScrappedNum(scrappedNum);
|
return orderReportRecord;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean close(Long planId) {
|
checkPlanIsClose(planId);
|
this.orderService.update(Wrappers.<Order>lambdaUpdate().set(Order::getOrderStatus, OrderStatusEnum.CLOSE.getCode()).eq(Order::getPlanId, planId));
|
this.orderProcessService.update(Wrappers.<OrderProcess>lambdaUpdate().set(OrderProcess::getProcessStatus, OrderProcessStatusEnum.CLOSE.getCode()).eq(OrderProcess::getPlanId, planId));
|
return Boolean.valueOf(update(Wrappers.<Plan>lambdaUpdate().set(Plan::getPlanStatus, PlanStatusEnum.CLOSE.getCode()).eq(Plan::getId, planId)));
|
}
|
|
private void checkPlanIsClose(Long planId) {
|
Plan plan = getPlan(String.valueOf(planId));
|
boolean flag = plan.getPlanStatus().equals(PlanStatusEnum.CLOSE.getCode()) || plan.getPlanStatus().equals(PlanStatusEnum.FINISHED.getCode());
|
long count = this.orderReportRecordService.count(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId).eq(OrderReportRecord::getRecordStatus, CommonConstant.DISABLE));
|
|
if (flag || count > 0) {
|
throw new ServiceException(MessageUtils.message("cps.plan.can.not.close", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean editWorkstation(OrderEditWorkstationVO orderEditWorkstationVO) {
|
Order order = (Order)this.orderService.getOne(Wrappers.<Order>lambdaQuery().eq(Order::getId, orderEditWorkstationVO.getOrderId()));
|
|
if (Func.isEmpty(order) || OrderStatusEnum.CLOSE.getCode().equals(order.getOrderStatus()) || OrderStatusEnum.COMPLETE.getCode().equals(order.getOrderStatus())) {
|
throw new ServiceException(MessageUtils.message("cps.plan.order.can.not.edit", new Object[0]));
|
}
|
List<OrderProcess> orderProcessUpdateList = new ArrayList<>();
|
List<OrderWorkstation> orderWorkstationSaveList = new ArrayList<>();
|
List<OrderWorkstation> delOrderWorkstations = new ArrayList<>();
|
List<OrderProcessEditWorkStationVO> processWorkstationList = orderEditWorkstationVO.getOrderProcessEditWorkStationVOList();
|
List<OrderWorkstation> oldOrderWorkstations = this.orderWorkstationService.list(Wrappers.<OrderWorkstation>lambdaQuery()
|
.eq(OrderWorkstation::getOrderId, orderEditWorkstationVO.getOrderId()));
|
/*
|
List<OrderWorkstation> oldOrderWorkstations = this.orderWorkstationService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getOrderId();
|
}, orderEditWorkstationVO.getOrderId()));*/
|
Map<Long, List<OrderWorkstation>> oldOrderWorkstationMap = Func.isNotEmpty(oldOrderWorkstations) ? (Map) oldOrderWorkstations.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getProcessId();
|
})) : new HashMap<>(16);
|
for (OrderProcessEditWorkStationVO orderProcessEditWorkStationVO : processWorkstationList) {
|
List<String> workIds = Func.toStrList(",", orderProcessEditWorkStationVO.getWorkstationId());
|
List<OrderWorkstation> oldWorkstations = oldOrderWorkstationMap.containsKey(orderProcessEditWorkStationVO.getOrderProcessId()) ? oldOrderWorkstationMap.get(orderProcessEditWorkStationVO.getOrderProcessId()) : new ArrayList<>();
|
if (oldWorkstations.stream().anyMatch(workstation -> {
|
return workstation.getWorkstationStatus().equals(WorkstationStatusEnum.started.getCode()) && !workIds.contains(String.valueOf(workstation.getWorkstationId()));
|
})) {
|
throw new ServiceException(MessageUtils.message("cps.plan.order.workstaion.already.work", new Object[0]));
|
}
|
OrderProcess orderProcess = new OrderProcess();
|
orderProcess.setId(orderProcessEditWorkStationVO.getOrderProcessId());
|
orderProcess.setWorkstationId(orderProcessEditWorkStationVO.getWorkstationId());
|
orderProcess.setWorkstationName(orderProcessEditWorkStationVO.getWorkstationName());
|
orderProcessUpdateList.add(orderProcess);
|
packageProcessWorkstation(order, orderWorkstationSaveList, oldWorkstations, orderProcess);
|
oldWorkstations.forEach(old -> {
|
if (!workIds.contains(String.valueOf(old.getWorkstationId()))) {
|
delOrderWorkstations.add(old);
|
}
|
});
|
}
|
if (Func.isNotEmpty(delOrderWorkstations)) {
|
this.orderWorkstationService.removeBatchByIds(delOrderWorkstations);
|
}
|
if (Func.isNotEmpty(orderWorkstationSaveList)) {
|
this.orderWorkstationService.saveBatch(orderWorkstationSaveList);
|
}
|
return Boolean.valueOf(this.orderProcessService.updateBatchById(orderProcessUpdateList));
|
}
|
|
private void packageProcessWorkstation(Order order, List<OrderWorkstation> orderWorkstationSaveList, List<OrderWorkstation> oldWorkstations, OrderProcess orderProcess) {
|
if (Func.isNotEmpty(orderProcess.getWorkstationId())) {
|
List<Long> oldWorkstationIds = (List) oldWorkstations.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
String[] workstationIdSplit = orderProcess.getWorkstationId().split(",");
|
String[] workstationNameSplit = orderProcess.getWorkstationName().split(",");
|
for (int i = 0; i < workstationIdSplit.length; i++) {
|
if (!oldWorkstationIds.contains(Long.valueOf(workstationIdSplit[i]))) {
|
OrderWorkstation orderWorkstation = new OrderWorkstation();
|
orderWorkstation.setWorkstationId(Long.valueOf(workstationIdSplit[i]));
|
if (Func.isNotEmpty(workstationNameSplit) && workstationNameSplit.length == workstationIdSplit.length) {
|
orderWorkstation.setWorkstationName(workstationNameSplit[i]);
|
}
|
orderWorkstation.setWorkstationStatus(WorkstationStatusEnum.UNDRESSED.getCode());
|
orderWorkstation.setPlanId(order.getPlanId());
|
orderWorkstation.setOrderId(order.getId());
|
orderWorkstation.setProcessId(orderProcess.getId());
|
orderWorkstationSaveList.add(orderWorkstation);
|
}
|
}
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public IPage<Plan> listPage(IPage<Plan> page, PlanQueryVO planQueryVO) {
|
QueryWrapper<Plan> queryWrapper = new QueryWrapper<>();
|
handlerSystemField(planQueryVO, queryWrapper);
|
String extraFiledSql = this.handlerFieldSqlParse.getExtraFiledSql(planQueryVO.getFilter(), BusinessTypeEnums.PLAN_ORDER.getCode());
|
queryWrapper.apply(Func.isNotEmpty(extraFiledSql), extraFiledSql, new Object[0]);
|
order(planQueryVO.getSortName(), planQueryVO.getOrder(), queryWrapper);
|
IPage<Plan> page2 = page(page, queryWrapper);
|
List<Plan> records = page2.getRecords();
|
Map<Long, List<Order>> orderMap = getOrderMap(records);
|
Map<String, String> productTypeMap = getProductTypeNameMap(records);
|
for (Plan plan : records) {
|
String fieldResult = this.handlerFieldSqlParse.handlerFieldQueryResult(planQueryVO.getTypeId(), plan.getExtendField());
|
plan.setExtendField(fieldResult);
|
List<Order> orders = orderMap.get(plan.getId());
|
if (Func.isNotEmpty(orders)) {
|
String reportSituation = (String) orders.stream().map(order -> {
|
return String.valueOf(order.getQualifyNum().intValue() + order.getScrappedNum().intValue());
|
}).collect(Collectors.joining("/"));
|
plan.setReportSituation(reportSituation);
|
}
|
String productTypeName = productTypeMap.get(String.valueOf(plan.getProductId()));
|
plan.setProductTypeLabel(productTypeName);
|
plan.setHavePlanOrder(Boolean.valueOf(Func.isNotEmpty(orders)));
|
}
|
return page2;
|
}
|
|
private void order(String sortName, String order, QueryWrapper<Plan> queryWrapper) {
|
if (Func.isNotEmpty(sortName) && Func.isNotEmpty(order)) {
|
queryWrapper.orderBy(Boolean.TRUE.booleanValue(), order.equals(FieldConstant.ASC), StrUtil.toUnderlineCase(sortName));
|
} else {
|
queryWrapper.orderByDesc(SystemFieldConstant.CREATE_TIME, new String[]{"code"});
|
}
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
private Map<Long, List<Order>> getOrderMap(List<Plan> plans) {
|
Map<Long, List<Order>> orderMap = new HashMap<>(10);
|
if (Func.isNotEmpty(plans)) {
|
List<Long> planIds = plans.stream().map(Plan::getId).collect(Collectors.toList());
|
List<Order> orderList = this.orderService.list(Wrappers.<Order>lambdaQuery().in(CollectionUtil.isNotEmpty(planIds), Order::getPlanId, planIds));
|
/*
|
List<Order> orderList = this.orderService.list((Wrapper) Wrappers.lambdaQuery().in(CollectionUtil.isNotEmpty(planIds), (v0) -> {
|
return v0.getPlanId();
|
}, planIds));
|
|
orderMap = (Map) orderList.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getPlanId();
|
})); */
|
orderMap = orderList.stream().collect(Collectors.groupingBy(Order::getPlanId));
|
}
|
return orderMap;
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
private Map<String, String> getProductTypeNameMap(List<Plan> plans) {
|
Map<String, String> productTypeMap = new HashMap<>(10);
|
List<Long> products = (List) plans.stream().map((v0) -> {
|
return v0.getProductId();
|
}).filter((v0) -> {
|
return Func.isNotEmpty(v0);
|
}).collect(Collectors.toList());
|
if (Func.isNotEmpty(products)) {
|
List<PlanProductTypeDTO> productTypeRes = this.planMapper.getProductType(products);
|
productTypeMap = (Map) productTypeRes.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getProductId();
|
}, (v0) -> {
|
return v0.getProductTypeName();
|
}));
|
}
|
return productTypeMap;
|
}
|
|
private void handlerSystemField(PlanQueryVO planQueryVO, QueryWrapper<Plan> wrapper) {
|
wrapper.eq(Func.isNotEmpty(planQueryVO.getTypeId()), SystemFieldConstant.TYPE_ID, planQueryVO.getTypeId()).eq(Func.isNotEmpty(planQueryVO.getCategory()), SystemFieldConstant.CATEGORY, planQueryVO.getCategory()).likeRight(Func.isNotEmpty(planQueryVO.getCode()), "code", planQueryVO.getCode()).likeRight(Func.isNotEmpty(planQueryVO.getIndentCode()), SystemFieldConstant.INDENT_CODE, planQueryVO.getIndentCode()).likeRight(Func.isNotEmpty(planQueryVO.getStandardModel()), SystemFieldConstant.STANDARD_MODEL, planQueryVO.getStandardModel()).in(Func.isNotEmpty(planQueryVO.getPlanStatus()), SystemFieldConstant.PLAN_STATUS, planQueryVO.getPlanStatus()).ge(Func.isNotEmpty(planQueryVO.getPlanStartTime()), SystemFieldConstant.PLAN_START_TIME, planQueryVO.getPlanStartTime()).le(Func.isNotEmpty(planQueryVO.getPlanEndTime()), SystemFieldConstant.PLAN_END_TIME, planQueryVO.getPlanEndTime()).likeRight(Func.isNotEmpty(planQueryVO.getProductName()), SystemFieldConstant.PRODUCT_NAME, planQueryVO.getProductName());
|
if (Func.isNotEmpty(planQueryVO.getProductTypeIds())) {
|
List<Long> productIds = getProductIds(planQueryVO.getProductTypeIds());
|
wrapper.in(Func.isNotEmpty(productIds), SystemFieldConstant.PRODUCT_ID, productIds);
|
}
|
}
|
|
private List<Long> getProductIds(List<Long> productTypeIds) {
|
List<Product> products = this.productService.list(Wrappers.<Product>lambdaQuery().in(CollectionUtil.isNotEmpty(productTypeIds), Product::getTypeId, productTypeIds));
|
if (CollectionUtil.isEmpty(products)) {
|
return new ArrayList<>();
|
}
|
return products.stream().map(Product::getId).collect(Collectors.toList());
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public Plan modify(PlanModifyVO planModifyVO) {
|
Plan historyPlan = getPlan(String.valueOf(planModifyVO.getId()));
|
checkPlanIsEditable(historyPlan, planModifyVO);
|
Plan plan = PlanConvert.INSTANCE.convertModifyPlan(planModifyVO);
|
plan.setUnassignedNum(Integer.valueOf(planModifyVO.getPlanNum().intValue() - historyPlan.getAssignedNum().intValue()));
|
plan.setStartTime(historyPlan.getStartTime());
|
plan.setEndTime(historyPlan.getEndTime());
|
if (plan.getUnassignedNum().equals(plan.getPlanNum())) {
|
plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
|
} else if (plan.getPlanNum().equals(Integer.valueOf(historyPlan.getQualifyNum().intValue() + historyPlan.getScrappedNum().intValue())) && plan.getUnassignedNum().equals(CommonConstant.ZERO)) {
|
plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
|
Order order = this.orderService.getOne(Wrappers.<Order>lambdaQuery()
|
.eq(Order::getPlanId, plan.getId())
|
.eq(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode())
|
.orderByDesc(Order::getEndTime), Boolean.FALSE.booleanValue());
|
|
plan.setEndTime(order.getEndTime());
|
}
|
updateById(plan);
|
return plan;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public Plan getPlan(String id) {
|
if (Func.isEmpty(id)) {
|
throw new ServiceException(MessageUtils.message("plan.not.found", new Object[0]));
|
}
|
Plan plan = (Plan) getById(id);
|
if (Func.isEmpty(plan)) {
|
throw new ServiceException(MessageUtils.message("plan.not.found", new Object[0]));
|
}
|
return plan;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public List<PlanStatusCountVO> statusCount(String templateId) {
|
List<PlanStatusCountVO> result = new ArrayList<>();
|
List<Plan> list = list(Wrappers.<Plan>lambdaQuery().select(Plan::getPlanStatus).eq(Plan::getTypeId, templateId));
|
Map<Integer, Integer> countMap = new HashMap<>(8);
|
if (Func.isNotEmpty(list)) {
|
countMap = list.stream().collect(Collectors.groupingBy(Plan::getPlanStatus, Collectors.mapping(Plan::getPlanStatus, Collectors.reducing(Integer.valueOf(0), e -> Integer.valueOf(1), Integer::sum))));
|
}
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.WAIT_PUBLISH);
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.WAIT_MACHINE);
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.MACH_ING);
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.PAUSE);
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.FINISHED);
|
packageStatusCountInfo(countMap, result, PlanStatusEnum.CLOSE);
|
return result;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public void updatePlanByStart(Plan plan, Date startTime) {
|
if (PlanStatusEnum.WAIT_MACHINE.getCode().equals(plan.getPlanStatus())) {
|
plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
|
if (Func.isEmpty(plan.getStartTime())) {
|
plan.setStartTime(startTime);
|
}
|
updateById(plan);
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public Boolean checkPlanStatus(Long planId) {
|
boolean result = false;
|
Plan plan = (Plan) getById(planId);
|
if (plan == null) {
|
throw new ServiceException("计划不存在");
|
}
|
List<Integer> planStatus = Arrays.asList(PlanStatusEnum.PAUSE.getCode(), PlanStatusEnum.CLOSE.getCode());
|
if (planStatus.contains(plan.getPlanStatus())) {
|
result = true;
|
}
|
return Boolean.valueOf(result);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public List<PlanCraftVO> listCraft() {
|
List<PlanCraftDTO> planCrafts = this.planMapper.getListCraft();
|
if (Func.isEmpty(planCrafts)) {
|
return Collections.emptyList();
|
}
|
List<PlanCraftVO> result = new ArrayList<>();
|
Map<Long, List<PlanCraftDTO>> craftMap = planCrafts.stream().collect(Collectors.groupingBy(PlanCraftDTO::getCraftId));
|
|
craftMap.forEach((craftId, crafts) -> {
|
if (Func.isEmpty(crafts)) {
|
return;
|
}
|
PlanCraftDTO planCraftData = (PlanCraftDTO) crafts.get(CommonConstant.ZERO.intValue());
|
PlanCraftVO planCraftVO = PlanConvert.INSTANCE.convertCraft(planCraftData);
|
List<PlanCraftVersionVO> versionList = new ArrayList<>();
|
crafts.forEach(c -> {
|
versionList.add(c.getCraftVersion());
|
});
|
planCraftVO.setCraftVersions(versionList);
|
result.add(planCraftVO);
|
});
|
return result;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public List<PlanBomVO> listBom(Long id) {
|
if (Func.isEmpty(id)) {
|
return new ArrayList<>();
|
}
|
List<BomVersion> list = this.bomVersionService.list(Wrappers.<BomVersion>lambdaQuery().eq(BomVersion::getCraftId, id)
|
.eq(BomVersion::getVersionStatus, CommonConstant.ENABLE));
|
return PlanConvert.INSTANCE.convertBom(list);
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public CraftRoutingDetailVO getCraftPlan(Long id) {
|
if (Func.isEmpty(id)) {
|
return new CraftRoutingDetailVO();
|
}
|
Plan plan = getPlan(String.valueOf(id));
|
if (Func.isEmpty(plan.getCraftId())) {
|
return new CraftRoutingDetailVO();
|
}
|
return this.craftRoutingService.detailCraft(plan.getCraftId());
|
}
|
|
private void packageStatusCountInfo(Map<Integer, Integer> countMap, List<PlanStatusCountVO> result, PlanStatusEnum planStatusEnum) {
|
PlanStatusCountVO fVO = new PlanStatusCountVO();
|
fVO.setPlanStatus(planStatusEnum.getCode());
|
fVO.setPlanStatusStr(planStatusEnum.getName());
|
if (countMap.containsKey(planStatusEnum.getCode())) {
|
fVO.setCount(countMap.get(planStatusEnum.getCode()));
|
}
|
result.add(fVO);
|
}
|
|
private void checkPlanIsEditable(Plan plan, PlanModifyVO planModifyVO) {
|
planBaseCheck(planModifyVO.getPlanNum(), planModifyVO.getPlanStartTime(), planModifyVO.getPlanEndTime(), planModifyVO.getExtendField());
|
Integer planStatus = plan.getPlanStatus();
|
if (planStatus.equals(PlanStatusEnum.PAUSE.getCode()) || planStatus.equals(PlanStatusEnum.CLOSE.getCode()) || planStatus.equals(PlanStatusEnum.FINISHED.getCode())) {
|
throw new ServiceException(MessageUtils.message("plan.status.not.modify", new Object[0]));
|
}
|
if (Func.isEmpty(planModifyVO.getPlanNum()) || planModifyVO.getPlanNum().intValue() < plan.getAssignedNum().intValue()) {
|
throw new ServiceException(MessageUtils.message("plan.num.not.less.than.have.been.distributed.num", new Object[0]));
|
}
|
}
|
|
private void planBaseCheck(Integer planNum, Date startTime, Date endTime, String exJson) {
|
if (planNum.intValue() <= 0) {
|
throw new ServiceException(MessageUtils.message("plan.num.must.greater.than.zero", new Object[0]));
|
}
|
if (endTime.compareTo((Date) cn.hutool.core.date.DateUtil.parseDate(LocalDate.now().toString())) < 0) {
|
throw new ServiceException(MessageUtils.message("cps.plan.start.time.cannot.be.greater.than.the.end.time", new Object[0]));
|
}
|
if (startTime.compareTo(endTime) > 0) {
|
throw new ServiceException(MessageUtils.message("cps.plan.start.time.not.be.greater.than.end.time", new Object[0]));
|
}
|
this.handlerFieldSqlParse.handlerFieldSaveOrUpdateCheck(exJson, BusinessTypeEnums.PLAN_ORDER.getCode());
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public void reportPlan(Plan plan, Integer orderQualifyNum, Integer orderScrappedNum, Boolean isDel) {
|
Long planId = plan.getId();
|
Integer oldQualifyNum = Func.isNotEmpty(plan.getQualifyNum()) ? plan.getQualifyNum() : CommonConstant.ZERO;
|
Integer oldScrappedNum = Func.isNotEmpty(plan.getScrappedNum()) ? plan.getScrappedNum() : CommonConstant.ZERO;
|
Integer planNum = plan.getPlanNum();
|
Integer newQualifyNum = Integer.valueOf(oldQualifyNum.intValue() + orderQualifyNum.intValue());
|
Integer newScrappedNum = Integer.valueOf(oldScrappedNum.intValue() + orderScrappedNum.intValue());
|
Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
|
if (planNum.intValue() < newReportNum.intValue()) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
|
}
|
plan.setQualifyNum(newQualifyNum);
|
plan.setScrappedNum(newScrappedNum);
|
plan.setReportNum(newReportNum);
|
|
LambdaUpdateWrapper<Plan> planLambdaUpdateWrapper = Wrappers.<Plan>lambdaUpdate().eq(Plan::getId, planId);
|
|
boolean completePlan = false;
|
if (planNum.equals(newReportNum)) {
|
completePlan = true;
|
}
|
if (completePlan) {
|
planLambdaUpdateWrapper.set((v0) -> {
|
return v0.getPlanStatus();
|
}, PlanStatusEnum.FINISHED.getCode());
|
Date endTime = null;
|
OrderReportRecord latestRecord = this.orderReportRecordService.getLatestRecord(planId, null, null);
|
if (latestRecord != null) {
|
endTime = latestRecord.getWorkshopTime();
|
}
|
if (endTime == null) {
|
endTime = new Date();
|
}
|
plan.setEndTime(endTime);
|
}
|
if (planNum.intValue() > newReportNum.intValue() && PlanStatusEnum.FINISHED.getCode().equals(plan.getPlanStatus())) {
|
planLambdaUpdateWrapper.set(Plan::getPlanStatus, PlanStatusEnum.MACH_ING.getCode());
|
planLambdaUpdateWrapper.set(Plan::getPlanEndTime, null);
|
}
|
if (isDel.booleanValue()) {
|
updatePlanStartTime(plan, planLambdaUpdateWrapper);
|
}
|
update(plan, planLambdaUpdateWrapper);
|
}
|
|
private void updatePlanStartTime(Plan plan, LambdaUpdateWrapper<Plan> planLambdaUpdateWrapper) {
|
Date startTime = null;
|
OrderReportRecord earliestRecord = this.orderReportRecordService.getEarliestRecord(plan.getId(), null, null, null);
|
if (earliestRecord != null) {
|
startTime = earliestRecord.getStartTime();
|
}
|
if (startTime == null) {
|
planLambdaUpdateWrapper.set(Plan::getStartTime, null);
|
planLambdaUpdateWrapper.set(Plan::getPlanStatus, PlanStatusEnum.WAIT_MACHINE.getCode());
|
|
}
|
if (!plan.getStartTime().equals(startTime)) {
|
planLambdaUpdateWrapper.set(Plan::getStartTime, startTime);
|
}
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
@Transactional(rollbackFor = {Exception.class})
|
public Plan reportCurrentPlan(List<OrderProcessReportWorkDTO> reportWorkDTOList, Plan plan, Integer orderQualityNum) {
|
List<OrderProcessReportWorkDTO> reportRecords = (List) reportWorkDTOList.stream().filter(s -> {
|
return Func.isEmpty(s.getMainSequenceId());
|
}).collect(Collectors.toList());
|
Integer reportScrappedNum = (Integer) reportRecords.stream().map((v0) -> {
|
return v0.getScrappedNum();
|
}).reduce(0, (v0, v1) -> {
|
return Integer.sum(v0, v1);
|
});
|
Integer planNum = plan.getPlanNum();
|
Integer newQualifyNum = Integer.valueOf(plan.getQualifyNum().intValue() + (orderQualityNum == null ? 0 : orderQualityNum.intValue()));
|
Integer newScrappedNum = Integer.valueOf(plan.getScrappedNum().intValue() + reportScrappedNum.intValue());
|
Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
|
if (planNum.intValue() < newReportNum.intValue()) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
|
}
|
boolean completePlan = false;
|
if (planNum.equals(newReportNum)) {
|
completePlan = true;
|
}
|
if (completePlan) {
|
plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
|
plan.setReportNum(newReportNum);
|
Date endTime = null;
|
OrderReportRecord latestRecord = this.orderReportRecordService.getLatestRecord(plan.getId(), null, null);
|
if (latestRecord != null) {
|
endTime = latestRecord.getWorkshopTime();
|
}
|
if (endTime == null) {
|
endTime = new Date();
|
}
|
plan.setEndTime(endTime);
|
} else {
|
plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
|
plan.setEndTime(null);
|
}
|
plan.setReportNum(newReportNum);
|
plan.setQualifyNum(newQualifyNum);
|
plan.setScrappedNum(newScrappedNum);
|
return plan;
|
}
|
|
@Override // org.springblade.modules.coproduction.service.IPlanService
|
public Plan delReportRecordCurrentPlan(List<OrderProcessReportWorkDTO> reportWorkDTOList, Plan plan, Order order, List<Long> removeRecordIds) {
|
List<OrderProcessReportWorkDTO> reportRecords = (List) reportWorkDTOList.stream().filter(s -> {
|
return Func.isEmpty(s.getMainSequenceId());
|
}).collect(Collectors.toList());
|
Integer reportScrappedNum = (Integer) reportRecords.stream().map((v0) -> {
|
return v0.getScrappedNum();
|
}).reduce(0, (v0, v1) -> {
|
return Integer.sum(v0, v1);
|
});
|
Integer delNum = Integer.valueOf(order.getDelOrderNum() == null ? 0 : order.getDelOrderNum().intValue());
|
Integer planNum = plan.getPlanNum();
|
Integer newQualifyNum = Integer.valueOf(plan.getQualifyNum().intValue() + delNum.intValue());
|
Integer newScrappedNum = Integer.valueOf(plan.getScrappedNum().intValue() + reportScrappedNum.intValue());
|
Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
|
if (planNum.intValue() < newReportNum.intValue()) {
|
throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
|
}
|
if (planNum.intValue() == newQualifyNum.intValue() + newScrappedNum.intValue()) {
|
plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
|
plan.setReportNum(newReportNum);
|
plan.setEndTime(cn.hutool.core.date.DateUtil.date());
|
} else {
|
plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
|
plan.setEndTime(null);
|
}
|
boolean completePlan = false;
|
if (planNum.equals(newReportNum)) {
|
completePlan = true;
|
}
|
if (!completePlan) {
|
plan.setEndTime(null);
|
}
|
plan.setQualifyNum(newQualifyNum);
|
plan.setScrappedNum(newScrappedNum);
|
plan.setReportNum(newReportNum);
|
delRecordPlanStartTime(plan, removeRecordIds);
|
return plan;
|
}
|
|
private void delRecordPlanStartTime(Plan plan, List<Long> removeRecordIds) {
|
Date startTime = null;
|
OrderReportRecord earliestRecord = this.orderReportRecordService.getEarliestRecord(plan.getId(), null, null, removeRecordIds);
|
if (earliestRecord != null) {
|
startTime = earliestRecord.getStartTime();
|
}
|
if (startTime == null) {
|
plan.setStartTime(null);
|
plan.setPlanStatus(PlanStatusEnum.WAIT_MACHINE.getCode());
|
}
|
Date planStartTime = plan.getStartTime();
|
if (startTime != null && planStartTime != null && !planStartTime.equals(startTime)) {
|
plan.setStartTime(startTime);
|
}
|
}
|
}
|
