zy-asrs.git - Gitblit

			@@ -3,22 +3,24 @@
			import com.alibaba.fastjson.JSON;
			import com.baomidou.mybatisplus.mapper.EntityWrapper;
			import com.baomidou.mybatisplus.mapper.Wrapper;
			import com.core.common.Arith;
			import com.core.common.Cools;
			import com.core.exception.CoolException;
			import com.zy.asrs.entity.*;
			import com.zy.asrs.entity.result.FindLocNoAttributeVo;
			import com.zy.asrs.service.*;
			import com.zy.asrs.utils.Utils;
			import com.zy.asrs.utils.VersionUtils;
			import com.zy.common.model.LocTypeDto;
			import com.zy.common.model.Shelves;
			import com.zy.common.model.StartupDto;
			import com.zy.common.properties.SlaveProperties;
			import com.zy.system.entity.Config;
			import com.zy.system.service.ConfigService;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import java.util.ArrayList;
			import java.util.List;

			/**
			@@ -36,6 +38,8 @@
			@Autowired
			private RowLastnoService rowLastnoService;
			@Autowired
			private RowLastnoTypeService rowLastnoTypeService;
			@Autowired
			private BasCrnpService basCrnpService;
			@Autowired
			private StaDescService staDescService;
			@@ -47,9 +51,16 @@
			private LocDetlService locDetlService;
			@Autowired
			private SlaveProperties slaveProperties;
			@Autowired
			private WrkDetlService wrkDetlService;
			@Autowired
			private ConfigService configService;
			@Autowired
			private MatService matService;

			/**
			* 生成工作号
			*
			* @param wrkMk
			* @return workNo(工作号)
			*/
			@@ -62,17 +73,17 @@
			int workNo = wrkLastno.getWrkNo();
			int sNo = wrkLastno.getSNo();
			int eNo = wrkLastno.getENo();
			workNo = workNo>=eNo ? sNo : workNo+1;
			workNo = workNo >= eNo ? sNo : workNo + 1;
			while (true) {
			WrkMast wrkMast = wrkMastService.selectById(workNo);
			if (null != wrkMast) {
			workNo = workNo>=eNo ? sNo : workNo+1;
			workNo = workNo >= eNo ? sNo : workNo + 1;
			} else {
			break;
			}
			}
			// 修改序号记录
			if (workNo > 0){
			if (workNo > 0) {
			wrkLastno.setWrkNo(workNo);
			wrkLastnoService.updateById(wrkLastno);
			}
			@@ -80,74 +91,768 @@
			if (workNo == 0) {
			throw new CoolException("生成工作号失败，请联系管理员");
			} else {
			if (wrkMastService.selectById(workNo)!=null) {
			if (wrkMastService.selectById(workNo) != null) {
			throw new CoolException("生成工作号" + workNo + "在工作档中已存在");
			}
			}
			return workNo;
			}

			//拆盘机处空板扫码，驱动托盘向码垛位，不入库
			@Transactional
			public StartupDto getScanBarcodeEmptyBoard() {
			StartupDto startupDto = new StartupDto();
			Integer staNo = 0;
			if (wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("io_type", 201).eq("staNo", 216)) < 2) {
			staNo = 216;
			}
			if (wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("io_type", 201).eq("staNo", 220)) < 2) {
			staNo = 220;
			}

			startupDto.setStaNo(staNo);
			return startupDto;
			}

			/**
			* 检索库位号
			* @param whsType 类型 1:双深式货架
			* @param staDescId 路径工作类型
			* @param sourceStaNo 源站
			* @param matNos 商品编号集合
			*
			* @param staDescId 路径ID
			* @param sourceStaNo 源站
			* @param findLocNoAttributeVo 属性
			* @param locTypeDto 类型
			* @return locNo 检索到的库位号
			*/
			@Transactional
			public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto, int times) {
			// whsType = getWhsType(sourceStaNo, times);
			switch (sourceStaNo){
			case 101:
			case 109:
			case 117:
			whsType=1; //1-8货架
			slaveProperties.setDoubleDeep(false);
			slaveProperties.setGroupCount(2);
			break;
			case 201:
			slaveProperties.setDoubleDeep(true);
			slaveProperties.setGroupCount(4);
			whsType=2; //9-12货架
			break;
			case 207:
			whsType=3; //13-14货架
			slaveProperties.setDoubleDeep(false);
			slaveProperties.setGroupCount(2);
			break;
			case 213:
			slaveProperties.setDoubleDeep(true);
			slaveProperties.setGroupCount(4);
			whsType=4; //15-18货架
			break;
			default:
			throw new CoolException("根据入库站获取库位排号分配失败，入库站：" + sourceStaNo);
			public StartupDto getLocNo(Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto, String barcode) {
			List<Integer> crnList = new ArrayList<>();
			if (barcode.startsWith("11")) {
			crnList.add(4);
			crnList.add(5);

			Config config = configService.selectConfigByCode("11CrnConfig");
			List<Integer> list = JSON.parseArray(config.getValue(), Integer.class);
			for (Integer crn : list) {
			crnList.remove(crn);
			}

			if (crnList.isEmpty()) {
			crnList.add(4);
			crnList.add(5);

			configService.updateValue("11CrnConfig", "[]");
			}else {
			if (!list.isEmpty()) {
			crnList.addAll(list);
			}
			}
			}else if (barcode.startsWith("13")) {
			crnList.add(1);
			crnList.add(2);
			crnList.add(3);

			Config config = configService.selectConfigByCode("13CrnConfig");
			List<Integer> list = JSON.parseArray(config.getValue(), Integer.class);
			for (Integer crn : list) {
			crnList.remove(crn);
			}

			if (crnList.isEmpty()) {
			crnList.add(1);
			crnList.add(2);
			crnList.add(3);

			configService.updateValue("13CrnConfig", "[]");
			}else {
			if (!list.isEmpty()) {
			crnList.addAll(list);
			}
			}

			if (staDescId != 10) {
			//检测是否为呆滞料
			String matnr = findLocNoAttributeVo.getMatnr();
			Mat mat = matService.selectByMatnr(matnr);
			if (mat == null) {
			throw new CoolException(matnr + "物料信息不存在");
			}

			if (mat.getTscp() != null && mat.getTscp() == 1) {
			crnList.add(0, 1);
			}
			}
			}else if (barcode.startsWith("16")) {
			crnList.add(6);
			}else {
			throw new CoolException("托盘码:{}" + barcode + "规则错误，无法找到匹配堆垛机");
			}

			StartupDto startupDto = null;
			StringBuilder builder = new StringBuilder();
			for (Integer crnNo : crnList) {
			try {
			startupDto = searchLocNoByCrnNo(staDescId, sourceStaNo, findLocNoAttributeVo, locTypeDto, crnNo);
			if(startupDto != null) {
			break;
			}
			} catch (Exception e) {
			builder.append(e.getMessage()).append(",");
			}
			}

			if(startupDto == null) {
			builder.append("找不到空库位");
			throw new CoolException(builder.toString());
			}

			Integer crnNo = startupDto.getCrnNo();
			if (barcode.startsWith("11")) {
			Config config = configService.selectConfigByCode("11CrnConfig");
			List<Integer> list = JSON.parseArray(config.getValue(), Integer.class);
			List<Integer> newList = new ArrayList<>();
			for (Integer crn : list) {
			if(crn == crnNo) {
			continue;
			}
			newList.add(crn);
			}
			newList.add(crnNo);
			configService.updateValue("11CrnConfig", JSON.toJSONString(newList));
			}else if (barcode.startsWith("13")) {
			Config config = configService.selectConfigByCode("13CrnConfig");
			List<Integer> list = JSON.parseArray(config.getValue(), Integer.class);
			List<Integer> newList = new ArrayList<>();
			for (Integer crn : list) {
			if(crn == crnNo) {
			continue;
			}
			newList.add(crn);
			}
			newList.add(crnNo);
			configService.updateValue("13CrnConfig", JSON.toJSONString(newList));
			}

			return startupDto;
			}

			/**
			* 检索库位号
			*
			* @param staDescId 路径ID
			* @param sourceStaNo 源站
			* @param findLocNoAttributeVo 属性
			* @param locTypeDto 类型
			* @return locNo 检索到的库位号
			*/
			@Transactional
			public StartupDto searchLocNoByCrnNo(Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto, Integer crnNo) {
			Config devpTaskStackOverConfig = configService.selectConfigByCode("devpTaskStackOver");
			int devpTaskStackOver = Integer.parseInt(devpTaskStackOverConfig.getValue());
			Integer devpWorkingCount = queryDevpWorkingCount();
			if (devpWorkingCount > devpTaskStackOver) {
			throw new CoolException("输送线任务过载，当前输送线承载数量:{}" + devpWorkingCount);
			}

			if (!basCrnpService.checkSiteError(crnNo, true)) {
			throw new CoolException(crnNo + "号堆垛机异常");
			}

			Config crnSearchDetectTaskCountConfig = configService.selectConfigByCode("crnSearchDetectTaskCount");
			int crnSearchDetectTaskCount = Integer.parseInt(crnSearchDetectTaskCountConfig.getValue());

			Config applyInTaskTotalCountConfig = configService.selectConfigByCode("applyInTaskTotalCount");
			int applyInTaskTotalCount = Integer.parseInt(applyInTaskTotalCountConfig.getValue());

			Config emptyInKeepLimitConfig = configService.selectConfigByCode("emptyInKeepLimit");
			int emptyInKeepLimit = Integer.parseInt(emptyInKeepLimitConfig.getValue());

			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57));
			if (wrkMasts.size() > crnSearchDetectTaskCount) {
			log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), crnSearchDetectTaskCount);
			throw new CoolException(crnNo + "号堆垛机已达到入库控制上限！");
			}

			List<WrkMast> wrkMastsList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57, 101, 103, 107, 110));
			if (wrkMastsList.size() > applyInTaskTotalCount) {
			log.error(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！！！任务数量： {}，控制数量：{}", wrkMastsList.size(), applyInTaskTotalCount);
			throw new CoolException(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！");
			}

			List<LocMast> searchLocMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_type1", locTypeDto.getLocType1()).eq("loc_sts", "O").eq("crn_no", crnNo));
			if (searchLocMasts.size() <= emptyInKeepLimit) {
			log.error(crnNo + "号堆垛机到达空库位预留上限！！！尺寸规格： {}", JSON.toJSONString(locTypeDto));
			throw new CoolException(crnNo + "号堆垛机到达空库位预留上限！尺寸规格：" + (locTypeDto.getLocType1() == 1 ? "高" : "低"));
			}

			if (crnNo == 1) {
			if (wrkMasts.size() >= 1) {
			log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), 1);
			throw new CoolException(crnNo + "号堆垛机已达到入库控制上限！");
			}
			}

			LocMast locMast = null;
			if (staDescId == 10) {
			//搜索空托盘
			locMast = searchEmptyPallet(crnNo, locTypeDto);
			}else {
			//满托盘
			locMast = searchMaxPallet(crnNo, findLocNoAttributeVo, locTypeDto);
			}

			if(locMast == null) {
			throw new CoolException(crnNo + "号堆垛机找不到符合尺寸的空库位");
			}

			StartupDto startupDto = new StartupDto();

			// 获取目标站
			Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>().eq("type_no", staDescId).eq("stn_no", sourceStaNo).eq("crn_no", locMast.getCrnNo());
			StaDesc staDesc = staDescService.selectOne(wrapper);
			if (Cools.isEmpty(staDesc)) {
			log.error("type_no={},stn_no={},crn_no={}", staDescId, sourceStaNo, crnNo);
			throw new CoolException("入库路径不存在");
			} else {
			BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
			if (!staNo.getAutoing().equals("Y")) {
			log.error("目标站" + staDesc.getCrnStn() + "不可用");
			throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
			}
			startupDto.setStaNo(staNo.getDevNo());
			}
			String locNo = locMast.getLocNo();
			// 生成工作号
			int workNo = getWorkNo(0);
			// 返回dto
			startupDto.setWorkNo(workNo);
			startupDto.setCrnNo(locMast.getCrnNo());
			startupDto.setSourceStaNo(sourceStaNo);
			startupDto.setLocNo(locNo);
			return startupDto;
			}

			public Integer queryDevpWorkingCount() {
			List<WrkMast> wrkMastsIn = wrkMastService.selectList(new EntityWrapper<WrkMast>()
			.in("wrk_sts", 2, 3, 4, 5));

			RowLastno rowLastno = rowLastnoService.selectById(whsType);
			if (Cools.isEmpty(rowLastno)) {
			throw new CoolException("数据异常，请联系管理员");
			List<WrkMast> wrkMastsOut = wrkMastService.selectList(new EntityWrapper<WrkMast>()
			.in("wrk_sts", 12, 14, 15));

			int count = 0;
			count += wrkMastsIn.size();
			count += wrkMastsOut.size();
			return count;
			}

			//搜索满托盘库位
			public LocMast searchMaxPallet(Integer crnNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto) {
			//获取堆垛机排
			List<Integer> rowList = locMastService.selectRowByCrnNo(crnNo);
			//获取深库位排
			List<Integer> deepRowList = new ArrayList<>();
			for (Integer row : rowList) {
			if (Utils.isDeepLoc(slaveProperties, row)) {
			deepRowList.add(row);
			}
			}

			// ===============>>>> 开始执行
			int curRow = rowLastno.getCurrentRow();
			LocMast targetLocMast = null;
			List<String> locNos = locDetlService.getSameDetlList(findLocNoAttributeVo.getMatnr(), deepRowList);
			for (String locNo : locNos) {
			//检测对应浅库位是否可用
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, locNo);
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
			if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
			targetLocMast = shallowLoc;
			break;
			}
			}
			}

			if(targetLocMast == null) {
			if (crnNo == 1) {
			return searchMaxPalletByOne(crnNo, findLocNoAttributeVo, locTypeDto);
			}

			//相近物料匹配失败，搜索深库位可用空库位
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("crn_no", crnNo)
			.eq("loc_sts", "O")
			.in("row1", deepRowList)
			.orderBy("lev1", true)
			.orderBy("bay1", true));
			for (LocMast locMast : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast, locTypeDto)) {
			continue;
			}

			//深库位直接选择
			targetLocMast = locMast;
			break;
			}

			if(targetLocMast == null) {
			//深库位搜索失败，搜索可用空库位
			List<LocMast> shallowLocMasts = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("crn_no", crnNo)
			.eq("loc_sts", "O")
			.orderBy("lev1", true)
			.orderBy("bay1", true));
			for (LocMast locMast : shallowLocMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast, locTypeDto)) {
			continue;
			}

			targetLocMast = locMast;
			break;
			}
			}

			}

			return targetLocMast;
			}

			//1号堆垛机搜索逻辑
			public LocMast searchMaxPalletByOne(Integer crnNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto) {
			List<Integer> nearRowList = new ArrayList<Integer>() {{
			add(4);
			add(6);
			add(3);
			add(1);
			}};

			LocMast targetLocMast = null;
			for (Integer row : nearRowList) {
			//相近物料匹配失败，搜索深库位可用空库位
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("crn_no", crnNo)
			.eq("loc_sts", "O")
			.eq("row1", row)
			.orderBy("lev1", true)
			.orderBy("bay1", true));
			for (LocMast locMast : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast, locTypeDto)) {
			continue;
			}

			//深库位直接选择
			targetLocMast = locMast;
			break;
			}

			if (targetLocMast != null) {
			break;
			}
			}

			return targetLocMast;
			}

			//搜索空托盘
			public LocMast searchEmptyPallet(Integer crnNo, LocTypeDto locTypeDto) {
			// 靠近摆放规则 --- 空托
			LocMast targetLocMast = null;

			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("loc_sts", "D")
			.eq("crn_no", crnNo)
			);
			for (LocMast loc : locMasts) {
			if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
			continue;
			}
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
			// 检测目标库位是否为空库位
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
			if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
			targetLocMast = shallowLoc;
			break;
			}
			}
			}

			if (targetLocMast == null) {
			List<LocMast> locMastsList = locMastService.selectList(new EntityWrapper<LocMast>()
			.eq("loc_sts", "O")
			.eq("crn_no", crnNo)
			.orderBy("lev1", false)
			.orderBy("bay1", true));
			for (LocMast locMast : locMastsList) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast, locTypeDto)) {
			continue;
			}

			boolean shallowLoc = Utils.isShallowLoc(slaveProperties, locMast.getLocNo());
			if (shallowLoc) {
			//浅库位，先判断深库位
			String deepLoc2 = Utils.getDeepLoc2(slaveProperties, locMast.getLocNo());
			if (!Cools.isEmpty(deepLoc2)) {
			LocMast locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>()
			.eq("loc_no", deepLoc2)
			.eq("loc_sts", "O")
			.eq("crn_no", crnNo)
			);
			if (!Cools.isEmpty(locMast2)) {
			targetLocMast = locMast2;
			break;
			}
			}
			}else {
			//空的深库位直接选择
			targetLocMast = locMast;
			break;
			}
			}

			if(targetLocMast == null) {
			//深库位找完都没找到，直接找浅库位
			for (LocMast locMast : locMastsList) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast, locTypeDto)) {
			continue;
			}

			//空库位直接选择
			targetLocMast = locMast;
			}
			}
			}

			return targetLocMast;
			}

			// /**
			// * 检索库位号
			// *
			// * @param staDescId 路径ID
			// * @param sourceStaNo 源站
			// * @param findLocNoAttributeVo 属性
			// * @param locTypeDto 类型
			// * @return locNo 检索到的库位号
			// */
			// @Transactional
			// public StartupDto getLocNo(Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, LocTypeDto locTypeDto) {
			// // try {
			// Integer whsType = Utils.GetWhsType(sourceStaNo);
			// RowLastno rowLastno = rowLastnoService.selectById(whsType);
			// RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
			// /**
			// * 库型 1: 标准堆垛机库 2: 平库 3: 穿梭板 4: 四向车 5: AGV 0: 未知
			// */
			// switch (rowLastnoType.getType()) {
			// case 1:
			// Config crnSearchDetectTaskCountConfig = configService.selectConfigByCode("crnSearchDetectTaskCount");
			// int crnSearchDetectTaskCount = Integer.parseInt(crnSearchDetectTaskCountConfig.getValue());
			//
			// Config applyInTaskTotalCountConfig = configService.selectConfigByCode("applyInTaskTotalCount");
			// int applyInTaskTotalCount = Integer.parseInt(applyInTaskTotalCountConfig.getValue());
			// int crnNo = 7;
			// boolean flag = true;
			// List<String> data = new ArrayList<>();
			// while (crnNo > 1) {
			// crnNo--;
			// List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "O").eq("crn_no", crnNo).eq("whs_type", rowLastnoType.getType().longValue()).eq("loc_type1", locTypeDto.getLocType1()).eq("loc_type2", locTypeDto.getLocType2()));
			// if (locMasts.size() <= 15) {
			// log.error(crnNo + "号堆垛机没有空库位！！！尺寸规格： {}", JSON.toJSONString(locTypeDto));
			// data.add(crnNo + "号没有空库位;");
			// } else {
			// List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57));
			// if (wrkMasts.size() > crnSearchDetectTaskCount) {
			// log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), crnSearchDetectTaskCount);
			// data.add(crnNo + "号入库控制上限;");
			// continue;
			// }
			// List<WrkMast> wrkMastsList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57, 101, 103, 107, 110));
			// if (wrkMastsList.size() > applyInTaskTotalCount) {
			// log.error(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！！！任务数量： {}，控制数量：{}", wrkMastsList.size(), applyInTaskTotalCount);
			// data.add(crnNo + "号申请入库时总任务数量上限;");
			// continue;
			// }
			// flag = false;
			// break;
			// }
			//
			// }
			// if (!flag) {
			// return getLocNoRun(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, 0, locTypeDto, 0);
			// } else {
			// log.info("数据：{}", data);
			// throw new CoolException(data.toString());
			// }
			// case 2:
			// log.error("站点={} 未查询到对应的规则", sourceStaNo);
			// break;
			// case 3:
			// log.error("站点={} 未查询到对应的规则", sourceStaNo);
			// break;
			// case 4:
			// return getLocNoRun4(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, 4, locTypeDto, 0);
			// case 5:
			// return getLocNoRun5(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, 0, locTypeDto, 0);
			// default:
			// log.error("站点={} 未查询到对应的规则", sourceStaNo);
			// break;
			// }
			//
			//// } catch (Exception e) {
			//// log.error("站点={} 未查询到对应的规则，{}", sourceStaNo, e.getMessage());
			//// }
			// return null;
			// }

			/**
			* 检索库位号
			*
			* @param whsType 类型 1:双深式货架
			* @param staDescId 路径ID
			* @param sourceStaNo 源站
			* @param findLocNoAttributeVo 属性
			* @param moveCrnNo 源
			* @param locTypeDto 类型
			* @param times 轮询次数
			* @return locNo 检索到的库位号
			*/
			@Transactional
			public StartupDto getLocNoRun(Integer whsType, Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, Integer moveCrnNo, LocTypeDto locTypeDto, int times) {

			// 初始化参数
			int crnNo = 0; //堆垛机号
			int nearRow = 0; //最浅库位排
			int curRow = 0; //最深库位排
			int rowCount = 0; //轮询轮次
			LocMast locMast = null; // 目标库位

			StartupDto startupDto = new StartupDto();
			RowLastno rowLastno = rowLastnoService.selectById(whsType);
			if (Cools.isEmpty(rowLastno)) {
			throw new CoolException("数据异常，请联系管理员===>库位规则未知");
			}
			RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
			if (Cools.isEmpty(rowLastnoType)) {
			throw new CoolException("数据异常，请联系管理员===》库位规则类型未知");
			}
			int sRow = rowLastno.getsRow();
			int eRow = rowLastno.geteRow();
			int crn_qty = rowLastno.getCrnQty();
			int rowCount = eRow - sRow + 1;
			// 目标堆垛机号
			int crnNo = 0;
			// 目标库位
			LocMast locMast = null;
			int crnNumber = rowLastno.getCrnQty();

			// 靠近摆放规则 --- 同天同规格物料
			if (!Cools.isEmpty(matNos)) {
			List<String> locNos = locDetlService.getSameDetlToday(matNos.get(0), sRow, eRow);

			// ===============>>>> 开始执行
			curRow = rowLastno.getCurrentRow();

			if (!Cools.isEmpty(moveCrnNo) && moveCrnNo != 0) {
			crnNumber = moveCrnNo;
			if (times == 0) {
			curRow = moveCrnNo * 4 - 1;
			} else {
			curRow = moveCrnNo * 4 - 2;
			}
			}


			Config crnSearchDetectTaskCountConfig = configService.selectConfigByCode("crnSearchDetectTaskCount");
			int crnSearchDetectTaskCount = Integer.parseInt(crnSearchDetectTaskCountConfig.getValue());

			Config applyInTaskTotalCountConfig = configService.selectConfigByCode("applyInTaskTotalCount");
			int applyInTaskTotalCount = Integer.parseInt(applyInTaskTotalCountConfig.getValue());

			Config crnSearchListConfig = configService.selectConfigByCode("123CrnSearchList");
			int crnSearchList = Integer.parseInt(crnSearchListConfig.getValue());

			//此程序用于优化堆垛机异常时的运行时间
			for (int i = times; i < crnNumber * 2; i++) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRow, crnNumber);
			curRow = locNecessaryParameters[1];
			crnNo = locNecessaryParameters[2];
			if (basCrnpService.checkSiteError(crnNo, true)) {
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57));
			if (wrkMasts.size() > crnSearchDetectTaskCount) {
			log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), crnSearchDetectTaskCount);
			continue;
			}

			List<WrkMast> wrkMastsList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57, 101, 103, 107, 110));
			if (wrkMastsList.size() > applyInTaskTotalCount) {
			log.error(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！！！任务数量： {}，控制数量：{}", wrkMastsList.size(), applyInTaskTotalCount);
			continue;
			}

			rowCount = locNecessaryParameters[0];
			nearRow = locNecessaryParameters[3];
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			int crnCountO = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).eq("io_type", 1));
			if (locMasts.size() - crnCountO <= 15) {
			log.error(crnNo + "号堆垛机没有空库位！！！尺寸规格： {}，轮询次数：{}", JSON.toJSONString(locTypeDto), times);
			nearRow = 0;
			times++;
			continue;
			}
			break;
			} else {
			times++;
			}
			}

			//优化系统，提高搜索1号堆垛机次数
			if (crnNo == 2 \|\| crnNo == 3) {
			if (crnSearchList >= 2) {
			if (basCrnpService.checkSiteError(1, true)) {
			boolean flag = true;
			//尝试找1号弯轨堆垛机库位
			crnNo = 1;
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57));
			if (wrkMasts.size() > crnSearchDetectTaskCount) {
			log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), crnSearchDetectTaskCount);
			flag = false;
			}

			List<WrkMast> wrkMastsList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57, 101, 103, 107, 110));
			if (wrkMastsList.size() > applyInTaskTotalCount) {
			log.error(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！！！任务数量： {}，控制数量：{}", wrkMastsList.size(), applyInTaskTotalCount);
			flag = false;
			}

			if (flag) {
			List<Integer> nearRowList = new ArrayList<Integer>() {{
			add(4);
			add(6);
			add(3);
			add(1);
			}};
			for (Integer near : nearRowList) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", near).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()).eq("loc_type1", locTypeDto.getLocType1()).eq("loc_type2", locTypeDto.getLocType2()));
			int crnCountO = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).eq("io_type", 1));
			if (locMasts.size() - crnCountO <= 15) {
			log.error(crnNo + "号堆垛机没有空库位！！！尺寸规格： {}，轮询次数：{}", JSON.toJSONString(locTypeDto), times);
			} else {
			nearRow = near;
			break;
			}
			}
			}
			}
			}
			}

			if (nearRow == 0) {
			if (locTypeDto.getLocType2() == 2) {
			//尝试找1号弯轨堆垛机库位
			crnNo = 1;
			if (basCrnpService.checkSiteError(crnNo, true)) {
			boolean flag = true;
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57));
			if (wrkMasts.size() > crnSearchDetectTaskCount) {
			log.error(crnNo + "号堆垛机已达到入库控制上限！！！任务数量： {}，控制数量：{}", wrkMasts.size(), crnSearchDetectTaskCount);
			flag = false;
			}

			List<WrkMast> wrkMastsList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("io_type", 1, 10, 53, 57, 101, 103, 107, 110));
			if (wrkMastsList.size() > applyInTaskTotalCount) {
			log.error(crnNo + "号堆垛机已达到申请入库时总任务数量上限(入库、出库)！！！任务数量： {}，控制数量：{}", wrkMastsList.size(), applyInTaskTotalCount);
			flag = false;
			}

			if (flag) {
			List<Integer> nearRowList = new ArrayList<Integer>() {{
			add(4);
			add(6);
			add(3);
			add(1);
			}};
			for (Integer near : nearRowList) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", near).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()).eq("loc_type1", locTypeDto.getLocType1()).eq("loc_type2", locTypeDto.getLocType2()));
			int crnCountO = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).eq("io_type", 1));
			if (locMasts.size() - crnCountO <= 15) {
			log.error(crnNo + "号堆垛机没有空库位！！！尺寸规格： {}，轮询次数：{}", JSON.toJSONString(locTypeDto), times);
			} else {
			nearRow = near;
			break;
			}
			}
			}
			}

			if (nearRow == 0) {
			throw new CoolException("无可用堆垛机");
			}
			}
			// else {
			// throw new CoolException("无可用堆垛机");
			// }
			}

			boolean signRule1 = false;
			boolean signRule2 = false;


			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			// 靠近摆放规则 --- 同天同规格物料 //分离版
			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && staDescId == 1) {
			signRule1 = true;
			}
			// 靠近摆放规则 --- 同天同规格物料 //互通版
			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && staDescId == 1) {
			signRule2 = true;
			}

			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && (staDescId == 11 \|\| staDescId == 111)) {
			signRule1 = true;
			}
			}

			if (signRule1) {
			if (nearRow != curRow) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}

			if (crnNo == 1) {
			if (locMast1.getRow1() == 1 \|\| locMast1.getRow1() == 6) {
			locMast = locMast1;//单深库位直接使用
			break;
			}

			//获取目标库位所在巷道最浅非空库位
			List<LocMast> locMastList = locMastService.selectList(new EntityWrapper<LocMast>().eq("whs_type", rowLastnoType.getType().longValue()).eq("crn_no", locMast1.getCrnNo()).eq("bay1", locMast1.getBay1()).notIn("loc_sts", "O").orderBy("row1", false));
			if (locMastList.isEmpty()) {
			locMast = locMast1;
			break;
			}

			LocMast locMastF = locMastList.get(0);
			if (!slaveProperties.getDoubleLocs().contains(locMastF.getRow1())) {
			continue;
			}

			LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", locMastF.getLocNo()));
			if (!Cools.isEmpty(locDetl) && findLocNoAttributeVo.beSimilar(locDetl)) {
			String shallowLoc = Utils.getShallowLoc(slaveProperties, locMastF.getLocNo());
			LocMast shallowLocMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc).eq("loc_sts", "O"));
			if (shallowLocMast != null) {
			locMast = shallowLocMast;
			break;
			}
			}
			continue;
			}

			//获取目标库位所在巷道最浅非空库位
			LocMast locMastF = locMastService.selectLocByLocStsPakInF(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMastF) && locMastF.getLocSts().equals("F")) {
			LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", locMastF.getLocNo()));
			if (!Cools.isEmpty(locDetl) && findLocNoAttributeVo.beSimilar(locDetl)) {
			//获取目标库位所在巷道最深空库位
			locMast = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			break;
			}
			}
			}
			}
			} else if (signRule2) {
			List<String> locNos = locDetlService.getSameDetlToday(findLocNoAttributeVo.getMatnr(), sRow, eRow);
			for (String locNo : locNos) {
			if (Utils.isShallowLoc(slaveProperties, locNo)) {
			continue;
			@@ -156,7 +861,7 @@
			// 检测目标库位是否为空库位
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
			if (VersionUtils.locMoveCheckLocType(shallowLoc, locTypeDto)) {
			if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
			if (basCrnpService.checkSiteError(shallowLoc.getCrnNo(), true)) {
			locMast = shallowLoc;
			crnNo = locMast.getCrnNo();
			@@ -167,187 +872,606 @@
			}
			}

			// 靠近摆放规则 --- 空托
			if (staDescId == 10) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow));
			if (locMasts.size() > 0) {
			for (LocMast loc : locMasts) {
			if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
			continue;
			}
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
			// 检测目标库位是否为空库位
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
			if (basCrnpService.checkSiteError(shallowLoc.getCrnNo(), true)) {
			locMast = shallowLoc;
			crnNo = locMast.getCrnNo();
			break;
			}
			}
			}
			}
			}
			if (null == locMast){
			switch (curRow){
			case 1:
			case 3:
			case 5:
			curRow=curRow+2;
			crnNo=(curRow+1)/2;
			break;
			case 7:
			crnNo=1;
			curRow=2;
			break;
			case 13:
			crnNo=6;
			curRow=14;
			break;
			case 2:
			case 4:
			case 6:
			curRow=curRow+2;
			crnNo=curRow/2;
			break;
			case 8:
			crnNo=1;
			curRow=1;
			break;
			case 14:
			crnNo=6;
			curRow=13;
			break;
			case 9:
			crnNo=5;
			curRow=12;
			break;
			case 10:
			crnNo=5;
			curRow=11;
			break;
			case 11:
			crnNo=5;
			curRow=9;
			break;
			case 12:
			crnNo=5;
			curRow=10;
			break;
			case 15:
			crnNo=7;
			curRow=18;
			break;
			case 16:
			crnNo=7;
			curRow=17;
			break;
			case 17:
			crnNo=7;
			curRow=15;
			break;
			case 18:
			crnNo=7;
			curRow=16;
			break;
			default:
			throw new CoolException("根据入库站获取库位排号分配失败，入库站：" + sourceStaNo);
			}
			}

			// // 如果没有相近物料，则按规则轮询货架
			// if (null == locMast) {
			// Shelves shelves = new Shelves(rowCount, crn_qty);
			// int divides = (int) Arith.divides(1, curRow - 1, 4);
			// curRow = (int) Arith.remainder(curRow, 4);
			// if (curRow == 0) {
			// curRow = 4;
			// }
			// for (int i = 0; i < shelves.group; i ++) {
			// curRow = shelves.start(curRow);
			// if (curRow < 0) {
			// throw new CoolException("检索库位失败，请联系管理员");
			// // 靠近摆放规则 --- 空托 //分离版
			// if (staDescId == 10 && Utils.BooleanWhsTypeStaIoType(whsType)) {
			// List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O"));
			// for (LocMast locMast1:locMasts){
			// if (VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			// continue;
			// }
			// Integer crnNo1 = shelves.get(curRow);
			// crnNo1 = crnNo1 + divides*1;
			// if (basCrnpService.checkSiteError(crnNo1, true)) {
			// crnNo = crnNo1;
			// curRow = curRow + divides*4;
			// String shallowLoc = Utils.getDeepLoc(slaveProperties,locMast1.getLocNo());
			// LocMast locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",shallowLoc));
			// if (!Cools.isEmpty(locMast2) && locMast2.getLocSts().equals("D")){
			// locMast = locMast1;
			// break;
			// }
			// }
			// }

			if (crnNo == 0) {
			throw new CoolException("没有可用的堆垛机");
			// 靠近摆放规则 --- 空托 //互通版
			if (staDescId == 10 && Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow).eq("whs_type", rowLastnoType.getType().longValue()));
			if (!locMasts.isEmpty()) {
			for (LocMast loc : locMasts) {
			if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
			continue;
			}
			String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
			// 检测目标库位是否为空库位
			LocMast shallowLoc = locMastService.selectById(shallowLocNo);
			if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
			if (VersionUtils.locMoveCheckLocTypeComplete(shallowLoc, locTypeDto)) {
			if (basCrnpService.checkSiteError(shallowLoc.getCrnNo(), true)) {
			locMast = shallowLoc;
			crnNo = locMast.getCrnNo();
			break;
			}
			}
			}
			}
			}
			}

			Wrapper<StaDesc> wrapper = null;
			StaDesc staDesc = null;
			BasDevp staNo = null;


			if (Utils.BooleanWhsTypeSta(rowLastno, staDescId)) {

			// 更新库位排号
			if (Cools.isEmpty(locMast)) {
			rowLastno.setCurrentRow(curRow);
			rowLastnoService.updateById(rowLastno);
			}
			}
			// 开始查找库位 ==============================>>

			// 1.按规则查找库位
			if (Cools.isEmpty(locMast) && crnNo != 0) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()).ne("inv_wh", 1).orderBy("lev1", true).orderBy("bay1", true));
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}
			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			String shallowLoc = Utils.getShallowLoc(slaveProperties, locMast1.getLocNo());
			LocMast locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			if (!Cools.isEmpty(locMast2)) {
			locMast = locMast2;
			break;
			}
			} else {
			if (!Cools.isEmpty(locMast1)) {
			locMast = locMast1;
			break;
			}
			}
			}

			if (Cools.isEmpty(locMast) && Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}
			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			String shallowLoc = Utils.getDeepLoc(slaveProperties, locMast1.getLocNo());
			LocMast locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			if (!Cools.isEmpty(locMast2)) {
			locMast = locMast2;
			break;
			} else {
			locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc).eq("loc_sts", "F").eq("whs_type", rowLastnoType.getType().longValue()));
			if (!Cools.isEmpty(locMast2)) {
			locMast = locMast1;
			break;
			} else {
			locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc).eq("loc_sts", "D").eq("whs_type", rowLastnoType.getType().longValue()));
			if (!Cools.isEmpty(locMast2)) {
			locMast = locMast1;
			break;
			}
			}
			}
			} else {
			if (!Cools.isEmpty(locMast1)) {
			locMast = locMast1;
			break;
			}
			}
			}
			}
			}

			if (!Cools.isEmpty(locMast) && !basCrnpService.checkSiteError(crnNo, true)) {
			locMast = null;
			}

			// 递归查询
			if (Cools.isEmpty(locMast) \|\| !locMast.getLocSts().equals("O")) {
			// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
			if (times < rowCount * 2) {
			times = times + 1;
			return getLocNoRun(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, times);
			}
			// // 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
			// if (locTypeDto.getLocType1() < 2) {
			// int i = locTypeDto.getLocType1() + 1;
			// locTypeDto.setLocType1((short)i);
			// return getLocNo(1, staDescId, sourceStaNo, matnr,batch,grade, locTypeDto, 0);
			// }
			log.error("系统没有空库位！！！尺寸规格： {}，轮询次数：{},{}", JSON.toJSONString(locTypeDto), times, moveCrnNo);
			throw new CoolException("没有空库位");
			}

			if (crnNo == 2 \|\| crnNo == 3) {
			crnSearchList++;
			configService.updateValue("123CrnSearchList", String.valueOf(crnSearchList));
			}

			if (crnNo == 1) {
			configService.updateValue("123CrnSearchList", String.valueOf(0));
			}
			//针对1号堆垛机打的补丁，防止找到库位时，找到最浅库位
			String deepLoc2 = Utils.getDeepLoc2(slaveProperties, locMast.getLocNo());
			if (!Cools.isEmpty(deepLoc2)) {
			LocMast locMastNew = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", locMast.getCrnNo()).eq("loc_no", deepLoc2).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			if (!Cools.isEmpty(locMastNew)) {
			locMast = locMastNew;
			}
			}


			// 获取目标站
			Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
			.eq("type_no", staDescId)
			.eq("stn_no", sourceStaNo)
			.eq("crn_no", crnNo);
			StaDesc staDesc = staDescService.selectOne(wrapper);
			wrapper = new EntityWrapper<StaDesc>().eq("type_no", staDescId).eq("stn_no", sourceStaNo).eq("crn_no", locMast.getCrnNo());
			staDesc = staDescService.selectOne(wrapper);
			if (Cools.isEmpty(staDesc)) {
			log.error("type_no={},stn_no={},crn_no={}", staDescId, sourceStaNo, crnNo);
			throw new CoolException("入库路径不存在");
			// throw new CoolException("入库路径不存在");
			crnNo = 0;
			} else {
			staNo = basDevpService.selectById(staDesc.getCrnStn());
			if (!staNo.getAutoing().equals("Y")) {
			log.error("目标站" + staDesc.getCrnStn() + "不可用");
			// throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
			crnNo = 0;
			}
			startupDto.setStaNo(staNo.getDevNo());
			}
			BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
			if (!staNo.getAutoing().equals("Y")) {
			throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
			String locNo = locMast.getLocNo();
			// 生成工作号
			int workNo = getWorkNo(0);
			// 返回dto
			startupDto.setWorkNo(workNo);
			startupDto.setCrnNo(locMast.getCrnNo());
			startupDto.setSourceStaNo(sourceStaNo);
			startupDto.setLocNo(locNo);
			return startupDto;
			}

			public StartupDto getLocNoRun4(Integer whsType, Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, Integer moveCrnNo, LocTypeDto locTypeDto, int times) {

			// 初始化参数
			int crnNo = 0; //堆垛机号
			int nearRow = 0; //最浅库位排
			int curRow = 0; //最深库位排
			int rowCount = 0; //轮询轮次
			LocMast locMast = null; // 目标库位

			StartupDto startupDto = new StartupDto();
			RowLastno rowLastno = rowLastnoService.selectById(whsType);
			if (Cools.isEmpty(rowLastno)) {
			throw new CoolException("数据异常，请联系管理员===>库位规则未知");
			}
			RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
			if (Cools.isEmpty(rowLastnoType)) {
			throw new CoolException("数据异常，请联系管理员===》库位规则类型未知");
			}
			int sRow = rowLastno.getsRow();
			int eRow = rowLastno.geteRow();
			int crnNumber = rowLastno.getCrnQty();

			// ===============>>>> 开始执行
			curRow = rowLastno.getCurrentRow();

			if (!Cools.isEmpty(moveCrnNo) && moveCrnNo != 0) {
			crnNumber = moveCrnNo;
			// if (times==0){
			// curRow = moveCrnNo*4-1;
			// }else {
			// curRow = moveCrnNo*4-2;
			// }
			}

			//此程序用于优化堆垛机异常时的运行时间
			for (int i = times; i < crnNumber * 2; i++) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRow, crnNumber);
			rowCount = locNecessaryParameters[0];
			curRow = locNecessaryParameters[1];
			crnNo = locNecessaryParameters[2];
			nearRow = locNecessaryParameters[3];
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", crnNo).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			if (locMasts.size() <= 5) {
			nearRow = 0;
			times++;
			continue;
			}
			break;

			}
			if (crnNo == 0) {
			throw new CoolException("无可用库位");
			}


			// 相似工作档案 --- 同天同规格物料
			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && (staDescId == 1 \|\| staDescId == 11 \|\| staDescId == 111)) {
			//查询相似工作档案
			List<WrkMast> wrkMasts = wrkMastService.selectWrkMastWrkDetl(staDescId, findLocNoAttributeVo, crnNo);
			int nearbay = 0; //相似工作档案目标库位列
			int nearlev = 0; //相似工作档案目标库位层
			for (WrkMast wrkMast : wrkMasts) {
			int curRowW = curRow; //相似工作档案最深库位排
			int nearRowW = nearRow; //相似工作档案最浅库位排
			if (Cools.isEmpty(wrkMast.getLocNo())) {
			continue;
			}
			//目标排为最外层排
			if (Utils.getRow(wrkMast.getLocNo()) == nearRow) {
			continue;
			}
			//起始站不一致
			if (!wrkMast.getSourceStaNo().equals(sourceStaNo)) {
			continue;
			}
			//相同列、层过滤
			if (Utils.getBay(wrkMast.getLocNo()) == nearbay && Utils.getLev(wrkMast.getLocNo()) == nearlev) {
			continue;
			} else {
			nearbay = Utils.getBay(wrkMast.getLocNo());
			nearlev = Utils.getLev(wrkMast.getLocNo());
			}

			//获取目标库位所在巷道并排序
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,wrkMast.getLocNo(), curRow>nearRow);
			LocMast locMastGro = locMastService.selectById(wrkMast.getLocNo());

			for (int i = 0; i < crnNumber * 2; i++) {
			if (!(Utils.getRow(locMastGro.getLocNo()) > nearRowW && Utils.getRow(locMastGro.getLocNo()) <= curRowW) && !(Utils.getRow(locMastGro.getLocNo()) < nearRowW && Utils.getRow(locMastGro.getLocNo()) >= curRowW)) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRowW, crnNumber);
			curRowW = locNecessaryParameters[1];
			nearRowW = locNecessaryParameters[3];
			} else {
			break;
			}
			}

			//获取目标库位所在巷道最浅非空库位
			LocMast locMast2 = locMastService.selectLocByLocStsPakInF(curRowW, nearRowW, locMastGro, rowLastnoType.getType().longValue());

			//目标库位所在巷道最浅非空库位存在&&非最外侧库位&&入库状态
			if (!Cools.isEmpty(locMast2) && Utils.getRow(locMast2.getLocNo()) != nearRowW && (locMast2.getLocSts().equals("S") \|\| locMast2.getLocSts().equals("Q"))) {
			//获取库存明细
			WrkDetl wrkDetl = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
			//判断同规格物料
			if (!Cools.isEmpty(wrkDetl) && findLocNoAttributeVo.beSimilar(wrkDetl)) {
			int row2 = 0;
			if (Utils.getRow(locMast2.getLocNo()) > nearRowW) {
			row2 = Utils.getRow(locMast2.getLocNo()) - 1;
			} else {
			row2 = Utils.getRow(locMast2.getLocNo()) + 1;
			}
			String targetLocNo = zerofill(String.valueOf(row2), 2) + locMast2.getLocNo().substring(2);
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", targetLocNo).eq("loc_sts", "O"));
			if (Cools.isEmpty(locMast)) {
			continue;
			}
			break;
			}
			}
			}

			}

			// 相似工作档 --- 空托
			if (Cools.isEmpty(locMast) && staDescId == 10) {
			List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("io_type", 10).eq("crn_no", crnNo).eq("whs_type", rowLastnoType.getType().longValue()));
			int nearbay = 0;
			int nearlev = 0;
			for (WrkMast wrkMast : wrkMasts) {
			int curRowW = curRow; //相似工作档案最深库位排
			int nearRowW = nearRow; //相似工作档案最浅库位排
			if (Cools.isEmpty(wrkMast.getLocNo())) {
			continue;
			}
			if (Utils.getRow(wrkMast.getLocNo()) == nearRow) {
			continue;
			}
			//起始站不一致
			if (!wrkMast.getSourceStaNo().equals(sourceStaNo)) {
			continue;
			}
			if (Utils.getBay(wrkMast.getLocNo()) == nearbay && Utils.getLev(wrkMast.getLocNo()) == nearlev) {
			continue;
			} else {
			nearbay = Utils.getBay(wrkMast.getLocNo());
			nearlev = Utils.getLev(wrkMast.getLocNo());
			}
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,wrkMast.getLocNo(), curRow>nearRow);
			LocMast locMastGro = locMastService.selectById(wrkMast.getLocNo());

			for (int i = 0; i < crnNumber * 2; i++) {
			if (!(Utils.getRow(locMastGro.getLocNo()) > nearRowW && Utils.getRow(locMastGro.getLocNo()) <= curRowW) && !(Utils.getRow(locMastGro.getLocNo()) < nearRowW && Utils.getRow(locMastGro.getLocNo()) >= curRowW)) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRowW, crnNumber);
			curRowW = locNecessaryParameters[1];
			nearRowW = locNecessaryParameters[3];
			} else {
			break;
			}
			}

			LocMast locMast2 = locMastService.selectLocByLocStsPakInF(curRowW, nearRowW, locMastGro, rowLastnoType.getType().longValue());

			if (!Cools.isEmpty(locMast2) && Utils.getRow(locMast2.getLocNo()) != nearRowW && locMast2.getLocSts().equals("S")) {
			int row2 = 0;
			if (Utils.getRow(locMast2.getLocNo()) > nearRowW) {
			row2 = Utils.getRow(locMast2.getLocNo()) - 1;
			} else {
			row2 = Utils.getRow(locMast2.getLocNo()) + 1;
			}
			String targetLocNo = zerofill(String.valueOf(row2), 2) + locMast2.getLocNo().substring(2);
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", targetLocNo).eq("loc_sts", "O"));
			if (Cools.isEmpty(locMast)) {
			continue;
			}
			break;
			}
			}
			}

			boolean signRule1 = false;
			boolean signRule2 = false;


			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			// 靠近摆放规则 --- 同天同规格物料 //分离版
			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && staDescId == 1) {
			// signRule1 = true;
			}
			// 靠近摆放规则 --- 同天同规格物料 //互通版
			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && staDescId == 1) {
			signRule2 = true;
			}

			if (!Cools.isEmpty(findLocNoAttributeVo.getMatnr()) && (staDescId == 11 \|\| staDescId == 111)) {
			signRule1 = true;
			}
			}

			if (signRule1) {
			if (nearRow != curRow) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()));
			for (LocMast locMast1 : locMasts) {
			//获取巷道
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,locMast1.getLocNo(), curRow>nearRow);
			//获取目标库位所在巷道最浅非空库位
			LocMast locMastF = locMastService.selectLocByLocStsPakInF(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMastF) && locMastF.getLocSts().equals("F")) {
			LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", locMastF.getLocNo()));
			if (!Cools.isEmpty(locDetl) && findLocNoAttributeVo.beSimilar(locDetl)) {
			//获取目标库位所在巷道最深空库位
			locMast = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			break;
			}
			}
			}
			}
			} else if (signRule2) {
			List<String> locNos = locDetlService.getSameDetlToday(findLocNoAttributeVo.getMatnr(), sRow, eRow);
			int nearbay = 0;
			int nearlev = 0;
			for (String locNo : locNos) {
			int curRowW = curRow; //相似工作档案最深库位排
			int nearRowW = nearRow; //相似工作档案最浅库位排
			if (Cools.isEmpty(locNo)) {
			continue;
			}
			if (Utils.getRow(locNo) == nearRow) {
			continue;
			}
			if (Utils.getBay(locNo) == nearbay && Utils.getLev(locNo) == nearlev) {
			continue;
			} else {
			nearbay = Utils.getBay(locNo);
			nearlev = Utils.getLev(locNo);
			}
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,wrkMast.getLocNo(), curRow>nearRow);
			LocMast locMastGro = locMastService.selectById(locNo);

			for (int i = 0; i < crnNumber * 2; i++) {
			if (!(Utils.getRow(locMastGro.getLocNo()) > nearRowW && Utils.getRow(locMastGro.getLocNo()) <= curRowW) && !(Utils.getRow(locMastGro.getLocNo()) < nearRowW && Utils.getRow(locMastGro.getLocNo()) >= curRowW)) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRowW, crnNumber);
			curRowW = locNecessaryParameters[1];
			nearRowW = locNecessaryParameters[3];
			} else {
			break;
			}
			}

			LocMast locMast2 = locMastService.selectLocByLocStsPakInF(curRowW, nearRowW, locMastGro, rowLastnoType.getType().longValue());

			if (!Cools.isEmpty(locMast2) && Utils.getRow(locMast2.getLocNo()) != nearRowW && locMast2.getLocSts().equals("S")) {
			int row2 = 0;
			if (Utils.getRow(locMast2.getLocNo()) > nearRowW) {
			row2 = Utils.getRow(locMast2.getLocNo()) - 1;
			} else {
			row2 = Utils.getRow(locMast2.getLocNo()) + 1;
			}
			String targetLocNo = zerofill(String.valueOf(row2), 2) + locMast2.getLocNo().substring(2);
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", targetLocNo).eq("loc_sts", "O"));
			if (Cools.isEmpty(locMast)) {
			continue;
			}
			break;
			}
			}
			}

			// // 靠近摆放规则 --- 空托 //分离版
			// if (staDescId == 10 && Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			// List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O"));
			// for (LocMast locMast1:locMasts){
			// //获取巷道
			//// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,locMast1.getLocNo(), curRow>nearRow);
			// //获取目标库位所在巷道最浅非空库位
			// LocMast locMastF = locMastService.selectLocByLocStsPakInF(curRow,nearRow,locMast1,rowLastnoType.getType().longValue());
			// if (!Cools.isEmpty(locMastF) && locMastF.getLocSts().equals("D")){
			// //获取目标库位所在巷道最浅非空库位
			// locMast = locMastService.selectLocByLocStsPakInO(curRow,nearRow,locMast1,rowLastnoType.getType().longValue());
			// break;
			// }
			// }
			// }

			// 靠近摆放规则 --- 空托 //互通版
			if (staDescId == 10 && Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow));
			int nearbay = 0;
			int nearlev = 0;
			for (LocMast locMastSign : locMasts) {
			int curRowW = curRow; //相似工作档案最深库位排
			int nearRowW = nearRow; //相似工作档案最浅库位排
			if (Cools.isEmpty(locMastSign.getLocNo())) {
			continue;
			}
			if (Utils.getRow(locMastSign.getLocNo()) == nearRow) {
			continue;
			}
			if (Utils.getBay(locMastSign.getLocNo()) == nearbay && Utils.getLev(locMastSign.getLocNo()) == nearlev) {
			continue;
			} else {
			nearbay = Utils.getBay(locMastSign.getLocNo());
			nearlev = Utils.getLev(locMastSign.getLocNo());
			}
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,wrkMast.getLocNo(), curRow>nearRow);
			LocMast locMastGro = locMastService.selectById(locMastSign.getLocNo());

			for (int i = 0; i < crnNumber * 2; i++) {
			if (!(Utils.getRow(locMastGro.getLocNo()) > nearRowW && Utils.getRow(locMastGro.getLocNo()) <= curRowW) && !(Utils.getRow(locMastGro.getLocNo()) < nearRowW && Utils.getRow(locMastGro.getLocNo()) >= curRowW)) {
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRowW, crnNumber);
			curRowW = locNecessaryParameters[1];
			nearRowW = locNecessaryParameters[3];
			} else {
			break;
			}
			}

			LocMast locMast2 = locMastService.selectLocByLocStsPakInF(curRowW, nearRowW, locMastGro, rowLastnoType.getType().longValue());

			if (!Cools.isEmpty(locMast2) && Utils.getRow(locMast2.getLocNo()) != nearRowW && locMast2.getLocSts().equals("S")) {
			int row2 = 0;
			if (Utils.getRow(locMast2.getLocNo()) > nearRowW) {
			row2 = Utils.getRow(locMast2.getLocNo()) - 1;
			} else {
			row2 = Utils.getRow(locMast2.getLocNo()) + 1;
			}
			String targetLocNo = zerofill(String.valueOf(row2), 2) + locMast2.getLocNo().substring(2);
			locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", targetLocNo).eq("loc_sts", "O"));
			if (Cools.isEmpty(locMast)) {
			continue;
			}
			break;
			}
			}
			}

			Wrapper<StaDesc> wrapper = null;
			StaDesc staDesc = null;
			BasDevp staNo = null;

			if (Utils.BooleanWhsTypeSta(rowLastno, staDescId)) {
			// 获取目标站
			wrapper = new EntityWrapper<StaDesc>().eq("type_no", staDescId).eq("stn_no", sourceStaNo).eq("crn_no", crnNo);
			staDesc = staDescService.selectOne(wrapper);
			if (Cools.isEmpty(staDesc)) {
			log.error("入库路径不存在:type_no={},stn_no={},crn_no={}", staDescId, sourceStaNo, crnNo);
			crnNo = 0;
			} else {
			staNo = basDevpService.selectById(staDesc.getCrnStn());
			if (!staNo.getAutoing().equals("Y")) {
			log.error("目标站" + staDesc.getCrnStn() + "不可用");
			crnNo = 0;
			}
			startupDto.setStaNo(staNo.getDevNo());
			}
			}

			// 更新库位排号
			rowLastno.setCurrentRow(curRow);
			rowLastnoService.updateById(rowLastno);
			if (Utils.BooleanWhsTypeSta(rowLastno, staDescId) && Cools.isEmpty(locMast)) {
			rowLastno.setCurrentRow(curRow);
			rowLastnoService.updateById(rowLastno);
			}

			// 开始查找库位 ==============================>>

			// 1.当检索库排为浅库位排时，优先寻找当前库排的深库位排
			if (locMast == null) {
			if (Utils.isShallowLoc(slaveProperties, curRow)) {
			Integer deepRow = Utils.getDeepRow(slaveProperties, curRow);
			locMast = locMastService.queryFreeLocMast(deepRow, locTypeDto.getLocType1());
			// todo:luxiaotao 如果用浅排找到的深库位，那么则需要判断这个深库位对应的浅库位是否有货（F、X、D）
			// 因库位移转、需预留空库位
			if (!locMastService.checkEmptyCount(locMast)) {
			locMast = null;
			// 1.按规则查找库位
			if (Cools.isEmpty(locMast) && crnNo != 0) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()).orderBy("lev1", true).orderBy("bay1", true));//最浅库位
			//System.out.println(nearRow);
			//System.out.println(curRow);
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}
			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			//获取目标库位所在巷道最深空库位
			LocMast locMast2 = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMast2) && locMast2.getBay1() == curRow) {
			locMast = locMast2;
			break;
			}

			}
			}
			if (Cools.isEmpty(locMast)) {
			locMast = locMastService.queryFreeLocMast(curRow, locTypeDto.getLocType1());
			// 因库位移转、需预留空库位
			if (!locMastService.checkEmptyCount(locMast)) {
			locMast = null;
			}
			// 目标库位 ===>> 浅库位，则校验其深库位是否为 F D X
			if (null != locMast && Utils.isShallowLoc(slaveProperties, locMast.getLocNo())) {
			LocMast deepLoc = locMastService.selectById(Utils.getDeepLoc(slaveProperties, locMast.getLocNo()));
			if (!deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("X")) {
			locMast = null;

			//未找到允许混料
			if (Cools.isEmpty(locMast) && Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}
			}
			// 目标库位 ===>> 深库位，则校验其浅库位是否为 O
			if (null != locMast && Utils.isDeepLoc(slaveProperties, locMast.getLocNo())) {
			LocMast shallowLoc = locMastService.selectById(Utils.getShallowLoc(slaveProperties, locMast.getLocNo()));
			if (!shallowLoc.getLocSts().equals("O")) {
			locMast = null;
			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			//获取目标库位所在巷道并排序
			// List<String> groupOutsideLocCrn = Utils.getGroupOutLocCrn(curRow,nearRow,locMast1.getLocNo(), curRow>nearRow);

			//获取目标库位所在巷道最浅非空库位
			LocMast locMast2 = locMastService.selectLocByLocStsPakInF(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (Cools.isEmpty(locMast2)) {
			LocMast locMast3 = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMast3)) {
			locMast = locMast3;
			break;
			}
			} else {
			if ((locMast2.getLocSts().equals("F") && staDescId == 1) \|\| (locMast2.getLocSts().equals("D") && staDescId == 10)) {
			LocMast locMast3 = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMast3)) {
			locMast = locMast3;
			break;
			}
			}
			}
			}
			}
			}
			}

			// 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
			if (Cools.isEmpty(locMast)) {
			// 递归查询
			if (Cools.isEmpty(locMast) \|\| !locMast.getLocSts().equals("O")) {
			// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
			if (times < rowCount) {
			if (times < rowCount * 2) {
			times = times + 1;
			return getLocNo(1, staDescId, sourceStaNo, matNos, locTypeDto, times);
			}

			// 轻货物找轻库位为空时，可以去找重库位仓
			if (locTypeDto.getLocType1() == 1) {
			locTypeDto.setLocType1((short) 2);
			return getLocNo(1, staDescId, sourceStaNo, matNos, locTypeDto, times);
			return getLocNoRun4(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, times);
			}
			log.error("系统没有空库位！！！尺寸规格： {}，轮询次数：{}", JSON.toJSONString(locTypeDto), times);
			throw new CoolException("没有空库位");
			@@ -360,11 +1484,116 @@
			startupDto.setWorkNo(workNo);
			startupDto.setCrnNo(crnNo);
			startupDto.setSourceStaNo(sourceStaNo);
			startupDto.setStaNo(staNo.getDevNo());
			startupDto.setLocNo(locNo);
			return startupDto;
			}

			public StartupDto getLocNoRun5(Integer whsType, Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, Integer moveCrnNo, LocTypeDto locTypeDto, int times) {

			// 初始化参数
			int crnNo = 0; //堆垛机号
			int nearRow = 0; //最浅库位排
			int curRow = 0; //最深库位排
			int rowCount = 0; //轮询轮次
			LocMast locMast = null; // 目标库位

			StartupDto startupDto = new StartupDto();
			RowLastno rowLastno = rowLastnoService.selectById(whsType);
			if (Cools.isEmpty(rowLastno)) {
			throw new CoolException("数据异常，请联系管理员===>库位规则未知");
			}
			RowLastnoType rowLastnoType = rowLastnoTypeService.selectById(rowLastno.getTypeId());
			if (Cools.isEmpty(rowLastnoType)) {
			throw new CoolException("数据异常，请联系管理员===》库位规则类型未知");
			}
			int sRow = rowLastno.getsRow();
			int eRow = rowLastno.geteRow();
			int crnNumber = eRow - sRow + 1;

			// ===============>>>> 开始执行
			curRow = rowLastno.getCurrentRow();

			if (!Cools.isEmpty(moveCrnNo) && moveCrnNo != 0) {
			crnNumber = moveCrnNo;
			}

			//此程序用于优化堆垛机异常时的运行时间
			int[] locNecessaryParameters = Utils.LocNecessaryParameters(rowLastno, curRow, crnNumber);
			curRow = locNecessaryParameters[1];
			crnNo = locNecessaryParameters[2];
			rowCount = locNecessaryParameters[0];
			nearRow = locNecessaryParameters[3];

			Wrapper<StaDesc> wrapper = null;
			StaDesc staDesc = null;
			BasDevp staNo = null;

			if (Utils.BooleanWhsTypeSta(rowLastno, staDescId)) {
			// 获取目标站
			wrapper = new EntityWrapper<StaDesc>().eq("type_no", staDescId).eq("stn_no", sourceStaNo).eq("crn_no", crnNo);
			staDesc = staDescService.selectOne(wrapper);
			if (Cools.isEmpty(staDesc)) {
			log.error("type_no={},stn_no={},crn_no={}", staDescId, sourceStaNo, crnNo);
			// throw new CoolException("入库路径不存在");
			crnNo = 0;
			} else {
			staNo = basDevpService.selectById(staDesc.getCrnStn());
			if (!staNo.getAutoing().equals("Y")) {
			log.error("目标站" + staDesc.getCrnStn() + "不可用");
			// throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
			crnNo = 0;
			}
			startupDto.setStaNo(staNo.getDevNo());
			}
			}

			// 更新库位排号
			if (Utils.BooleanWhsTypeSta(rowLastno, staDescId) && Cools.isEmpty(locMast)) {
			rowLastno.setCurrentRow(curRow);
			rowLastnoService.updateById(rowLastno);
			}

			// 开始查找库位 ==============================>>

			// 1.按规则查找库位
			if (Cools.isEmpty(locMast) && crnNo != 0) {
			List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("row1", nearRow).eq("loc_sts", "O").eq("whs_type", rowLastnoType.getType().longValue()).orderBy("lev1", true).orderBy("bay1", true));//最浅库位
			for (LocMast locMast1 : locMasts) {
			if (!VersionUtils.locMoveCheckLocTypeComplete(locMast1, locTypeDto)) {
			continue;
			}
			if (Utils.BooleanWhsTypeStaIoType(rowLastno)) {
			//获取目标库位所在巷道最深空库位
			LocMast locMast2 = locMastService.selectLocByLocStsPakInO(curRow, nearRow, locMast1, rowLastnoType.getType().longValue());
			if (!Cools.isEmpty(locMast2) && locMast2.getBay1() == curRow) {
			locMast = locMast2;
			break;
			}
			}
			}
			}

			// 递归查询
			if (Cools.isEmpty(locMast) \|\| !locMast.getLocSts().equals("O")) {
			// 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
			if (times < rowCount * 2) {
			times = times + 1;
			return getLocNoRun5(whsType, staDescId, sourceStaNo, findLocNoAttributeVo, moveCrnNo, locTypeDto, times);
			}
			log.error("系统没有空库位！！！尺寸规格： {}，轮询次数：{}", JSON.toJSONString(locTypeDto), times);
			throw new CoolException("没有空库位");
			}
			String locNo = locMast.getLocNo();

			// 生成工作号
			int workNo = getWorkNo(0);
			// 返回dto
			startupDto.setWorkNo(workNo);
			startupDto.setCrnNo(crnNo);
			startupDto.setSourceStaNo(sourceStaNo);
			startupDto.setLocNo(locNo);
			return startupDto;
			}

			public static String zerofill(String msg, Integer count) {
			if (msg.length() == count) {
			@@ -373,44 +1602,10 @@
			return msg.substring(0, 16);
			} else {
			StringBuilder msgBuilder = new StringBuilder(msg);
			for(int i = 0; i < count - msg.length(); ++i) {
			for (int i = 0; i < count - msg.length(); ++i) {
			msgBuilder.insert(0, "0");
			}
			return msgBuilder.toString();
			}
			}

			/**
			* 根据入库站获取库位排号分配
			*/
			private Integer getWhsType(Integer sourceStaNo, int times) {
			if (times >= 16) {
			return 4;
			}
			switch (sourceStaNo) {
			case 173:
			case 176:
			case 180:
			case 185:
			return 1;
			case 189:
			case 194:
			case 198:
			case 202:
			return 2;
			case 206:
			// case 211:
			// case 215:
			// case 219:
			// case 223:
			case 227:
			return 3;
			case 305:
			case 303:
			case 301:
			return 4;
			default:
			throw new CoolException("根据入库站获取库位排号分配失败，入库站：" + sourceStaNo);
			}
			}