/*
|
* Copyright (c) 2018-2025, ztt All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the pig4cloud.com developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: ztt
|
*/
|
package com.chinaztt.mes.technology.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.alibaba.excel.EasyExcel;
|
import com.alibaba.excel.ExcelWriter;
|
import com.alibaba.excel.write.metadata.WriteSheet;
|
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.chinaztt.ifs.api.feign.IfsFeignClient;
|
import com.chinaztt.mes.basic.dto.ParamDTO;
|
import com.chinaztt.mes.basic.entity.Param;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.entity.Template;
|
import com.chinaztt.mes.basic.mapper.BasicParamTemplateMapper;
|
import com.chinaztt.mes.basic.mapper.ParamMapper;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.basic.util.DictUtils;
|
import com.chinaztt.mes.common.handler.StateMachineHandler;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.common.util.StateResult;
|
import com.chinaztt.mes.technology.dto.*;
|
import com.chinaztt.mes.technology.entity.*;
|
import com.chinaztt.mes.technology.excel.RoutingData;
|
import com.chinaztt.mes.technology.excel.RoutingExcelData;
|
import com.chinaztt.mes.technology.excel.StructureData;
|
import com.chinaztt.mes.technology.mapper.*;
|
import com.chinaztt.mes.technology.service.RoutingService;
|
import com.chinaztt.mes.technology.state.routing.RoutingStateMachineConfig;
|
import com.chinaztt.mes.technology.state.routing.constant.RoutingEvents;
|
import com.chinaztt.mes.technology.state.routing.constant.RoutingStateStringValues;
|
import com.chinaztt.mes.technology.state.routing.constant.RoutingStates;
|
import com.chinaztt.ztt.common.core.util.R;
|
import lombok.AllArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.messaging.Message;
|
import org.springframework.messaging.support.MessageBuilder;
|
import org.springframework.statemachine.config.StateMachineFactory;
|
import org.springframework.statemachine.persist.StateMachinePersister;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.net.URLEncoder;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 工艺
|
*
|
* @author zhangxy
|
* @date 2020-08-19 09:36:29
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@AllArgsConstructor
|
@Service
|
@Slf4j
|
public class RoutingServiceImpl extends ServiceImpl<RoutingMapper, Routing> implements RoutingService {
|
|
private BomMapper bomMapper;
|
private BasicParamTemplateMapper templateMapper;
|
private DictUtils dictUtils;
|
private IfsFeignClient ifsFeignClient;
|
private OperationMapper operationMapper;
|
private ParamMapper paramMapper;
|
private PartMapper partMapper;
|
private RoutingOperationMapper routingOperationMapper;
|
private RoutingOperationParamMapper routingOperationParamMapper;
|
private RoutingOperationRefMapper routingOperationRefMapper;
|
private RoutingOperationTemplateMapper routingOperationTemplateMapper;
|
private StateMachineFactory<RoutingStates, RoutingEvents> routingStateMachineFactory;
|
private StateMachinePersister<RoutingStates, RoutingEvents, Routing> persister;
|
private NumberGenerator<Routing> numberGenerator;
|
private NumberGenerator<RoutingOperationTemplate> newNumberGenerator;
|
|
|
@Override
|
public IPage<List<RoutingDTO>> getPage(Page page, QueryWrapper<RoutingDTO> ew) {
|
return baseMapper.getRoutingPage(page, ew);
|
}
|
|
@Override
|
public RoutingDTO getRoutingById(Long id) {
|
RoutingDTO routing = baseMapper.getRoutingDtoById(id);
|
setIndex(routing);
|
return routing;
|
}
|
|
|
private void setIndex(RoutingDTO routing) {
|
if (null == routing) {
|
return;
|
}
|
List<RoutingOperationDTO> operations = routing.getOperations();
|
if (CollectionUtil.isEmpty(operations)) {
|
return;
|
}
|
if (operations.size() == 1) {
|
operations.get(0).setIndex(1);
|
return;
|
}
|
Set<Long> roIds = operations.stream().map(r -> r.getId()).collect(Collectors.toSet());
|
List<RefDTO> refs = routing.getRefs();
|
Map<Long, Long> refMap = refs.stream().collect(Collectors.toMap(RefDTO::getFromId, RefDTO::getToId));
|
|
//找到第一个节点
|
final Long first = roIds.stream().filter(id -> refMap.keySet().contains(id) && !refMap.values().contains(id)).findFirst().get();
|
operations.stream().filter(e -> e.getId().equals(first)).findFirst().get().setIndex(1);
|
|
Long fromId = first;
|
int index = 2;
|
|
while (refMap.get(fromId) != null) {
|
Long toId = refMap.get(fromId);
|
if (toId == null) {
|
break;
|
}
|
operations.stream().filter(o -> o.getId().equals(toId)).findAny().get().setIndex(index);
|
fromId = toId;
|
index++;
|
}
|
routing.setOperations(operations.stream().sorted(Comparator.comparing(RoutingOperationDTO::getIndex))
|
.collect(Collectors.toList()));
|
}
|
|
public List<RoutingDTO> getByRoutingId(Long id) {
|
List<RoutingDTO> routing = baseMapper.getRoutingById(id);
|
if (routing == null) {
|
throw new RuntimeException("工艺不存在");
|
}
|
return routing;
|
}
|
|
@Override
|
public RoutingDTO fullSave(RoutingDTO routingDTO) {
|
if (CollectionUtil.isEmpty(routingDTO.getOperations())) {
|
throw new RuntimeException("请添加工序");
|
}
|
List<RoutingOperationDTO> operations = routingDTO.getOperations().stream().sorted().collect(Collectors.toList());
|
//判断编号是重复
|
int noCount = baseMapper.selectCount(Wrappers.<Routing>lambdaQuery().eq(Routing::getRoutingNo, routingDTO.getRoutingNo()));
|
if (noCount > 0) {
|
throw new RuntimeException("编号重复");
|
}
|
//主表中【零件号】、【工艺版本】、【替代】值的组合须唯一。
|
noCount = baseMapper.selectCount(Wrappers.<Routing>lambdaQuery().eq(Routing::getPartId, routingDTO.getPartId())
|
.eq(Routing::getBomTypeDb, routingDTO.getBomTypeDb())
|
.eq(Routing::getAlternativeNo, routingDTO.getAlternativeNo()));
|
if (noCount > 0) {
|
throw new RuntimeException("该版本零件已存在工艺路线");
|
}
|
routingDTO.setRoutingNo(numberGenerator.generateNumberWithPrefix(Routing.DIGIT, Routing.PREFIX, Routing::getRoutingNo));
|
baseMapper.insert(routingDTO);
|
for (int num = 0; num < operations.size(); num++) {
|
RoutingOperationDTO op = operations.get(num);
|
if (num + 1 == operations.size()) {
|
op.setIsLast(true);
|
} else {
|
op.setIsLast(false);
|
}
|
op.setOperationOrder(op.getIndex());
|
op.setRoutingId(routingDTO.getId());
|
routingOperationMapper.insert(op);
|
//复制工序模板和工序模板参数
|
copyTemplateParam(op);
|
}
|
createRef(routingDTO.getId(), operations);
|
RoutingDTO routing = getRoutingById(routingDTO.getId());
|
//对接IFS
|
routingIfsSync(Arrays.asList(routing.getId()));
|
|
return routing;
|
}
|
|
@Override
|
public RoutingDTO fullUpdate(RoutingDTO routingDTO) {
|
if (CollectionUtil.isEmpty(routingDTO.getOperations())) {
|
throw new RuntimeException("请添加工序");
|
}
|
List<RoutingOperationDTO> operations = routingDTO.getOperations().stream().sorted().collect(Collectors.toList());
|
int noCount = baseMapper.selectCount(Wrappers.<Routing>lambdaQuery().ne(Routing::getId, routingDTO.getId())
|
.eq(Routing::getRoutingNo, routingDTO.getRoutingNo()));
|
if (noCount > 0) {
|
throw new RuntimeException("编号重复");
|
}
|
//主表中【零件号】、【工艺版本】、【替代】值的组合须唯一。
|
noCount = baseMapper.selectCount(Wrappers.<Routing>lambdaQuery().ne(Routing::getId, routingDTO.getId())
|
.eq(Routing::getPartId, routingDTO.getPartId())
|
.eq(Routing::getBomTypeDb, routingDTO.getBomTypeDb())
|
.eq(Routing::getAlternativeNo, routingDTO.getAlternativeNo()));
|
if (noCount > 0) {
|
throw new RuntimeException("该版本零件已存在工艺路线");
|
}
|
routingDTO.setIfsSync(false);
|
baseMapper.updateById(routingDTO);
|
List<RoutingOperation> dbOperations = routingOperationMapper.selectList(Wrappers.<RoutingOperation>query().lambda().eq(RoutingOperation::getRoutingId, routingDTO.getId()));
|
Set<Long> dbOperationIds = new HashSet<>();
|
if (!CollectionUtil.isEmpty(dbOperations)) {
|
dbOperationIds = dbOperations.stream().map(o -> o.getId()).collect(Collectors.toSet());
|
//删除原有关系记录
|
routingOperationRefMapper.delete(Wrappers.<RoutingOperationRef>lambdaQuery().eq(RoutingOperationRef::getRoutingId, routingDTO.getId()));
|
}
|
for (int num = 0; num < operations.size(); num++) {
|
RoutingOperationDTO op = operations.get(num);
|
if (num + 1 == operations.size()) {
|
op.setIsLast(true);
|
} else {
|
op.setIsLast(false);
|
}
|
op.setRoutingId(routingDTO.getId());
|
op.setOperationOrder(op.getIndex());
|
if (op.getId() != null && op.getId() > 0) {
|
routingOperationMapper.updateById(op);
|
} else {
|
routingOperationMapper.insert(op);
|
//复制工序模板和工序模板参数
|
copyTemplateParam(op);
|
}
|
dbOperationIds.remove(op.getId());
|
}
|
//删除不要的工序节点
|
if (CollectionUtil.isNotEmpty(dbOperationIds)) {
|
routingOperationMapper.delete(Wrappers.<RoutingOperation>lambdaQuery().in(RoutingOperation::getId, dbOperationIds));
|
routingOperationTemplateMapper.delete(Wrappers.<RoutingOperationTemplate>lambdaQuery().in(RoutingOperationTemplate::getRoutingOperationId, dbOperationIds));
|
routingOperationParamMapper.delete(Wrappers.<RoutingOperationParam>lambdaQuery().in(RoutingOperationParam::getRoutingOperationId, dbOperationIds));
|
}
|
createRef(routingDTO.getId(), operations);
|
RoutingDTO routing = getRoutingById(routingDTO.getId());
|
//对接IFS
|
routingIfsSync(Arrays.asList(routing.getId()));
|
|
return routing;
|
}
|
|
@Override
|
public boolean routingOperationChange(RoutingOperationDTO routingOperationDTO) {
|
routingOperationMapper.updateById(routingOperationDTO);
|
return true;
|
}
|
|
@Override
|
public R<Boolean> changeState(Long id, String event) {
|
Routing routing = baseMapper.selectById(id);
|
Message<RoutingEvents> message = MessageBuilder.withPayload(RoutingEvents.valueOf(event)).setHeader("routing", routing).build();
|
|
StateMachineHandler handler = new StateMachineHandler(routingStateMachineFactory, persister, RoutingStateMachineConfig.MACHINE_ID, routing);
|
StateResult res = handler.sendEvent(message, routing.getId());
|
if (res.isSuccess()) {
|
return R.ok();
|
} else {
|
return R.failed(res.getMsg());
|
}
|
}
|
|
|
@Override
|
public boolean changeState(List<Long> ids, String event) {
|
for (Long id : ids) {
|
Routing routing = baseMapper.selectById(id);
|
Message<RoutingEvents> message = MessageBuilder.withPayload(RoutingEvents.valueOf(event)).setHeader("routing", routing).build();
|
StateMachineHandler handler = new StateMachineHandler(routingStateMachineFactory, persister, RoutingStateMachineConfig.MACHINE_ID, routing);
|
StateResult res = handler.sendEvent(message, routing.getId());
|
if (!res.isSuccess()) {
|
throw new RuntimeException(res.getMsg());
|
}
|
}
|
return true;
|
}
|
|
|
/**
|
* 复制工序模板和工序参数
|
*/
|
public void copyTemplateParam(RoutingOperationDTO op) {
|
//通过工序id获取工序模板
|
List<Template> operationTemplateList = templateMapper.getTemplate(op.getOperationId());
|
if (operationTemplateList != null) {
|
for (Template operationTemplate : operationTemplateList) {
|
RoutingOperationTemplate newOperationTemplate = new RoutingOperationTemplate();
|
newOperationTemplate.setOperationTemplateName(operationTemplate.getTemplateName());
|
newOperationTemplate.setOperationTemplateNo(operationTemplate.getTemplateNo());
|
newOperationTemplate.setOperationTemplateType(operationTemplate.getTemplateType());
|
newOperationTemplate.setRemark(operationTemplate.getRemark());
|
newOperationTemplate.setDataType(operationTemplate.getDataType());
|
newOperationTemplate.setRoutingOperationId(op.getId());
|
newOperationTemplate.setSystemNo(newNumberGenerator.generateNumberWithPrefix(RoutingOperationTemplate.DIGIT, RoutingOperationTemplate.PREFIX, RoutingOperationTemplate::getSystemNo));
|
routingOperationTemplateMapper.insert(newOperationTemplate);
|
//通过工序模板id获取工序参数
|
List<ParamDTO> paramList = paramMapper.getParam(operationTemplate.getId());
|
if (paramList != null) {
|
for (ParamDTO param : paramList) {
|
RoutingOperationParam routingOperation = new RoutingOperationParam();
|
routingOperation.setCode(param.getCode());
|
routingOperation.setParameterItem(param.getParameterItem());
|
routingOperation.setRoutingId(op.getRoutingId());
|
routingOperation.setOperationId(op.getOperationId());
|
routingOperation.setType(param.getType());
|
routingOperation.setUnit(param.getUnit());
|
routingOperation.setRoutingOperationId(op.getId());
|
routingOperation.setOperationTemplateId(newOperationTemplate.getId());
|
routingOperation.setParamValue(param.getDefaultValue());
|
routingOperationParamMapper.insert(routingOperation);
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 工艺路线复制工序模板和工序参数
|
*/
|
public void copyRoutingTemplateParam(RoutingOperationDTO op, Long operationId) {
|
//通过工序id获取工序模板
|
List<RoutingOperationTemplate> routingOperationTemplateList = routingOperationTemplateMapper.selectList(Wrappers.<RoutingOperationTemplate>lambdaQuery().eq(RoutingOperationTemplate::getRoutingOperationId, operationId));
|
if (CollectionUtil.isNotEmpty(routingOperationTemplateList)) {
|
for (RoutingOperationTemplate routingOperationTemplate : routingOperationTemplateList) {
|
RoutingOperationTemplate newOperationTemplate = new RoutingOperationTemplate();
|
newOperationTemplate.setOperationTemplateName(routingOperationTemplate.getOperationTemplateName());
|
newOperationTemplate.setOperationTemplateNo(routingOperationTemplate.getOperationTemplateNo());
|
newOperationTemplate.setOperationTemplateType(routingOperationTemplate.getOperationTemplateType());
|
newOperationTemplate.setRemark(routingOperationTemplate.getRemark());
|
newOperationTemplate.setDataType(routingOperationTemplate.getDataType());
|
newOperationTemplate.setRoutingOperationId(op.getId());
|
newOperationTemplate.setSystemNo(newNumberGenerator.generateNumberWithPrefix(RoutingOperationTemplate.DIGIT, RoutingOperationTemplate.PREFIX, RoutingOperationTemplate::getSystemNo));
|
routingOperationTemplateMapper.insert(newOperationTemplate);
|
//通过工序模板id获取工序参数
|
List<RoutingOperationParam> routingOperationParamList = routingOperationParamMapper.selectList(Wrappers.<RoutingOperationParam>lambdaQuery().eq(RoutingOperationParam::getOperationTemplateId, routingOperationTemplate.getId()).eq(RoutingOperationParam::getRoutingOperationId, operationId));
|
if (CollectionUtil.isNotEmpty(routingOperationParamList)) {
|
for (RoutingOperationParam routingOperationParam : routingOperationParamList) {
|
RoutingOperationParam routingOperation = new RoutingOperationParam();
|
routingOperation.setCode(routingOperationParam.getCode());
|
routingOperation.setParameterItem(routingOperationParam.getParameterItem());
|
routingOperation.setRoutingId(op.getRoutingId());
|
routingOperation.setOperationId(op.getOperationId());
|
routingOperation.setType(routingOperationParam.getType());
|
routingOperation.setUnit(routingOperationParam.getUnit());
|
routingOperation.setRoutingOperationId(op.getId());
|
routingOperation.setParamValue(routingOperationParam.getParamValue());
|
routingOperation.setOperationTemplateId(newOperationTemplate.getId());
|
routingOperationParamMapper.insert(routingOperation);
|
}
|
}
|
}
|
}
|
}
|
|
@Override
|
public JSONObject operationDetail(Long operationId, Long routingOperationId) {
|
JSONObject obj = new JSONObject();
|
obj.put("operation", operationMapper.getFullById(operationId));
|
if (routingOperationId != null && routingOperationId > 0) {
|
obj.put("routingOperation", routingOperationMapper.getDtoByPk(routingOperationId));
|
}
|
return obj;
|
}
|
|
@Override
|
public RoutingOperationDTO getDtoByPk(Long id) {
|
return routingOperationMapper.getDtoByPk(id);
|
}
|
|
|
@Override
|
public void importExcel(List<RoutingExcelData> list) {
|
if (CollectionUtil.isEmpty(list)) {
|
return;
|
}
|
Map<String, List<RoutingExcelData>> map = list.stream().collect(Collectors.groupingBy(RoutingExcelData::getRoutingKey));
|
for (String routingKey : map.keySet()) {
|
Routing routing = baseMapper.selectByPartNoVA(routingKey);
|
if (routing == null) {
|
routing = routingImport(map.get(routingKey).get(0));
|
}
|
List<RoutingOperation> routingOperationList = new ArrayList<>();
|
//添加工序
|
for (RoutingExcelData routingExcelData : map.get(routingKey)) {
|
routingOperationList.add(routingOperationImport(routing, routingExcelData));
|
}
|
routingOperationList = routingOperationList.stream().sorted(Comparator.comparing(RoutingOperation::getOperationOrder)).collect(Collectors.toList());
|
//确定最后一道工序
|
if (CollectionUtil.isNotEmpty(routingOperationList)) {
|
RoutingOperation routingOperationLast = routingOperationList.get(routingOperationList.size() - 1);
|
routingOperationLast.setIsLast(true);
|
routingOperationMapper.updateById(routingOperationLast);
|
}
|
//添加排序
|
addRoutingOptionRef(routingOperationList);
|
}
|
}
|
|
|
/**
|
* 添加工艺路线主表
|
*
|
* @param routingExcelData
|
* @return
|
*/
|
private Routing routingImport(RoutingExcelData routingExcelData) {
|
Part part = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, routingExcelData.getPartNo())
|
.eq(Part::getEngChgLevel, routingExcelData.getPartVersion()));
|
if (part == null) {
|
throw new RuntimeException("零件号:" + routingExcelData.getPartNo() + "不存在");
|
}
|
Routing routing = baseMapper.selectOne(Wrappers.<Routing>lambdaQuery()
|
.eq(Routing::getAlternativeNo, routingExcelData.getAlternativeNo())
|
.eq(Routing::getBomTypeDb, routingExcelData.getBomTypeDb())
|
.eq(Routing::getPartId, part.getId()));
|
if (routing == null) {
|
routing = new Routing();
|
//零件id
|
routing.setPartId(part.getId());
|
//替代编号
|
routing.setAlternativeNo(routingExcelData.getAlternativeNo());
|
//替代描述
|
routing.setAlternativeDesc(routingExcelData.getAlternativeDesc());
|
//工艺路线编号
|
routing.setRoutingNo(numberGenerator.generateNumberWithPrefix(Routing.DIGIT, Routing.PREFIX, Routing::getRoutingNo));
|
//状态
|
routing.setState(RoutingStateStringValues.DRAFT);
|
//没有同步ifs
|
routing.setIfsSync(false);
|
//bom类型
|
routing.setBomTypeDb(routingExcelData.getBomTypeDb());
|
//线芯
|
routing.setWireCore(routingExcelData.getWireCore());
|
|
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyyMMdd");
|
//逐步采用时间
|
routing.setPhaseInDate(LocalDate.parse(routingExcelData.getPhaseInDate(), df).atStartOfDay());
|
//逐步淘汰时间
|
if (!StringUtils.isEmpty(routingExcelData.getPhaseOutDate())) {
|
routing.setPhaseOutDate(LocalDate.parse(routingExcelData.getPhaseOutDate(), df).atStartOfDay());
|
}
|
routing.setVersion(routingExcelData.getPartVersion());
|
routing.setActive(true);
|
//根据零件号，替代，类型，版本查询bom
|
List<Bom> bomList = bomMapper.selectList(Wrappers.<Bom>lambdaQuery()
|
.eq(Bom::getPartId, routing.getPartId())
|
.eq(Bom::getBomTypeDb, routing.getBomTypeDb())
|
.eq(Bom::getAlternativeNo, routing.getAlternativeNo())
|
.eq(Bom::getVersion, routing.getVersion())
|
.orderByDesc());
|
//设置bom的id
|
if (CollectionUtil.isNotEmpty(bomList)) {
|
routing.setBomId(bomList.get(0).getId());
|
}
|
baseMapper.insert(routing);
|
}
|
return routing;
|
}
|
|
/**
|
* 添加工艺路线明细表
|
*
|
* @param routing
|
*/
|
private RoutingOperation routingOperationImport(Routing routing, RoutingExcelData routingExcelData) {
|
List<Operation> operations = operationMapper.selectList(Wrappers.<Operation>lambdaQuery()
|
.eq(Operation::getName, routingExcelData.getOperationName()).eq(Operation::getActive, true));
|
if (operations.size() != 1) {
|
throw new RuntimeException("工序" + routingExcelData.getOperationName() + "不存在或存在重名工序");
|
}
|
Part childPart = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, routingExcelData.getChildPartNo())
|
.eq(Part::getEngChgLevel, routingExcelData.getChildPartVersion()));
|
if (childPart == null) {
|
throw new RuntimeException("缺少零件基础数据" + routingExcelData.getPartNo());
|
}
|
RoutingOperation routingOperation = new RoutingOperation();
|
//如果工序的零件和工艺路线的零件id 一样 就是最后一道工序
|
routingOperation.setIsLast(false);
|
//工艺路线id
|
routingOperation.setRoutingId(routing.getId());
|
//工序id
|
routingOperation.setOperationId(operations.get(0).getId());
|
//零件id
|
routingOperation.setPartId(childPart.getId());
|
//是否检测为 true
|
routingOperation.setInspection(true);
|
//工作中心
|
routingOperation.setWorkCenter(routingExcelData.getWorkCenter());
|
//人工类别编号
|
routingOperation.setLaborClassNo(routingExcelData.getLaborClassNo());
|
//因素单位
|
routingOperation.setRunTimeCodeDb(routingExcelData.getRunTimeCodeDb());
|
//劳力运转因素
|
routingOperation.setLaborRunFactor(new BigDecimal(routingExcelData.getLaborRunFactor()));
|
//劳力设置时间
|
routingOperation.setLaborSetupTime(new BigDecimal(routingExcelData.getLaborSetupTime()));
|
//机器运转因素
|
routingOperation.setMachRunFactor(new BigDecimal(routingExcelData.getMachRunFactor()));
|
//机器设置时间
|
routingOperation.setMachSetupTime(new BigDecimal(routingExcelData.getMachSetupTime()));
|
//工序号
|
routingOperation.setOperationOrder(Integer.valueOf(routingExcelData.getOperationOrder()));
|
if (!StringUtils.isEmpty(routingExcelData.getCrewSize())) {
|
routingOperation.setCrewSize(new BigDecimal(routingExcelData.getCrewSize()));
|
}
|
routingOperationMapper.insert(routingOperation);
|
return routingOperation;
|
}
|
|
/**
|
* 排序
|
*
|
* @param routingOperationList
|
*/
|
private void addRoutingOptionRef(List<RoutingOperation> routingOperationList) {
|
if (routingOperationList.size() > 1) {
|
for (int i = 1; i < routingOperationList.size(); i++) {
|
RoutingOperationRef routingOperationRef = new RoutingOperationRef();
|
routingOperationRef.setFromId(routingOperationList.get(i - 1).getId());
|
routingOperationRef.setToId(routingOperationList.get(i).getId());
|
routingOperationRef.setRoutingId(routingOperationList.get(i).getRoutingId());
|
routingOperationRefMapper.insert(routingOperationRef);
|
}
|
}
|
}
|
|
/**
|
* 横向数据导入
|
*
|
* @param headMap
|
* @param dataList
|
*/
|
@Override
|
public void importExcelExt(Map<Integer, String> headMap, List<Map<Integer, String>> dataList) {
|
//数据拼接
|
List<RoutingExcelDTO> routingExcelDTOList = routingExtMake(headMap, dataList);
|
//插入数据
|
routingExtAdd(routingExcelDTOList);
|
}
|
|
private List<RoutingExcelDTO> routingExtMake
|
(Map<Integer, String> headMap, List<Map<Integer, String>> dataList) {
|
log.info("--start---导入判断----");
|
List<RoutingExcelDTO> routingExcelDTOList = new ArrayList<>();
|
//存储工序名的下标
|
List<Integer> operationIndexList = new ArrayList<>();
|
//存储文字信息的下标
|
List<Integer> operationIndex2List = new ArrayList<>();
|
//人工类型数据字典
|
Map<String, String> diclaclass = dictUtils.getDicKey("labor_class_type");
|
//工作中心数据字典
|
Map<String, String> dicworkcenter = dictUtils.getDicKey("work_center_type");
|
//因素单位数据字典
|
Map<String, String> dicruntimedb = dictUtils.getDicKey("runtimecodedb_type");
|
try {
|
for (int i = 0; i < headMap.size(); i++) {
|
String columnName = headMap.get(i);
|
if ("工序名".equals(columnName)) {
|
operationIndexList.add(i);
|
}
|
if ("班组人员".equals(columnName)) {
|
operationIndex2List.add(i);
|
}
|
}
|
for (Map<Integer, String> map : dataList) {
|
RoutingExcelDTO routingExcelDTO = new RoutingExcelDTO();
|
//零件编号
|
String partNo = map.get(0);
|
routingExcelDTO.setPartNo(partNo);
|
//零件名称
|
String partName = map.get(1);
|
routingExcelDTO.setPartName(partName);
|
//线芯
|
String wireCore = map.get(2);
|
routingExcelDTO.setWireCore(wireCore);
|
//零件描述
|
String description = map.get(3);
|
routingExcelDTO.setDescription(description);
|
//BOM编号
|
String bomNumber = map.get(4);
|
routingExcelDTO.setBomNumber(bomNumber);
|
//工艺版本
|
String version = map.get(5);
|
routingExcelDTO.setVersion(version);
|
//工艺类型
|
String bomTypeDb = map.get(6);
|
routingExcelDTO.setBomTypeDb(bomTypeDb);
|
//逐步采用日期
|
String phaseInDate = map.get(7);
|
routingExcelDTO.setPhaseInDate(phaseInDate);
|
//逐步淘汰日期
|
String phaseOutDate = map.get(8);
|
routingExcelDTO.setPhaseOutDate(phaseOutDate);
|
//替代
|
String alternativeNo = map.get(9);
|
routingExcelDTO.setAlternativeNo(alternativeNo);
|
//替代描述
|
String alternativeDesc = map.get(10);
|
routingExcelDTO.setAlternativeDesc(alternativeDesc);
|
List<OperationNode> operationNodeList = routingOptingExtMake(headMap, operationIndexList, operationIndex2List, map, diclaclass, dicworkcenter, dicruntimedb);
|
routingExcelDTO.setOperationNodeList(operationNodeList);
|
routingExcelDTOList.add(routingExcelDTO);
|
}
|
} catch (Exception e) {
|
throw new RuntimeException(e.getMessage());
|
}
|
return routingExcelDTOList;
|
}
|
|
/**
|
* 拼接工序excel 数据
|
*
|
* @param headMap 表头
|
* @param operationIndexList 存储工序名的下标
|
* @param operationIndex2List 存储文字信息的下标
|
* @param map 数据
|
* @param diclaclass 人工类型数据字典
|
* @param dicworkcenter 工作中心数据字典
|
* @param dicruntimedb 因素单位数据字典
|
* @return
|
*/
|
private List<OperationNode> routingOptingExtMake(Map<Integer, String> headMap, List<Integer> operationIndexList, List<Integer> operationIndex2List, Map<Integer, String> map, Map<String, String> diclaclass, Map<String, String> dicworkcenter, Map<String, String> dicruntimedb) {
|
List<OperationNode> operationNodeList = new ArrayList<>();
|
for (int i = 0; i < operationIndexList.size(); i++) {
|
int start = operationIndexList.get(i);
|
int end = operationIndex2List.get(i);
|
OperationNode operationNode = new OperationNode();
|
String operationName = map.get(start);
|
if (StringUtils.isEmpty(operationName)) {
|
continue;
|
}
|
//工序顺序
|
operationNode.setOperationOrder(i + 1);
|
//判断是否最后一道工序
|
if (i == operationIndexList.size() - 1) {
|
operationNode.setIsLast(true);
|
} else {
|
operationNode.setIsLast(false);
|
}
|
//工序名称
|
operationNode.setOperationName(operationName);
|
//零件编号
|
operationNode.setPartNo(map.get(start + 1));
|
//零件名称
|
operationNode.setPartName(map.get(start + 2));
|
//零件版本
|
operationNode.setVersion(map.get(start + 3));
|
//模板名称
|
operationNode.setTemplateName(map.get(start + 4));
|
//这中间是参数
|
if (start + 5 <= end - 16) {
|
Map<String, String> paramMap = new LinkedHashMap<>(8);
|
for (int j = start + 5; j <= end - 16; j++) {
|
paramMap.put(headMap.get(j), map.get(j));
|
}
|
operationNode.setParamMap(paramMap);
|
}
|
operationNode.setProductionCounting("是".equals(map.get(end - 15)));
|
operationNode.setDaq("是".equals(map.get(end - 14)));
|
operationNode.setInspection("是".equals(map.get(end - 13)));
|
operationNode.setAutoInspection("是".equals(map.get(end - 12)));
|
operationNode.setSemiFinished("是".equals(map.get(end - 11)));
|
operationNode.setMaterialCost("是".equals(map.get(end - 10)));
|
operationNode.setReserved("是".equals(map.get(end - 9)));
|
//文字信息
|
operationNode.setRemark(map.get(end - 8));
|
//工作中心
|
operationNode.setWorkCenter(StringUtils.isEmpty(map.get(end - 7)) ? null :
|
(StringUtils.isEmpty(dicworkcenter.get(map.get(end - 7)))) ? null : dicworkcenter.get(map.get(end - 7)));
|
//机器运转因素
|
operationNode.setMachRunFactor(map.get(end - 6));
|
//机器设置时间
|
operationNode.setMachSetupTime(map.get(end - 5));
|
//人工类别
|
operationNode.setLaborClassNo(StringUtils.isEmpty(map.get(end - 4)) ? null :
|
(StringUtils.isEmpty(diclaclass.get(map.get(end - 4)))) ? null : diclaclass.get(map.get(end - 4)));
|
//劳力运转因素
|
operationNode.setLaborRunFactor(map.get(end - 3));
|
//劳力设置时间
|
operationNode.setLaborSetupTime(map.get(end - 2));
|
//因素单位
|
operationNode.setRunTimeCodeDb(StringUtils.isEmpty(map.get(end - 1)) ? null :
|
(StringUtils.isEmpty(dicruntimedb.get(map.get(end - 1)))) ? null : dicruntimedb.get(map.get(end - 1)));
|
//班组人员
|
operationNode.setCrewSize(map.get(end));
|
|
|
operationNodeList.add(operationNode);
|
}
|
return operationNodeList;
|
}
|
|
/**
|
* 横向数据导入插入
|
*
|
* @param routingExcelDTOList
|
*/
|
private void routingExtAdd(List<RoutingExcelDTO> routingExcelDTOList) {
|
//循环处理
|
for (RoutingExcelDTO routingExcelDTO : routingExcelDTOList) {
|
Routing routing = new Routing();
|
Part partFather = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, routingExcelDTO.getPartNo())
|
.eq(Part::getEngChgLevel, routingExcelDTO.getVersion()));
|
if (partFather == null) {
|
throw new RuntimeException("缺少零件基础数据" + routingExcelDTO.getPartNo());
|
}
|
//零件id
|
routing.setPartId(partFather.getId());
|
//替代编号
|
routing.setAlternativeNo(StringUtils.isEmpty(routingExcelDTO.getAlternativeNo()) ? "*" : routingExcelDTO.getAlternativeNo());
|
//替代描述
|
routing.setAlternativeDesc(routingExcelDTO.getAlternativeDesc());
|
//根据替代编号，版本号判断唯一性
|
int count = getBaseMapper().selectCount(Wrappers.<Routing>lambdaQuery()
|
.eq(Routing::getAlternativeNo, routing.getAlternativeNo())
|
.eq(Routing::getBomTypeDb, routing.getBomTypeDb())
|
.eq(Routing::getPartId, routing.getPartId()));
|
if (count > 0) {
|
throw new RuntimeException(" 零件号：" + routingExcelDTO.getPartNo() + " ！ 版本号：" + routingExcelDTO.getVersion() + " 替代号:" + routing.getAlternativeNo() + "重复！");
|
}
|
//工艺路线编号
|
routing.setRoutingNo(numberGenerator.generateNumberWithPrefix(Routing.DIGIT, Routing.PREFIX, Routing::getRoutingNo));
|
//查询BOM
|
routing.setDescription(routingExcelDTO.getDescription());
|
if (!StringUtils.isEmpty(routingExcelDTO.getBomNumber())) {
|
Bom bom = bomMapper.selectOne(Wrappers.<Bom>lambdaQuery().eq(Bom::getNumber, routingExcelDTO.getBomNumber()));
|
if (null != bom) {
|
routing.setBomId(bom.getId());
|
}
|
}
|
routing.setState(RoutingStateStringValues.DRAFT);
|
//版本
|
routing.setVersion(routingExcelDTO.getVersion());
|
//线芯
|
routing.setWireCore(routingExcelDTO.getWireCore());
|
//类型
|
routing.setBomTypeDb(StringUtils.isEmpty(routingExcelDTO.getBomTypeDb()) ? "M" : routingExcelDTO.getBomTypeDb());
|
//是否同步ifs
|
routing.setIfsSync(false);
|
//逐步采用时间
|
if (StringUtils.isEmpty(routingExcelDTO.getPhaseInDate())) {
|
throw new RuntimeException("缺少逐步采用日期");
|
}
|
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
routing.setPhaseInDate(LocalDate.parse(routingExcelDTO.getPhaseInDate(), df).atStartOfDay());
|
//逐步淘汰时间
|
if (!StringUtils.isEmpty(routingExcelDTO.getPhaseOutDate())) {
|
routing.setPhaseOutDate(LocalDate.parse(routingExcelDTO.getPhaseOutDate(), df).atStartOfDay());
|
}
|
//根据零件号，替代，类型，版本查询bom
|
List<Bom> bomList = bomMapper.selectList(Wrappers.<Bom>lambdaQuery()
|
.eq(Bom::getPartId, routing.getPartId())
|
.eq(Bom::getBomTypeDb, routing.getBomTypeDb())
|
.eq(Bom::getVersion, routing.getVersion())
|
.orderByDesc());
|
//设置bom的id
|
if (CollectionUtil.isNotEmpty(bomList)) {
|
routing.setBomId(bomList.get(0).getId());
|
} else {
|
throw new RuntimeException(partFather.getPartNo() + "替代" + routing.getAlternativeNo() + "不存在bom");
|
}
|
baseMapper.insert(routing);
|
List<Long> partIds = bomMapper.getBomPartIdByBomId(routing.getBomId());
|
//工艺路线工序新增
|
routingOptingExtAdd(routingExcelDTO.getOperationNodeList(), routing.getId(), routingExcelDTO.getPartNo(), partFather, partIds);
|
|
}
|
}
|
|
/**
|
* 工艺路线工序新增接口
|
*
|
* @param operationNodeList 工序节点
|
* @param routingId 工艺路线id
|
* @param partNo 零件号
|
*/
|
private void routingOptingExtAdd(List<OperationNode> operationNodeList, Long routingId, String partNo, Part partFather, List<Long> partIds) {
|
//工艺路线的list
|
List<RoutingOperation> routingOperationList = new ArrayList<>();
|
for (OperationNode operationNode : operationNodeList) {
|
RoutingOperation routingOperation = new RoutingOperation();
|
routingOperation.setRoutingId(routingId);
|
if (StringUtils.isEmpty(operationNode.getWorkCenter())) {
|
throw new RuntimeException("缺少工作中心");
|
}
|
List<Operation> operations = operationMapper.selectList(Wrappers.<Operation>lambdaQuery()
|
.eq(Operation::getName, operationNode.getOperationName())
|
.eq(Operation::getActive, true));
|
if (operations.size() != 1) {
|
throw new RuntimeException("工序" + operationNode.getOperationName() + "不存在或存在重名工序");
|
}
|
Long operationId = operations.get(0).getId();
|
routingOperation.setOperationId(operationId);
|
Part part = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, operationNode.getPartNo())
|
.eq(Part::getEngChgLevel, operationNode.getVersion()));
|
if (part == null) {
|
throw new RuntimeException("缺少零件基础数据" + operationNode.getPartNo());
|
}
|
if (!partIds.contains(part.getId())) {
|
throw new RuntimeException("零件" + partFather.getPartNo() + "工艺路线中的零件在bom中不存在");
|
}
|
routingOperation.setPartId(part.getId());
|
if (StringUtils.isEmpty(operationNode.getWorkCenter())) {
|
throw new RuntimeException("缺少工作中心");
|
}
|
routingOperation.setOperationOrder(operationNode.getOperationOrder());
|
routingOperation.setWorkCenter(operationNode.getWorkCenter());
|
routingOperation.setLaborClassNo(operationNode.getLaborClassNo());
|
routingOperation.setLaborSetupTime(!StringUtils.isEmpty(operationNode.getLaborSetupTime()) ? new BigDecimal(operationNode.getLaborSetupTime()) : BigDecimal.ZERO);
|
routingOperation.setLaborRunFactor(!StringUtils.isEmpty(operationNode.getLaborRunFactor()) ? new BigDecimal(operationNode.getLaborRunFactor()) : BigDecimal.ZERO);
|
routingOperation.setMachRunFactor(!StringUtils.isEmpty(operationNode.getMachRunFactor()) ? new BigDecimal(operationNode.getMachRunFactor()) : BigDecimal.ZERO);
|
routingOperation.setMachSetupTime(!StringUtils.isEmpty(operationNode.getMachSetupTime()) ? new BigDecimal(operationNode.getMachSetupTime()) : BigDecimal.ZERO);
|
routingOperation.setRunTimeCodeDb(operationNode.getRunTimeCodeDb());
|
if (!StringUtils.isEmpty(operationNode.getCrewSize())) {
|
routingOperation.setCrewSize(new BigDecimal(operationNode.getCrewSize()));
|
}
|
routingOperation.setIsLast(operationNode.getIsLast());
|
routingOperation.setRemark(operationNode.getRemark());
|
routingOperation.setProductionCounting(operationNode.isProductionCounting());
|
routingOperation.setDaq(operationNode.isDaq());
|
routingOperation.setInspection(operationNode.isInspection());
|
routingOperation.setAutoInspection(operationNode.isAutoInspection());
|
routingOperation.setSemiFinished(operationNode.isSemiFinished());
|
routingOperation.setMaterialCost(operationNode.isMaterialCost());
|
routingOperation.setReserved(operationNode.isReserved());
|
if (operationNode.getPartNo().equals(partNo)) {
|
routingOperation.setIsMaster(true);
|
} else {
|
routingOperation.setIsMaster(false);
|
}
|
routingOperationMapper.insert(routingOperation);
|
routingOperationList.add(routingOperation);
|
//复制工序模板和工序模板参数
|
Long routingOperationId = routingOperation.getId();//工艺路线下工序id
|
List<Template> operationTemplateList = templateMapper.getTemplate(operationId);
|
String templateName = trimAllWhitespace(operationNode.getTemplateName());
|
if (!CollectionUtils.isEmpty(operationTemplateList) && !StringUtils.isEmpty(templateName)) {
|
Optional<Template> templateOptional = operationTemplateList.stream().filter(e -> e.getTemplateName().equals(templateName)).findFirst();
|
if (templateOptional.isPresent()) {
|
Template template = templateOptional.get();
|
RoutingOperationTemplate routingOperationTemplate = new RoutingOperationTemplate();
|
routingOperationTemplate.setOperationTemplateName(template.getTemplateName());
|
routingOperationTemplate.setOperationTemplateNo(template.getTemplateNo());
|
routingOperationTemplate.setOperationTemplateType(template.getTemplateType());
|
routingOperationTemplate.setRemark(template.getRemark());
|
routingOperationTemplate.setDataType(template.getDataType());
|
routingOperationTemplate.setRoutingOperationId(routingOperationId);
|
routingOperationTemplate.setSystemNo(newNumberGenerator.generateNumberWithPrefix(RoutingOperationTemplate.DIGIT
|
, RoutingOperationTemplate.PREFIX, RoutingOperationTemplate::getSystemNo));
|
routingOperationTemplateMapper.insert(routingOperationTemplate);
|
Long routingOperationTemplateId = routingOperationTemplate.getId();
|
//通过工序模板id获取工序参数
|
List<ParamDTO> paramList = paramMapper.getParam(template.getId());
|
if (!CollectionUtils.isEmpty(paramList)) {
|
Map<String, String> paramMap = operationNode.getParamMap();
|
if (!CollectionUtils.isEmpty(paramMap)) {
|
for (Map.Entry<String, String> entry : paramMap.entrySet()
|
) {
|
String paramName = trimAllWhitespace(entry.getKey());
|
System.out.println("*************** paramName" + paramName);
|
String paramValue = entry.getValue();
|
Optional<ParamDTO> paramOptional =
|
paramList.stream().filter(el -> paramName.equals(el.getParameterItem())).findFirst();
|
if (paramOptional.isPresent()) {
|
Param param = paramOptional.get();
|
RoutingOperationParam routingOperationParam = new RoutingOperationParam();
|
routingOperationParam.setCode(param.getCode());
|
routingOperationParam.setParameterItem(param.getParameterItem());
|
routingOperationParam.setRoutingId(routingId);
|
routingOperationParam.setOperationId(operationId);
|
routingOperationParam.setType(param.getType());
|
routingOperationParam.setUnit(param.getUnit());
|
routingOperationParam.setRoutingOperationId(routingOperationId);
|
routingOperationParam.setOperationTemplateId(routingOperationTemplateId);
|
routingOperationParam.setParamValue(paramValue);
|
routingOperationParamMapper.insert(routingOperationParam);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
createRefNew(routingId, routingOperationList);
|
}
|
|
/**
|
* 移除字符串中所有的空白格（包含换行\r、回车\n、制表\t符）
|
*
|
* @param str 原始串
|
* @return 无空格后的串
|
*/
|
public String trimAllWhitespace(String str) {
|
if (str == null || str.isEmpty()) {
|
return str;
|
}
|
int len = str.length();
|
StringBuilder sb = new StringBuilder(str.length());
|
for (int i = 0; i < len; i++) {
|
char c = str.charAt(i);
|
if (!Character.isWhitespace(c)) {
|
sb.append(c);
|
}
|
}
|
return sb.toString();
|
}
|
|
|
@Override
|
public R<List<Routing>> copyRoutingSave(List<RoutingDTO> routing) {
|
if (CollectionUtil.isEmpty(routing)) {
|
return R.failed("请选择工艺路线");
|
}
|
if (CollectionUtil.isNotEmpty(routing)) {
|
return R.failed("相同替代零件不可有多个工艺路线");
|
}
|
List<Routing> routingDTOList = new ArrayList<>();
|
for (RoutingDTO routingList : routing) {
|
Routing newRouting = baseMapper.selectOne(Wrappers.<Routing>lambdaQuery().eq(Routing::getId, routingList.getId()));
|
List<RoutingOperation> routingOperationList = routingOperationMapper.selectList(Wrappers.<RoutingOperation>lambdaQuery().eq(RoutingOperation::getRoutingId, newRouting.getId()));
|
//插入工艺路线
|
newRouting.setId(null);
|
newRouting.setRoutingNo(numberGenerator.generateNumberWithPrefix(Routing.DIGIT, Routing.PREFIX, Routing::getRoutingNo));
|
newRouting.setState(RoutingStateStringValues.DRAFT);
|
newRouting.setCreateTime(null);
|
newRouting.setUpdateTime(null);
|
newRouting.setCreateUser(null);
|
newRouting.setUpdateUser(null);
|
baseMapper.insert(newRouting);
|
routingDTOList.add(newRouting);
|
//插入工艺工序表
|
setIndex(routingList);
|
List<RoutingOperationDTO> operations = routingList.getOperations();
|
operations.forEach(op -> {
|
Long operationId = op.getId();
|
op.setRoutingId(newRouting.getId());
|
routingOperationMapper.insert(op);
|
//复制工序模板和工序模板参数
|
copyRoutingTemplateParam(op, operationId);
|
});
|
//生成工序节点关系表
|
createRef(newRouting.getId(), operations);
|
for (RoutingOperation routingOperation : routingOperationList) {
|
List<RoutingOperationParam> routingOperationParamList = routingOperationParamMapper.selectList(Wrappers.<RoutingOperationParam>lambdaQuery().eq(RoutingOperationParam::getRoutingId, routingList.getId())
|
.eq(RoutingOperationParam::getOperationId, routingOperation.getOperationId()));
|
if (!CollectionUtil.isEmpty(routingOperationParamList)) {
|
for (RoutingOperationParam routingOperationParam : routingOperationParamList) {
|
routingOperationParam.setId(null);
|
routingOperationParam.setRoutingId(newRouting.getId());
|
routingOperationParamMapper.insert(routingOperationParam);
|
}
|
}
|
}
|
}
|
return R.ok(routingDTOList);
|
}
|
|
@Override
|
public List<RoutingOperationTemplate> getOperationTemplate(RoutingDTO routingDTO) {
|
List<RoutingOperationTemplate> routingOperationTemplateList = routingOperationTemplateMapper.selectList(Wrappers.<RoutingOperationTemplate>lambdaQuery().eq(RoutingOperationTemplate::getRoutingOperationId, routingDTO.getRoutingOperationId()));
|
if (!CollectionUtil.isNotEmpty(routingOperationTemplateList)) {
|
routingOperationTemplateList = new ArrayList<>();
|
}
|
return routingOperationTemplateList;
|
}
|
|
@Override
|
public List<RoutingOperationParam> getOperationTemplateParam(RoutingDTO routingDTO) {
|
List<RoutingOperationParam> routingOperationParamList = routingOperationParamMapper.selectList(Wrappers.<RoutingOperationParam>lambdaQuery()
|
.eq(RoutingOperationParam::getRoutingOperationId, routingDTO.getRoutingOperationId()).eq(RoutingOperationParam::getOperationTemplateId, routingDTO.getOperationTemplateId())
|
.orderByAsc(RoutingOperationParam::getId));
|
if (!CollectionUtil.isNotEmpty(routingOperationParamList)) {
|
routingOperationParamList = new ArrayList<>();
|
}
|
return routingOperationParamList;
|
}
|
|
@Override
|
public R getOperationTemplateAndParam(Long routingOperationId) {
|
List<RoutingOperationTemplate> routingOperationTemplateList = routingOperationTemplateMapper.selectList(
|
Wrappers.<RoutingOperationTemplate>lambdaQuery().eq(RoutingOperationTemplate::getRoutingOperationId, routingOperationId));
|
if (CollectionUtil.isEmpty(routingOperationTemplateList)) {
|
return R.ok();
|
}
|
for (RoutingOperationTemplate rt : routingOperationTemplateList) {
|
List<RoutingOperationParam> routingOperationParamList = routingOperationParamMapper.selectList(Wrappers.<RoutingOperationParam>lambdaQuery()
|
.eq(RoutingOperationParam::getRoutingOperationId, routingOperationId)
|
.eq(RoutingOperationParam::getOperationTemplateId, rt.getId())
|
.orderByAsc(RoutingOperationParam::getRoutingOperationId)
|
.orderByAsc(RoutingOperationParam::getId));
|
rt.setParamList(routingOperationParamList);
|
}
|
return R.ok(routingOperationTemplateList);
|
}
|
|
@Override
|
public List<RoutingOperationTemplate> addOperationTemplate(RoutingDTO routingDTO) {
|
List<RoutingOperationTemplate> routingOperationTemplateList = new ArrayList<>();
|
for (Template template : routingDTO.getRoutingOperationTemplateList()) {
|
List<ParamDTO> paramList = paramMapper.getParam(template.getId());
|
RoutingOperationTemplate newRoutingOperationTemplate = new RoutingOperationTemplate();
|
newRoutingOperationTemplate.setSystemNo(newNumberGenerator.generateNumberWithPrefix(RoutingOperationTemplate.DIGIT, RoutingOperationTemplate.PREFIX, RoutingOperationTemplate::getSystemNo));
|
newRoutingOperationTemplate.setRoutingOperationId(routingDTO.getRoutingOperationId());
|
newRoutingOperationTemplate.setOperationTemplateName(template.getTemplateName());
|
newRoutingOperationTemplate.setOperationTemplateNo(template.getTemplateNo());
|
newRoutingOperationTemplate.setRemark(template.getRemark());
|
newRoutingOperationTemplate.setDataType(template.getDataType());
|
newRoutingOperationTemplate.setOperationTemplateType(template.getTemplateType());
|
routingOperationTemplateMapper.insert(newRoutingOperationTemplate);
|
//通过工序模板id获取工序参数
|
if (paramList != null) {
|
for (ParamDTO param : paramList) {
|
RoutingOperationParam routingOperation = new RoutingOperationParam();
|
routingOperation.setCode(param.getCode());
|
routingOperation.setParameterItem(param.getParameterItem());
|
routingOperation.setRoutingId(routingDTO.getId());
|
routingOperation.setOperationId(routingDTO.getOperationId());
|
routingOperation.setType(param.getType());
|
routingOperation.setUnit(param.getUnit());
|
routingOperation.setRoutingOperationId(routingDTO.getRoutingOperationId());
|
routingOperation.setOperationTemplateId(newRoutingOperationTemplate.getId());
|
routingOperation.setParamValue(param.getDefaultValue());
|
routingOperationParamMapper.insert(routingOperation);
|
}
|
}
|
routingOperationTemplateList.add(newRoutingOperationTemplate);
|
}
|
return routingOperationTemplateList;
|
}
|
|
@Override
|
public IPage<List<RoutingOperationTemplate>> getRoutingOperationTemplatePage(Page page, QueryWrapper<RoutingOperationTemplate> ew) {
|
return routingOperationTemplateMapper.selectPage(page, ew);
|
}
|
|
@Override
|
public boolean deleteOperationTemplate(Long id) {
|
RoutingOperationTemplate routingOperationTemplate = routingOperationTemplateMapper.selectById(id);
|
routingOperationTemplateMapper.deleteById(id);
|
routingOperationParamMapper.delete(Wrappers.<RoutingOperationParam>lambdaQuery().eq(RoutingOperationParam::getRoutingOperationId, routingOperationTemplate.getRoutingOperationId())
|
.eq(RoutingOperationParam::getOperationTemplateId, id));
|
return false;
|
}
|
|
@Override
|
public List<RoutingOperationParam> addOperationTemplateParam(RoutingDTO routingDTO) {
|
List<RoutingOperationParam> routingOperationParamList = new ArrayList<>();
|
for (RoutingOperationParam routingOperationParam : routingDTO.getRoutingOperationParam()) {
|
int count = routingOperationParamMapper.selectCount(Wrappers.<RoutingOperationParam>lambdaQuery().eq(RoutingOperationParam::getRoutingOperationId, routingDTO.getRoutingOperationId())
|
.eq(RoutingOperationParam::getOperationTemplateId, routingDTO.getOperationTemplateId()).eq(RoutingOperationParam::getCode, routingOperationParam.getCode()));
|
if (count > 0) {
|
continue;
|
}
|
routingOperationParam.setRoutingOperationId(routingDTO.getRoutingOperationId());
|
routingOperationParam.setOperationTemplateId(routingDTO.getOperationTemplateId());
|
routingOperationParam.setRoutingId(routingDTO.getId());
|
routingOperationParam.setOperationId(routingDTO.getOperationId());
|
routingOperationParamMapper.insert(routingOperationParam);
|
routingOperationParamList.add(routingOperationParam);
|
}
|
return routingOperationParamList;
|
}
|
|
@Override
|
public boolean deleteOperationTemplateParam(Long id) {
|
routingOperationParamMapper.deleteById(id);
|
return false;
|
}
|
|
@Override
|
public R updateRoutingTemplateParamById(RoutingDTO routing) {
|
for (RoutingOperationParam routingOperationParam : routing.getRoutingOperationParam()) {
|
routingOperationParamMapper.updateById(routingOperationParam);
|
}
|
return R.ok();
|
}
|
|
|
/**
|
* 保存工艺主表和工序节点信息
|
*
|
* @param part
|
* @param data
|
* @param operation
|
* @return RoutingOperation
|
*/
|
private RoutingOperation saveRoutingOperation(Part part, RoutingData data, Operation operation) {
|
//保存工艺主表信息Routing
|
Routing routing = new Routing();
|
routing.setPartId(part.getId());
|
routing.setRoutingNo(data.getRoutingNo());
|
baseMapper.insert(routing);
|
//保存工序节点信息 RoutingOperation
|
RoutingOperation routingOperation = new RoutingOperation();
|
routingOperation.setRoutingId(routing.getId());
|
routingOperation.setOperationId(operation.getId());
|
routingOperation.setProductionCounting(operation.getProductionCounting());
|
routingOperation.setDaq(operation.getDaq());
|
routingOperation.setSemiFinished(operation.getSemiFinished());
|
routingOperation.setInspection(operation.getInspection());
|
routingOperation.setMaterialCost(operation.getMaterialCost());
|
routingOperation.setLoc("-400 0");
|
routingOperationMapper.insert(routingOperation);
|
return routingOperation;
|
}
|
|
/**
|
* 生成工序节点关系表
|
*
|
* @param routingId
|
* @param operations
|
*/
|
private void createRef(Long routingId, List<RoutingOperationDTO> operations) {
|
if (operations == null || operations.size() == 1) {
|
return;
|
}
|
for (int i = 1; i < operations.size(); i++) {
|
RoutingOperationDTO current = operations.get(i);
|
RoutingOperationRef rr = new RoutingOperationRef();
|
RoutingOperationDTO pre = operations.get(i - 1);
|
rr.setFromId(pre.getId());
|
rr.setToId(current.getId());
|
rr.setRoutingId(routingId);
|
routingOperationRefMapper.insert(rr);
|
}
|
}
|
|
/**
|
* 生成工序节点关系表
|
*
|
* @param routingId
|
* @param operations
|
*/
|
private void createRefNew(Long routingId, List<RoutingOperation> operations) {
|
if (operations == null || operations.size() == 1) {
|
return;
|
}
|
for (int i = 1; i < operations.size(); i++) {
|
RoutingOperation current = operations.get(i);
|
RoutingOperationRef rr = new RoutingOperationRef();
|
RoutingOperation pre = operations.get(i - 1);
|
rr.setFromId(pre.getId());
|
rr.setToId(current.getId());
|
rr.setRoutingId(routingId);
|
routingOperationRefMapper.insert(rr);
|
}
|
}
|
|
/**
|
* 导入模板下载
|
*
|
* @param response
|
* @throws IOException
|
*/
|
@Override
|
public void exportModel(HttpServletResponse response) throws IOException {
|
response.setContentType("application/vnd.ms-excel");
|
response.setCharacterEncoding("UTF-8");
|
// 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
|
String fileName = URLEncoder.encode("routingImportModel", "UTF-8");
|
response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
|
try {
|
//新建ExcelWriter
|
ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
|
//获取sheet0对象
|
WriteSheet mainSheet = EasyExcel.writerSheet(0, "导入模板").head(RoutingExcelData.class).build();
|
//向sheet0写入数据 传入空list这样只导出表头
|
List<RoutingExcelData> routingExcelDataArrayList = new ArrayList<>();
|
RoutingExcelData routingExcelData = new RoutingExcelData();
|
routingExcelData.setPartNo("必填");
|
routingExcelData.setPartVersion("必填");
|
routingExcelData.setPhaseInDate("必填格式 ：20220202");
|
routingExcelData.setPhaseOutDate("非必填格式 ：20220202");
|
routingExcelData.setChildPartNo("必填");
|
routingExcelData.setChildPartVersion("必填");
|
routingExcelData.setWorkCenter("必填");
|
routingExcelData.setOperationName("必填");
|
routingExcelDataArrayList.add(routingExcelData);
|
excelWriter.write(routingExcelDataArrayList, mainSheet);
|
//关闭流
|
excelWriter.finish();
|
} catch (IOException e) {
|
throw new RuntimeException("导出失败");
|
}
|
}
|
|
/**
|
* 工艺路线的对接
|
*
|
* @param ids
|
* @return
|
*/
|
@Override
|
public boolean routingIfsSync(List<Long> ids) {
|
JSONObject jsonObject = new JSONObject()
|
.fluentPut("RECORD_ID", UUID.randomUUID().toString())
|
.fluentPut("SYSCODE", "LMES")
|
.fluentPut("SYSMODEL", "工艺路线");
|
JSONArray batchInfoArray = new JSONArray();
|
List<RoutingDTO> routingDtoList = new ArrayList<>();
|
for (Long id : ids) {
|
ifsRoutingDataMake(routingDtoList, batchInfoArray, id);
|
}
|
if (CollectionUtil.isEmpty(batchInfoArray)) {
|
throw new RuntimeException("缺少工艺数据");
|
}
|
// jsonObject.put("BATCH_INFO", batchInfoArray);
|
// R result = ifsFeignClient.importRoutingStd(jsonObject, true);
|
// if (result.getCode() == 1) {
|
// throw new RuntimeException("IFS错误——" + result.getMsg());
|
// } else {
|
// //如果对接成功将是否ifs 改为 true
|
// routingDtoList.forEach(routingDTO -> {
|
// routingDTO.setIfsSync(true);
|
// baseMapper.updateById(routingDTO);
|
// });
|
// }
|
return true;
|
}
|
|
/**
|
* ifs 数据拼接
|
*
|
* @param routingDtoList
|
* @param batchInfoArray
|
* @param id
|
*/
|
private void ifsRoutingDataMake(List<RoutingDTO> routingDtoList, JSONArray batchInfoArray, Long id) {
|
//用于更新用的
|
RoutingDTO routingDTO = baseMapper.getRoutingDtoById(id);
|
if (routingDTO == null) {
|
throw new RuntimeException("工艺路线" + id + "丢失或不可用");
|
}
|
routingDtoList.add(routingDTO);
|
|
JSONObject batchinfoJsonObj = new JSONObject();
|
//零件号
|
batchinfoJsonObj.put("PART_NO", routingDTO.getPartNo());
|
//版本号
|
batchinfoJsonObj.put("ROUTING_REVISION", routingDTO.getVersion());
|
//结构类型
|
batchinfoJsonObj.put("BOM_TYPE_DB", routingDTO.getBomTypeDb());
|
//启用时间
|
batchinfoJsonObj.put("PHASE_IN_DATE", DateTimeFormatter.ofPattern("yyyyMMdd").format(routingDTO.getPhaseInDate()));
|
if (routingDTO.getPhaseOutDate() != null) {
|
//弃用时间
|
batchinfoJsonObj.put("PHASE_OUT_DATE", DateTimeFormatter.ofPattern("yyyyMMdd").format(routingDTO.getPhaseOutDate()));
|
}
|
JSONArray alternateInfo = new JSONArray();
|
JSONObject alobj = new JSONObject()
|
.fluentPut("ALTERNATIVE_NO", routingDTO.getAlternativeNo())
|
.fluentPut("ALTERNATIVE_DESC", routingDTO.getAlternativeDesc())
|
.fluentPut("IS_BUILD", "TRUE");
|
JSONArray operationInfo = new JSONArray();
|
for (RoutingOperationDTO routingOperationDTO : routingDTO.getOperations()) {
|
JSONObject oiobj = new JSONObject();
|
//工序号 排序用的
|
oiobj.put("OPERATION_NO", routingOperationDTO.getOperationOrder() != null
|
? new BigDecimal(routingOperationDTO.getOperationOrder()).multiply(BigDecimal.TEN)
|
: BigDecimal.TEN);
|
//工序描述
|
oiobj.put("OPERATION_DESCRIPTION", routingOperationDTO.getOperationName());
|
//工作中心号
|
oiobj.put("WORK_CENTER_NO", routingOperationDTO.getWorkCenter());
|
//机器运转因素
|
oiobj.put("MACH_RUN_FACTOR", routingOperationDTO.getMachRunFactor());
|
//机器设置时间
|
oiobj.put("MACH_SETUP_TIME", routingOperationDTO.getMachSetupTime());
|
//劳力运转因素
|
oiobj.put("LABOR_RUN_FACTOR", routingOperationDTO.getLaborRunFactor());
|
//劳力设置时间
|
oiobj.put("LABOR_SETUP_TIME", routingOperationDTO.getLaborSetupTime());
|
//因素单位
|
oiobj.put("RUN_TIME_CODE_DB", routingOperationDTO.getRunTimeCodeDb());
|
//人工类别
|
oiobj.put("LABOR_CLASS_NO", routingOperationDTO.getLaborClassNo());
|
//班组人员
|
oiobj.put("CREW_SIZE", null == routingOperationDTO.getCrewSize() ? 1 : routingOperationDTO.getCrewSize());
|
//外协工序对接
|
oiobj.put("OUTSIDE_OP_ITEM", routingOperationDTO.getOutsideOpItem());
|
|
operationInfo.add(oiobj);
|
}
|
alobj.put("OPERATION_INFO", operationInfo);
|
alternateInfo.add(alobj);
|
batchinfoJsonObj.put("ALTERNATE_INFO", alternateInfo);
|
batchInfoArray.add(batchinfoJsonObj);
|
}
|
|
|
/**
|
* 工艺路线替代提前制造
|
*
|
* @param ids
|
* @return
|
*/
|
@Override
|
public boolean routingIfsCal(List<Long> ids) {
|
JSONObject jsonObject = new JSONObject()
|
.fluentPut("RECORD_ID", UUID.randomUUID().toString())
|
.fluentPut("SYSCODE", "LMES")
|
.fluentPut("SYSMODEL", "工艺路线替代提前制造");
|
JSONArray batchInfoArray = new JSONArray();
|
for (Long id : ids) {
|
RoutingDTO routingDTO = baseMapper.getRoutingDtoById(id);
|
JSONObject batchinfoJsonObj = new JSONObject();
|
//零件号
|
batchinfoJsonObj.put("PART_NO", routingDTO.getPartNo());
|
//能力
|
batchinfoJsonObj.put("DAILY_CAPACITY", "AVERAGE");
|
//批量大小
|
batchinfoJsonObj.put("ORDER_SIZE", 1);
|
//提前期计算基础
|
batchinfoJsonObj.put("LEADTIME_BASIS", 3);
|
//替代
|
batchinfoJsonObj.put("ALTERNATIVE_NO", routingDTO.getAlternativeNo());
|
//工艺类型
|
batchinfoJsonObj.put("BOM_TYPE_DB", routingDTO.getBomTypeDb());
|
//工艺版本
|
batchinfoJsonObj.put("ROUTING_REVISION", routingDTO.getVersion());
|
//更新选项
|
batchinfoJsonObj.put("UPDATE_LEAD_TIME", "Y");
|
|
batchInfoArray.add(batchinfoJsonObj);
|
}
|
jsonObject.put("BATCH_INFO", batchInfoArray);
|
if (batchInfoArray.size() > 0) {
|
R result = ifsFeignClient.modifyManufLeadtimeStd(jsonObject, true);
|
if (result.getCode() == 1) {
|
throw new RuntimeException("IFS错误——" + result.getMsg());
|
}
|
}
|
return true;
|
}
|
|
@Override
|
public List<RoutingDTO> getRoutingByDocumentIdAndOperationId(Long documentId, Long operationId) {
|
return this.baseMapper.getRoutingByDocumentIdAndOperationId(documentId, operationId);
|
}
|
|
}
|
