/*
 *    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.mapper.*;
import com.chinaztt.mes.technology.service.RoutingService;
import com.chinaztt.mes.technology.state.bom.constant.BomStateStringValues;
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("编号重复");
		}
		Bom bom = bomMapper.selectById(routingDTO.getBomId());
		if(Objects.equals(BomStateStringValues.DRAFT,bom.getState())){
			throw new RuntimeException("BOM状态未通过！");
		}
		//主表中【零件号】、【工艺版本】、【替代】值的组合须唯一。
		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);
    }

}