zy-asrs-master.git

			@@ -1,28 +1,37 @@
			package com.zy.asrs.wms.apis.wcs.services.Impl;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
			import com.zy.asrs.framework.common.R;
			import com.zy.asrs.framework.exception.CoolException;
			import com.zy.asrs.wms.apis.wcs.entity.domain.EssTaskStatus;
			import com.zy.asrs.wms.apis.wcs.entity.domain.SystemProperties;
			import com.zy.asrs.wms.apis.wcs.entity.enums.EssTaskStatus;
			import com.zy.asrs.wms.apis.wcs.entity.request.*;
			import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
			import com.zy.asrs.wms.apis.wcs.services.WcsApiService;
			import com.zy.asrs.wms.asrs.entity.Task;
			import com.zy.asrs.wms.asrs.entity.WaitPakin;
			import com.zy.asrs.wms.apis.wcs.utils.HttpEssUtils;
			import com.zy.asrs.wms.asrs.entity.*;
			import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;
			import com.zy.asrs.wms.asrs.entity.enums.OrderPickStatus;
			import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
			import com.zy.asrs.wms.asrs.service.TaskService;
			import com.zy.asrs.wms.asrs.service.WaitPakinService;
			import com.zy.asrs.wms.asrs.service.WorkService;
			import com.zy.asrs.wms.asrs.service.*;
			import io.jsonwebtoken.lang.Collections;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.http.HttpEntity;
			import org.springframework.http.HttpHeaders;
			import org.springframework.http.HttpMethod;
			import org.springframework.http.ResponseEntity;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.util.LinkedMultiValueMap;
			import org.springframework.util.MultiValueMap;
			import org.springframework.web.client.RestTemplate;

			import java.util.ArrayList;
			import java.util.List;
			import java.util.Map;
			import javax.annotation.Resource;
			import java.util.*;
			import java.util.stream.Collectors;

			@Slf4j
			@@ -35,133 +44,408 @@
			private WorkService workService;
			@Autowired
			private TaskService taskService;
			@Autowired
			private TaskDetlService taskDetlService;
			@Autowired
			private CacheSiteService cacheSiteService;
			@Autowired
			private OrderService orderService;
			@Autowired
			private OrderDetlService orderDetlService;
			@Autowired
			private WaveSeedService waveSeedService;

			@Autowired
			private RestTemplate restTemplate;

			@Autowired
			private PlatformService platformService;

			@Resource
			private SystemProperties systemProperties;


			/**
			* 容器到达接收
			* 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档执行状态
			* * 当前问题：
			* * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置
			* * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能
			* * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区
			* * 当前问题：
			* * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置
			* * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能
			* * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区
			*
			* @param arrivedParam
			* @param hostId
			* @return
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType) {
			List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));
			if (Collections.isEmpty(tasks)) {
			public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType, Long hostId){
			Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));
			if (task == null) {
			return R.error("任务不存在！！");
			}
			log.info("容器到达接收，任务号：{}，当前状态：{}，上报状态：{}",task.getTaskNo(),task.getTaskSts$(),TaskStsType.WCS_CONTAINER_RECEIVE.desc);

			taskType = task.getTaskType() > 100 ? "outStock":"inStock";

			if (taskType.equals("inStock")) {
			//DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)
			.set(Task::getOriginLoc, arrivedParam.getSlotCode())
			.eq(Task::getBarcode, arrivedParam.getContainerCode()));
			if (task.getTaskSts() == 198) {
			return R.error("播种中！！");
			}
			if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_IN.id ) {
			//DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)
			//输送线节点编码，不是源库位
			.set(Task::getOriginSite, arrivedParam.getSlotCode())
			.eq(Task::getBarcode, arrivedParam.getContainerCode()));
			} else {
			log.warn("{}没有下发任务",task.getTaskNo());
			R.error(task.getTaskNo()+"没有下发任务");
			}
			} else {
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_ARRIVED.id)
			.set(Task::getOriginLoc, arrivedParam.getSlotCode())
			.eq(Task::getBarcode, arrivedParam.getContainerCode()));
			if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_ARRIVED.id
			\|\| task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id ) {
			// 到达拣选位，控制播种墙亮灯
			List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getBarcode, task.getBarcode()));
			if(cacheSites.size() == 0) {
			log.error("条码：{}，未找到播种墙亮灯",task.getBarcode());
			throw new CoolException("未找到播种墙");
			}
			for (CacheSite cacheSite:cacheSites) {
			// 获取任务明细数量
			List<TaskDetl> taskDetlByTaskId = taskDetlService.getTaskDetlByTaskId(task.getId());
			int sum = (int)taskDetlByTaskId.stream().mapToDouble(TaskDetl::getAnfme).sum();
			SlapLightControlParam slapLightControlParam = new SlapLightControlParam();
			slapLightControlParam
			.setControllerCode(cacheSite.getMemo())
			.setTagCode(cacheSite.getSiteNo())
			.setColor("GREEN")
			.setIndex(cacheSite.getIndex())
			.setMode("LIGHT")
			.setDisplay(sum + "");
			// 发起亮灯请求
			log.info("任务{}到达拣选位，播种墙亮灯下发",task.getTaskNo(), JSONObject.toJSONString(slapLightControlParam));
			CommonReponse response = HttpEssUtils.post("到达拣选位，播种墙亮灯", HttpEssUtils.PLT_SEND_COMMAND, slapLightControlParam);
			if (response.getCode().equals(0)) {
			log.info("任务{}到达拣选位，播种墙{}亮灯成功",task.getTaskNo(),cacheSite.getSiteNo());
			} else {
			log.info("任务{}到达拣选位，播种墙{}亮灯失败",task.getTaskNo(),cacheSite.getSiteNo());
			}
			}
			boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WAVE_SEED.id)
			.set(Task::getOriginSite, arrivedParam.getSlotCode())
			.eq(Task::getBarcode, arrivedParam.getContainerCode()));
			if (!update) {
			throw new CoolException("容器到达任务更新失败！！");
			}

			} else if(task.getTaskSts().equals(TaskStsType.UPDATED_OUT.id)) {
			ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
			conveyorStarParam.setSlotCode(task.getOriginSite())
			.setContainerCode(task.getBarcode())
			.setDirection("200");
			// 出库完成，清除输送线条码，取下箱子
			CommonReponse response = HttpEssUtils.post("清除输送线条码", HttpEssUtils.CONVEYOR_START, conveyorStarParam);
			if (response.getCode().equals(200)) {
			log.info("{}出库完成，清除{}输送线条码{}成功",task.getTaskNo(),task.getOriginSite(),task.getBarcode());
			}
			}
			}

			return R.success("success");
			}

			/**
			* 容器执行状态上报
			*
			* @param callbackParam
			* @param stockType
			* @param hostId
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType) {
			Long type = 100L;
			public void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType, Long hostId) {
			List<Task> list = taskService.list(new LambdaQueryWrapper<Task>()
			.eq(Task::getBarcode, callbackParam.getContainerCode())
			.ge(Task::getTaskType, type)
			.eq(Task::getTaskNo, callbackParam.getTaskCode()));
			if (!Collections.isEmpty(list)) {
			list.forEach(task -> {
			TaskStsType taskStsType = null;
			if (stockType.equals("inStock")) { //入库任务
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
			if (task.getTaskSts() == TaskStsType.WCS_CONTAINER_RECEIVE.id) {
			taskStsType = TaskStsType.WCS_TOTE_LOAD;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_LOAD.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
			if (task.getTaskSts() == TaskStsType.WCS_TOTE_LOAD.id) {
			taskStsType = TaskStsType.WCS_TOTE_UNLOAD;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_UNLOAD.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件
			if (task.getTaskSts() == TaskStsType.WCS_TOTE_UNLOAD.id) {
			taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_PUTAWAY_SUCESS.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			}
			boolean result = taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getRobotCode, callbackParam.getRobotCode())
			.set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
			.set(Task::getTaskSts, taskStsType.id)
			.set(Task::getExcudeStatus, callbackParam.getStatus())
			.set(Task::getTaskDesc, callbackParam.getMessage())
			.eq(Task::getBarcode, callbackParam.getContainerCode())
			.eq(Task::getTaskNo, callbackParam.getTaskCode()));
			log.info("容器执行状态上报，任务号：{}，当前状态：{}，上报状态：{}",task.getTaskNo(),task.getTaskSts$(),callbackParam.getEventType());
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_ALLOCATED.event)) {
			return;
			}
			// ESS只能配置一个状态上报接口，根据任务号判断是入库任务或出库任务
			String taskType = task.getTaskType() > 100 ? "outStock":"inStock";
			TaskStsType taskStsType = null;
			if (taskType.equals("inStock")) { //入库任务
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
			// if (task.getTaskSts() == TaskStsType.WCS_CONVEYOR_START.id) {
			taskStsType = TaskStsType.WCS_TOTE_LOAD;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_LOAD.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
			// if (task.getTaskSts() == TaskStsType.WCS_TOTE_LOAD.id) {
			taskStsType = TaskStsType.WCS_TOTE_UNLOAD;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_UNLOAD.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件
			// if (task.getTaskSts() == TaskStsType.WCS_TOTE_UNLOAD.id) {
			taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_PUTAWAY_SUCESS.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			}
			boolean result = taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getRobotCode, callbackParam.getRobotCode())
			// .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
			.set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())
			.set(Task::getExcudeStatus, callbackParam.getStatus())
			.set(Task::getTaskDesc, callbackParam.getMessage())
			.eq(Task::getBarcode, callbackParam.getContainerCode())
			.eq(Task::getTaskNo, callbackParam.getTaskCode()));

			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event) && result) {
			workService.completeTask(task.getId());
			}
			} else { //出库任务
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
			//TODO 定时器开启后，要删除 \|\| task.getTaskType() == TaskStsType.GENERATE_OUT.id
			if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id \|\| task.getTaskSts() == TaskStsType.GENERATE_OUT.id) {
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
			if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id) {
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //上报完成状态
			if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.id) {
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TASK_DONE;
			} else {
			String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.desc + "任务";
			log.error(errMsg);
			throw new CoolException(errMsg);
			}
			}
			//event事件为task，表明任务上报完成状态
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event) && result) {
			//任务状态修改为 99 入库完成
			workService.completeTask(task.getId());
			}
			} else { //出库任务
			if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
			// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id ) {
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
			// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id) {
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			} else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //上报完成状态
			// if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.id \|\| task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id) {
			//出库任务完成，修改状态为容器到达，定时任务生成播种波次
			taskStsType = TaskStsType.WCS_EXECUTE_OUT_TASK_DONE;
			// } else {
			// String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.desc + "任务";
			// log.error(errMsg);
			// throw new CoolException(errMsg);
			// }
			}
			//更新出库状态及相关字段
			boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getRobotCode, callbackParam.getRobotCode())
			.set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
			.set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())
			.set(Task::getExcudeStatus, callbackParam.getStatus())
			.set(Task::getTaskDesc, callbackParam.getMessage())
			.eq(Task::getBarcode, callbackParam.getContainerCode())
			.eq(Task::getTaskNo, callbackParam.getTaskCode()));

			//更新出库状态及相关字段
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getRobotCode, callbackParam.getRobotCode())
			.set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
			.set(Task::getTaskSts, taskStsType.id)
			.set(Task::getExcudeStatus, callbackParam.getStatus())
			.set(Task::getTaskDesc, callbackParam.getMessage())
			.eq(Task::getBarcode, callbackParam.getContainerCode())
			.eq(Task::getTaskNo, callbackParam.getTaskCode()));

			if (!update) {
			throw new CoolException("任务更新失败！！");
			}

			});
			}

			});
			} else {
			throw new CoolException("更新内容不存在！！");
			}
			}

			/**
			* 容器流动通知
			*
			* @param code
			* @return
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public synchronized R containerConveryor(String code) throws Exception{
			Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
			if (Objects.isNull(task)) {
			throw new CoolException("容器码任务不存在！！");
			}
			try {
			ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
			conveyorStarParam.setSlotCode(task.getOriginSite())
			.setContainerCode(task.getBarcode());
			if (task.getTaskType() == 101) { //任务类型为101全盘出库，直接取下容器，传200
			conveyorStarParam.setDirection("200");
			} else if (task.getTaskType() == 103 \|\| task.getTaskType() == 107) { //如果为任务类型为103，需走回库操作，传100
			conveyorStarParam.setDirection("100");
			}
			//调用三方接口，将任务推送至ESS平台
			MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			// 设置请求参数
			HttpHeaders headers = new HttpHeaders();
			headers.add("Content-Type", "application/json");
			headers.add("api-version", "v2.0");
			HttpEntity httpEntity = new HttpEntity<>(conveyorStarParam, headers);
			log.info("请求地址：{}，请求参数：{}", HttpEssUtils.CONVEYOR_START, JSONObject.toJSONString(conveyorStarParam));
			ResponseEntity<String> exchange = restTemplate.exchange("http://192.168.2.200:9046/conveyor/moveContainer", HttpMethod.POST, httpEntity, String.class);
			log.info("下发流动通知返回结果：{}", exchange);
			if (exchange.getBody() == null) {
			throw new CoolException("下发流动通知失败！！");
			} else {
			CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);
			if (commonReponse.getCode() == 0) {
			//流动通知下发完成后，修改任务状态为输送线流动中。。
			if (task.getTaskType() == 103 \|\| task.getTaskType() == 107) {
			//更新库存信息,修改任务状态为4 （RCS容器流动任务已下发）
			workService.pickTask(task.getId());
			} else {
			taskService.update(new LambdaUpdateWrapper<Task>()
			.eq(Task::getId, task.getId())
			.set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));
			}
			log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());
			} else {
			throw new CoolException("下发流动通知失败！！");
			}
			}
			} catch (Exception ex) {
			log.error("UNK", ex);
			}
			return R.ok();
			}


			@Override
			public R rfidCallback(RfidSingalRequest request) {
			return null;
			}

			@Override
			public R getPlatforms() {
			return R.ok(platformService.list(new LambdaQueryWrapper<>()));
			}

			/**
			* 拍灯拣料逻辑，详细说明见接口调用说明
			*
			* @param request
			* @return
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public R slapLightLogic(Map<String, Object> request) {
			String taskNo = request.get("taskNo").toString();
			String orderNo = request.get("orderNo").toString();

			List<CacheSite> performs = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
			if (Objects.isNull(performs.stream().findFirst().get().getPlatformId())) {
			throw new CoolException("请打印明细，并绑定目标集货区");
			}

			//* 1. 判断当前容器是否还有物料未拣，未拣完闪灯，拣完通知容器流动，并灭灯
			SlapLightControlParam slapParam = new SlapLightControlParam();
			MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			//判断当前任务是否还有物料未拣
			if (!checked(orderNo, taskNo)) {
			log.info("未完成闪灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
			//调用三方接口,闪灯不做操作
			// 设置请求参数
			throw new CoolException("当前任务未完成，不能执行此操作！！");
			// params.add("params", JSONObject.toJSONString(slapParam));
			} else {
			//调用三方接口,灭灯通知容器流动，传灭灯参数
			//todo 判断当前订单是否完成，完成灭灯，未完成保持拣货状态亮灯
			Order one = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, orderNo));
			if (Objects.isNull(one)) {
			throw new CoolException("当前订单明细不存在！！");
			}
			// //获取播种已完成的订单明细
			// List<OrderDetl> detlList = orderDetls.stream().filter(detl -> {
			// return detl.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val;
			// }).collect(Collectors.toList());

			//判断数量是否与订单明细的需求量相同，相同则订单完成
			if (one.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val) {
			//播种完成，释放绑定站点
			List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
			for (CacheSite cacheSite : cacheSites) {
			if (!cacheSite.getSiteStatus().equals(CacheSiteStatusType.O.id)) {
			cacheSite.setSiteStatus(CacheSiteStatusType.O.id);
			cacheSite.setOrderId(null);
			cacheSite.setBarcode(null);
			cacheSite.setOrderNo(null);
			cacheSite.setPlatformId(null);
			cacheSite.setPlatformNo(null);
			cacheSite.setUpdateTime(new Date());
			if (!cacheSiteService.updateById(cacheSite)) {
			throw new CoolException("播种站点更新失败");
			}
			}
			}
			}
			params.add("params", JSONObject.toJSONString(slapParam));
			log.info("完成灭灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
			}

			Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, request.get("taskNo")));
			if (Objects.isNull(task)) {
			throw new CoolException("任务不存在！！");
			}
			try {
			containerConveryor(task.getBarcode());
			} catch (Exception e) {
			log.error("执行异常:UNK", e);
			throw new CoolException(e.getMessage());
			}

			return R.ok();
			}

			/**
			* 判断当前任务下，订单是否已完成拣货
			*
			* @param orderNo
			* @param taskNo
			* @return
			*/
			public synchronized boolean checked(String orderNo, String taskNo) {
			if (Objects.isNull(orderNo)) {
			throw new CoolException("订单编码不能为空！！");
			}
			if (Objects.isNull(taskNo)) {
			throw new CoolException("任务编码不能为空！！");
			}

			List<TaskDetl> taskDetls = taskDetlService.list(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getTaskNo, taskNo));
			if (taskDetls.isEmpty()) {
			throw new CoolException("订单明细不存在！！");
			}

			List<Long> detlIds = taskDetls.stream().map(TaskDetl::getId).collect(Collectors.toList());

			double taskNum = taskDetls.stream().mapToDouble(TaskDetl::getAnfme).sum();

			List<WaveSeed> seeds = waveSeedService.list(new LambdaQueryWrapper<WaveSeed>().in(WaveSeed::getTaskDetlId, detlIds));
			if (seeds.isEmpty()) {
			throw new CoolException("播种信息不存在！！！");
			}
			double seedNum = seeds.stream().mapToDouble(WaveSeed::getWorkQty).sum();
			//判断任务需求总量是否等播种总数量
			if (taskNum == seedNum) {
			return true;
			} else {
			return false;
			}
			}