package com.chinaztt.mes.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.chinaztt.mes.basic.dto.ParamDTO;
|
import com.chinaztt.mes.basic.entity.*;
|
import com.chinaztt.mes.basic.mapper.*;
|
import com.chinaztt.mes.basic.util.DictUtils;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.dto.ParamReveiveDTO;
|
import com.chinaztt.mes.dto.ProductTreeDTO;
|
import com.chinaztt.mes.dto.StructureDTO;
|
import com.chinaztt.mes.mapper.PocMapper;
|
import com.chinaztt.mes.plan.dto.CustomerOrderDTO;
|
import com.chinaztt.mes.plan.dto.ManufacturingOrderDTO;
|
import com.chinaztt.mes.plan.dto.MasterProductionScheduleTheoryQuantityDTO;
|
import com.chinaztt.mes.plan.entity.Customer;
|
import com.chinaztt.mes.plan.entity.CustomerOrder;
|
import com.chinaztt.mes.plan.entity.JoinModelCustomer;
|
import com.chinaztt.mes.plan.entity.MasterProductionSchedule;
|
import com.chinaztt.mes.plan.mapper.*;
|
import com.chinaztt.mes.plan.service.CustomerOrderService;
|
import com.chinaztt.mes.plan.service.CustomerService;
|
import com.chinaztt.mes.plan.service.ManufacturingOrderService;
|
import com.chinaztt.mes.plan.service.MasterProductionScheduleService;
|
import com.chinaztt.mes.plan.state.auditstate.constant.AuditStateStringValues;
|
import com.chinaztt.mes.plan.state.orderstate.constant.CustomerOrderStateStringValues;
|
import com.chinaztt.mes.production.dto.OperationTaskDTO;
|
import com.chinaztt.mes.production.entity.OperationTask;
|
import com.chinaztt.mes.production.mapper.OperationTaskMapper;
|
import com.chinaztt.mes.production.service.OperationTaskService;
|
import com.chinaztt.mes.service.PocService;
|
import com.chinaztt.mes.technology.dto.BomDTO;
|
import com.chinaztt.mes.technology.dto.RoutingDTO;
|
import com.chinaztt.mes.technology.dto.StructureTree;
|
import com.chinaztt.mes.technology.entity.*;
|
import com.chinaztt.mes.technology.mapper.*;
|
import com.chinaztt.mes.technology.service.BomService;
|
import com.chinaztt.mes.technology.service.DocumentService;
|
import com.chinaztt.mes.technology.service.RoutingService;
|
import com.chinaztt.mes.technology.state.bom.constant.BomStates;
|
import com.chinaztt.mes.technology.state.document.constant.DocumentStateStringValues;
|
import com.chinaztt.mes.technology.state.routing.constant.RoutingStates;
|
import com.chinaztt.ztt.admin.api.entity.SysDictItem;
|
import com.sun.corba.se.spi.orbutil.threadpool.Work;
|
import lombok.AllArgsConstructor;
|
import lombok.CustomLog;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.print.Doc;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.UUID;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author xucg
|
* @date 2023-08-17
|
* @apiNote
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional
|
public class PocServiceImpl implements PocService {
|
|
private BomMapper bomMapper;
|
private BomService bomService;
|
private BasicParamTemplateMapper basicParamTemplateMapper;
|
private CustomerMapper customerMapper;
|
private CustomerOrderMapper customerOrderMapper;
|
private CustomerOrderService customerOrderService;
|
private CustomerService customerService;
|
private DocumentService documentService;
|
private MasterProductionScheduleTheoryQuantityMapper masterProductionScheduleTheoryQuantityMapper;
|
private MasterProductionScheduleMapper masterProductionScheduleMapper;
|
private ManufacturingOrderService manufacturingOrderService;
|
private OperationMapper operationMapper;
|
private OperationTaskMapper operationTaskMapper;
|
private OperationJoinTemplateMapper operationJoinTemplateMapper;
|
private OperationTaskService operationTaskService;
|
private PartMapper partMapper;
|
private ParamMapper paramMapper;
|
private PocMapper pocMapper;
|
private ParamJoinTemplateMapper paramJoinTemplateMapper;
|
private RoutingMapper routingMapper;
|
private RoutingService routingService;
|
private RoutingOperationMapper routingOperationMapper;
|
private StructureMapper structureMapper;
|
private StructureComponentMapper structureComponentMapper;
|
private LocationMapper locationMapper;
|
private NumberGenerator<Bom> bomNumberGenerator;
|
private NumberGenerator<Document> documentNumberGenerator;
|
private NumberGenerator<MasterProductionSchedule> masterProductionScheduleNumberGenerator;
|
private NumberGenerator<Routing> routingNumberGenerator;
|
private NumberGenerator<Template> templateNumberGenerator;
|
private JoinModelCustomerMapper joinModelCustomerMapper;
|
private WorkstationMapper workstationMapper;
|
|
/**
|
* 生产bom 添加零件 添加工序的混合个功能
|
*
|
* @param productTreeDTO 传入的零件参数
|
*/
|
@Override
|
public void fullSave(ProductTreeDTO productTreeDTO) {
|
//新增的产品结构 用于等会生成bom
|
List<StructureDTO> newStructureList = new ArrayList<>();
|
//零件，工序，产品结构的自动添加
|
Part partRoot = fullSave(new Part(), newStructureList, null, productTreeDTO, null, null);
|
//生成BOM
|
saveBomByStructure(newStructureList);
|
//生成工艺文件
|
Document document = documentSave(partRoot);
|
//生成销售订单
|
saveCustomer(partRoot, document);
|
|
}
|
|
/**
|
* 生产bom 添加零件 添加工序的混合个功能
|
*
|
* @param partRoot 根零件
|
* @param newStructureList 保存新增的产品结构 用于新增BOM
|
* @param structureFather 父零件的产品结构
|
* @param productTreeDTO 传入的零件参数
|
* @param ct 时间
|
* @param le 层级
|
*/
|
private Part fullSave(Part partRoot, List<StructureDTO> newStructureList, StructureDTO structureFather, ProductTreeDTO productTreeDTO, LocalDateTime ct, Integer le) {
|
//零件名称识别
|
le = le == null ? 1 : le + 1;
|
List<String> partNameList = new ArrayList<>();
|
if (partNameList.contains(productTreeDTO.getPartName())) {
|
productTreeDTO.setPartName(productTreeDTO.getPartName() + "-" + le);
|
}
|
//用来创建零件编号 因为系统零件编号是手动填入的 所以需要系统生成一个
|
ct = ct == null ? LocalDateTime.now() : ct;
|
//零件
|
Part part = partSave(ct, productTreeDTO, le);
|
//如果有子节点就创建个产品结构主表
|
if (null != structureFather) {
|
strcutureChildSave(structureFather, productTreeDTO, part);
|
}
|
//定义一个产品结构
|
StructureDTO structure = null;
|
//如果有子节点就生成一个新的产品结构
|
if (CollectionUtils.isNotEmpty(productTreeDTO.getChildren())) {
|
structure = strcutureSave(part);
|
//看是不是最后一道工序如果 le == 1 就是最后一道工序
|
if (le == 1) {
|
//需要将根零件返回出来
|
partRoot = part;
|
structure.setIsLast(true);
|
}
|
//设置执行的次数
|
structure.setLe(le);
|
//将新增的产品结构添加到list中
|
newStructureList.add(structure);
|
//产出工序当前工序
|
Operation operation = operationSave(ct, productTreeDTO, le);
|
//这边转一下
|
if (CollectionUtils.isNotEmpty(productTreeDTO.getParamList())) {
|
productTreeDTO.setOperationParams(productTreeDTO.getParamList().stream().map(ParamReveiveDTO::getName).collect(Collectors.toList()));
|
}
|
//将参数传到后面去
|
structure.setOperationParams(productTreeDTO.getOperationParams());
|
//填入产出工序
|
structure.setChildComOp(operation);
|
}
|
//递归执行当前方法
|
if (null != productTreeDTO.getChildren()) {
|
for (ProductTreeDTO childPart : productTreeDTO.getChildren()) {
|
fullSave(partRoot, newStructureList, structure, childPart, ct, le);
|
}
|
}
|
return partRoot;
|
}
|
|
/**
|
* 编号构造 根据时间
|
*
|
* @param localDateTime 时间
|
* @param sign 标识
|
* @return
|
*/
|
private String noMake(LocalDateTime localDateTime, String sign) {
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
|
return sign + formatter.format(localDateTime);
|
}
|
|
/**
|
* 新增零件
|
*
|
* @param ct 调用方法的时间
|
* @param productTreeDTO 传参的零件节点
|
* @param le 递归次数
|
* @return
|
*/
|
private Part partSave(LocalDateTime ct, ProductTreeDTO productTreeDTO, Integer le) {
|
Part part = new Part();
|
part.setPartNo(noMake(ct, "PA") + le);
|
part.setPartName(productTreeDTO.getPartName());
|
part.setSpecs(productTreeDTO.getPartName());
|
part.setPartModel(productTreeDTO.getPartName());
|
part.setUnit(productTreeDTO.getUnit());
|
part.setLotTrackingIfs(false);
|
part.setEngChgLevel("1");
|
part.setPlanningMethod("A");
|
//层级是1 就是成品 零件属性 1 原材料 2 半成品 3 成品 零件类型 1
|
//零件类型 1 已制造 2 制造配方 3 已采购（原材料） 4 已采购 6 费用
|
if (le == 1) {
|
part.setMaterialType("1");
|
part.setMaterialAttribute("3");
|
}
|
//层级>1 没有子节点就是原材料
|
if (le > 1 && CollectionUtils.isEmpty(productTreeDTO.getChildren())) {
|
part.setMaterialType("3");
|
part.setMaterialAttribute("1");
|
}
|
//其他就是半成品了
|
if (le > 1 && CollectionUtils.isNotEmpty(productTreeDTO.getChildren())) {
|
part.setMaterialType("1");
|
part.setMaterialAttribute("2");
|
}
|
partMapper.insert(part);
|
return part;
|
}
|
|
/**
|
* 新增工序
|
*
|
* @param ct 调用方法的时间
|
* @param productTreeDTO 传参的零件节点
|
* @param le 递归次数
|
* @return
|
*/
|
private Operation operationSave(LocalDateTime ct, ProductTreeDTO productTreeDTO, Integer le) {
|
Operation operation = new Operation();
|
operation.setOperationNo(noMake(ct, "OP") + le);
|
operation.setName(productTreeDTO.getOperationName());
|
operation.setProductionCounting(true);
|
operation.setDaq(false);
|
operation.setInspection(true);
|
operation.setAutoInspection(true);
|
operation.setMachRunFactor(BigDecimal.ZERO);
|
operation.setMachSetupTime(BigDecimal.ZERO);
|
operation.setLaborRunFactor(BigDecimal.ZERO);
|
operation.setLaborSetupTime(BigDecimal.ZERO);
|
operation.setMaterialCost(false);
|
operation.setRunTimeCodeDb("1");
|
operation.setCrewSize(BigDecimal.ONE);
|
operationMapper.insert(operation);
|
return operation;
|
}
|
|
/**
|
* 保存产品结构主表
|
*
|
* @param partParent 父零件
|
* @return
|
*/
|
private StructureDTO strcutureSave(Part partParent) {
|
StructureDTO structure = new StructureDTO();
|
structure.setPartId(partParent.getId());
|
structure.setVersion(partParent.getEngChgLevel());
|
structure.setBomTypeDb("M");
|
structure.setAlternativeNo("*");
|
structure.setIfsSync(true);
|
structureMapper.insert(structure);
|
return structure;
|
}
|
|
/**
|
* 保存产品结构明细
|
*
|
* @param structure 产品结构主表
|
* @param productTreeDTO 导入bom的数据
|
* @param partChild 子零件
|
* @return
|
*/
|
private void strcutureChildSave(StructureDTO structure, ProductTreeDTO productTreeDTO, Part partChild) {
|
StructureComponent structureComponent = new StructureComponent();
|
structureComponent.setPartId(partChild.getId());
|
structureComponent.setStructureId(structure.getId());
|
structureComponent.setOperationId(structure.getChildComOp().getId());
|
structureComponent.setPlanningMethod(partChild.getPlanningMethod());
|
structureComponent.setQpa(productTreeDTO.getQty());
|
structureComponentMapper.insert(structureComponent);
|
}
|
|
/**
|
* 生成BOM
|
*
|
* @param structurelist 产品结构的list
|
*/
|
private void saveBomByStructure(List<StructureDTO> structurelist) {
|
structurelist = structurelist.stream().sorted(Comparator.comparing(StructureDTO::getLe).reversed()).collect(Collectors.toList());
|
for (StructureDTO structure : structurelist) {
|
//新增工序参数
|
Template template = basicParamSave(structure.getOperationParams(), structure.getChildComOp());
|
Bom bom = new Bom();
|
bom.setPartId(structure.getPartId());
|
bom.setBomTypeDb(structure.getBomTypeDb());
|
bom.setVersion(structure.getVersion());
|
bom.setAlternativeNo(structure.getAlternativeNo());
|
bom.setAlternativeDesc(structure.getAlternativeDesc());
|
bom.setState(BomStates.ACCEPTED.getValue());
|
bom.setNumber(bomNumberGenerator.generateNumberWithPrefix(Bom.DIGIT, Bom.PREFIX, Bom::getNumber));
|
StructureTree tree = bomService.getAllBomExt(bom, 998);
|
BomDTO bomDTO = new BomDTO();
|
BeanUtils.copyProperties(bom, bomDTO);
|
bomDTO.setTree(tree);
|
//创建BOM
|
bomMapper.insert(bom);
|
routingSave(bom, structure.getChildComOp(), structure.getIsLast(), (structurelist.indexOf(structure) + 1), template);
|
bomService.saveBomComp(bomDTO.getTree(), bom);
|
}
|
}
|
|
/**
|
* 基础参数设置
|
*
|
* @param params 参数list
|
* @param operation 工序
|
* @return 基础参数模板集
|
*/
|
private Template basicParamSave(List<String> params, Operation operation) {
|
//新增基础模板
|
Template template = new Template();
|
template.setTemplateNo(templateNumberGenerator.generateNumberWithPrefix(Template.DIGIT, Template.PREFIX, Template::getTemplateNo));
|
template.setDataType("生产要求");
|
template.setTemplateType("生产要求");
|
template.setTemplateName(operation.getName() + "的生产要求");
|
basicParamTemplateMapper.insert(template);
|
long i = 0;
|
//新增参数和参数模板关联关系
|
for (String name : params) {
|
i++;
|
Param param = new Param();
|
param.setCode(UUID.randomUUID().toString().replace("-", ""));
|
param.setParameterItem(name);
|
param.setType("1");
|
param.setUnit("/");
|
paramMapper.insert(param);
|
ParamJoinTemplate paramJoinTemplate = new ParamJoinTemplate();
|
paramJoinTemplate.setSort(i);
|
paramJoinTemplate.setTechnologyOperationTemplateId(template.getId());
|
paramJoinTemplate.setTechnologyOperationParamId(param.getId());
|
paramJoinTemplateMapper.insert(paramJoinTemplate);
|
}
|
//新增工序参数关联关系
|
OperationJoinTemplate operationJoinTemplate = new OperationJoinTemplate();
|
operationJoinTemplate.setTechnologyOperationId(operation.getId());
|
operationJoinTemplate.setTechnologyTemplateId(template.getId());
|
operationJoinTemplateMapper.insert(operationJoinTemplate);
|
return template;
|
}
|
|
/**
|
* 检测标准
|
*/
|
private void testStandardSave() {
|
|
}
|
|
/**
|
* @param bom BOM
|
* @param operation 工序
|
* @param isLast 是否最后工序
|
* @param operationOrder 工序序号
|
* @param template 参数模板
|
*/
|
private void routingSave(Bom bom, Operation operation, boolean isLast, int operationOrder, Template template) {
|
Routing routing = new Routing();
|
routing.setRoutingNo(routingNumberGenerator.generateNumberWithPrefix(Routing.DIGIT, Routing.PREFIX, Routing::getRoutingNo));
|
routing.setPartId(bom.getPartId());
|
routing.setState(RoutingStates.ACCEPTED.getValue());
|
routing.setMaster(false);
|
routing.setVersion(bom.getVersion());
|
routing.setBomTypeDb(bom.getBomTypeDb());
|
routing.setBomId(bom.getId());
|
routing.setAlternativeNo(bom.getAlternativeNo());
|
routing.setAlternativeDesc(bom.getAlternativeDesc());
|
routing.setIfsSync(true);
|
routing.setPhaseInDate(LocalDateTime.now());
|
routingMapper.insert(routing);
|
saveRoutingOperation(routing, operation, isLast, operationOrder, template);
|
}
|
|
/**
|
* 添加工艺路线工序
|
*
|
* @param routing 工艺路线主表
|
* @param operation 工序
|
* @param isLast 是否最后一道工序
|
* @param operationOrder 工序序号
|
* @param template 参数模板
|
*/
|
private void saveRoutingOperation(Routing routing, Operation operation, boolean isLast, int operationOrder, Template template) {
|
RoutingOperation routingOperation = new RoutingOperation();
|
routingOperation.setRoutingId(routing.getId());
|
routingOperation.setOperationId(operation.getId());
|
routingOperation.setPartId(routing.getPartId());
|
routingOperation.setOperationOrder(operationOrder * 10);
|
routingOperation.setProductionCounting(operation.getProductionCounting());
|
routingOperation.setDaq(operation.getDaq());
|
routingOperation.setSemiFinished(operation.getSemiFinished());
|
routingOperation.setInspection(operation.getInspection());
|
routingOperation.setAutoInspection(operation.getAutoInspection());
|
routingOperation.setMaterialCost(operation.getMaterialCost());
|
routingOperation.setWorkCenter(operation.getWorkCenter());
|
routingOperation.setMachRunFactor(operation.getMachRunFactor());
|
routingOperation.setMachSetupTime(operation.getMachSetupTime());
|
routingOperation.setLaborClassNo(operation.getLaborClassNo());
|
routingOperation.setLaborRunFactor(operation.getLaborRunFactor());
|
routingOperation.setLaborSetupTime(operation.getLaborSetupTime());
|
routingOperation.setRunTimeCodeDb(operation.getRunTimeCodeDb());
|
routingOperation.setCrewSize(operation.getCrewSize());
|
routingOperation.setIsLast(isLast);
|
routingOperation.setOutsideOpItem(operation.getOutsideOpItem());
|
routingOperationMapper.insert(routingOperation);
|
addOperationTemplate(routingOperation, template);
|
}
|
|
/**
|
* 设置工艺路线参数模板集
|
*
|
* @param routingOperation
|
* @param template
|
*/
|
private void addOperationTemplate(RoutingOperation routingOperation, Template template) {
|
List<Template> templateList = new ArrayList<>();
|
templateList.add(template);
|
//工艺路线新增参数模板集
|
RoutingDTO routingDTO = new RoutingDTO();
|
routingDTO.setRoutingOperationId(routingOperation.getId());
|
routingDTO.setRoutingOperationTemplateList(templateList);
|
routingService.addOperationTemplate(routingDTO);
|
}
|
|
/**
|
* 工艺文件的生成
|
*
|
* @param part 成品零件
|
*/
|
private Document documentSave(Part part) {
|
Document document = new Document();
|
document.setNumber(documentNumberGenerator.generateNumberWithPrefix(Document.DIGIT, Document.PREFIX, Document::getNumber));
|
document.setName(part.getPartName());
|
document.setState(DocumentStateStringValues.ACCEPTED);
|
document.setVersion(part.getEngChgLevel());
|
document.setPartId(part.getId());
|
document.setPartName(part.getPartName());
|
document.setPartNo(part.getPartNo());
|
document.setDocType("M");
|
return (Document) documentService.fullSave(document).getData();
|
}
|
|
/**
|
* 创建销售订单主表
|
*
|
* @param part
|
* @param document
|
*/
|
private void saveCustomer(Part part, Document document) {
|
Customer customer = new Customer();
|
customer.setContractNo(customerService.contractNoMake());
|
customer.setCustomerContractNo("ZTHLASUN");
|
customer.setCustomerNo("ZTHLCAIZEA");
|
customer.setCustomerName("蔡泽军工");
|
customer.setEntityName("蔡泽台海战争一期");
|
customer.setSalesDepartment("市场部");
|
customer.setProvince("江苏省");
|
customer.setSalesMan("shz");
|
customer.setSalerWorkCode("ZT-038169");
|
customerMapper.insert(customer);
|
saveCustomerOrder(customer, part, document);
|
}
|
|
/**
|
* 创建销售订单明细
|
*
|
* @param customer
|
* @param part
|
* @param document
|
*/
|
private void saveCustomerOrder(Customer customer, Part part, Document document) {
|
CustomerOrder customerOrder = new CustomerOrder();
|
customerOrder.setCustomerOrderNo(customer.getContractNo());
|
customerOrder.setCustomerNo(customer.getCustomerNo());
|
customerOrder.setCustomerName(customer.getCustomerName());
|
customerOrder.setCustomerId(customer.getId());
|
customerOrder.setOtcPartSync(true);
|
customerOrder.setCoState("03plan");
|
customerOrder.setBuyQtyDue(new BigDecimal(10));
|
customerOrder.setReservedQuantity(BigDecimal.ZERO);
|
customerOrder.setDeliveryQuantity(BigDecimal.ZERO);
|
customerOrder.setProductName(part.getPartName());
|
customerOrder.setIsDocument(true);
|
customerOrder.setTechnologyDocumentId(document.getId());
|
customerOrder.setIsAudit("03accepted");
|
// customerOrder.setOtcLineNo();
|
customerOrder.setSalesPartNo(part.getPartNo());
|
customerOrder.setSalesPartName(part.getPartName());
|
customerOrder.setPartNo(part.getPartNo());
|
customerOrder.setOtcQuantity(new BigDecimal(10));
|
customerOrder.setOtcUnit(part.getUnit());
|
customerOrder.setVersion(1);
|
customerOrder.setWantedDeliveryDate(LocalDateTime.now().plusDays(30));
|
customerOrder.setManufactureAttr("N");
|
customerOrder.setIsSend(false);
|
customerOrderMapper.insert(customerOrder);
|
masterSchduleSave(customerOrder, part, document);
|
}
|
|
/**
|
* 创建主计划
|
*
|
* @param customerOrder
|
* @param part
|
* @param document
|
*/
|
private void masterSchduleSave(CustomerOrder customerOrder, Part part, Document document) {
|
CustomerOrderDTO customerOrderDTO = new CustomerOrderDTO();
|
customerOrderDTO.setId(customerOrder.getId());
|
customerOrderDTO.setCoState(customerOrder.getCoState());
|
customerOrderDTO.setBuyQtyDue(customerOrder.getBuyQtyDue());
|
customerOrderDTO.setCustomerId(customerOrder.getCustomerId());
|
customerOrderDTO.setManufactureAttr(customerOrder.getManufactureAttr());
|
customerOrderDTO.setRequireNumber(customerOrder.getBuyQtyDue());
|
customerOrderDTO.setTechnologyDocumentId(customerOrder.getTechnologyDocumentId());
|
customerOrderDTO.setQtyPlaned(customerOrder.getBuyQtyDue());
|
customerOrderDTO.setWantedDeliveryDate(customerOrder.getWantedDeliveryDate());
|
customerOrderDTO.setPartId(part.getId());
|
customerOrderDTO.setIsAudit(customerOrder.getIsAudit());
|
customerOrderDTO.setDocNumber(document.getNumber());
|
MasterProductionSchedule masterProductionSchedule = createMasterProductionSchedule(customerOrderDTO);
|
ManufacturingOrderSave(masterProductionSchedule);
|
}
|
|
/**
|
* 创建主计划
|
*
|
* @param customerOrderDTO
|
* @return
|
*/
|
private MasterProductionSchedule createMasterProductionSchedule(CustomerOrderDTO customerOrderDTO) {
|
BigDecimal qta = customerOrderDTO.getQtyPlaned();
|
//保存主生产计划
|
MasterProductionSchedule masterProductionSchedule = new MasterProductionSchedule();
|
masterProductionSchedule.setMpsNo(masterProductionScheduleNumberGenerator.generateNumberWithPrefix(MasterProductionSchedule.DIGIT, MasterProductionSchedule.PREFIX, MasterProductionSchedule::getMpsNo));
|
masterProductionSchedule.setPartId(customerOrderDTO.getPartId());
|
//将审核状态和工艺文件的id同步给生产计划
|
masterProductionSchedule.setIsAudit(customerOrderDTO.getIsAudit());
|
masterProductionSchedule.setTechnologyDocumentId(customerOrderDTO.getTechnologyDocumentId());
|
masterProductionSchedule.setManufactureAttr(customerOrderDTO.getManufactureAttr());
|
masterProductionSchedule.setDocNumber(customerOrderDTO.getDocNumber());
|
masterProductionSchedule.setQtyRequired(qta);
|
masterProductionSchedule.setRequiredDate(customerOrderDTO.getWantedDeliveryDate());
|
masterProductionSchedule.setRemark(customerOrderDTO.getRemark());
|
masterProductionSchedule.setSource("销售订单");
|
masterProductionScheduleMapper.insert(masterProductionSchedule);
|
//更新客户订单的下发数量
|
customerOrderDTO.setRequireNumber(customerOrderDTO.getRequireNumber().add(customerOrderDTO.getQtyPlaned()));
|
if (customerOrderDTO.getRequireNumber().compareTo(customerOrderDTO.getBuyQtyDue()) >= 0) {//已下发数量等于销售数量（小于销售数量不能更改状态），状态应该更新为已计划。目前状态依旧为待计划。
|
customerOrderDTO.setCoState(CustomerOrderStateStringValues.PLANED);
|
}
|
customerOrderMapper.updateById(customerOrderDTO);
|
//计算半成品用量
|
customerOrderService.calPlanTheory(masterProductionSchedule);
|
//保存主计划与客户订单的关系
|
JoinModelCustomer joinModelCustomer = new JoinModelCustomer();
|
joinModelCustomer.setCustomerOrderId(customerOrderDTO.getId());
|
joinModelCustomer.setModel("plan_master_production_schedule");
|
joinModelCustomer.setModelId(masterProductionSchedule.getId());
|
joinModelCustomerMapper.insert(joinModelCustomer);
|
return masterProductionSchedule;
|
}
|
|
/**
|
* 创建车间订单
|
*
|
* @param masterProductionSchedule
|
*/
|
private void ManufacturingOrderSave(MasterProductionSchedule masterProductionSchedule) {
|
List<MasterProductionScheduleTheoryQuantityDTO> masterProductionScheduleTheoryQuantityDTOList = masterProductionScheduleTheoryQuantityMapper.getTheoryQuantity(masterProductionSchedule.getId());
|
List<ManufacturingOrderDTO> manufacturingOrderDTOS = new ArrayList<>();
|
for (MasterProductionScheduleTheoryQuantityDTO dto : masterProductionScheduleTheoryQuantityDTOList) {
|
ManufacturingOrderDTO manufacturingOrderDTO = new ManufacturingOrderDTO();
|
manufacturingOrderDTO.setMpsId(dto.getMid());
|
manufacturingOrderDTO.setPartId(dto.getPartId());
|
manufacturingOrderDTO.setPartNo(dto.getPartNo());
|
manufacturingOrderDTO.setPartName(dto.getPartName());
|
manufacturingOrderDTO.setTechnologyRoutingId(dto.getRoutingId());
|
manufacturingOrderDTO.setBomId(dto.getBomId());
|
manufacturingOrderDTO.setQtyRequired(dto.getQuantity());
|
manufacturingOrderDTO.setWorkshopTypeCode("M");
|
manufacturingOrderDTO.setRequiredDate(masterProductionSchedule.getRequiredDate());
|
manufacturingOrderDTO.setWorkShop(workShopSave());
|
manufacturingOrderDTO.setScheduleTheoryQuantityId(dto.getId());
|
manufacturingOrderDTO.setManufactureAttr(masterProductionSchedule.getManufactureAttr());
|
manufacturingOrderDTO.setIsReportOperation(true);
|
manufacturingOrderDTOS.add(manufacturingOrderDTO);
|
}
|
try {
|
List<ManufacturingOrderDTO> moRetrunList = manufacturingOrderService.addAll(manufacturingOrderDTOS);
|
operationTaskSave(moRetrunList);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
|
/**
|
* 工单新增
|
*
|
* @param moRetrunList
|
*/
|
private void operationTaskSave(List<ManufacturingOrderDTO> moRetrunList) {
|
int i = 0;
|
List<OperationTaskDTO> saveList = new ArrayList<>();
|
for (ManufacturingOrderDTO manufacturingOrderDTO : moRetrunList) {
|
List<OperationTaskDTO> operationTaskDTOList = operationTaskMapper.getFromMoOptionByMoId(manufacturingOrderDTO.getId());
|
for (OperationTaskDTO operationTaskDTO : operationTaskDTOList) {
|
i++;
|
operationTaskDTO.setWorkCenter(workCenterSave());
|
Workstation workstation = workStationSave(i, workCenterSave());
|
operationTaskDTO.setWorkstationId(workstation.getId());
|
Location location = LocationSave(i);
|
operationTaskDTO.setLocationId(location.getId());
|
operationTaskDTO.setReelSpec("载具规格111");
|
operationTaskDTO.setDiscNum(new Long(1));
|
operationTaskDTO.setPlannedStartDate(LocalDateTime.now());
|
operationTaskDTO.setPlannedFinishDate(LocalDateTime.now().plusDays(30));
|
saveList.add(operationTaskDTO);
|
}
|
}
|
operationTaskService.batchFullSave(saveList);
|
}
|
|
/**
|
* @param i
|
* @param workCenter
|
* @return
|
*/
|
private Workstation workStationSave(int i, String workCenter) {
|
Workstation workstation = new Workstation();
|
workstation.setName("测试设备" + i);
|
workstation.setWorkstationNo(UUID.randomUUID().toString().replace("-", ""));
|
workstation.setWorkCenter(workCenter);
|
workstation.setType("物理设备");
|
workstationMapper.insert(workstation);
|
return workstation;
|
}
|
|
/**
|
* @param i
|
* @return
|
*/
|
private Location LocationSave(int i) {
|
Location location = new Location();
|
location.setLocNo(UUID.randomUUID().toString().replace("-", ""));
|
location.setLocName("测试产出合格库位" + i);
|
location.setLocType("2");
|
location.setLocStatus(1);
|
locationMapper.insert(location);
|
return location;
|
}
|
|
/**
|
* @return
|
*/
|
private String workShopSave() {
|
List<String> workshops = pocMapper.getDicItem("work_shop");
|
if (CollectionUtils.isEmpty(workshops)) {
|
return "测试车间";
|
} else {
|
return workshops.get(0);
|
}
|
}
|
|
/**
|
* @return
|
*/
|
private String workCenterSave() {
|
List<String> workshops = pocMapper.getDicItem("work_center_type");
|
if (CollectionUtils.isEmpty(workshops)) {
|
return "测试工作中心";
|
} else {
|
return workshops.get(0);
|
}
|
}
|
}
|
