/*
 *    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.production.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.util.CollectionUtils;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
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.mes.basic.entity.Part;
import com.chinaztt.mes.basic.entity.Template;
import com.chinaztt.mes.basic.entity.Workstation;
import com.chinaztt.mes.basic.mapper.BasicParamTemplateMapper;
import com.chinaztt.mes.basic.mapper.PartMapper;
import com.chinaztt.mes.basic.mapper.WorkstationMapper;
import com.chinaztt.mes.common.constant.Constant;
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.plan.dto.ManufacturingOrderDTO;
import com.chinaztt.mes.plan.dto.ManufacturingOrderOperationTemplateDTO;
import com.chinaztt.mes.plan.dto.MoTestStandardDTO;
import com.chinaztt.mes.plan.dto.MoTestStandardParamDTO;
import com.chinaztt.mes.plan.entity.*;
import com.chinaztt.mes.plan.mapper.*;
import com.chinaztt.mes.plan.service.ManufacturingOrderService;
import com.chinaztt.mes.plan.state.manufacturing.constant.ManufacturingOrderStateStringValues;
import com.chinaztt.mes.production.dto.*;
import com.chinaztt.mes.production.dto.mould.BasicInfoForPdaFeedDTO;
import com.chinaztt.mes.production.entity.*;
import com.chinaztt.mes.production.mapper.*;
import com.chinaztt.mes.production.service.OperationTaskParamService;
import com.chinaztt.mes.production.service.OperationTaskRecordService;
import com.chinaztt.mes.production.service.OperationTaskService;
import com.chinaztt.mes.production.state.operationtask.OperationTaskStateMachineConfig;
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskEvents;
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStateStringValues;
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStates;
import com.chinaztt.mes.production.vo.OperationTaskScreenVO;
import com.chinaztt.mes.quality.entity.*;
import com.chinaztt.mes.quality.mapper.*;
import com.chinaztt.mes.quality.service.impl.ReportServiceImpl;
import com.chinaztt.mes.technology.entity.Operation;
import com.chinaztt.mes.technology.mapper.OperationMapper;
import com.chinaztt.mes.warehouse.dto.PalletTransportsMaterialDTO;
import com.chinaztt.mes.warehouse.entity.JoinStockOrder;
import com.chinaztt.mes.warehouse.entity.Stock;
import com.chinaztt.mes.warehouse.mapper.JoinStockOrderMapper;
import com.chinaztt.mes.warehouse.mapper.StockMapper;
import com.chinaztt.ztt.admin.api.feign.RemoteParamService;
import com.chinaztt.ztt.common.core.constant.SecurityConstants;
import com.chinaztt.ztt.common.core.util.R;
import com.chinaztt.ztt.common.oss.OssProperties;
import com.chinaztt.ztt.common.oss.service.OssTemplate;
import com.chinaztt.ztt.common.sequence.sequence.Sequence;
import com.google.gson.Gson;
import lombok.AllArgsConstructor;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.springframework.core.env.Environment;
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.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

/**
 * 工序任务
 *
 * @author zhangxy
 * @date 2020-09-18 09:26:35
 */
