zy-wcs.git - Gitblit

			@@ -4,13 +4,17 @@
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.core.common.Cools;
			import com.core.common.R;
			import com.core.exception.CoolException;
			import com.zy.asrs.controller.CrnController;
			import com.zy.asrs.controller.OpenController;
			import com.zy.asrs.controller.SiteController;
			import com.zy.asrs.domain.enums.TaskStatusType;
			import com.zy.asrs.domain.enums.WorkNoType;
			import com.zy.asrs.domain.param.CrnOperatorParam;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.entity.param.Result;
			import com.zy.asrs.entity.param.StorageEscalationParam;
			import com.zy.asrs.entity.param.TaskOverToWms;
			import com.zy.asrs.mapper.*;
			import com.zy.asrs.service.*;
			@@ -35,15 +39,18 @@
			import com.zy.core.thread.SiemensDevpThread;
			import com.zy.system.entity.Config;
			import com.zy.system.service.ConfigService;
			import lombok.Synchronized;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.scheduling.annotation.Async;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			import org.springframework.transaction.interceptor.TransactionAspectSupport;

			import java.io.IOException;
			import java.util.*;
			import java.util.concurrent.CompletableFuture;

			/**
			* 立体仓库WCS系统主流程业务
			@@ -90,23 +97,339 @@
			private ApiLogService apiLogService;
			@Autowired
			private CommonService commonService;

			@Value("${wms.count}")
			private Integer maxCount;
			@Autowired
			private WrkMastService wrkMastService;
			@Value("${wms.url}")
			private String wmsUrl;
			@Value("${wms.inboundTaskApplyPath}")
			private String inboundTaskApplyPath;
			@Value("${wms.movePath}")
			private String movePath;
			@Value("${wms.TaskExecCallback}")
			private String TaskExecCallback;
			@Value("${wms.taskStatusFeedbackPath}")
			private String taskStatusFeedbackPath;
			@Autowired
			private CrnController crnController;


			public void generateStoreWrkFile() throws IOException, InterruptedException {
			@Autowired
			private SiteController siteController;
			@Synchronized
			public void shiftTargetToCyclePoint() throws IOException, InterruptedException {
			try {
			for (DevpSlave devp : slaveProperties.getDevp()) {
			for (DevpSlave.Sta outSta : devp.getOutSta()) {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			if (devpThread == null) {
			continue;
			}

			StaProtocol staProtocol = getClonedStation(devpThread, outSta.getStaNo());
			if (staProtocol == null) {
			continue;
			}

			// 获取其他相关站点
			StaProtocol staProtocol1 = getClonedStation(devpThread, 1001);
			StaProtocol staProtocol2 = getClonedStation(devpThread, 1002);
			StaProtocol staProtocol3 = getClonedStation(devpThread, 1003);
			StaProtocol staProtocol4 = getClonedStation(devpThread, 1004);
			StaProtocol staProtocol6 = getClonedStation(devpThread, 111);

			boolean result = false;
			switch (outSta.getStaNo()) {
			case 105:
			result = (staProtocol1 != null && staProtocol1.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 105);
			break;
			case 107:
			result = (staProtocol2 != null && staProtocol2.isLoading());
			break;
			case 109:
			result = (staProtocol3 != null && staProtocol3.isLoading());
			break;
			case 110:
			result = ((staProtocol4 != null && staProtocol4.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 110) \|\|
			(staProtocol6 != null && staProtocol6.isLoading() && staProtocol.isLoading() && staProtocol.getStaNo() == 111));
			break;
			default:
			break;
			}

			if (result) {
			if (staProtocol.getSiteId() == 107 \|\| staProtocol.getSiteId() == 109) {
			StaProtocol staProtocol5 = getClonedStation(devpThread, staProtocol.getSiteId() - 1);
			if (staProtocol5 != null && (staProtocol5.isLoading() && (staProtocol5.getStaNo() == 107 \|\| staProtocol5.getStaNo() == 109))) {
			short workNo = staProtocol5.getWorkNo();
			staProtocol5.setWorkNo(workNo);
			staProtocol5.setStaNo((short) 112);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol5));
			}
			} else {
			if(staProtocol.isLoading() && (staProtocol.getStaNo() == 105 \|\| staProtocol.getStaNo() == 110 \|\| staProtocol.getStaNo() == 111)){
			short workNo = staProtocol.getWorkNo();
			staProtocol.setWorkNo(workNo);
			staProtocol.setStaNo((short) 112);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
			}
			}
			}
			}
			}
			} catch (Exception e) {
			log.error("shiftTargetToCyclePoint error", e);
			}
			}

			/**
			* 获取站点并克隆
			*/
			private StaProtocol getClonedStation(DevpThread devpThread, int staNo) {
			StaProtocol staProtocol = devpThread.getStation().get(staNo);
			return (staProtocol != null) ? staProtocol.clone() : null;
			}

			// 112循环站点至出库站
			public synchronized void shiftCyclePointToTarget() throws IOException, InterruptedException {
			try {
			for (DevpSlave devp : slaveProperties.getDevp()) {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			if (devpThread == null) {
			continue;
			}

			StaProtocol staProtocol = devpThread.getStation().get(112);
			if (staProtocol.getStaNo() != 112 \|\| staProtocol.getWorkNo() == 0 \|\| !staProtocol.isLoading() \|\| staProtocol.getWorkNo() > 9000 \|\| staProtocol.getWorkNo() < 6000) {
			continue;
			}
			// 查询任务信息
			TaskWrk taskWrk = taskWrkMapper.selectStaWorking(Integer.valueOf(staProtocol.getWorkNo()));
			if (taskWrk == null \|\| taskWrk.getWrkNo() < 6001 \|\| taskWrk.getWrkNo() > 9000) {
			continue;
			}

			short workNo = staProtocol.getWorkNo();
			// 再写入目标站点
			staProtocol.setWorkNo(workNo);
			staProtocol.setStaNo(Short.valueOf(taskWrk.getTargetPoint()));
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
			Thread.sleep(200);

			log.info("Shifted from cycle station 112 to target {}, workNo: {}", taskWrk.getTargetPoint(), workNo);
			}
			} catch (Exception e) {
			log.error("shiftCyclePointToTarget error", e);
			}
			}





			public synchronized void generateStoreWrkFile1() throws IOException, InterruptedException {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历入库口
			for (DevpSlave.Sta inSta : devp.getInSta()) {
			StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
			// 获取入库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
			StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			Short workNo = staProtocol.getWorkNo();
			Short stano = staProtocol.getStaNo();

			// 尺寸检测异常
			boolean back = false;
			String errMsg = "";
			if (staProtocol.isFrontErr()) {
			errMsg = "前超限";
			back = true;
			}
			if (!back && staProtocol.isBackErr()) {
			errMsg = "后超限";
			back = true;
			}
			if (!back && staProtocol.isHighErr()) {
			errMsg = "高超限";
			back = true;
			}
			if (!back && staProtocol.isLeftErr()) {
			errMsg = "左超限";
			back = true;
			}
			if (!back && staProtocol.isRightErr()) {
			errMsg = "右超限";
			back = true;
			}
			if (!back && staProtocol.isWeightErr()) {
			errMsg = "超重";
			back = true;
			}
			if (!back && staProtocol.isBarcodeErr()) {
			errMsg = "扫码失败";
			back = true;
			}
			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && workNo >= 9790
			&& staProtocol.isPakMk()) {
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			if (barcodeThread == null) {
			continue;
			}
			String BoxNo = barcodeThread.getBarcode();
			TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", BoxNo));
			if (!Cools.isEmpty(taskWrk1)) {
			log.info("托盘码：" + BoxNo + "任务档存在");
			if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk1.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
			if (Cools.isEmpty(staDesc)) {
			return;
			} else {
			continue;
			}
			}
			}
			if (back) {
			storageEscalationParam.setWCSStatus(1);
			storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + errMsg);
			}
			log.info("组托入库={}", storageEscalationParam);
			storageEscalationParam.setBoxNo(BoxNo);
			String response = "";
			Boolean success = false;
			try {
			response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath(inboundTaskApplyPath)
			.setJson(JSON.toJSONString(storageEscalationParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if(back){
			if(staProtocol.getWorkNo()>=9801&&staProtocol.getWorkNo()<=9825){
			staProtocol.setStaNo((short)105);
			} else if (staProtocol.getWorkNo()>=9826&&staProtocol.getWorkNo()<=9850) {
			staProtocol.setStaNo((short)107);
			}else if (staProtocol.getWorkNo()>=9851&&staProtocol.getWorkNo()<=9875) {
			staProtocol.setStaNo((short)109);
			}else if (staProtocol.getWorkNo()>=9876 && staProtocol.getWorkNo() <= 9900){
			staProtocol.setStaNo((short)110);
			}
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}else{
			if (!Cools.isEmpty(response)&&!Cools.isEmpty(jsonObject.get("ReturnStatus"))&&jsonObject.get("ReturnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("Result").toString())) {
			Result result = JSON.parseObject(jsonObject.get("Result").toString(), Result.class);
			// 创新一个入库工作档
			TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
			if (Cools.isEmpty(taskWrk)) {
			taskWrk = createTask1(result, BoxNo);
			if (Cools.isEmpty(taskWrk)) {
			log.error("库位异常，库位号：={}", taskWrk.getOriginTargetPoint());
			} else {
			taskWrkService.insert(taskWrk);
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			HashMap<String, Object> hashMap = new HashMap<>();
			hashMap.put("TaskNo",taskWrk.getTaskNo());
			try {
			//开始上报,任务开始时，WCS回调WMS
			response = new HttpHandler.Builder()
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(hashMap))
			.build()
			.doPost();
			JSONObject jsonObject1 = JSON.parseObject(response);
			Boolean bool = false;
			if(jsonObject1.get("ReturnStatus").equals(0)){
			taskWrk.setStatus(2);//派发任务
			bool = true;
			taskWrkService.updateById(taskWrk);
			}
			apiLogService.save("wcs开始入库任务上报wms"
			, wmsUrl + TaskExecCallback
			, null
			, "127.0.0.1"
			, JSON.toJSONString(hashMap)
			, response
			, bool
			);
			} catch (Exception e) {

			}
			}
			} else {
			// staProtocol.setWorkNo((short) 9991);
			if(staProtocol.getWorkNo()>=9801&&staProtocol.getWorkNo()<=9825){
			staProtocol.setStaNo((short)105);
			} else if (staProtocol.getWorkNo()>=9826&&staProtocol.getWorkNo()<=9850) {
			staProtocol.setStaNo((short)107);
			}else if (staProtocol.getWorkNo()>=9851&&staProtocol.getWorkNo()<=9875) {
			staProtocol.setStaNo((short)109);
			}else{
			staProtocol.setStaNo((short)110);
			}
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}

			} else {
			// staProtocol.setWorkNo((short) 9991);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}
			}
			} catch (Exception e) {
			log.error("请求入库调用接口失败");
			log.error("异常信息打印：" + e);
			try {
			BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
			if (Cools.isEmpty(basDevp)) {
			log.error("站点号异常" + inSta.getStaNo());
			} else if (basDevp.getStaErr() != 0) {
			basDevp.setStaErr(2);
			basDevpService.updateById(basDevp);
			}
			} catch (Exception e1) {
			// 退回
			log.error("扫码检测程序异常" + inSta.getStaNo() + "异常信息" + e1);
			}
			} finally {
			apiLogService.save("wms请求入库货位接口"
			, wmsUrl + inboundTaskApplyPath
			, null
			, "127.0.0.1"
			, JSON.toJSONString(storageEscalationParam)
			, response
			, success
			);
			}
			log.info("入库请求参数=" + JSON.toJSONString(BoxNo));
			log.info("入库请求返回参数=" + JSON.toJSONString(response));
			}
			}
			}
			} catch (Exception e) {
			log.error("generateStoreWrkFile e", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			}
			}

			public synchronized void generateStoreWrkFile() throws IOException, InterruptedException {
			try {
			// 根据输送线plc遍历
			for (DevpSlave devp : slaveProperties.getDevp()) {
			// 遍历入库口
			@@ -155,20 +478,20 @@
			}
			// 退回
			if (back) {
			if (stano == inSta.getBackSta().shortValue()){
			if (stano == inSta.getBackSta().shortValue()) {
			continue;
			}
			if (workNo == 0 && stano == 0){
			if (workNo == 0 && stano == 0) {
			continue;
			}
			if (!staProtocol.isPakMk()){
			if (!staProtocol.isPakMk()) {
			continue;
			}
			// News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
			staProtocol.setWorkNo(workNo);
			staProtocol.setStaNo(inSta.getBackSta().shortValue());
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			if (taskWrk != null) {
			taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			@@ -179,7 +502,7 @@
			// 判断是否满足入库条件
			if (staProtocol.isAutoing() && staProtocol.isLoading()
			&& staProtocol.isInEnable()
			&& !staProtocol.isEmptyMk() && (workNo >= 0)
			&& !staProtocol.isEmptyMk() && (workNo >= 9899)
			&& staProtocol.isPakMk()) {
			// 获取条码扫描仪信息
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
			@@ -187,130 +510,185 @@
			continue;
			}
			String barcode = barcodeThread.getBarcode();
			if(!Cools.isEmpty(barcode)) {
			if (!Cools.isEmpty(barcode) && !barcode.equals("99999999")) {
			// 请求wms接口，获取工作号和目标库位
			ToWmsDTO toWmsDTO = new ToWmsDTO(barcode,staProtocol.getSiteId(),staProtocol.isHigh() ? 2 : 1);
			TaskWrk taskWrk1=taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode",barcode));
			if(!Cools.isEmpty(taskWrk1)){
			log.info("托盘码："+barcode+"任务档存在");
			continue;
			ToWmsDTO toWmsDTO = new ToWmsDTO(barcode, staProtocol.getSiteId(), staProtocol.isHigh() ? 2 : 1);
			TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));
			if (!Cools.isEmpty(taskWrk1)) {
			log.info("托盘码：" + barcode + "任务档存在");
			if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk1.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
			if (Cools.isEmpty(staDesc)) {
			log.info("托盘码：" + barcode + "任务档存在");
			return;
			} else {
			staProtocol.setWorkNo(taskWrk1.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}
			}
			return;
			}
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("Content-Type","application/json");
			headParam.put("Content-Type", "application/json");
			System.out.println(JSON.toJSONString(toWmsDTO));
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(inboundTaskApplyPath)
			.setJson(JSON.toJSONString(toWmsDTO))
			.build()
			.doPost();
			try {
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(inboundTaskApplyPath)
			.setJson(JSON.toJSONString(toWmsDTO))
			.build()
			.doPost();
			} catch (Exception e) {
			log.error("请求入库调用接口失败");
			log.error("异常信息打印：" + e);
			try {
			BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
			if (Cools.isEmpty(basDevp)) {
			log.error("站点号异常" + inSta.getStaNo());
			} else if (basDevp.getStaErr() != 0) {
			basDevp.setStaErr(2);
			basDevpService.updateById(basDevp);
			}
			} catch (Exception e1) {
			// 退回
			log.error("扫码检测程序异常" + inSta.getStaNo() + "异常信息" + e1);
			}
			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			// if (taskWrk != null) {
			// taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			// taskWrkMapper.updateById(taskWrk);
			// }
			continue;
			}

			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wms请求入库货位接口"
			,wmsUrl+inboundTaskApplyPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(toWmsDTO)
			,response
			,true
			);
			log.info("入库请求参数{}" + JSON.toJSONString(toWmsDTO));
			log.info("入库请求返回参数{}" + JSON.toJSONString(response));
			if (jsonObject.getInteger("code").equals(200) && !Cools.isEmpty(jsonObject.get("data").toString())) {
			GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
			try {
			BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
			if (Cools.isEmpty(basDevp)) {
			log.error("站点号异常1" + inSta.getStaNo());
			throw new CoolException("站点号异常1,未查询到站点信息" + inSta.getStaNo());
			}
			Integer staNoCrnNo = Utils.StaNoCrnNo(inSta.getStaNo());
			if (staNoCrnNo == 0) {
			basDevp.setStaErr(1);
			basDevpService.updateById(basDevp);
			log.error("站点号异常2" + inSta.getStaNo());
			throw new CoolException("站点号异常2,站点号不存在" + inSta.getStaNo());
			} else {
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("crn_no", staNoCrnNo.longValue())
			.eq("loc_no", getWmsDto.getLocNo()));
			if (Cools.isEmpty(locMast)) {
			basDevp.setStaErr(1);
			basDevpService.updateById(basDevp);
			log.error("站点号异常3" + inSta.getStaNo());
			throw new CoolException("站点号异常3：此巷道不存在目标库位" + inSta.getStaNo());
			}
			}
			} catch (Exception e) {
			// log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e);
			// 退回
			log.error("扫码检测程序异常" + inSta.getStaNo() + errMsg);
			log.error("扫码检测程序异常,异常信息" + e);

			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			// TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			// if (taskWrk != null) {
			// taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			// taskWrkMapper.updateById(taskWrk);
			// }
			continue;
			}
			//查看该库位是否为空库位
			LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("loc_sts", "O")
			.eq("loc_no", getWmsDto.getLocNo()));
			if (Cools.isEmpty(locMast)) {
			try {
			HashMap<String, Object> headParam1 = new HashMap<>();
			headParam1.put("taskNo", getWmsDto.getTaskNo());
			headParam1.put("status", 6);
			headParam1.put("ioType", 1);
			headParam1.put("barcode", barcode);
			String response2;
			response2 = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam1))
			.build()
			.doPost();
			JSONObject jsonObject1 = JSON.parseObject(response2);
			apiLogService.save("wcs派发库位==》不为空《==上报wms"
			, wmsUrl + taskStatusFeedbackPath
			, null
			, "127.0.0.1"
			, JSON.toJSONString(headParam1)
			, response
			, true
			);
			} catch (Exception e) {
			log.error("wcs派发库位==》不为空《==上报wms", getWmsDto.getWrkNo());
			throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息：" + e);
			}
			}

			// 创新一个入库工作档
			TaskWrk taskWrk = taskWrkService.selectByTaskNo(getWmsDto.getWrkNo());
			if(Cools.isEmpty(taskWrk)) {
			taskWrk = createTask(getWmsDto,barcode);
			if (Cools.isEmpty(taskWrk)){
			if (Cools.isEmpty(taskWrk)) {
			taskWrk = createTask(getWmsDto, barcode);
			if (Cools.isEmpty(taskWrk)) {
			log.error("库位异常，库位号：{}", getWmsDto.getTargetLocationCode());
			}else {
			} else {
			taskWrkService.insert(taskWrk);
			StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			.eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getSiteId()));
			.eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			}
			}

			}else {
			} else {
			continue;
			}
			apiLogService.save("wms请求入库货位接口"
			, wmsUrl + inboundTaskApplyPath
			, null
			, "127.0.0.1"
			, JSON.toJSONString(toWmsDTO)
			, response
			, true
			);

			// StaDescService staDescService = SpringUtils.getBean(StaDescService.class);
			//
			// ToWmsDTO toWmsDTO = new ToWmsDTO();
			// Map<String, Object> map = new HashMap<>();
			// map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
			// List<Integer> list = openServiceImpl.getInEnableRoadway();
			// TaskWrk taskWrk = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));
			//
			// if (Cools.isEmpty(taskWrk)){
			// continue;
			// }
			// //StaDesc staDesc1 = staDescService.selectOne(new EntityWrapper<StaDesc>().eq("stn_no",inSta.getBackSta()));
			// if (taskWrk.getTargetPoint() != null && taskWrk.getStartPoint() != null){
			// if ( taskWrk.getWrkNo() != null && taskWrk.getWrkNo().shortValue() == workNo ){
			// continue;
			// }
			// //获取堆垛机站点
			// StaDesc staDesc = new StaDesc();
			// if (devp.getId() <= 1){
			// staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			// .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).lt("stn_no", 200));
			// }else {
			// staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
			// .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).lt("stn_no", 400).ge("stn_no", 250));
			// }
			// staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			// staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
			// MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
			// Thread.sleep(500);
			// }else {
			// //TaskWrk taskWrk = taskWrkService.selectByTaskNo(param.getTaskNo());
			// toWmsDTO.setWarehouseId("1688469798893297665");
			// toWmsDTO.setContainerCode(barcode);
			// toWmsDTO.setApplyType("TUNNEL_LOCATION");
			// toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
			// toWmsDTO.setCanInboundTunnels(list);
			// String response = null;
			// try {
			// response = new HttpHandler.Builder()
			// .setHeaders(map)
			// .setUri(wmsUrl)
			// .setPath(inboundTaskApplyPath)
			// .setJson(JSON.toJSONString(toWmsDTO))
			// .build()
			// .doPost();
			// }catch (Exception e){
			// log.error("wms通讯失败,"+e.getMessage());
			// continue;
			// }
			// apiLogService.save("wms请求入库货位接口"
			// ,wmsUrl+"wcsManager/wcsInterface/inboundTaskApply"
			// ,null
			// ,"127.0.0.1"
			// ,JSON.toJSONString(toWmsDTO)
			// ,response
			// ,true
			// );
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			// GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
			// taskWrk.setOriginTargetPoint(getWmsDto.getTargetLocationCode());
			// taskWrk.setTargetPoint(Utils.getWcsLocNo(getWmsDto.getTargetLocationCode()));
			// taskWrk.setStartPoint(String.valueOf(inSta.getBackSta()));
			// if (!taskWrkService.updateById(taskWrk)){
			// log.error("保存wms库位号失败");
			// }
			//
			// }else {
			// log.error("wms通讯失败,"+jsonObject.get("msg"));
			//
			// }
			// }
			} else {
			// 退回
			log.error("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);

			staProtocol.setWorkNo((short) 9999);
			staProtocol.setStaNo(inSta.getStaNo().shortValue());
			devpThread.setPakMk(staProtocol.getSiteId(), false);
			MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
			TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
			if (taskWrk != null) {
			taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
			taskWrkMapper.updateById(taskWrk);
			}
			}
			}

			@@ -327,64 +705,52 @@
			/**
			* 堆垛机站出库到出库站
			*/
			public void crnStnToOutStn() {
			public synchronized void crnStnToOutStn() {
			for (CrnSlave crnSlave : slaveProperties.getCrn()) {
			// 遍历堆垛机出库站
			for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
			List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
			for (StaDesc staDesc : staDescs){
			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			// 查询工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
			if (taskWrk == null) {
			for (StaDesc staDesc : staDescs) {
			try {
			// 获取堆垛机出库站信息
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			// 判断工作档条件
			if (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 2) {
			// 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, taskWrk.getCrnNo());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol.statusType == CrnStatusType.FETCHING \|\| crnProtocol.statusType == CrnStatusType.PUTTING) {
			// 移动中
			if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 \|\| staProtocol.getStaNo() == 0)) {
			// 查询工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
			if (taskWrk == null) {
			continue;
			}
			// 判断堆垛机状态等待确认
			if (crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(taskWrk.getWrkNo().shortValue())
			&& crnProtocol.getTaskFinish() == 0
			&& crnProtocol.forkPosType == CrnForkPosType.HOME) {
			// 命令下发区 --------------------------------------------------------------------------
			log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
			// R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
			staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
			staProtocol.setStaNo(staDesc.getStnNo().shortValue());
			boolean offer = false;
			try {
			offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
			} catch (Exception e) {
			log.error("下发输送线任务失败：异常:" + e);
			log.error("下发输送线任务失败：异常:offer:" + offer);
			}
			// JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
			if (offer) {
			log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
			taskWrk.setStatus(5);
			taskWrk.setWrkSts(14);
			taskWrkService.updateById(taskWrk);

			//取出输送线命令
			List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
			if (commandInfos.isEmpty()) {
			continue;//命令空
			}

			// CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
			// CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
			Integer commandStep = taskWrk.getCommandStep();
			CommandInfo commandInfo = commandInfos.get(commandStep);
			CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
			//StaProtocol staProtocol1 = JSON.parseObject(commandInfo.getCommand(), StaProtocol.class);
			StaProtocol staProtocol1 = JSON.parseObject(commandPackage.getCommand().toString(), StaProtocol.class);
			if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol1))) {
			log.error("输送线命令下方失败！！！ [工作号:{}]", taskWrk.getWrkNo());
			continue;//命令下发失败
			}

			// 复位堆垛机
			crnThread.setResetFlag(true);

			} else {
			log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
			// log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
			}
			}
			} catch (Exception e) {
			log.error("出库到出库站异常:异常信息：" + e);
			}
			}

			@@ -400,12 +766,15 @@
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			if (crnProtocol == null) {
			continue;
			}
			BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
			if (basCrnp == null) {
			log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
			continue;
			}


			// 只有当堆垛机空闲并且无任务时才继续执行
			if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
			@@ -430,9 +799,10 @@
			crnProtocol.setLastIo("O");
			}
			}

			// 库位移转
			this.locToLoc(crn, crnProtocol);
			}
			// 库位移转
			this.locToLoc(crn, crnProtocol);

			}
			}
			@@ -440,7 +810,7 @@
			/**
			* 入库 ===>> 堆垛机站到库位
			*/
			public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
			public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
			for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
			List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
			for (StaDesc staDesc : staDescs) {
			@@ -460,16 +830,17 @@
			continue;
			}
			if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
			&& staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
			&& staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
			flag = true;
			}
			if (!flag) {
			continue;
			}


			// 获取工作状态为2（设备上走）的入库工作档
			TaskWrk taskWrk = taskWrkMapper.selectPakIn(slave.getId(), staProtocol.getWorkNo().intValue(), staDesc.getStnNo().toString());
			if(null == taskWrk) {
			if (null == taskWrk) {
			continue;
			}

			@@ -483,46 +854,14 @@
			continue;
			}

			int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
			taskWrk.setWrkNo(workNo);//工作号
			taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
			// int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
			// taskWrk.setWrkNo(workNo);//工作号
			// taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
			taskWrk.setAssignTime(new Date());//派发时间
			taskWrk.setWrkSts(3);//工作状态 3.吊车入库
			taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
			taskWrk.setModiTime(new Date());
			taskWrk.setModiUser(9988L);
			taskWrkService.updateById(taskWrk);

			// //取出命令
			// List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
			// Integer commandStep = taskWrk.getCommandStep();
			// if (commandInfos.isEmpty()) {
			// continue;//命令空
			// }
			// CommandInfo commandInfo = commandInfos.get(commandStep);
			// CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
			// CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
			//
			// if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
			// log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			// } else {
			// // 修改工作档状态 2.设备上走 => 3.吊车入库中
			// Date now = new Date();
			// taskWrk.setWrkSts(3);
			// taskWrk.setModiTime(now);
			// if (taskWrkMapper.updateById(taskWrk) == 0) {
			// log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", taskWrk.getWrkNo());
			// }
			// //开始运行
			// String response = CrnStartRunning(taskWrk);
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			//
			// }else {
			// log.error("入库开始运行通讯失败,"+jsonObject.get("msg"));
			//
			// }
			// }

			// 命令下发区 --------------------------------------------------------------------------
			CrnCommand crnCommand = new CrnCommand();
			@@ -536,43 +875,20 @@
			crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint())); // 目标库位列
			crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint())); // 目标库位层
			crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint())); // 目标库位排
			crnCommand.setCommand((short)1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
			crnCommand.setCommand((short) 1);
			log.info("堆垛机入库任务下发={}",crnCommand);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
			log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			throw new CoolException("堆垛机命令生成失败");
			}else{
			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发入库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs派发入库任务上报wms失败", taskWrk);
			throw new CoolException("wcs派发入库任务上报wms失败");
			} else {
			try {
			taskWrkService.updateById(taskWrk);
			} catch (Exception e) {
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，工作号={}", taskWrk.getWrkNo());
			log.error("修改工作档状态 2.设备上走 => 3.吊车入库中失败！！，异常：" + e);
			}

			}
			}

			// return;
			}
			}

			@@ -580,17 +896,17 @@
			* 出库 ===>> 库位到堆垛机站
			* 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
			*/
			public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
			public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) {
			List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
			if (taskWrksInitial.size()==0){
			if (taskWrksInitial.size() == 0) {
			return;
			}
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
			for (StaDesc staDesc : staDescs){
			for (StaDesc staDesc : staDescs) {
			// 获取工作状态为11（生成出库ID）的出库工作档
			List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(),staDesc.getStnNo().toString());
			for (TaskWrk taskWrk : taskWrks){
			List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), staDesc.getStnNo().toString());
			for (TaskWrk taskWrk : taskWrks) {
			if (taskWrk == null) {
			continue;
			}
			@@ -599,6 +915,29 @@
			log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getStartPoint(), taskWrk.getIoType());
			continue;
			}

			LocMast locMast=locMastService.selectByLocNo(taskWrk.getStartPoint());
			//判断其库位是否为深库位，如果为深库位找其浅库位是都有货
			if(locMast.getRow1()==1\|\|locMast.getRow1()==5){
			LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("row1", (locMast.getRow1()+1))
			.eq("bay1",locMast.getBay1())
			.eq("lev1",locMast.getLev1()).eq("loc_sts","F"));
			if (!Cools.isEmpty(locMast1)){
			log.info(locMast.getLocNo()+"出深库位，浅库位有货");
			continue;
			}
			}else if(locMast.getRow1()==4\|\|locMast.getRow1()==8){
			LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("row1", (locMast.getRow1()-1))
			.eq("bay1",locMast.getBay1())
			.eq("lev1",locMast.getLev1()).eq("loc_sts","F"));
			if (!Cools.isEmpty(locMast1)){
			log.info(locMast.getLocNo()+"出深库位，浅库位有货");
			continue;
			}
			}

			// 获取堆垛机出库站信息
			SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
			StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
			@@ -616,7 +955,7 @@
			}

			// 判断堆垛机出库站状态
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
			if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
			&& staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
			// 命令下发区 --------------------------------------------------------------------------

			@@ -624,20 +963,16 @@
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			break;
			}

			// 已经存在吊车执行任务时，则过滤
			if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
			int storeCount = basDevpService.getStoreCount();
			if(storeCount >= maxCount){
			log.error("输送线暂存数达到上限{}",storeCount);
			break;
			}


			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			taskWrk.setWrkSts(12);
			taskWrk.setStatus(2);
			taskWrk.setModiTime(now);
			if (taskWrkMapper.updateById(taskWrk) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			// 已经存在吊车执行任务时，则过滤
			if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
			break;
			}
			CrnCommand command = new CrnCommand();
			command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
			@@ -650,89 +985,52 @@
			command.setDestinationPosX(crnStn.getRow().shortValue()); // 目标库位排
			command.setDestinationPosY(crnStn.getBay().shortValue()); // 目标库位列
			command.setDestinationPosZ(crnStn.getLev().shortValue()); // 目标库位层
			command.setCommand((short)1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command),false)) {
			command.setCommand((short) 1);

			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command), false)) {
			log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(command));
			throw new CoolException("堆垛机命令生成失败");
			}else{
			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发入库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs派发出库任务上报wms失败", taskWrk);
			throw new CoolException("wcs派发入库任务上报wms失败");
			} else {
			try {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			Date now = new Date();
			taskWrk.setWrkSts(12);
			taskWrk.setModiTime(now);
			if (taskWrkMapper.updateById(taskWrk) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			}
			} catch (Exception e) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，异常：" + e);
			}

			// try {
			// HashMap<String, Object> headParam = new HashMap<>();
			// headParam.put("taskNo", taskWrk.getTaskNo());
			// headParam.put("status", taskWrk.getStatus());
			// headParam.put("ioType", taskWrk.getIoType());
			// headParam.put("barcode", taskWrk.getBarcode());
			// String response;
			// response = new HttpHandler.Builder()
			// // .setHeaders(headParam)
			// .setUri(wmsUrl)
			// .setPath(taskStatusFeedbackPath)
			// .setJson(JSON.toJSONString(headParam))
			// .build()
			// .doPost();
			// JSONObject jsonObject = JSON.parseObject(response);
			// apiLogService.save("wcs派发出库任务上报wms"
			// , wmsUrl + taskStatusFeedbackPath
			// , null
			// , "127.0.0.1"
			// , JSON.toJSONString(headParam)
			// , response
			// , true
			// );
			// } catch (Exception e) {
			// log.error("wcs派发出库任务上报wms失败", JSON.toJSONString(taskWrk));
			//// throw new CoolException("wcs派发入库任务上报wms失败");
			// }
			}

			// // 双深库位且浅库位有货，则需先对浅库位进行库位移转
			// if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
			//
			// taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
			//
			// List<TaskWrk> taskWrks1 = taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
			// if (Cools.isEmpty(taskWrks1) && taskWrks1.size()!=0){
			// continue;
			// }
			// String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
			// TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
			// if (!Cools.isEmpty(hallowLocNoTask)){
			// continue;
			// }
			// }
			//
			// //取出命令
			// List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
			// Integer commandStep = taskWrk.getCommandStep();
			// if (commandInfos.isEmpty()) {
			// continue;//命令空
			// }
			//
			// //判断末端命令是否执行
			// CommandInfo commandInfo2 = commandInfos.get(commandInfos.size() - 1);
			// if (commandInfo2.getCommandStatus() != CommandStatusType.CREATE.id) {
			// continue;//指令已执行
			// }
			//
			// CommandInfo commandInfo = commandInfos.get(commandStep);
			// CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
			// CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
			//
			// if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
			// log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			// } else {
			//
			// //开始运行
			// String response = CrnStartRunning(taskWrk);
			// JSONObject jsonObject = JSON.parseObject(response);
			// if (jsonObject.getInteger("code").equals(200)) {
			//
			// }else {
			// log.error("出库开始运行通讯失败,"+jsonObject.get("msg"));
			//
			// }
			// }

			}
			}
			}
			@@ -742,23 +1040,24 @@
			/**
			* 库位移转
			*/
			public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
			public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
			for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
			// 获取工作状态为11（生成出库ID）的移库工作档
			List<TaskWrk> taskWrks = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>()
			.eq("crn_no",slave.getId())
			.eq("wrk_sts",11)
			.eq("io_type",3));
			for (TaskWrk taskWrk : taskWrks){
			.eq("crn_no", slave.getId())
			.eq("wrk_sts", 11)
			.eq("io_type", 3)
			.orderBy("io_pri", false));
			for (TaskWrk taskWrk : taskWrks) {

			// 双深库位且浅库位有货，则需先对浅库位进行库位移转
			if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
			TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
			if (!Cools.isEmpty(hallowLocNoTask)){
			continue;
			}
			}
			// if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
			// String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
			// TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
			// if (!Cools.isEmpty(hallowLocNoTask)){
			// continue;
			// }
			// }
			// 堆垛机控制过滤
			if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) \|\| crnProtocol.getTaskNo() != 0) {
			continue;
			@@ -768,44 +1067,7 @@
			if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
			continue;
			}
			if (Cools.isEmpty(taskWrk.getTargetPoint())){
			List<Integer> list = openServiceImpl.getInEnableRoadway();
			Map<String, Object> map = new HashMap<>();
			map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
			ToWmsDTO toWmsDTO = new ToWmsDTO();
			toWmsDTO.setWarehouseId("1688469798893297665");
			toWmsDTO.setContainerCode(taskWrk.getBarcode());
			toWmsDTO.setApplyType("TUNNEL_LOCATION");
			toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
			toWmsDTO.setCanInboundTunnels(list);
			String response = null;
			try {
			response = new HttpHandler.Builder()
			.setHeaders(map)
			.setUri(wmsUrl)
			.setPath("wcsManager/wcsInterface/inboundTaskApply")
			.setJson(JSON.toJSONString(toWmsDTO))
			.build()
			.doPost();
			}catch (Exception e){
			log.error("wms通讯失败,"+e.getMessage());
			continue;
			}
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
			taskWrk.setOriginTargetPoint(getWmsDto.getTargetLocationCode());
			taskWrk.setTargetPoint(Utils.getWcsLocNo(getWmsDto.getTargetLocationCode()));
			if (!taskWrkService.updateById(taskWrk)){
			log.error("保存wms库位号失败");
			}
			continue;
			}else {
			log.error("wms通讯失败,"+jsonObject.get("msg"));
			continue;
			}

			}
			if (taskWrk == null \|\| Cools.isEmpty(taskWrk.getTargetPoint()) \|\| taskWrk.getTargetPoint().equals("") \|\| taskWrk.getWrkNo() == null) {
			continue;
			}
			@@ -818,22 +1080,20 @@
			// 命令下发区 --------------------------------------------------------------------------




			// 1.堆垛机开始移动
			CrnCommand crnCommand = new CrnCommand();
			crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
			crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
			crnCommand.setAckFinish((short) 0); // 任务完成确认位
			crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式: 库位移转
			crnCommand.setSourcePosZ(Utils.getRowShort(taskWrk.getStartPoint())); // 源库位排
			crnCommand.setSourcePosX(Utils.getBayShort(taskWrk.getStartPoint())); // 源库位列
			crnCommand.setSourcePosY(Utils.getLevShort(taskWrk.getStartPoint())); // 源库位层
			crnCommand.setDestinationPosZ(Utils.getRowShort(taskWrk.getTargetPoint())); // 目标库位排
			crnCommand.setDestinationPosX(Utils.getBayShort(taskWrk.getTargetPoint())); // 目标库位列
			crnCommand.setDestinationPosY(Utils.getLevShort(taskWrk.getTargetPoint())); // 目标库位层
			crnCommand.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint())); // 源库位排
			crnCommand.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint())); // 源库位列
			crnCommand.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint())); // 源库位层
			crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint())); // 目标库位排
			crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint())); // 目标库位列
			crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint())); // 目标库位层
			crnCommand.setCommand((short) 1);
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
			if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
			log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
			} else {
			// 修改工作档状态 11.生成出库ID => 12.吊车出库中
			@@ -843,16 +1103,39 @@
			if (taskWrkMapper.updateById(taskWrk) == 0) {
			log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中失败！！，工作号={}", taskWrk.getWrkNo());
			}
			//开始运行
			String response = CrnStartRunning(taskWrk);
			JSONObject jsonObject = JSON.parseObject(response);
			if (jsonObject.getInteger("code").equals(200)) {
			String response = "";
			Boolean bool=false;
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("TaskNo", taskWrk.getTaskNo());
			try {
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			if(jsonObject.get("ReturnStatus").equals(0)){
			bool = true;
			taskWrk.setStatus(2);
			taskWrkMapper.updateById(taskWrk);
			}

			}else {
			log.error("移库任务开始运行通讯失败,"+jsonObject.get("msg"));
			continue;
			} catch (Exception e) {
			log.error("wcs派发移库库任务上报wms失败", taskWrk);
			// throw new CoolException("wcs派发移库库任务上报wms失败");
			}finally {
			apiLogService.save("wcs派发移库任务上报wms"
			, wmsUrl + taskStatusFeedbackPath
			, null
			, "127.0.0.1"
			, JSON.toJSONString(headParam)
			, response
			, bool
			);
			}
			break;

			}
			return;
			}
			@@ -911,29 +1194,33 @@
			/**
			* 执行对工作档的完成操作
			*/
			public void storeFinished() throws InterruptedException {
			public synchronized void storeFinished() throws InterruptedException {
			for (CrnSlave crn : slaveProperties.getCrn()) {
			// 获取堆垛机信息
			CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
			CrnProtocol crnProtocol = crnThread.getCrnProtocol();
			if (crnProtocol == null) { continue; }
			if (crnProtocol == null) {
			continue;
			}

			// 状态：等待确认并且任务完成位 = 1
			if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
			//获取入库待确认工作档
			TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
			if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
			TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(), crnProtocol.getTaskNo().intValue());
			if (Cools.isEmpty(taskWrk) && crnProtocol.getTaskNo() != 999) {
			log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
			continue;
			}
			Thread.sleep(300);
			//确认完成信号
			CrnOperatorParam crnOperatorParam=new CrnOperatorParam();
			CrnOperatorParam crnOperatorParam = new CrnOperatorParam();
			crnOperatorParam.setCrnNo(crn.getId());

			crnController.crnTaskComplete(crnOperatorParam);
			if(!Cools.isEmpty(taskWrk)){
			if(taskWrk.getIoType()==1){
			R r = crnController.crnTaskComplete(crnOperatorParam);
			Thread.sleep(1000);
			if(!r.get("code").equals(200)){
			return;
			}
			if (!Cools.isEmpty(taskWrk)) {
			if (taskWrk.getIoType() == 1 && taskWrk.getWrkSts() == 3) {
			taskWrk.setWrkSts(4);//入库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			@@ -943,8 +1230,8 @@
			locMast.setModiTime(new Date());
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			}else if(taskWrk.getIoType()==2){
			taskWrk.setWrkSts(14);//出库完成
			} else if (taskWrk.getIoType() == 2 && taskWrk.getWrkSts() == 12) {
			taskWrk.setWrkSts(13);//出库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
			@@ -953,7 +1240,7 @@
			locMast.setModiTime(new Date());
			locMast.setModiUser(9999L);
			locMastService.updateById(locMast);
			}else if(taskWrk.getIoType()==3){
			} else if (taskWrk.getIoType() == 3 && taskWrk.getWrkSts() == 12) {
			taskWrk.setWrkSts(4);//入库完成
			taskWrk.setStatus(5);//完结
			//更新库位状态
			@@ -972,35 +1259,6 @@
			locMastService.updateById(locMast1);
			}
			taskWrkService.updateById(taskWrk);


			try{
			HashMap<String, Object> headParam = new HashMap<>();
			headParam.put("taskNo",taskWrk.getTaskNo());
			headParam.put("status",taskWrk.getStatus());
			headParam.put("ioType",taskWrk.getIoType());
			headParam.put("barcode",taskWrk.getBarcode());
			String response;
			response = new HttpHandler.Builder()
			// .setHeaders(headParam)
			.setUri(wmsUrl)
			.setPath(taskStatusFeedbackPath)
			.setJson(JSON.toJSONString(headParam))
			.build()
			.doPost();
			JSONObject jsonObject = JSON.parseObject(response);
			apiLogService.save("wcs派发入库任务上报wms"
			,wmsUrl+taskStatusFeedbackPath
			,null
			,"127.0.0.1"
			,JSON.toJSONString(headParam)
			,response
			,true
			);
			}catch (Exception e){
			log.error("wcs完结任务上报wms失败", taskWrk);
			throw new CoolException("wcs派发入库任务上报wms失败");
			}
			}

			}
			@@ -1010,7 +1268,7 @@
			/**
			* 堆垛机异常信息记录
			*/
			public void recCrnErr(){
			public synchronized void recCrnErr() {
			Date now = new Date();
			for (CrnSlave crn : slaveProperties.getCrn()) {
			// 获取堆垛机信息
			@@ -1032,7 +1290,7 @@
			continue;
			}
			BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
			String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
			String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
			BasErrLog basErrLog = new BasErrLog(
			null, // 编号
			wrkMast.getWrkNo(), // 工作号
			@@ -1079,7 +1337,7 @@
			// 记录新异常
			if (latest == null \|\| (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
			BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
			String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
			String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
			BasErrLog basErrLog = new BasErrLog(
			null, // 编号
			null, // 工作号
			@@ -1094,7 +1352,7 @@
			null, // 源站
			null, // 源库位
			null, // 条码
			(int)crnProtocol.getAlarm1(), // 异常码
			(int) crnProtocol.getAlarm1(), // 异常码
			errName, // 异常
			1, // 异常情况
			now, // 添加时间
			@@ -1125,28 +1383,86 @@
			}
			}

			//自动派发任务
			public void autoDistribute() {
			Config config = configService.selectByCode("autoDistribute");
			if (config == null) {
			return;
			// //自动派发任务
			// public synchronized void autoDistribute() {
			// Config config = configService.selectByCode("autoDistribute");
			// if (config == null) {
			// return;
			// }
			//
			// if (config.getValue().equals("false")) {//判断是否开启自动派发任务
			// return;
			// }
			//
			// for (TaskWrk taskWrk : taskWrkService.selectReceive()) {
			//
			// try {
			// taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
			// } catch (CoolException e) {
			// log.info(e.getMessage());
			// }
			// }
			// }

			//agv取放货任务完成
			public synchronized void autoCompleteAGV() {
			List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
			try {
			Thread.sleep(500);
			} catch (Exception e) {

			}

			if (config.getValue().equals("false")) {//判断是否开启自动派发任务
			return;
			}
			for (BasDevp basDevp : basDevps) {
			DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
			StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
			if (staProtocol == null) {
			continue;
			} else {
			staProtocol = staProtocol.clone();
			}
			if (basDevp.getWrkNo() != 0) {
			if (basDevp.getAgvTargetPick() != 0) {//取货
			staProtocol.setAgvTypeSign((short) 0);
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			boolean sign = true;
			if (basDevp.getAgvTargetPlace() != 0) {
			sign = false;
			basDevp.setAgvTargetPlace(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short) 3);//1
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			} else {
			if (basDevp.getAgvTargetPlace() != 0) {
			if (basDevp.getLoading().equals("Y")) {
			staProtocol.setAgvTypeSign((short) 1);
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			} else {
			log.error("AGV放货完成但输送线无物，复位信号 ===>> [staNo:{}] [basDevp:{}]", basDevp.getDevNo(), basDevp);
			basDevp.setAgvTargetPlace(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short) 3);//1
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}

			for (TaskWrk taskWrk : taskWrkService.selectReceive()) {

			try {
			taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
			} catch (CoolException e) {
			log.info(e.getMessage());
			}
			if (basDevp.getAgvTargetPick() != 0) {
			basDevp.setAgvTargetPick(0);
			basDevpService.updateById(basDevp);
			staProtocol.setAgvTypeSign((short) 2);//0
			staProtocol.setStaNo(basDevp.getDevNo().shortValue());
			MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
			}
			}
			}
			}

			//自动完成任务
			public synchronized void autoCompleteTask() {
			List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
			for (TaskWrk taskWrk : taskWrks) {
			@@ -1197,42 +1513,42 @@
			}


			public synchronized String CrnStartRunning(TaskWrk taskWrk){
			public synchronized String CrnStartRunning(TaskWrk taskWrk) {
			String tasktype = null;
			switch (taskWrk.getIoType()){
			switch (taskWrk.getIoType()) {
			case 1:
			tasktype= "RK";
			tasktype = "RK";
			break;
			case 2:
			tasktype= "CK";
			tasktype = "CK";
			break;
			case 3:
			tasktype= "YK";
			tasktype = "YK";
			break;
			default:
			tasktype= "未知";
			tasktype = "未知";
			}
			Map<String, Object> map = new HashMap<>();
			map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
			map.put("x-api-key", "7a15b5db-29b6-552c-8cff-0cfec3756da2");
			TaskOverToWms taskOverToWms = new TaskOverToWms();
			taskOverToWms.setFeedbackFrom("WCS"); //来源
			taskOverToWms.setWarehouseId("1688469798893297665"); //仓库标识
			taskOverToWms.setTaskNo(taskWrk.getTaskNo()); //任务号
			taskOverToWms.setTaskType(tasktype); // 任务类型
			taskOverToWms.setContainerCode(taskWrk.getBarcode()); // 容器编码
			if (taskWrk.getIoType() ==1 \|\| taskWrk.getIoType() == 3){
			if (taskWrk.getIoType() == 1 \|\| taskWrk.getIoType() == 3) {
			taskOverToWms.setEquipmentCode(String.valueOf(taskWrk.getCrnNo())); //设备编码
			taskOverToWms.setTargetLocationCode(taskWrk.getOriginTargetPoint()); //目标库位
			}else if (taskWrk.getIoType() ==2){
			Map<Integer,String> map1 = new HashMap<>();
			map1.put(102,"J-1101");
			map1.put(106,"J-1103");
			map1.put(110,"J-1105");
			map1.put(114,"J-1107");
			map1.put(118,"J-1109");
			map1.put(122,"J-1111");
			map1.put(305,"H-1101");
			map1.put(405,"G-1101");
			} else if (taskWrk.getIoType() == 2) {
			Map<Integer, String> map1 = new HashMap<>();
			map1.put(102, "J-1101");
			map1.put(106, "J-1103");
			map1.put(110, "J-1105");
			map1.put(114, "J-1107");
			map1.put(118, "J-1109");
			map1.put(122, "J-1111");
			map1.put(305, "H-1101");
			map1.put(405, "G-1101");
			taskOverToWms.setEquipmentCode(map1.get(taskWrk.getTargetPoint())); //设备编码
			taskOverToWms.setSourceLocationCode(taskWrk.getOriginStartPoint()); //源库位
			}
			@@ -1247,23 +1563,55 @@
			.setJson(JSON.toJSONString(taskOverToWms))
			.build()
			.doPost();
			}catch (Exception e){
			} catch (Exception e) {
			log.error("堆垛机任务完成，请求wms任务完成接口失败");
			}
			apiLogService.save("堆垛机开始运行"
			,wmsUrl+"wcsManager/wcsInterface/taskStatusFeedback"
			,null
			,"127.0.0.1"
			,JSON.toJSONString(taskOverToWms)
			,response
			,true
			, wmsUrl + "wcsManager/wcsInterface/taskStatusFeedback"
			, null
			, "127.0.0.1"
			, JSON.toJSONString(taskOverToWms)
			, response
			, true
			);
			return response;
			}

			private TaskWrk createTask(GetWmsDto dto, String barcode){
			private TaskWrk createTask1(Result result, String barcode) {
			String locNo = Utils.Fusion(result.getRow(), result.getFloor(), result.getColumn());


			Date now = new Date();
			TaskWrk taskWrk = new TaskWrk();
			int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
			taskWrk.setTaskNo(result.getTaskNo());//任务号
			taskWrk.setWrkNo(workNo1);
			taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
			taskWrk.setCreateTime(now);
			taskWrk.setIoType(1);//任务类型
			taskWrk.setIoPri(13);//优先级
			taskWrk.setBarcode(barcode);//条码
			LocMast locMast = locMastService.selectByLocNo(locNo);
			taskWrk.setCrnNo(locMast.getCrnNo());
			taskWrk.setTargetPoint(locNo);
			taskWrk.setStartPoint("116");
			if (result.getAlley().equals("1")) {
			taskWrk.setCrnNo(1);
			} else {
			taskWrk.setCrnNo(2);
			}
			if (taskWrk.getIoType() == 1) {
			taskWrk.setWrkSts(2);
			if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
			taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
			}
			}
			return taskWrk;
			}

			private TaskWrk createTask(GetWmsDto dto, String barcode) {
			String wcsLocNo = dto.getLocNo();
			if(Cools.isEmpty(wcsLocNo)){
			if (Cools.isEmpty(wcsLocNo)) {
			return null;
			}
			Date now = new Date();
			@@ -1280,7 +1628,7 @@
			taskWrk.setCrnNo(locMast.getCrnNo());
			taskWrk.setTargetPoint(wcsLocNo);
			taskWrk.setStartPoint(dto.getStaNo().toString());
			if(taskWrk.getIoType() == 1){
			if (taskWrk.getIoType() == 1) {
			taskWrk.setWrkSts(2);
			if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
			taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
			@@ -1302,6 +1650,5 @@
			}
			return taskWrk;
			}


			}