zy-asrs-master.git

			@@ -1,21 +1,34 @@
			package com.zy.asrs.wms.apis.wcs.schedule;

			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.exception.CoolException;
			import com.zy.asrs.wms.apis.wcs.entity.domain.SystemProperties;
			import com.zy.asrs.wms.apis.wcs.entity.request.PublishTasksParam;
			import com.zy.asrs.wms.apis.wcs.entity.request.TaskDescribe;
			import com.zy.asrs.wms.apis.wcs.entity.request.TaskParam;
			import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
			import com.zy.asrs.wms.asrs.entity.Task;
			import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
			import com.zy.asrs.wms.asrs.service.TaskService;
			import com.zy.asrs.wms.asrs.service.WorkService;
			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.jdbc.datasource.DataSourceTransactionManager;
			import org.springframework.scheduling.annotation.Scheduled;
			import org.springframework.stereotype.Component;
			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.Comparator;
			import java.util.List;
			import java.util.*;
			import java.util.stream.Collectors;

			@Slf4j
			@@ -94,68 +107,72 @@
			.eq(Task::getTaskSts, TaskStsType.GENERATE_IN.id))
			.stream().sorted(Comparator.comparing(Task::getTaskSts))
			.collect(Collectors.toList());
			if (tasks.size() == 0) {
			return;
			}

			// 数据组装
			// PublishTasksParam tasksParam = new PublishTasksParam();
			// //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
			// tasks.forEach(task -> {
			// List<TaskParam> params = new ArrayList<>();
			// TaskParam param = new TaskParam();
			// //设置容器编码
			// param.setTaskCode(task.getTaskNo());
			// List<TaskDescribe> taskDescribes = new ArrayList<>();
			// TaskDescribe describe = new TaskDescribe();
			// //设置目标库位，站点
			// describe.setContainerCode(task.getBarcode())
			// .setToLocationCode(task.getTargetLoc())
			// .setToStationCode(task.getTargetSite());
			// taskDescribes.add(describe);
			// param.setTaskDescribe(taskDescribes);
			// params.add(param);
			// tasksParam.setTasks(params);
			// });
			//
			// tasksParam.setTaskType("putaway");
			// // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
			// //调用三方接口，将任务推送至ESS平台
			// MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			// // 设置请求参数
			// params.add("params", JSONObject.toJSONString(tasksParam));
			// log.info("请求地址：{}，请求参数：{}", Constant.ISSUE_TASK_OF_EVENT, JSONObject.toJSONString(tasksParam));
			// HttpHeaders headers = new HttpHeaders();
			// headers.add("Content-Type", "application/json");
			// HttpEntity httpEntity = new HttpEntity<>(params, headers);
			// // 请求
			// ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);
			// log.info("下发任务返回结果：{}", exchange);
			// if (exchange.getBody() == null) {
			// throw new CoolException("下发任务失败！！");
			// } else {
			// CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
			// if (reponse.getCode() == 0) {
			//请求成功后，统一修改所有任务档状态为入库执行中。
			PublishTasksParam tasksParam = new PublishTasksParam();
			//TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
			tasks.forEach(task -> {
			List<TaskParam> params = new ArrayList<>();
			TaskParam param = new TaskParam();
			//设置容器编码
			param.setTaskCode(task.getTaskNo());
			List<TaskDescribe> taskDescribes = new ArrayList<>();
			TaskDescribe describe = new TaskDescribe();
			//设置目标库位，站点
			describe.setContainerCode(task.getBarcode())
			.setToLocationCode(task.getTargetLoc())
			.setToStationCode(task.getTargetSite());
			taskDescribes.add(describe);
			param.setTaskDescribe(taskDescribes);
			params.add(param);
			tasksParam.setTasks(params);
			});

			tasksParam.setTaskType("putaway");
			// TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
			//调用三方接口，将任务推送至ESS平台
			MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			// 设置请求参数
			params.add("params", JSONObject.toJSONString(tasksParam));
			log.info("请求地址：{}，请求参数：{}", "http://192.168.2.200:9046/task/create", JSONObject.toJSONString(tasksParam));
			HttpHeaders headers = new HttpHeaders();
			headers.add("Content-Type", "application/json");
			HttpEntity httpEntity = new HttpEntity<>(params, headers);
			// 请求
			ResponseEntity<String> exchange = restTemplate.exchange("http://192.168.2.200:9046/task/create", HttpMethod.POST, httpEntity, String.class);
			log.info("下发任务返回结果：{}", exchange);
			if (exchange.getBody() == null) {
			throw new CoolException("下发任务失败！！");
			} else {
			CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
			if (reponse.getCode() == 0) {
			// 请求成功后，统一修改所有任务档状态为入库执行中。
			tasks.forEach(task -> {
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_IN.id)
			.eq(Task::getBarcode, task.getBarcode()));
			});
			// } else {
			// // TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
			// throw new CoolException(reponse.getMsg());
			// }
			// }
			} else {
			// TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
			throw new CoolException(reponse.getMsg());
			}
			}
			}


			/**
			* //fixme 弃用
			* 出库任务---通知容器流动
			* 每隔3秒，获取当前出库任务列表状态为WCS_EXECUTE_OUT_ARRIVED的任务，并通知ESS流动输送线
			* 每隔3秒，获取当前出库任务列表状态为COMPLETE_OUT的任务，并通知ESS流动输送线
			*/
			@Scheduled(cron = "0/5 * * * * ? ")
			// @Scheduled(cron = "0/5 * * * * ? ")
			@Transactional(rollbackFor = Exception.class)
			public void conveyorToNotify() {
			List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
			.eq(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_ARRIVED.id).eq(Task::getStatus, 1));
			.eq(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_CONVEYOR.id).eq(Task::getStatus, 1));

			// 还需要再修改
			tasks.forEach(task -> {
			@@ -185,9 +202,9 @@
			// CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);
			// if (commonReponse.getCode() == 0) {
			//流动通知下发完成后，修改任务状态为输送线流动中。。
			taskService.update(new LambdaUpdateWrapper<Task>()
			.eq(Task::getId, task.getId())
			.set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));
			// taskService.update(new LambdaUpdateWrapper<Task>()
			// .eq(Task::getId, task.getId())
			// .set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));

			// log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());
			// } else {
			@@ -218,58 +235,62 @@
			//获取当前任务档中，所有为待出库状态的任务档，按时间升序排列
			List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
			.ge(Task::getTaskType, 101) //TODO 如何确认是101，还是103
			.eq(Task::getTaskSts, TaskStsType.GENERATE_OUT.id))
			.stream().sorted(Comparator.comparing(Task::getTaskSts))
			.eq(Task::getTaskSts, TaskStsType.GENERATE_OUT.id));
			if (tasks.isEmpty()) {
			return;
			}
			tasks.stream().sorted(Comparator.comparing(Task::getTaskSts))
			.collect(Collectors.toList());

			// 数据组装
			// PublishTasksParam tasksParam = new PublishTasksParam();
			// //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
			// tasks.forEach(task -> {
			// List<TaskParam> params = new ArrayList<>();
			// TaskParam param = new TaskParam();
			// //设置容器编码
			// param.setTaskCode(task.getTaskNo());
			// List<TaskDescribe> taskDescribes = new ArrayList<>();
			// TaskDescribe describe = new TaskDescribe();
			// //设置目标库位，站点
			// describe.setContainerCode(task.getBarcode())
			// .setToLocationCode(task.getTargetLoc())
			// .setToStationCode(task.getTargetSite());
			// taskDescribes.add(describe);
			// param.setTaskDescribe(taskDescribes);
			// params.add(param);
			// tasksParam.setTasks(params);
			// });
			//
			// tasksParam.setTaskType("carry");
			// // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
			// //调用三方接口，将任务推送至ESS平台
			// MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			// // 设置请求参数
			// params.add("params", JSONObject.toJSONString(tasksParam));
			// log.info("请求地址：{}，请求参数：{}", Constant.ISSUE_TASK_OF_EVENT, JSONObject.toJSONString(tasksParam));
			// HttpHeaders headers = new HttpHeaders();
			// headers.add("Content-Type", "application/json");
			// HttpEntity httpEntity = new HttpEntity<>(params, headers);
			// // 请求
			// ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);
			// log.info("下发任务返回结果：{}", exchange);
			// if (exchange.getBody() == null) {
			// throw new CoolException("下发任务失败！！");
			// } else {
			// CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
			// if (reponse.getCode() == 0) {
			PublishTasksParam tasksParam = new PublishTasksParam();
			//TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
			tasks.forEach(task -> {
			List<TaskParam> params = new ArrayList<>();
			TaskParam param = new TaskParam();
			//设置容器编码
			param.setTaskCode(task.getTaskNo());
			List<TaskDescribe> taskDescribes = new ArrayList<>();
			TaskDescribe describe = new TaskDescribe();
			//设置目标库位，站点
			describe.setContainerCode(task.getBarcode())
			.setToLocationCode(task.getTargetLoc())
			.setToStationCode(task.getTargetSite());
			taskDescribes.add(describe);
			param.setTaskDescribe(taskDescribes);
			params.add(param);
			tasksParam.setTasks(params);
			});

			tasksParam.setTaskType("carry");
			// TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
			//调用三方接口，将任务推送至ESS平台
			MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
			SystemProperties properties = new SystemProperties();
			// 设置请求参数
			params.add("params", JSONObject.toJSONString(tasksParam));
			log.info("请求地址：{}，请求参数：{}", properties.getBaseHost() + properties.getIssueTaskOfEvent(), JSONObject.toJSONString(tasksParam));
			HttpHeaders headers = new HttpHeaders();
			headers.add("Content-Type", "application/json");
			HttpEntity httpEntity = new HttpEntity<>(params, headers);
			// 请求
			ResponseEntity<String> exchange = restTemplate.exchange(properties.getBaseHost() + properties.getIssueTaskOfEvent(), HttpMethod.POST, httpEntity, String.class);
			log.info("下发任务返回结果：{}", exchange);
			if (exchange.getBody() == null) {
			throw new CoolException("下发任务失败！！");
			} else {
			CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
			if (reponse.getCode() == 0) {
			//请求成功后，统一修改所有任务档状态为入库执行中。
			tasks.forEach(task -> {
			taskService.update(new LambdaUpdateWrapper<Task>()
			.set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT.id)
			.eq(Task::getId, task.getId()));
			});
			// } else {
			// // TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
			// throw new CoolException(reponse.getMsg());
			// }
			// }
			} else {
			// TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
			throw new CoolException(reponse.getMsg());
			}
			}
			}
			}