@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class OperationTaskServiceImpl extends ServiceImpl<OperationTaskMapper, OperationTask> implements OperationTaskService {
	private ApplyPartMapper applyPartMapper;
	private BasicParamTemplateMapper basicParamTemplateMapper;
	private CustomerOrderMapper customerOrderMapper;
	private CustomerOrderParamMapper customerOrderParamMapper;
	private JoinStockOrderMapper joinStockOrderMapper;
	private ManufacturingOrderMapper manufacturingOrderMapper;
	private ManufacturingOrderService manufacturingOrderService;
	private MoStructureComponentMapper moStructureComponentMapper;
	private MoRoutingOperationMapper moRoutingOperationMapper;
	private MoRoutingMapper moRoutingMapper;
	private ManufacturingOrderOperationTemplateMapper manufacturingOrderOperationTemplateMapper;
	private ManufacturingOrderOperationParamMapper manufacturingOrderOperationParamMapper;
	private MoTestStandardParamMapper moTestStandardParamMapper;
	private MoTestStandardMapper moTestStandardMapper;
	private NumberGenerator<ReportSample> reportSampleNumberGenerator;
	private OperationTaskAttachmentMapper operationTaskAttachmentMapper;
	private OperationTaskSupplyMapper supplyMapper;
	private OperationTaskParamMapper operationTaskParamMapper;
	private OperationTaskProduceMapper operationTaskProduceMapper;
	private OperationTaskRecordMapper operationTaskRecordMapper;
	private OperationTaskMaterialMapper operationTaskMaterialMapper;
	private OperationTaskSupplyMapper operationTaskSupplyMapper;
	private OperationTaskMapper operationTaskMapper;
	private OperationMapper operationMapper;
	private ProductOutputMapper productOutputMapper;
	private PartMapper partMapper;
	private ReportSampleMapper reportSampleMapper;
	private ReportServiceImpl reportService;
	private ReportMeasuringToolMapper reportMeasuringToolMapper;
	private RemoteParamService remoteParamService;
	private ReportSampleItemMapper reportSampleItemMapper;
	private ReportMapper reportMapper;
	private StateMachineFactory<OperationTaskStates, OperationTaskEvents> operationTaskStateMachineFactory;
	private StateMachinePersister<OperationTaskStates, OperationTaskEvents, OperationTask> persister;
	private Sequence opTaskSequence;
	private WorkstationMapper workstationMapper;
	private StockMapper stockMapper;
	private SegmentationTaskRecordMapper segmentationTaskRecordMapper;
	private OperationTaskRecordService operationTaskRecordService;
	private OperationTaskParamService operationTaskParamService;
	private Environment environment;

	private final OssProperties ossProperties;
	private final OssTemplate minioTemplate;

	public static final String BUCKET_NAME = "mes";

	@Override
	public IPage<List<OperationTaskDTO>> getPage(Page page, QueryWrapper<OperationTaskDTO> ew) {
		return baseMapper.queryPage(page, ew);
	}

	@Override
	public List<OperationTaskDTO> getOperationTask(Long workstationId, String productSn, String salesOrder,
												   String productName, String outBatchNo, String mpsNo) {
		List<OperationTaskDTO> opreturn = new ArrayList<>();
		if (workstationId == null) {
			return opreturn;
		}
		Workstation workstation = workstationMapper.selectById(workstationId);
		if (workstation == null) {
			return opreturn;
		}
		Boolean operationStockStatus = null;
		if (StringUtils.isNotBlank(outBatchNo)) {
			List<Stock> stockList = stockMapper.selectList(Wrappers.<Stock>lambdaQuery()
					.eq(Stock::getPartBatchNo, outBatchNo));
			if (CollectionUtil.isNotEmpty(stockList)) {
				operationStockStatus = stockList.get(0).getOperationStockStatus();
			}
		}
		//对应工作中心工单下面工作站位空的工单 和 对应的当前工作站的工单
		QueryWrapper gen = Wrappers.<OperationTask>query().eq("oot.work_center", workstation.getWorkCenter());
		List<OperationTaskDTO> operationTaskDTOS = baseMapper.getOperationTask(gen, true, productSn, salesOrder,
				productName, outBatchNo, mpsNo, operationStockStatus);
		operationTaskDTOS.forEach(operationTaskDTO -> {
			if (operationTaskDTO.getWorkstationId() == null) {
				opreturn.add(operationTaskDTO);
			} else {
				if (workstationId.equals(operationTaskDTO.getWorkstationId())) {
					opreturn.add(operationTaskDTO);
				}
			}
		});
		return opreturn;
	}

	@Override
	public boolean changeState(List<Long> ids, String event) {
		if (CollectionUtil.isEmpty(ids)) {
			throw new RuntimeException("请选择至少一条工单");
		}
		for (Long id : ids) {
			changeStateCommon(id, event);
		}
		return true;
	}

	@Override
	public boolean changeState(Long id, String event) {
		if (id == null) {
			throw new RuntimeException("请选择一条工单");
		}
		changeStateCommon(id, event);
		return true;
	}

	public void changeStateCommon(Long id, String event) {
		OperationTask operationTask = baseMapper.selectById(id);
//		String moIfsNeedSync = remoteParamService.getByKey(Constant.MO_IFS_NEED_SYNC, SecurityConstants.FROM_IN).getData();
		if (event.equals("UNSUBMIT")) {
//			String taskMoNo = baseMapper.getTaskMoNo(id);
//			ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectOne(Wrappers.<ManufacturingOrder>lambdaQuery()
//					.eq(ManufacturingOrder::getMoNo, taskMoNo));
//			if (StringUtils.isBlank(manufacturingOrder.getIfsOrderNo()) && !org.apache.commons.lang3.StringUtils.equals(moIfsNeedSync, "false")) {
//				throw new RuntimeException("车间订单没有同步IFS");
//			}
			// 调用 ERP派工单新增接口
			ylErpJobOrderSave(id);
			operationTask.setState(OperationTaskStates.PENDING.getValue());
			updateById(operationTask);
		} else if (event.equals("UNSUBMIT")) {
			operationTask.setState(OperationTaskStates.UNSUBMIT.getValue());
			updateById(operationTask);
		} else {
			Message<OperationTaskEvents> message = MessageBuilder.withPayload(OperationTaskEvents.valueOf(event)).setHeader("operationTask", operationTask).build();
			StateMachineHandler handler = new StateMachineHandler(operationTaskStateMachineFactory, persister, OperationTaskStateMachineConfig.MACHINE_ID, operationTask);
			StateResult res = handler.sendEvent(message, operationTask.getId());
			if (!res.isSuccess()) {
				throw new RuntimeException(res.getMsg());
			}
		}
		//修改排程时间
		changePlanTime(operationTask, event);
	}

	/**
	 * 对接鹰联ERP派工
	 *
	 * @param id 工单id
	 */
	private void ylErpJobOrderSave(Long id) {
		CustomerOrder customerOrder = customerOrderMapper.getCustomerOrderNoByOperationTaskId(id);
		if (null == customerOrder) {
			return;
		}
		if (null == customerOrder.getCustomerOrderNo()) {
			return;
		}
		//区分一下是不是鹰联的订单  鹰联订单开头是YL
		if (!customerOrder.getCustomerOrderNo().startsWith("YL")) {
			return;
		}
		List<OperationTaskMaterial> operationTaskMaterials = operationTaskMaterialMapper.selectList(new LambdaQueryWrapper<OperationTaskMaterial>().eq(OperationTaskMaterial::getOperationTaskId, id));
		if (CollectionUtil.isEmpty(operationTaskMaterials)) {
			throw new RuntimeException("没有所需物料信息");
		}
		List<Long> partIds = operationTaskMaterials.stream().map(OperationTaskMaterial::getPartId).collect(Collectors.toList());
		List<Part> parts = partMapper.selectBatchIds(partIds);
		SaveWorkAssignsEntity saveWorkAssignsEntity = new SaveWorkAssignsEntity();
		saveWorkAssignsEntity.setIsHasXLH(true);
		saveWorkAssignsEntity.setTitle("派工单" + id);
		saveWorkAssignsEntity.setCode(id + "");
		saveWorkAssignsEntity.setHtid(customerOrder.getCustomerOrderNo());
		List<SaveWorkAssignsEntity.WorkAssignItems> workAssignItems = new ArrayList<>();
		List<SaveWorkAssignsEntity.WorkAssignWFPs> workAssignWFPs = new ArrayList<>();

		BigDecimal num = new BigDecimal(0);
		for (OperationTaskMaterial operationTaskMaterial : operationTaskMaterials) {
			SaveWorkAssignsEntity.WorkAssignItems item = new SaveWorkAssignsEntity.WorkAssignItems();
			item.setNeedNum(operationTaskMaterial.getQuantityRequired());
			Long productID = parts.stream().filter(e -> e.getId().equals(operationTaskMaterial.getPartId())).findFirst().get().getPartFamilyId();
			item.setProductID(productID);
			workAssignItems.add(item);
			num = num.add(operationTaskMaterial.getQuantityRequired());

			SaveWorkAssignsEntity.WorkAssignWFPs wfPs = new SaveWorkAssignsEntity.WorkAssignWFPs();
			wfPs.setNumMake(operationTaskMaterial.getQuantityRequired());
			wfPs.setIsOut(0);
			wfPs.setUnitID(2);
			workAssignWFPs.add(wfPs);
		}
		saveWorkAssignsEntity.setWorkAssignItems(workAssignItems);
		saveWorkAssignsEntity.setWorkAssignWFPs(workAssignWFPs);
		saveWorkAssignsEntity.setNumMake(num);
		R r = addERPJobOrder(saveWorkAssignsEntity);
		if (r.getCode() != 0) {
			throw new RuntimeException(r.getMsg());
		}
	}

	/**
	 * @param saveWorkAssignsEntity
	 * @return
	 */
	private R addERPJobOrder(SaveWorkAssignsEntity saveWorkAssignsEntity) {
		CloseableHttpClient httpClient = HttpClientBuilder.create().build();
		String syncErpUrl = environment.getProperty("addErpJobOrder");
		HttpPost httpPost = new HttpPost(syncErpUrl);
		String jsonParams = new Gson().toJson(saveWorkAssignsEntity);
		// 设置请求体为JSON格式
		StringEntity requestEntity = new StringEntity(jsonParams, ContentType.APPLICATION_JSON);
		httpPost.setEntity(requestEntity);
		String responseString = null;
		CloseableHttpResponse response = null;
		try {
			response = httpClient.execute(httpPost);
			HttpEntity entity = response.getEntity();
			responseString = EntityUtils.toString(entity, "UTF-8");
			return new Gson().fromJson(responseString, R.class);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return R.failed();
	}

	/**
	 * 工单开始结束之后 修改计划开始结束时间
	 *
	 * @param operationTask
	 * @param event
	 */
	private void changePlanTime(OperationTask operationTask, String event) {
		LocalDateTime localDateTime = LocalDateTime.now();
		//完成
		if ("COMPLETE".equals(event)) {
			List<OperationTask> operationTaskList = operationTaskMapper.selectList(Wrappers.<OperationTask>lambdaQuery()
					.orderByAsc(OperationTask::getPlannedFinishDate)
					.in(OperationTask::getState, Arrays.asList("07unsubmit", "01pending", "02inProgress", "03interrupted"))
					.eq(OperationTask::getWorkstationId, operationTask.getWorkstationId()));
			if (null != operationTask.getPlannedFinishDate()) {
				//获取时间的差值 分钟数  当前时间 - 计划完成时间
				Duration dur = Duration.between(operationTask.getPlannedFinishDate(), localDateTime);
				Long mis = dur.toMinutes();
				for (OperationTask taskChange : operationTaskList) {
					// 计划开始时间 = 计划开始时间 + 差值
					if (null != taskChange.getPlannedStartDate()) {
						taskChange.setPlannedStartDate(taskChange.getPlannedStartDate().plusMinutes(mis));
					}
					// 计划完成时间 = 计划完成时间 + 差值
					if (null != taskChange.getPlannedFinishDate()) {
						taskChange.setPlannedFinishDate(taskChange.getPlannedFinishDate().plusMinutes(mis));
					}
					baseMapper.updateById(taskChange);
				}
			}
		}
	}


	@Override
	public OperationTaskDTO getOperation(Long id) {
		OperationTaskDTO operationTaskDTO = baseMapper.getOperationTaskDTO(id);
		operationTaskDTO.setLocalDateTimes(Arrays.asList(operationTaskDTO.getPlannedStartDate(), operationTaskDTO.getPlannedFinishDate()));
		operationTaskDTO.setOutPutBatchList(operationTaskProduceMapper.selectList(Wrappers.<OperationTaskProduce>lambdaQuery()
				.eq(OperationTaskProduce::getOperationTaskId, operationTaskDTO.getId())));
		return operationTaskDTO;
	}

	/**
	 * 新增工单
	 *
	 * @param operationTaskDTO
	 * @return
	 */
	private String saveSingle(OperationTaskDTO operationTaskDTO) {
		//如果前台没有指定工单类型默认是 M 制造
		if (StringUtils.isBlank(operationTaskDTO.getOperationTaskType())) {
			operationTaskDTO.setOperationTaskType("M");
		}
		//判断工单类型和符不符合当前工序
		// 将IFS接口调用，放到最后一步，防止调用IFS接口成功，本地事务报错回滚，导致IFS接口数据无法回滚
		ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(operationTaskDTO.getMoId());
		//if (manufacturingOrder.getState().equals(ManufacturingOrderStateStringValues.PLANNED)) {
		//	manufacturingOrder.setState(ManufacturingOrderStateStringValues.ISSUED);
		//	//调用ifs修改ifs车间订单状态
		//	R result = manufacturingOrderService.changeState(manufacturingOrder, "RELEASE");
		//	if (result.getCode() == 1) {
		//		throw new RuntimeException(manufacturingOrder.getMoNo() + result.getMsg());
		//	}
		//}
		if (!checkTaskType(operationTaskDTO, manufacturingOrder)) {
			throw new RuntimeException("工序为：" + operationTaskDTO.getOperationName() + "的工单类型不符合");
		}
		operationTaskDTO.setOptaskNo(opTaskSequence.nextNo());
		operationTaskDTO.setState(OperationTaskStates.UNSUBMIT.getValue());
		baseMapper.insert(operationTaskDTO);
		// 设置优先级
		baseMapper.updateNextPriority(operationTaskDTO.getId());
		OperationTask operationTask = baseMapper.selectOne(Wrappers.<OperationTask>lambdaQuery().eq(OperationTask::getOptaskNo, operationTaskDTO.getOptaskNo()));
		OperationTaskSupply operationTaskSupply = new OperationTaskSupply();
		operationTaskSupply.setMoId(operationTaskDTO.getMoId());
		operationTaskSupply.setOperationTaskId(operationTask.getId());
		operationTaskSupply.setQuantitySupply(operationTaskDTO.getPlannedQuantity());
		operationTaskSupplyMapper.insert(operationTaskSupply);
		//添加工单所需物料
		addMoStructureComponent(operationTaskDTO.getMoId(), operationTaskDTO.getPartId(), operationTask);
		// 更新制造订单主表的当前工序名称
		//if (null != manufacturingOrder && !org.springframework.util.StringUtils.isEmpty(operationTaskDTO.getOperationName())) {
		//	manufacturingOrder.setCurrentOperation(operationTaskDTO.getOperationName());
		//}
		//manufacturingOrderMapper.updateById(manufacturingOrder);
		//修改段长关联关系
		// List<OperationTaskProduce> operationTaskProduceList = operationTaskDTO.getOutPutBatchList();
		// if (CollectionUtil.isNotEmpty(operationTaskProduceList)) {
		// 	for (OperationTaskProduce operationTaskProduce : operationTaskProduceList) {
		// 		operationTaskProduce.setOperationTaskId(operationTaskDTO.getId());
		// 		operationTaskProduceMapper.updateById(operationTaskProduce);
		// 	}
		// }
		return operationTaskDTO.getOptaskNo();
	}

	/**
	 * 单个工单新增
	 *
	 * @param operationTaskDTO
	 * @return
	 */
	@Override
	public String fullSave(OperationTaskDTO operationTaskDTO) {
		return batchFullSave(Collections.singletonList(operationTaskDTO)).get(0);
	}


	/**
	 * 制造类型的车间订单的最后一道工序禁止创建【类型】为修理的工单
	 * 修理类型的车间订单则没有这个要求
	 * 判断当前工单是不是最后一道工序
	 * M ：制造
	 * F ：修理
	 *
	 * @param operationTaskDTO
	 * @return
	 */
	private boolean checkTaskType(OperationTaskDTO operationTaskDTO, ManufacturingOrder manufacturingOrder) {
		boolean isLast = true;
		//查询当前工序
		MoRoutingOperation moRoutingOperation = moRoutingOperationMapper.selectById(operationTaskDTO.getMoRoutingOperationId());
		//设置工艺路线id
		operationTaskDTO.setRoutingOperationId(moRoutingOperation.getTechnologyRoutingOperationId());
		//如果车间订单类型是M 并且 工单是 F 类型
		if ("M".equals(manufacturingOrder.getWorkshopTypeCode()) && "F".equals(operationTaskDTO.getOperationTaskType())) {
			//查询最后一道工序
			MoRoutingOperation moRoutingOperationLast = moRoutingMapper.getLastMoRoutingOperation(operationTaskDTO.getMoId());
			//如果两个工序的id 不一样 那就不是最后一道工序
			if (moRoutingOperationLast.getId().equals(moRoutingOperation.getId())) {
				isLast = false;
			}
		}
		return isLast;
	}

	/**
	 * 批量新增工单
	 *
	 * @param operationTaskDTOList
	 * @return
	 */
	@Override
	public List<String> batchFullSave(List<OperationTaskDTO> operationTaskDTOList) {
		List<String> opTaskNoList = new ArrayList<>();
		operationTaskDTOList.forEach(operationTaskDTO -> {
			opTaskNoList.add(saveSingle(operationTaskDTO));
		});
		releaseManufacturingOrder(operationTaskDTOList.get(0));
		return opTaskNoList;
	}

	private void releaseManufacturingOrder(OperationTaskDTO operationTaskDTO) {
		//判断工单类型和符不符合当前工序
		ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(operationTaskDTO.getMoId());
		if (manufacturingOrder.getState().equals(ManufacturingOrderStateStringValues.PLANNED)) {
			manufacturingOrder.setState(ManufacturingOrderStateStringValues.ISSUED);
			//调用ifs修改ifs车间订单状态
//			R result = manufacturingOrderService.changeState(manufacturingOrder, "RELEASE");
//			if (result.getCode() == 1) {
//				throw new RuntimeException(manufacturingOrder.getMoNo() + result.getMsg());
//			}
		}
		//if (!checkTaskType(operationTaskDTO, manufacturingOrder)) {
		//	throw new RuntimeException("工序为：" + operationTaskDTO.getOperationName() + "的工单类型不符合");
		//}
		// 更新制造订单主表的当前工序名称
		if (null != manufacturingOrder && !org.springframework.util.StringUtils.isEmpty(operationTaskDTO.getOperationName())) {
			manufacturingOrder.setCurrentOperation(operationTaskDTO.getOperationName());
		}
		manufacturingOrderMapper.updateById(manufacturingOrder);
	}

//	public void addMoStructureComponent(Long moId, Long partId, OperationTask operationTask) {
//		ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(moId);
////	计算出需要的根节点的数量 用计划数量 除以这个零件所有涉及到的qpa
////	先找到当前零件的所在节点
//		List<MoStructureComponent> moStructureComponentList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
//				.eq(MoStructureComponent::getPlanManufacturingOrderId, manufacturingOrder.getId()).eq(MoStructureComponent::getPartId, partId));
//		if (CollectionUtil.isNotEmpty(moStructureComponentList)) {
//			BigDecimal sumUnitQpa = moStructureComponentList.stream().map(MoStructureComponent::getQpa).reduce(BigDecimal.ZERO, BigDecimal::add);
//			BigDecimal unitAcount = operationTask.getPlannedQuantity().divide(sumUnitQpa, 3, BigDecimal.ROUND_HALF_UP);
//			List<OperationTaskMaterial> materials = new ArrayList<>();
//			for (MoStructureComponent moStructureComponent : moStructureComponentList) {
//				//找到当前零件的下级节点
//				List<MoStructureComponent> newMoStructureComponentList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
//						.eq(MoStructureComponent::getPlanManufacturingOrderId, manufacturingOrder.getId())
//						.eq(MoStructureComponent::getParent, moStructureComponent.getId()));
//				if (CollectionUtil.isNotEmpty(newMoStructureComponentList)) {
//					for (MoStructureComponent newMoStructureComponent : newMoStructureComponentList) {
//						//工单所需物料保存
//						OperationTaskMaterial material = new OperationTaskMaterial();
//						material.setOperationTaskId(operationTask.getId());
//						material.setPartId(newMoStructureComponent.getPartId());
//						material.setQpa(newMoStructureComponent.getQpa().divide(moStructureComponent.getQpa(), 3, BigDecimal.ROUND_HALF_UP));
//						material.setQuantityRequired((newMoStructureComponent.getQpa().multiply(unitAcount)));
//						materials.add(material);
//					}
//				}
//			}
//			Map<Long, List<OperationTaskMaterial>> group = materials.stream().collect(Collectors.groupingBy(OperationTaskMaterial::getPartId));
//			for (Map.Entry<Long, List<OperationTaskMaterial>> map : group.entrySet()) {
//				OperationTaskMaterial material = new OperationTaskMaterial();
//				BigDecimal quantityRequired = BigDecimal.ZERO;
//				for (OperationTaskMaterial operationTaskMaterial : map.getValue()) {
//					material.setOperationTaskId(operationTaskMaterial.getOperationTaskId());
//					material.setPartId(operationTaskMaterial.getPartId());
//					material.setQpa(operationTaskMaterial.getQpa());
//					quantityRequired = quantityRequired.add(operationTaskMaterial.getQuantityRequired());
//				}
//				material.setQuantityRequired(quantityRequired);
//				operationTaskMaterialMapper.insert(material);
//			}
//		}
//}


	public void addMoStructureComponent(Long moId, Long partId, OperationTask operationTask) {
		MoRoutingOperation moRoutingOperation = moRoutingOperationMapper.selectById(operationTask.getMoRoutingOperationId());
		Operation operation = operationMapper.selectById(moRoutingOperation.getOperationId());
		if (operation == null) {
			throw new RuntimeException("工序丢失");
		}
		// 根据零件id 和 车间订单id 查询产品结构半成品节点
		List<MoStructureComponent> currentStrucList =
				moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
						.eq(MoStructureComponent::getPlanManufacturingOrderId, moId)
						.eq(MoStructureComponent::getPartId, partId)
						.and(wrapper -> wrapper.ne(MoStructureComponent::getOperationId, moRoutingOperation.getOperationId()).or(w -> w.isNull(MoStructureComponent::getOperationId))));
		// 零件id 的list
		if (CollectionUtil.isEmpty(currentStrucList)) {
			throw new RuntimeException("工序为：" + operation.getName() + "的工单生产的零件不存在车间订单bom中");
		}
		//if (operationTask.getOperationTaskType().equals("M")) {
		List<Long> partIds = new ArrayList<>();
		for (MoStructureComponent currentStruc : currentStrucList) {
			// 根据父节点id 和 消耗工序 车间订单id
			List<MoStructureComponent> childStrucList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
					.eq(MoStructureComponent::getPlanManufacturingOrderId, moId)
					.eq(MoStructureComponent::getParent, currentStruc.getId())
					.eq(MoStructureComponent::getOperationId, moRoutingOperation.getOperationId()));
			for (MoStructureComponent childStruc : childStrucList) {
				OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
				operationTaskMaterial.setOperationTaskId(operationTask.getId());
				operationTaskMaterial.setPartId(childStruc.getPartId());
				operationTaskMaterial.setQpa(childStruc.getQpa().divide(currentStruc.getQpa(), 3, BigDecimal.ROUND_HALF_UP));
				operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQpa().multiply(operationTask.getPlannedQuantity()));
				partIds.add(childStruc.getPartId());
				operationTaskMaterialMapper.insert(operationTaskMaterial);
			}
			//查找当前工序的上一道工序的产出
			MoRoutingOperation moRoutingOperationLast = getLastMoRoutingOperation(moId, operationTask.getMoRoutingOperationId());
			if (null != moRoutingOperationLast.getPartId()) {
				if (!partIds.contains(moRoutingOperationLast.getPartId())) {
					OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
					operationTaskMaterial.setOperationTaskId(operationTask.getId());
					operationTaskMaterial.setPartId(moRoutingOperationLast.getPartId());
					operationTaskMaterial.setQpa(BigDecimal.ONE);
					operationTaskMaterial.setQuantityRequired(operationTask.getPlannedQuantity());
					partIds.add(moRoutingOperationLast.getPartId());
					operationTaskMaterialMapper.insert(operationTaskMaterial);
				}
			}
		}
		//}
		//如果是修理就获取当前节点的零件
		//if (operationTask.getOperationTaskType().equals("F")) {
		//	OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
		//	operationTaskMaterial.setOperationTaskId(operationTask.getId());
		//	operationTaskMaterial.setPartId(partId);
		//	operationTaskMaterial.setQpa(BigDecimal.ONE);
		//	operationTaskMaterial.setQuantityRequired(operationTask.getPlannedQuantity());
		//	operationTaskMaterialMapper.insert(operationTaskMaterial);
		//}
	}

	/**
	 * 根据工艺路线工序id 获取上一道工序
	 *
	 * @param moId
	 * @param id
	 * @return
	 */
	private MoRoutingOperation getLastMoRoutingOperation(Long moId, Long id) {
		MoRoutingOperation moRoutingOperation = new MoRoutingOperation();
		List<MoRoutingOperation> moRoutingOperationList = moRoutingOperationMapper.selectList(Wrappers.<MoRoutingOperation>lambdaQuery()
				.eq(MoRoutingOperation::getMoId, moId)
				.orderByAsc(MoRoutingOperation::getOperationOrder));
		if (moRoutingOperationList.size() > 1) {
			for (int i = 1; i < moRoutingOperationList.size(); i++) {
				if (id.equals(moRoutingOperationList.get(i).getId())) {
					moRoutingOperation = moRoutingOperationList.get(i - 1);
					break;
				}
			}
		}
		return moRoutingOperation;
	}


	@Override
	public String fullUpdate(OperationTaskDTO operationTaskDTO) {
		OperationTask operationTask = baseMapper.selectById(operationTaskDTO.getId());
		baseMapper.updateById(operationTaskDTO);
		OperationTask newOperationTask = baseMapper.selectById(operationTaskDTO.getId());
		OperationTaskSupply operationTaskSupply = operationTaskSupplyMapper.selectOne(Wrappers.<OperationTaskSupply>lambdaQuery()
				.eq(OperationTaskSupply::getOperationTaskId, operationTaskDTO.getId()));
		if (!operationTask.getRoutingOperationId().equals(newOperationTask.getRoutingOperationId())) {
			operationTaskMaterialMapper.delete(Wrappers.<OperationTaskMaterial>lambdaQuery().eq(OperationTaskMaterial::getOperationTaskId, operationTaskDTO.getId()));
			if (operationTaskSupply == null || operationTaskSupply.getMoId() == null) {
				throw new RuntimeException("工单不存在对应制造订单，添加对应的所需物料");
			}
			//添加工单所需物料
			addMoStructureComponent(operationTaskSupply.getMoId(), operationTaskDTO.getPartId(), newOperationTask);
		}
		if (operationTask.getPlannedQuantity().compareTo(newOperationTask.getPlannedQuantity()) != 0) {
			List<OperationTaskMaterial> operationTaskMaterialList = operationTaskMaterialMapper.selectList(Wrappers.<OperationTaskMaterial>lambdaQuery()
					.eq(OperationTaskMaterial::getOperationTaskId, operationTaskDTO.getId()));
			for (OperationTaskMaterial operationTaskMaterial : operationTaskMaterialList) {
				operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQuantityRequired().subtract(operationTaskMaterial.getQuantityRequired())
						.add(operationTaskMaterial.getQpa().multiply(newOperationTask.getPlannedQuantity())));
				operationTaskMaterialMapper.updateById(operationTaskMaterial);
			}
			operationTaskSupply.setQuantitySupply(operationTaskDTO.getPlannedQuantity());
			operationTaskSupplyMapper.updateById(operationTaskSupply);
		}
		return operationTask.getOptaskNo();
	}

	@Override
	public boolean fullDelete(Long id) {
		baseMapper.deleteOperationById(id);

		return false;
	}

	@Override
	public List<ManufacturingOrderDTO> getOperationSupplyById(Long id) {
		List<ManufacturingOrderDTO> manufacturingOrderDTO = manufacturingOrderMapper.getOperationSupplyById(id);
		return manufacturingOrderDTO;
	}

	@Override
	public List<OperationTaskMaterialDTO> getMaterial(QueryWrapper<OperationTaskMaterialDTO> gen) {
		return operationTaskMaterialMapper.getMaterial(gen);
	}

	@Override
	public IPage<List<OperationTaskDTO>> pdaPage(Page page, QueryWrapper<OperationTaskDTO> gen) {
		return baseMapper.pdaPage(page, gen);
	}

	@Override
	public List<JSONObject> pdaMaterial(QueryWrapper<OperationTaskMaterialDTO> gen) {
		return operationTaskMaterialMapper.pdaMaterial(gen);
	}

	@Override
	public List<OperationTaskMaterial> getOperationMaterialById(Long id) {
		return operationTaskMaterialMapper.getOperationMaterialById(id);
	}

	@Override
	public OperationTaskMaterial getOperationMaterialByMaterialId(Long id) {
		return operationTaskMaterialMapper.getOperationMaterialByMaterialId(id);
	}

	@Override
	public R addOperationMaterial(OperationTaskMaterial operationTaskMaterial) {
		judgePartAndOperationTask(operationTaskMaterial.getPartId(), operationTaskMaterial.getOperationTaskId());
		BigDecimal quantityRequired = calQuantityRequired(operationTaskMaterial.getOperationTaskId(), operationTaskMaterial.getQpa());
		operationTaskMaterial.setQuantityRequired(quantityRequired);
		if (operationTaskMaterialMapper.insert(operationTaskMaterial) == 1) {
			return R.ok();
		} else {
			return R.failed();
		}
	}

	@Override
	public R updateOperationMaterial(OperationTaskMaterial operationTaskMaterial) {
		judgePartAndOperationTask(operationTaskMaterial.getPartId(), operationTaskMaterial.getOperationTaskId());
		BigDecimal quantityRequired = calQuantityRequired(operationTaskMaterial.getOperationTaskId(), operationTaskMaterial.getQpa());
		operationTaskMaterial.setQuantityRequired(quantityRequired);
		if (operationTaskMaterialMapper.updateById(operationTaskMaterial) == 1) {
			return R.ok();
		} else {
			return R.failed();
		}

	}


	/**
	 * 判断零件和工序任务是否存在
	 *
	 * @param partId
	 * @param operationTaskId
	 */
	public void judgePartAndOperationTask(Long partId, Long operationTaskId) {
		Part part = partMapper.selectById(partId);
		OperationTask operationTask = operationTaskMapper.selectById(operationTaskId);
		if (part == null || operationTask == null) {
			throw new RuntimeException("没有此零件或者此工序任务！");
		}
	}

	/**
	 * 计算需求数量
	 *
	 * @param operationTaskId
	 * @param qpa
	 */
	public BigDecimal calQuantityRequired(Long operationTaskId, BigDecimal qpa) {
		OperationTask operationTask = operationTaskMapper.selectById(operationTaskId);
		BigDecimal quantityRequired = operationTask.getPlannedQuantity().multiply(qpa).setScale(6, RoundingMode.HALF_UP);
		return quantityRequired;
	}


	@Override
	public R deleteOperationMaterial(Long id) {
		if (operationTaskMaterialMapper.deleteById(id) == 1) {
			return R.ok();
		} else {
			return R.failed();
		}
	}


	@Override
	public List<ManufacturingOrderOperationTemplateDTO> getTemplate(Long id) {
		List<ManufacturingOrderOperationTemplateDTO> manufacturingOrderOperationTemplateDTOList = manufacturingOrderOperationTemplateMapper.getTemplate(id);
		if (CollectionUtil.isNotEmpty(manufacturingOrderOperationTemplateDTOList)) {
			for (ManufacturingOrderOperationTemplateDTO manufacturingOrderOperationTemplateDTO : manufacturingOrderOperationTemplateDTOList) {
				List<ManufacturingOrderOperationParam> manufacturingOrderOperationParamList = manufacturingOrderOperationParamMapper.selectList(Wrappers.<ManufacturingOrderOperationParam>lambdaQuery().eq(ManufacturingOrderOperationParam::getMoRoutingOperationId, manufacturingOrderOperationTemplateDTO.getMoRoutingOperationId())
						.eq(ManufacturingOrderOperationParam::getOperationTemplateId, manufacturingOrderOperationTemplateDTO.getId()));
				if (CollectionUtil.isNotEmpty(manufacturingOrderOperationParamList)) {
					manufacturingOrderOperationTemplateDTO.setParamList(manufacturingOrderOperationParamList);
				} else {
					manufacturingOrderOperationTemplateDTO.setParamList(null);
				}
			}
		}
		return manufacturingOrderOperationTemplateDTOList;
	}

	@Override
	public IPage<List<Template>> getTemplateUpdate(Page page, Long id, Template template) {
		return basicParamTemplateMapper.getTemplateUpdate(page, id, template);
	}

	@Override
	public IPage<List<Template>> getTemplateByType(Page page, QueryWrapper<Template> gen) {
		return basicParamTemplateMapper.getTemplateByType(page, gen);
	}

	@Override
	public List<OperationTaskRecordDTO> getTemplateRecord(OperationTaskRecordDTO operationTaskRecordDTO) {
		QueryWrapper<OperationTaskRecordDTO> queryWrapper = Wrappers.<OperationTaskRecordDTO>query()
				.eq(null != operationTaskRecordDTO.getWorkstationId(), "ew.workstation_id", operationTaskRecordDTO.getWorkstationId())
				.eq(null != operationTaskRecordDTO.getTemplateType(), "ew.template_type", operationTaskRecordDTO.getTemplateType())
				.eq(null != operationTaskRecordDTO.getDutyRecordId(), "ew.duty_record_id", operationTaskRecordDTO.getDutyRecordId())
				.eq(null != operationTaskRecordDTO.getOperationTaskId(), "ew.operation_task_id", operationTaskRecordDTO.getOperationTaskId())
				.like(StringUtils.isNotBlank(operationTaskRecordDTO.getOutBatchNo()), "ew.out_batch_no", operationTaskRecordDTO.getOutBatchNo())
				.eq(null != operationTaskRecordDTO.getProductOutId(), "ew.product_out_id", operationTaskRecordDTO.getProductOutId())
				.like(StringUtils.isNotBlank(operationTaskRecordDTO.getTemplateName()), "ew.template_name", operationTaskRecordDTO.getTemplateName())
				.like(StringUtils.isNotBlank(operationTaskRecordDTO.getCreateUser()), "ew.create_user", operationTaskRecordDTO.getCreateUser())
				.eq(null != operationTaskRecordDTO.getSegmentationId(), "ew.segmentation_id", operationTaskRecordDTO.getSegmentationId())
				.orderByDesc("ew.create_time");
		if (null != operationTaskRecordDTO.getStartTime() && null != operationTaskRecordDTO.getEndTime()) {
			queryWrapper.between(null != operationTaskRecordDTO.getStartTime() && null != operationTaskRecordDTO.getEndTime()
					, "ew.create_time"
					, DateUtil.parse(operationTaskRecordDTO.getStartTime() + " 00:00:00", "yyyy-MM-dd HH:mm:ss")
					, DateUtil.parse(operationTaskRecordDTO.getEndTime() + " 23:59:59", "yyyy-MM-dd HH:mm:ss"));
		}
		return operationTaskRecordMapper.getTemplateRecord(queryWrapper);
	}


	@Override
	public boolean updateTemplateParam(List<OperationTaskParam> operationTaskParamList) {
		for (OperationTaskParam operationTaskParam : operationTaskParamList) {
			if (operationTaskParam.getId() != null) {
				if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
					operationTaskParamMapper.updateById(operationTaskParam);
				} else {
					operationTaskParamMapper.deleteById(operationTaskParam);
				}
			} else {
				if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
					operationTaskParamMapper.insert(operationTaskParam);
				}
			}
		}
		return false;
	}

	@Override
	public Object getOperationTaskById(Long id) {
		OperationTask operationTask = baseMapper.selectById(id);
		String status = "04completed";
		String newStatus = "05canceled";
		JSONObject order = new JSONObject();
		if (operationTask == null) {
			order.put("status", "1");
		} else {
			if (status.equals(operationTask.getState())) {
				order.put("status", "1");
			} else if (newStatus.equals(operationTask.getState())) {
				order.put("status", "1");
			} else {
				order.put("status", "0");
			}
		}
		return order;
	}

	@Override
	public List<OperationTaskParamDTO> getTemplateParam(OperationTaskParamDTO operationTaskParamDTO) {
		OperationTaskRecord operationTaskRecord = operationTaskRecordMapper.selectById(operationTaskParamDTO.getOperationTaskRecordId());
		List<OperationTaskParamDTO> operationTaskParamDTOList = operationTaskParamMapper.getTemplateParamUpdate(operationTaskParamDTO, operationTaskRecord.getOperationTemplateId());
		List<OperationTaskAttachment> operationTaskAttachmentList = operationTaskAttachmentMapper.selectList(Wrappers.<OperationTaskAttachment>lambdaQuery().eq(OperationTaskAttachment::getOperationTaskRecordId, operationTaskParamDTO.getOperationTaskRecordId()));
		operationTaskParamDTOList.get(0).setOperationTaskAttachmentList(operationTaskAttachmentList);
		return operationTaskParamDTOList;
	}

	@Override
	public OperationTaskRecord addTemplateParam(OperationTaskRecordDTO
														operationTaskRecordDTO, List<MultipartFile> file) {
		OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
		String name = null;
		if (operationTaskRecordDTO.getOperationTemplateId() != null) {
			Template template = basicParamTemplateMapper.selectById(operationTaskRecordDTO.getOperationTemplateId());
			name = template.getTemplateType();
		}
		if (operationTaskRecordDTO.getId() == null) {
			operationTaskRecord.setWorkstationId(operationTaskRecordDTO.getWorkstationId());
			operationTaskRecord.setPartId(operationTaskRecordDTO.getPartId());
			operationTaskRecord.setWorkstationId(operationTaskRecordDTO.getWorkstationId());
			operationTaskRecord.setDutyRecordId(operationTaskRecordDTO.getDutyRecordId());
			operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
			operationTaskRecord.setOperationTaskId(operationTaskRecordDTO.getOperationTaskId());
			operationTaskRecord.setOperationTemplateId(operationTaskRecordDTO.getOperationTemplateId());
			operationTaskRecord.setProductOutId(operationTaskRecordDTO.getProductOutId());
			operationTaskRecord.setOutBatchNo(operationTaskRecordDTO.getOutBatchNo());
			operationTaskRecordMapper.insert(operationTaskRecord);
			for (OperationTaskParam operationTaskParam : operationTaskRecordDTO.getOperationTaskParamList()) {
				if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
					operationTaskParam.setOperationTaskRecordId(operationTaskRecord.getId());
					operationTaskParamMapper.insert(operationTaskParam);
				}
			}
		} else {
			operationTaskRecord = operationTaskRecordMapper.selectById(operationTaskRecordDTO.getId());
			if (CollectionUtil.isNotEmpty(operationTaskRecordDTO.getOperationTaskParamList())) {
				for (OperationTaskParam operationTaskParam : operationTaskRecordDTO.getOperationTaskParamList()) {
					if (operationTaskParam.getId() != null) {
						if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
							operationTaskParamMapper.updateById(operationTaskParam);
						} else {
							operationTaskParamMapper.deleteById(operationTaskParam);
						}
					} else {
						if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
							// 查找是否存在已保存参数
							OperationTaskParam oldParam = operationTaskParamMapper.selectOne(Wrappers.<OperationTaskParam>lambdaQuery()
									.eq(OperationTaskParam::getOperationTemplateId, operationTaskParam.getOperationTemplateId())
									.eq(OperationTaskParam::getTechnologyOperationParamId, operationTaskParam.getTechnologyOperationParamId()));
							if (oldParam != null) {
								operationTaskParam.setId(oldParam.getId());
								operationTaskParamMapper.updateById(operationTaskParam);
							} else {
								operationTaskParam.setOperationTaskRecordId(operationTaskRecord.getId());
								operationTaskParamMapper.insert(operationTaskParam);
							}
						}
					}
				}
			}
		}
		if (CollectionUtil.isNotEmpty(file)) {
			uploadFile(file, operationTaskRecord.getId());
		}
		return operationTaskRecord;
	}

	@Override
	public OperationTaskRecord addTemplateParam(Long operationTaskId, Long dutyRecordId, Long workstationId, Long
			productOutId, String operationTaskParamList, Long operationTemplateId, Long id, List<MultipartFile> file) {
		OperationTaskRecordDTO operationTaskRecordDTO = new OperationTaskRecordDTO();
		if (null != productOutId) {
			ProductOutput productOutput = productOutputMapper.selectById(productOutId);
			if (null != productOutput.getPartId()) {
				operationTaskRecordDTO.setPartId(productOutput.getPartId());
				operationTaskRecordDTO.setProductOutId(productOutput.getId());
				operationTaskRecordDTO.setOutBatchNo(productOutput.getOutBatchNo());
			}
		}
		if (null != workstationId) {
			operationTaskRecordDTO.setWorkstationId(workstationId);
		}
		operationTaskRecordDTO.setId(id);
		operationTaskRecordDTO.setOperationTaskId(operationTaskId);
		operationTaskRecordDTO.setDutyRecordId(dutyRecordId);
		if (operationTaskParamList != null) {
			List<OperationTaskParam> operationTaskParam = JSONArray.parseArray(operationTaskParamList).toJavaList(OperationTaskParam.class);
			operationTaskRecordDTO.setOperationTaskParamList(operationTaskParam);
		} else {
			operationTaskRecordDTO.setOperationTaskParamList(new ArrayList<>());
		}
		operationTaskRecordDTO.setOperationTemplateId(operationTemplateId);
		return addTemplateParam(operationTaskRecordDTO, file);
	}


	@Override
	public List<OperationTaskRecord> batchAddTemplateRecord(TemplateRecordInputDTO templateRecordInputDTO) {
		String name = null;
		if (templateRecordInputDTO.getOperationTemplateId() != null) {
			Template template = basicParamTemplateMapper.selectById(templateRecordInputDTO.getOperationTemplateId());
			name = template.getTemplateType();
		}
		//产出表增加生产记录
		List<ProductOutput> productOutputList = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getProductOutIdList())) {
			productOutputList = productOutputMapper.selectBatchIds(templateRecordInputDTO.getProductOutIdList());
		}
		List<OperationTaskRecord> operationTaskRecordList = new ArrayList<>();
		for (ProductOutput productOutput : productOutputList) {
			OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
			operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
			operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
			operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
			operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
			operationTaskRecord.setPartId(productOutput.getPartId());
			operationTaskRecord.setOperationTaskId(templateRecordInputDTO.getOperationTaskId());
			operationTaskRecord.setProductOutId(productOutput.getId());
			operationTaskRecord.setOutBatchNo(productOutput.getOutBatchNo());
			operationTaskRecordList.add(operationTaskRecord);
		}
		//分割任务产出表增加生产记录
		List<SegmentationTaskRecord> segmentationTaskRecordList = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getSegmentationIdList())) {
			segmentationTaskRecordList = segmentationTaskRecordMapper.selectBatchIds(templateRecordInputDTO.getSegmentationIdList());
		}
		for (SegmentationTaskRecord segmentationTaskRecord : segmentationTaskRecordList) {
			OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
			operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
			operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
			operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
			operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
			operationTaskRecord.setPartId(segmentationTaskRecord.getPartId());
			operationTaskRecord.setSegmentationId(segmentationTaskRecord.getId());
			operationTaskRecord.setOutBatchNo(segmentationTaskRecord.getPartBatchNo());
			operationTaskRecordList.add(operationTaskRecord);
		}
		//未添加产出零件和分割任务零件的记录
		if (CollectionUtil.isEmpty(templateRecordInputDTO.getSegmentationIdList()) && CollectionUtil.isEmpty(templateRecordInputDTO.getProductOutIdList())) {
			OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
			operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
			operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
			operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
			operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
			operationTaskRecord.setOperationTaskId(templateRecordInputDTO.getOperationTaskId());
			operationTaskRecordList.add(operationTaskRecord);
		}

		operationTaskRecordService.saveBatch(operationTaskRecordList);

		//生产记录参数添加
		if (templateRecordInputDTO.getOperationTaskParamList() != null) {
			List<OperationTaskParam> operationTaskParamList = JSONArray.parseArray(templateRecordInputDTO.getOperationTaskParamList()).toJavaList(OperationTaskParam.class);
			for (OperationTaskParam operationTaskParam : operationTaskParamList) {
				if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
					List<OperationTaskParam> paramList = new ArrayList<>();
					for (OperationTaskRecord record : operationTaskRecordList) {
						OperationTaskParam param = new OperationTaskParam();
						BeanUtil.copyProperties(operationTaskParam, param);
						param.setOperationTaskRecordId(record.getId());
						paramList.add(param);
					}
					operationTaskParamService.saveBatch(paramList);
				}
			}
		}

		//附件
/*		if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getFile())) {
			operationTaskRecordList.stream().forEach(a->{
				uploadFile(templateRecordInputDTO.getFile(), a.getId());
			});
		}*/
		return operationTaskRecordList;
	}


	@Override
	public Boolean batchUpdateTemplateRecord(TemplateRecordInputDTO templateRecordInputDTO) {
		List<OperationTaskParam> operationTaskParamList = JSONArray.parseArray(templateRecordInputDTO.getOperationTaskParamList()).toJavaList(OperationTaskParam.class);
		if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getIdList())) {
			//删除原生产记录绑定的生产记录参数
			operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().in(OperationTaskParam::getOperationTaskRecordId, templateRecordInputDTO.getIdList()));
			//批量新增生产记录参数
			for (OperationTaskParam operationTaskParam : operationTaskParamList) {
				if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
					List<OperationTaskParam> paramList = new ArrayList<>();
					for (Long id : templateRecordInputDTO.getIdList()) {
						OperationTaskParam param = new OperationTaskParam();
						BeanUtil.copyProperties(operationTaskParam, param);
						param.setOperationTaskRecordId(id);
						paramList.add(param);
					}
					operationTaskParamService.saveBatch(paramList);
				}
			}

		}

		return true;
	}


	@Override
	public Boolean deleteBatchTemplateRecord(List<Long> idList) {
		operationTaskRecordMapper.deleteBatchIds(idList);
		operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().in(OperationTaskParam::getOperationTaskRecordId, idList));
		return true;
	}


	@Override
	public Boolean deleteTemplateRecord(OperationTaskRecordDTO operationTaskRecordDTO) {
		operationTaskRecordMapper.deleteById(operationTaskRecordDTO.getId());
		operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().eq(OperationTaskParam::getOperationTaskRecordId, operationTaskRecordDTO.getId()));
		return true;
	}

	@Override
	public R uploadFile(List<MultipartFile> file, Long operationTaskRecordId) {
		for (MultipartFile multipartFile : file) {
			String fileName = IdUtil.simpleUUID() + StrUtil.DOT + FileUtil.extName(multipartFile.getOriginalFilename());
			String url = String.format("/mes/operationTask/%s/%s", BUCKET_NAME, fileName);
			try {
				minioTemplate.putObject(BUCKET_NAME, fileName, multipartFile.getInputStream());
				if (operationTaskRecordId != null) {
					OperationTaskAttachment operationTaskAttachment = new OperationTaskAttachment();
					operationTaskAttachment.setUrl(url);
					operationTaskAttachment.setFileName(fileName);
					operationTaskAttachment.setOriginal(multipartFile.getOriginalFilename());
					operationTaskAttachment.setOperationTaskRecordId(operationTaskRecordId);
					operationTaskAttachmentMapper.insert(operationTaskAttachment);
				}
			} catch (Exception e) {
				log.error("上传失败", e);
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return R.failed(e.getLocalizedMessage());
			}
		}
		return R.ok();
	}

	@Override
	public R<Boolean> deleteFile(OperationTaskAttachment operationTaskAttachment) {
		try {
			minioTemplate.removeObject(ossProperties.getBucketName(), operationTaskAttachment.getFileName());
			operationTaskAttachment.deleteById(operationTaskAttachment.getId());
		} catch (Exception e) {
			log.error("删除文件失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return R.failed(e.getLocalizedMessage());
		}
		return R.ok();
	}

	@Override
	public R getFile(String bucket, String fileName, HttpServletResponse response) {
		try (InputStream inputStream = minioTemplate.getObject(bucket, fileName)) {
			response.setContentType("application/octet-stream; charset=UTF-8");
			IoUtil.copy(inputStream, response.getOutputStream());
		} catch (Exception e) {
			log.error("文件读取异常: {}", e);
			return R.failed(e.getLocalizedMessage());
		}
		return R.ok();
	}

	@Override
	public R combineOperationTask(List<Long> ids) {
		List<OperationTaskDTO> operationTasks = this.baseMapper.selectByIds(ids);
		if (operationTasks.stream().anyMatch(e -> e.getOperationId() == null || e.getWorkstationId() == null || e.getPartId() == null)) {
			return R.failed("选择工单缺少零件、工序或者工作站信息!");
		}
		OperationTask combineTask = new OperationTask();
		BigDecimal totalPlannedQuantity = BigDecimal.ZERO;
		Long totalDiscNum = 0L;
		List<OperationTask> updateList = new ArrayList<>();
		List<String> optaskNos = new ArrayList<>();
		for (int i = 0; i < operationTasks.size(); i++) {
			if (!operationTasks.get(i).getState().equals(OperationTaskStateStringValues.PENDING)) {
				return R.failed("工单不在等待中无法合并");
			}
			if (i > 0) {
				// 零件，工作站，工序相同就可以
				if (!operationTasks.get(i).getPartId().equals(operationTasks.get(i - 1).getPartId())
						|| !operationTasks.get(i).getOperationId().equals(operationTasks.get(i - 1).getOperationId())
						|| !operationTasks.get(i).getWorkstationId().equals(operationTasks.get(i - 1).getWorkstationId())) {
					return R.failed("工单存在差异无法合并");
				}
			}
			List<JoinStockOrder> joinStockOrders = joinStockOrderMapper.selectList(Wrappers.<JoinStockOrder>lambdaQuery().eq(JoinStockOrder::getOperationTaskId, operationTasks.get(i).getId()));
			if (!joinStockOrders.isEmpty()) {
				return R.failed("工单存在预留物料无法合并，请取消预留后合并");
			}

			totalPlannedQuantity = totalPlannedQuantity.add(operationTasks.get(i).getPlannedQuantity());
			Long dicNum = operationTasks.get(i).getDiscNum() == null ? new Long(0) : operationTasks.get(i).getDiscNum();
			totalDiscNum += dicNum;
			OperationTask update = new OperationTask();
			BeanUtil.copyProperties(operationTasks.get(i), update);
			update.setCombineState(OperationTask.COMBINE_STATE_SON);
			update.setState(OperationTaskStateStringValues.COMBINED);
			updateList.add(update);

			optaskNos.add(operationTasks.get(i).getOptaskNo());
		}
		BeanUtil.copyProperties(operationTasks.get(0), combineTask);
		combineTask.setOptaskNo(opTaskSequence.nextNo());
		combineTask.setPlannedQuantity(totalPlannedQuantity);
		combineTask.setDiscNum(totalDiscNum);
		combineTask.setCombineState(OperationTask.COMBINE_STATE_MAIN);
		combineTask.setRemark("被合并工单编号为：" + org.apache.commons.lang3.StringUtils.join(optaskNos, ","));
		this.baseMapper.insert(combineTask);

		// 生成关联表数据
		OperationTaskSupply supply = new OperationTaskSupply();
		supply.setOperationTaskId(combineTask.getId());
		OperationTaskSupply oldSupply = supplyMapper.selectOne(Wrappers.<OperationTaskSupply>lambdaQuery().eq(OperationTaskSupply::getOperationTaskId, operationTasks.get(0).getId()));
		supply.setMoId(oldSupply.getMoId());
		supply.setQuantitySupply(totalPlannedQuantity);
		supplyMapper.insert(supply);

		// 累加工序所需物料数据
		List<OperationTaskMaterial> materials = operationTaskMaterialMapper.selectList(Wrappers.<OperationTaskMaterial>lambdaQuery().in(OperationTaskMaterial::getOperationTaskId, ids));
		Map<Long, List<OperationTaskMaterial>> collect = materials.stream().collect(Collectors.groupingBy(OperationTaskMaterial::getPartId));
		for (Entry<Long, List<OperationTaskMaterial>> map : collect.entrySet()) {
			OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
			operationTaskMaterial.setOperationTaskId(combineTask.getId());
			operationTaskMaterial.setPartId(map.getKey());
			operationTaskMaterial.setQpa(map.getValue().get(0).getQpa());
			operationTaskMaterial.setQuantityRequired(BigDecimal.ZERO);
			for (OperationTaskMaterial material : map.getValue()) {
				operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQuantityRequired().add(material.getQuantityRequired()));
			}
			operationTaskMaterialMapper.insert(operationTaskMaterial);
		}

		updateList.forEach(task -> {
			task.setCombineTaskId(combineTask.getId());
			task.setCombineTaskNo(combineTask.getOptaskNo());
			if (StringUtils.isNotBlank(task.getRemark())) {
				if (StringUtils.endsWith(task.getRemark(), "。")) {
					task.setRemark(task.getRemark() + "合并工单编号为：" + combineTask.getOptaskNo());
				} else {
					task.setRemark(task.getRemark() + "。合并工单编号为：" + combineTask.getOptaskNo());
				}
			} else {
				task.setRemark("合并工单编号为：" + combineTask.getOptaskNo());
			}
		});
		this.updateBatchById(updateList);
		return R.ok();
	}

	@Override
	public List<OperationTaskDTO> getCombinedOperationTaskInfo(Long id) {
		OperationTask task = this.getById(id);
		if (!task.getCombineState().equals(OperationTask.COMBINE_STATE_MAIN)) {
			throw new RuntimeException("非合并订单");
		}
		return this.getBaseMapper().getCombinedOperationTaskInfo(id);
	}


	//*************************************************************************对接数据采集终端
	@Override
	public R getAllMessage(ProductOutputDTO productOutput) {
		//跳线车间SN码用的是system_no字段，现有系统SN码用的是out_batch_no字段
		//标准系统统一通过out_batch_no对应SN号，后面跳线车间需要修改

		if (StringUtils.isBlank(productOutput.getSystemNo()) || StringUtils.isBlank(productOutput.getInspectionType())) {
			return R.failed("查询参数systemNo或inspectionType为空");
		}

		InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO = new InfosOfferDetectionTerminalDTO();//new一个接口返回的数据对象，下面的操作就是往这个类里面set数据
		productOutput.setOutBatchNo(productOutput.getSystemNo());//对外的接口标准就不动了，内部进行校正，将systemNo值set到outBatchNo

		//判断该SN号是否已经有工序报工产出记录
		List<ProductOutputDTO> productOutputDTOList = productOutputMapper.getProductOutDetailsBySN(productOutput.getOutBatchNo());
		if (CollectionUtil.isEmpty(productOutputDTOList)) {
			return R.failed("该SN号查无工序报工产出明细");
		}

		infosOfferDetectionTerminalDTO.setSystemNo(productOutput.getOutBatchNo());//载入SN号（对外的字段标准不动，还是用systemNo）

		//根据报工产出的SN号查询客户订单信息
		CustomerOrder customerOrder = customerOrderMapper.getCustomerOrderByProductOutput(productOutput.getOutBatchNo());
		if (customerOrder != null) {
			infosOfferDetectionTerminalDTO.setCustomerOrderNo(customerOrder.getCustomerOrderNo());
			infosOfferDetectionTerminalDTO.setCustomerName(customerOrder.getCustomerName());
			//根据客户订单id查询客户订单参数
			List<CustomerOrderParam> customerOrderParamList = customerOrderParamMapper.selectList(Wrappers.<CustomerOrderParam>lambdaQuery().eq(CustomerOrderParam::getOrderId, customerOrder.getId()));
			//如果存在则取值
			if (CollectionUtil.isNotEmpty(customerOrderParamList)) {
				for (CustomerOrderParam customerOrderParam : customerOrderParamList) {
					//如果客户订单参数对象的field字段值=EntityName，则获取其参数值字段value（获取订单项目实体名称）
					if ("EntityName".equals(customerOrderParam.getField())) {
						infosOfferDetectionTerminalDTO.setEneityName(customerOrderParam.getValue());
					}
				}
			}
		}

		//根据报工产出的SN号查询报工产出
		ProductOutput newProductOutput = productOutputMapper.selectOne(Wrappers.<ProductOutput>lambdaQuery().eq(ProductOutput::getOutBatchNo, productOutput.getOutBatchNo()).last("limit 1"));
		if (newProductOutput != null) {
			infosOfferDetectionTerminalDTO.setManufactureDate(newProductOutput.getCreateTime());
			infosOfferDetectionTerminalDTO.setPartId(newProductOutput.getPartId());
			Part part = partMapper.selectById(newProductOutput.getPartId());
			if (part != null) {
				//给operationTaskDTO的零件名称、零件号、长度赋值
				infosOfferDetectionTerminalDTO.setPartName(part.getPartName());
				infosOfferDetectionTerminalDTO.setPartNo(part.getPartNo());
				//infosOfferDetectionTerminalDTO.setLength(part.getLength());//现有系统的零件基础数据中没有长度这个字段
			}
			infosOfferDetectionTerminalDTO.setLength(productOutputMapper.sumProdOutQtyByBatchNo(newProductOutput.getOutBatchNo()));//长度
		}

		//根据报工产出的SN号查询制造订单下的检测标准
		List<MoTestStandardDTO> moTestStandardList = manufacturingOrderMapper.getManufacturingOrder(productOutput.getOutBatchNo());
		List<MoTestStandardDTO> moTestStandardListNew = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(moTestStandardList)) {
			//根据检测类型剔除不匹配的检测标准（但检测标准数大于1时再去做剔除操作，增加业务的容错率）
			if (moTestStandardList.size() > 1) {
				moTestStandardListNew = moTestStandardList.stream().filter(o -> o.getInspectionType().equals(productOutput.getInspectionType())).collect(Collectors.toList());
			} else {
				moTestStandardListNew = moTestStandardList;
			}


			//取车间订单下所有检测标准对应的检测项目
			//遍历检测标准
			for (MoTestStandardDTO moTestStandardDTO : moTestStandardListNew) {
				//获取检测标准下的检测项目
				moTestStandardDTO.setMoTestStandardParamList(moTestStandardParamMapper.getTestStandardParam(moTestStandardDTO.getId()));
			}
		}
		infosOfferDetectionTerminalDTO.setMoTestStandardList(moTestStandardListNew);//获取到了车间订单下的检测标准

		//Gson gson = new Gson();
		//JSONObject jsonObject = JSONObject.parseObject(gson.toJson(infosOfferDetectionTerminalDTO));//过滤掉无效字段

		return R.ok(infosOfferDetectionTerminalDTO);
	}


	@Override
	public R saveReport(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO) {
		String testResult = "合格";//与采集终端程序约定好的（前期跳线车间已经约定好）

		//根据SN号查询检测汇报
		Report reportNew = reportMapper.selectOne(Wrappers.<Report>lambdaQuery().eq(Report::getOutBatchNo, infosOfferDetectionTerminalDTO.getSystemNo()).last("limit 1"));
		if (reportNew == null) {
			//不存在则创建

			//创建检测申请汇报表
			Report report = new Report();
			report.setOutBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());//SN
			report.setRemark(infosOfferDetectionTerminalDTO.getSystemNo());//备注
			report.setReportPerson(infosOfferDetectionTerminalDTO.getTestPeople());//汇报人
			report.setReportType(infosOfferDetectionTerminalDTO.getReportType());//检测汇报类型
			report.setCheckState("01checked");//检测状态=已检测
			reportService.save(report);

			//创建检测汇报零件
			ApplyPart applyPart = new ApplyPart();
			applyPart.setReportId(report.getId());//检测汇报id
			applyPart.setLotBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());//批次号
			applyPart.setPartId(infosOfferDetectionTerminalDTO.getPartId());//零件id
			//通过SN号获取产出数量
			BigDecimal prodOutQty = baseMapper.getProdOutQtyByBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());
			if (testResult.equals(infosOfferDetectionTerminalDTO.getConclusion())) {
				applyPart.setIsQualified(true);//合格
				applyPart.setQtyArrived(prodOutQty + "");//合格数量
				applyPart.setUnqualifiedArrived("0");//不合格数量
			} else {
				applyPart.setIsQualified(false);//不合格
				applyPart.setQtyArrived("0");//合格数量
				applyPart.setUnqualifiedArrived(prodOutQty + "");//不合格数量
			}
			Long operationId = baseMapper.getOperationId(infosOfferDetectionTerminalDTO.getSystemNo());
			if (null != operationId) {
				applyPart.setOperationId(operationId);//工序id
			}

			Part part = partMapper.selectById(infosOfferDetectionTerminalDTO.getPartId());

			if (part != null) {
				//applyPart.setPartDesc(part.getDescription());//零件描述
				applyPart.setPartDesc(part.getPartName());//零件基础数据中的【零件描述】字段已基本被废弃
				applyPart.setPartNo(part.getPartNo());//零件号
			}

			//通过SN查产出
			ProductOutput productOutput = productOutputMapper.selectOne(Wrappers.<ProductOutput>lambdaQuery().eq(ProductOutput::getOutBatchNo, infosOfferDetectionTerminalDTO.getSystemNo()).last("limit 1"));
			if (productOutput != null) {
				applyPart.setSystemNo(productOutput.getSystemNo());//报工产出系统编号
			}

			//创建检测汇报样品
			ReportSample reportSample = new ReportSample();
			reportSample.setSampleNo(reportSampleNumberGenerator.generateNumberWithPrefix(ReportSample.DIGIT, ReportSample.PREFIX, ReportSample::getSampleNo));//样品编号
			reportSample.setReportId(report.getId());//检测汇报id


			if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMoTestStandardParamList())) {
				//检测汇报样品
				reportSample.setTestStandardId(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());//检测标准id
				//检测汇报零件
				applyPart.setMoTestStandardId(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());//检测标准id
				//查询制造订单的检测标准主表
				MoTestStandard moTestStandard = moTestStandardMapper.selectById(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());
				if (moTestStandard != null) {
					applyPart.setTestStandardNo(moTestStandard.getStandardNo());//检测标准编号
					reportSample.setTestStandardNo(moTestStandard.getStandardNo());//检测标准编号
					reportSample.setRemark(moTestStandard.getRemark());//检测标准备注
				}
			}

			applyPartMapper.insert(applyPart);//创建检测汇报零件
			if (null != productOutput) {
				reportSample.setSystemNo(productOutput.getSystemNo());
			}
			reportSampleMapper.insert(reportSample);//创建检测汇报样品

			//创建检测汇报样品对应的检测项目
			saveReportSampleItem(infosOfferDetectionTerminalDTO, reportSample);
			//创建检测汇报测量器具
			saveReportSampleMeasuringTool(infosOfferDetectionTerminalDTO, report, reportSample);

		} else {
			//存在则删除后创建
			//根据检测汇报id获取检测汇报样品
			ReportSample reportSample = reportSampleMapper.selectOne(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, reportNew.getId()).last("limit 1"));
			//根据检测汇报样品id删除检测汇报样品检测项
			reportSampleItemMapper.deleteReportSampleTestItemsBySampleId(reportSample.getId());
			//根据检测汇报id删除检测汇报测量器具
			reportMeasuringToolMapper.deleteByReportId(reportNew.getId());
			//重新创建检测汇报样品检测项明细
			saveReportSampleItem(infosOfferDetectionTerminalDTO, reportSample);
			//创建检测汇报测量器具
			saveReportSampleMeasuringTool(infosOfferDetectionTerminalDTO, reportNew, reportSample);

		}
		return R.ok();
	}

	/**
	 * 创建检测汇报样品检测项目明细
	 *
	 * @param infosOfferDetectionTerminalDTO
	 * @param reportSample
	 */
	public void saveReportSampleItem(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO, ReportSample
			reportSample) {
		if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMoTestStandardParamList())) {
			for (MoTestStandardParamDTO moTestStandardParam : infosOfferDetectionTerminalDTO.getMoTestStandardParamList()) {
				ReportSampleItem reportSampleItem = new ReportSampleItem();
				MoTestStandardParam testStandardParam = moTestStandardParamMapper.selectById(moTestStandardParam.getId());//根据制造订单检测标准参数id获取检测标准参数
				if (testStandardParam != null) {
					reportSampleItem.setSort(testStandardParam.getIndex());//排序
					reportSampleItem.setAisle(testStandardParam.getAisle());//通道
					reportSampleItem.setPosition(testStandardParam.getPosition());//位置
				}
				if ("采集项".equals(moTestStandardParam.getParamType())) {
					reportSampleItem.setTestUser(infosOfferDetectionTerminalDTO.getCollectPeople());//检测人
				}
				if ("互调采集".equals(moTestStandardParam.getParamType())) {
					reportSampleItem.setTestUser(infosOfferDetectionTerminalDTO.getInterpolationPeople());//检测人
				}
				reportSampleItem.setReportSampleId(reportSample.getId());//检测汇报样品id
				reportSampleItem.setItemsId(moTestStandardParam.getId());//检测项id
				reportSampleItem.setItemCode(moTestStandardParam.getCode());//检测项目编号
				reportSampleItem.setItemType(moTestStandardParam.getType());//检测项目类型
				reportSampleItem.setItemName(moTestStandardParam.getParameterItem());//检测项目
				reportSampleItem.setItemReference(moTestStandardParam.getReferenceValue());//参考值
				reportSampleItem.setItemValue(moTestStandardParam.getItemValue());//检测值
				reportSampleItem.setParamType(moTestStandardParam.getParamType());//参数项的检测类型
				reportSampleItem.setTestValue(moTestStandardParam.getTestValue());//计算值
				reportSampleItemMapper.insert(reportSampleItem);//创建检测汇报样品检测项
			}
		}
	}

	/**
	 * 创建检测汇报测量器具明细
	 *
	 * @param infosOfferDetectionTerminalDTO
	 * @param report
	 * @param reportSample
	 */
	public void saveReportSampleMeasuringTool(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO, Report
			report, ReportSample reportSample) {
		if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMeasuringToolList())) {
			for (MeasuringToolDTO measuringToolDTO : infosOfferDetectionTerminalDTO.getMeasuringToolList()) {
				//创建检测汇报测量器具
				ReportMeasuringTool reportMeasuringTool = new ReportMeasuringTool();
				reportMeasuringTool.setReportId(report.getId());//检测汇报id
				reportMeasuringTool.setReportSampleId(reportSample.getId());//检测汇报样品id
				reportMeasuringTool.setMeasuringToolCode(measuringToolDTO.getMeasuringToolCode());//测量器具代码
				reportMeasuringTool.setMeasuringToolName(measuringToolDTO.getMeasuringToolName());//测量器具名称
				reportMeasuringToolMapper.insert(reportMeasuringTool);//创建检测汇报测量器具
			}
		}
	}

	@Override
	public R getApplyReportType() {
		ApplyReportTypeDTO applyReportTypeDTO = new ApplyReportTypeDTO();
		List<ApplyReportTypeDetailDTO> applyReportTypeDetailDTOList = operationTaskMapper.getApplyReportType();
		applyReportTypeDTO.setApplyReportTypeList(applyReportTypeDetailDTOList);
		return R.ok(applyReportTypeDTO);
	}

	//*************************************************************************对接数据采集终端
	@Override
	public R getFromMoOptionByMoId(Long moId) {
		return R.ok(baseMapper.getFromMoOptionByMoId(moId));
	}

	@Override
	public R addReserve(List<Long> ids) {
		List<OperationTaskMaterialDTO> operationTaskMaterialDTOList = operationTaskMaterialMapper.getOperationMaterialByIds(ids);
		Map<Long, PalletTransportsMaterialDTO> materialMap = new HashMap<>();
		//根据零件id 合并需求数量
		for (OperationTaskMaterialDTO operationTaskMaterialDTO : operationTaskMaterialDTOList) {
			PalletTransportsMaterialDTO palletTransportsMaterialDTO = new PalletTransportsMaterialDTO();
			palletTransportsMaterialDTO.setDemandQuantity(BigDecimal.ZERO);
			palletTransportsMaterialDTO.setPartNo(operationTaskMaterialDTO.getPartNo());
			palletTransportsMaterialDTO.setPartName(operationTaskMaterialDTO.getPartName());
			palletTransportsMaterialDTO.setUnit(operationTaskMaterialDTO.getUnit());
			palletTransportsMaterialDTO.setPartId(operationTaskMaterialDTO.getPartId());
			if (materialMap.get(operationTaskMaterialDTO.getPartId()) != null) {
				palletTransportsMaterialDTO = materialMap.get(operationTaskMaterialDTO.getPartId());
			}
			palletTransportsMaterialDTO.setDemandQuantity(operationTaskMaterialDTO.getQuantityRequired().add(palletTransportsMaterialDTO.getDemandQuantity()));
			materialMap.put(operationTaskMaterialDTO.getPartId(), palletTransportsMaterialDTO);
		}
		return R.ok(materialMap.values());
	}

	@Override
	public R getPalletOptaskCode(List<Long> ids) {
		List<String> operationTaskNos = baseMapper.getPalletOptaskCode(ids);
		if (CollectionUtils.isEmpty(operationTaskNos)) {
			return R.ok();
		} else {
			String msg = String.join(",", operationTaskNos);
			return R.failed("工单：" + msg + "已存在物料需求！");
		}
	}

	@Override
	public R getBasicInfoForPdaFeedByWorkstationNo(String workstationNo) {
		BasicInfoForPdaFeedDTO basicInfoForPdaFeedDTO = new BasicInfoForPdaFeedDTO();
		String msg = "";
		//根据工作站编号查询线边仓
		basicInfoForPdaFeedDTO.setLocationList(baseMapper.getFeedLocationListByWorkstationNo(workstationNo));
		//根据工作站编号查询工单（工单直接指定了工作站）
		basicInfoForPdaFeedDTO.setOperationTaskList(baseMapper.getActiveOperationTaskListByWorkstationNo(workstationNo));
		//根据工作站编号查询工单（工单没有直接指定工作站，而是指定了工作中心）
		List<OperationTask> operationTaskList = baseMapper.getActiveOperationTaskListUnPointWorkstationByWorkstationNo(workstationNo);
		for (OperationTask operationTask : operationTaskList) {
			basicInfoForPdaFeedDTO.getOperationTaskList().add(operationTask);
		}
		//按计划开始时间正序排
		operationTaskList = basicInfoForPdaFeedDTO.getOperationTaskList().stream().sorted(Comparator.comparing(OperationTask::getPlannedStartDate)).collect(Collectors.toList());
		basicInfoForPdaFeedDTO.setOperationTaskList(operationTaskList);

		if (CollectionUtil.isEmpty(basicInfoForPdaFeedDTO.getLocationList()) || CollectionUtil.isEmpty(basicInfoForPdaFeedDTO.getOperationTaskList())) {
			msg = "工作站=" + workstationNo + "->对应的线边仓||可用的工单为空";
		}
		return R.ok(basicInfoForPdaFeedDTO, msg);
	}

	@Override
	public List<OperationTaskDTO> getByPalletTransId(Long id) {
		return baseMapper.getByPalletTransId(id);
	}

	@Override
	public Boolean batchUpdatePriority(List<OperationTask> operationTaskList) {
		List<OperationTask> updateList = new ArrayList<>();
		for (OperationTask operationTask : operationTaskList) {
			OperationTask update = new OperationTask();
			update.setId(operationTask.getId());
			update.setPriority(operationTask.getPriority());
			updateList.add(update);
		}
		this.updateBatchById(updateList);
		return true;
	}

	@Override
	public Boolean checkIsStart(Long id, Long workstationId) {
		OperationTask task = this.getById(id);
		List<OperationTaskDTO> operationTask = this.getOperationTask(workstationId, null, null, null, null, null);
		List<OperationTaskDTO> collect = operationTask.stream().filter(p -> p.getPriority().compareTo(task.getPriority()) < 0).collect(Collectors.toList());
		if (!collect.isEmpty()) {
			for (OperationTaskDTO check : collect) {
				if (check.getState().equals(OperationTaskStateStringValues.PENDING) || check.getState().equals(OperationTaskStateStringValues.INPROGRESS)) {
					return false;
				}
			}
		}
		return true;
	}

	@Override
	public void checkStatus(Long id, String event) {
		if (id == null) {
			throw new RuntimeException("请选择一条工单");
		}
		if (("COMPLETE").equals(event)) {
			OperationTask operationTask = baseMapper.selectById(id);
			if (operationTask != null) {
				if (operationTask.getCompletedQuantity().compareTo(operationTask.getPlannedQuantity()) < 0) {
					throw new RuntimeException("完成数量小于计划数量，不允许结束工单");
				}
			}
		}
	}


	@Override
	public List<OperationTaskScreenVO> getByCustomerOrderId(Long customerOrderId) {
		return baseMapper.getByCustomerOrderId(customerOrderId);
	}
}