package com.vincent.rsf.server.manager.utils;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.framework.common.Cools;
|
import com.vincent.rsf.framework.common.SpringUtils;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.manager.entity.*;
|
import com.vincent.rsf.server.manager.service.*;
|
import com.vincent.rsf.server.system.entity.TaskPathTemplateMerge;
|
import com.vincent.rsf.server.system.service.TaskPathTemplateMergeService;
|
import lombok.extern.slf4j.Slf4j;
|
import routeR.calculationR.RouteWmsStepFlow;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Objects;
|
|
@Slf4j
|
public class WarehouseLocationRetrievalUtil {
|
|
private BasStationService basStationService;
|
private WarehouseAreasService warehouseAreasService;
|
|
public WarehouseLocationRetrievalUtil() {
|
basStationService = SpringUtils.getBean(BasStationService.class);
|
warehouseAreasService = SpringUtils.getBean(WarehouseAreasService.class);
|
}
|
|
//判断目标是否是库区
|
public boolean retrieveMissionmMergeReservoirAreaIsItAvailable(String missionArea) {
|
boolean matches = missionArea.matches("\\d+");
|
if (!matches) {
|
return false;
|
}
|
WarehouseAreas warehouseAreas = warehouseAreasService.getById(Long.parseLong(missionArea));
|
if (Cools.isEmpty(warehouseAreas)){
|
return false;
|
}
|
return true;
|
}
|
|
//判断目标是否是站点
|
public BasStation retrieveMissionmMergeSizeIsItAvailable(String missionSize) {
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, missionSize).last("limit 1"));
|
if (Cools.isEmpty(basStation)){
|
basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.apply("station_alias != '[]'") // 不是空数组
|
.apply("JSON_CONTAINS(station_alias, '\"{0}\"') = 1", missionSize)
|
.eq(BasStation::getDeleted, 0) // 通常需要加上未删除条件
|
.last("LIMIT 1"));
|
}
|
if (Cools.isEmpty(basStation)){
|
return null;
|
}
|
return basStation;
|
}
|
|
//根据条码获取规则
|
public BasContainer getContainerByBarcode(String barcode) {
|
if (Cools.isEmpty(barcode)) {
|
throw new CoolException("容器码不能为空");
|
}
|
BasContainerService basContainerService = SpringUtils.getBean(BasContainerService.class);
|
List<BasContainer> containers = basContainerService.list(new LambdaQueryWrapper<>());
|
for (BasContainer container : containers) {
|
String codeType = container.getCodeType(); // 获取正则表达式
|
if (barcode.matches(codeType)) { // 判断条码是否符合这个正则
|
return container;
|
}
|
}
|
throw new CoolException("容器码:"+barcode+"异常==>未找到匹配的规则");
|
}
|
|
//根据物料ID获取物料
|
public Matnr getMatnrByMatnrId(Long matnrId) {
|
if (Cools.isEmpty(matnrId)) {
|
throw new CoolException("物料ID不能为空");
|
}
|
MatnrService matnrService = SpringUtils.getBean(MatnrService.class);
|
Matnr matnr = matnrService.selectMatnrById(matnrId);
|
if (matnr == null) {
|
throw new CoolException("物料ID:"+matnrId+"异常==>未找到对应物料");
|
}
|
return matnr;
|
}
|
|
//判断物料是否可用此仓库
|
public boolean retrieveMatnrIsItAvailable(String areaId, Long matnrId) {
|
return retrieveMatnrIsItAvailable(Long.parseLong(areaId),matnrId);
|
}
|
public boolean retrieveMatnrIsItAvailable(Long areaId, Long matnrId) {
|
Matnr matnrByMatnrId = getMatnrByMatnrId(matnrId);
|
if (matnrByMatnrId.getWarehouseRestrictionCode() == null || matnrByMatnrId.getWarehouseRestrictionCode().equals("") || matnrByMatnrId.getWarehouseRestrictionCode().equals("all")) {
|
return true;
|
}
|
//判断是否兼容
|
String warehouseRestrictionCode = matnrByMatnrId.getWarehouseRestrictionCode();
|
//根据code获取
|
MatnrRestrictionWarehouseService matnrRestrictionWarehouseService = SpringUtils.getBean(MatnrRestrictionWarehouseService.class);
|
MatnrRestrictionWarehouse serviceOne = matnrRestrictionWarehouseService.getOne(new LambdaQueryWrapper<MatnrRestrictionWarehouse>().eq(MatnrRestrictionWarehouse::getMatnrRestrictionCode, warehouseRestrictionCode).last("limit 1"));
|
if (Objects.isNull(serviceOne)) {
|
return false;
|
}
|
//查询area是否在
|
return serviceOne.getProductionLineCode().contains(areaId.intValue());
|
}
|
|
|
// 根据库区、容器检索符合条件移库库区
|
public List<String> getOutWarehouseAreasByReservoirAreaAndContainer(Long sourceCode, String barcode,Integer type) {
|
return getOutWarehouseAreasByReservoirAreaAndContainer(sourceCode,barcode,type.toString());
|
}
|
public List<String> getOutWarehouseAreasByReservoirAreaAndContainer(Long sourceCode, String barcode,String type) {
|
List<String> outboundSite = new ArrayList<>();
|
List<String> outboundSiteByReservoirAreaAndContainer = getOutWarehouseAreasByReservoirAreaAndContainer(sourceCode, barcode);
|
for (String areaId : outboundSiteByReservoirAreaAndContainer) {
|
WarehouseAreas warehouseAreas = warehouseAreasService.getById(Long.parseLong(areaId));
|
if (!Cools.isEmpty(warehouseAreas)){
|
outboundSite.add(areaId);
|
}
|
}
|
return outboundSite;
|
}
|
|
// 根据库区、容器检索符合条件出库站点
|
private List<String> getOutWarehouseAreasByReservoirAreaAndContainer(Long sourceCode, String barcode) {
|
return getTargetTypeByReservoirAreaAndContainer(String.valueOf(sourceCode), barcode,1,false);
|
}
|
|
// 根据库区、容器检索符合条件出库站点
|
public List<String> getOutboundSiteByReservoirAreaAndContainer(Long sourceCode, String barcode,Integer type) {
|
return getOutboundSiteByReservoirAreaAndContainer(sourceCode,barcode,type.toString());
|
}
|
public List<String> getOutboundSiteByReservoirAreaAndContainer(Long sourceCode, String barcode,String type) {
|
List<String> outboundSite = new ArrayList<>();
|
List<String> outboundSiteByReservoirAreaAndContainer = getOutboundSiteByReservoirAreaAndContainer(sourceCode, barcode);
|
for (String site : outboundSiteByReservoirAreaAndContainer) {
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, site).last("limit 1"));
|
if (!Cools.isEmpty(basStation)){
|
BasStationTypeService basStationTypeService = SpringUtils.getBean(BasStationTypeService.class);
|
BasStationType one = basStationTypeService.getOne(new LambdaQueryWrapper<BasStationType>().eq(BasStationType::getStationTypeCode, basStation.getContainerType()).last("limit 1"));
|
if (!Cools.isEmpty(one)) {
|
if (one.getTaskType().contains(type)){
|
outboundSite.add(site);
|
}
|
}
|
}
|
}
|
return outboundSite;
|
}
|
|
// 根据库区、容器检索符合条件出库站点
|
private List<String> getOutboundSiteByReservoirAreaAndContainer(Long sourceCode, String barcode) {
|
return getTargetTypeByReservoirAreaAndContainer(String.valueOf(sourceCode), barcode,1,true);
|
}
|
|
// 根据库区、容器检索符合条件站点或库区
|
private List<String> getTargetTypeByReservoirAreaAndContainer(String code, String barcode,int type,boolean isInOrOut) {
|
List<String> obtainOutboundStations = new ArrayList<>();
|
BasContainer containerByBarcode = getContainerByBarcode(barcode);
|
if (containerByBarcode == null) {
|
log.error("容器码:"+barcode+"异常==>未找到匹配的规则");
|
return obtainOutboundStations;
|
}
|
Long containerType = containerByBarcode.getContainerType();
|
TaskPathTemplateMergeService taskPathTemplateMergeService = SpringUtils.getBean(TaskPathTemplateMergeService.class);
|
if (isInOrOut) {//根据起点检索终点
|
List<TaskPathTemplateMerge> taskPathTemplateMergeList = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>()
|
.eq(TaskPathTemplateMerge::getSourceType, code)
|
.eq(TaskPathTemplateMerge::getContainerType, containerType)
|
);
|
if (taskPathTemplateMergeList.isEmpty()) {
|
return obtainOutboundStations;
|
}
|
for (TaskPathTemplateMerge taskPathTemplateMerge : taskPathTemplateMergeList) {
|
switch (type){
|
case 1://站点
|
if (retrieveBarcodeIsItAvailableBySite(containerByBarcode,taskPathTemplateMerge.getTargetType())){
|
obtainOutboundStations.add(taskPathTemplateMerge.getTargetType());
|
}
|
break;
|
case 2://库区
|
if (retrieveMissionmMergeReservoirAreaIsItAvailable(taskPathTemplateMerge.getTargetType())){
|
obtainOutboundStations.add(taskPathTemplateMerge.getTargetType());
|
}
|
break;
|
}
|
}
|
} else {//根据终点检索起点
|
List<TaskPathTemplateMerge> taskPathTemplateMergeList = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>()
|
.eq(TaskPathTemplateMerge::getTargetType, code)
|
.eq(TaskPathTemplateMerge::getContainerType, containerType)
|
);
|
if (taskPathTemplateMergeList.isEmpty()) {
|
return obtainOutboundStations;
|
}
|
for (TaskPathTemplateMerge taskPathTemplateMerge : taskPathTemplateMergeList) {
|
switch (type){
|
case 1://站点
|
if (retrieveBarcodeIsItAvailableBySite(containerByBarcode,taskPathTemplateMerge.getSourceType())){
|
obtainOutboundStations.add(taskPathTemplateMerge.getSourceType());
|
}
|
break;
|
case 2://库区
|
if (retrieveMissionmMergeReservoirAreaIsItAvailable(taskPathTemplateMerge.getSourceType())){
|
obtainOutboundStations.add(taskPathTemplateMerge.getSourceType());
|
}
|
break;
|
}
|
}
|
}
|
|
return obtainOutboundStations;
|
}
|
|
// 根据站点检索容器是否可行至此站点
|
public boolean retrieveBarcodeIsItAvailableBySite(BasContainer containerByBarcode,BasStation basStation) {
|
if (basStation.getContainerType().contains(containerByBarcode.getContainerType())) {
|
return true;
|
}
|
return false;
|
}
|
|
// 根据站点检索容器是否可行至此站点
|
public boolean retrieveBarcodeIsItAvailableBySite(String barcode,BasStation basStation) {
|
BasContainer containerByBarcode = getContainerByBarcode(barcode);
|
if (basStation.getContainerType().contains(containerByBarcode.getContainerType())) {
|
return true;
|
}
|
return false;
|
}
|
|
|
// 根据站点检索容器是否可行至此站点
|
public boolean retrieveBarcodeIsItAvailableBySite(BasContainer containerByBarcode,String siteCode) {
|
BasStation basStation = retrieveMissionmMergeSizeIsItAvailable(siteCode);
|
if (Cools.isEmpty(basStation)){
|
return false;
|
}
|
if (basStation.getContainerType().contains(containerByBarcode.getContainerType())) {
|
return true;
|
}
|
return false;
|
}
|
|
// 根据站点检索容器是否可行至此站点
|
public boolean retrieveBarcodeIsItAvailableBySite(String barcode,String siteCode) {
|
BasStation basStation = retrieveMissionmMergeSizeIsItAvailable(siteCode);
|
if (Cools.isEmpty(basStation)){
|
return false;
|
}
|
BasContainer containerByBarcode = getContainerByBarcode(barcode);
|
if (basStation.getContainerType().contains(containerByBarcode.getContainerType())) {
|
return true;
|
}
|
|
return false;
|
}
|
|
// 根据站点检索库区是否可入至此站点
|
public boolean retrieveWarehouseAreasIsItAvailableInBySite(String warehouseCode,BasStation basStation) {
|
// TODO: 实现逻辑
|
|
return false;
|
}
|
|
// 根据站点检索库区是否可入至此站点
|
public boolean retrieveWarehouseAreasIsItAvailableInBySite(String warehouseCode,String siteCode) {
|
// TODO: 实现逻辑
|
return false;
|
}
|
|
// 根据站点检索库区是否可出至此站点
|
public boolean retrieveWarehouseAreasIsItAvailableOutBySite(String warehouseCode,BasStation basStation) {
|
// TODO: 实现逻辑
|
return false;
|
}
|
|
// 根据站点检索库区是否可出至此站点
|
public boolean retrieveWarehouseAreasIsItAvailableOutBySite(String warehouseCode,String siteCode) {
|
// TODO: 实现逻辑
|
return false;
|
}
|
|
// 根据站点检索符合条件库区
|
public List<String> getWarehouseAreasBySite(String siteCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点检索符合条件容器
|
public List<BasContainer> getContainersBySite(String siteCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点检索符合条件任务类型
|
public List<String> getTaskTypesBySite(String siteCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据物料检索符合条件库区
|
public List<String> getWarehouseAreasByMaterial(String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据物料检索符合条件容器
|
public List<BasContainer> getContainersByMaterial(String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据物料检索符合条件站点
|
public List<String> getSitesByMaterial(String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据库区检索符合条件站点
|
public List<String> getSitesByWarehouseArea(String warehouseAreaCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料检索符合条件容器
|
public List<BasContainer> getContainersBySiteAndMaterial(String siteCode, String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料检索符合条件库区
|
public List<String> getWarehouseAreasBySiteAndMaterial(String siteCode, String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料检索符合条件路径
|
public List<String> getPathsBySiteAndMaterial(String siteCode, String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料检索符合条件任务类型
|
public List<String> getTaskTypesBySiteAndMaterial(String siteCode, String materialCode) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料\容器检索符合条件库区
|
public List<String> getWarehouseAreasBySiteMaterialContainer(String siteCode, String materialCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\物料\容器检索符合条件任务类型
|
public List<String> getTaskTypesBySiteMaterialContainer(String siteCode, String materialCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\容器检索符合条件容器
|
public List<BasContainer> getContainersBySiteAndContainerType(String siteCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\容器检索符合条件库区
|
public List<String> getWarehouseAreasBySiteAndContainer(String siteCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\容器检索符合条件路径
|
public List<String> getPathsBySiteAndContainer(String siteCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 根据站点\容器检索符合条件任务类型
|
public List<String> getTaskTypesBySiteAndContainer(String siteCode, String containerType) {
|
// TODO: 实现逻辑
|
return null;
|
}
|
|
// 出库校验：根据源库区\目标站点\容器判断是否存在路径
|
public boolean queryPathIsItAvailableOutArea(Long sourceCode, String targetCode, String barcode,Integer type) {
|
return queryPathIsItAvailableOutArea(sourceCode.toString(),targetCode,barcode,type.toString());
|
}
|
public boolean queryPathIsItAvailableOutArea(String sourceCode, String targetCode, String barcode,Integer type) {
|
return queryPathIsItAvailableOutArea(sourceCode,targetCode,barcode,type.toString());
|
}
|
public boolean queryPathIsItAvailableOutArea(String sourceCode, String targetCode, String barcode,String type) {
|
if (queryPathIsItAvailable(sourceCode, targetCode, barcode)){
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, targetCode).last("limit 1"));
|
if (!Cools.isEmpty(basStation)){
|
if (type.equals("in")){
|
if (basStation.getInAble()==1){
|
return true;
|
}
|
} else if (type.equals("out")){
|
if (basStation.getOutAble()==1){
|
return true;
|
}
|
}
|
BasStationTypeService basStationTypeService = SpringUtils.getBean(BasStationTypeService.class);
|
BasStationType one = basStationTypeService.getOne(new LambdaQueryWrapper<BasStationType>().eq(BasStationType::getStationTypeCode, basStation.getContainerType()).last("limit 1"));
|
if (!Cools.isEmpty(one)) {
|
if (one.getTaskType().contains(type)){
|
return true;
|
}
|
log.error("目标站点:" + targetCode+" 不支持作业此任务类型："+type);
|
}
|
log.error("目标站点:" + targetCode+" 不支持作业此任务类型："+type);
|
}
|
log.error("queryPathIsItAvailableInArea: error");
|
}
|
return false;
|
}
|
|
// 出库校验：根据源站点\目标库区\容器判断是否存在路径
|
public boolean queryPathIsItAvailableInArea(String sourceCode, Long targetCode, String barcode,String type) {
|
return queryPathIsItAvailableInArea(sourceCode,targetCode.toString(),barcode,type);
|
}
|
public boolean queryPathIsItAvailableInArea(String sourceCode, Long targetCode, String barcode,Integer type) {
|
return queryPathIsItAvailableInArea(sourceCode,targetCode.toString(),barcode,type.toString());
|
}
|
public boolean queryPathIsItAvailableInArea(String sourceCode, String targetCode, String barcode,Integer type) {
|
return queryPathIsItAvailableInArea(sourceCode,targetCode,barcode,type.toString());
|
}
|
public boolean queryPathIsItAvailableInArea(String sourceCode, String targetCode, String barcode,String type) {
|
if (queryPathIsItAvailable(sourceCode, targetCode, barcode)){
|
BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
|
.eq(BasStation::getStationName, sourceCode).last("limit 1"));
|
if (!Cools.isEmpty(basStation)){
|
if (type.equals("in")){
|
if (basStation.getInAble()==1){
|
return true;
|
}
|
} else if (type.equals("out")){
|
if (basStation.getOutAble()==1){
|
return true;
|
}
|
}
|
BasStationTypeService basStationTypeService = SpringUtils.getBean(BasStationTypeService.class);
|
BasStationType one = basStationTypeService.getOne(new LambdaQueryWrapper<BasStationType>().eq(BasStationType::getStationTypeCode, basStation.getContainerType()).last("limit 1"));
|
if (!Cools.isEmpty(one)) {
|
if (one.getTaskType().contains(type)){
|
return true;
|
}
|
log.error("当前站点:" + sourceCode+" 不支持作业此任务类型："+type);
|
}
|
log.error("当前站点:" + sourceCode+" 不支持作业此任务类型："+type);
|
}
|
log.error("queryPathIsItAvailableInArea: error");
|
}
|
return false;
|
}
|
|
// 校验：根据起点\目标点\容器判断是否存在路径
|
private boolean queryPathIsItAvailable(String sourceCode, String targetCode, String barcode) {
|
BasContainer containerByBarcode = getContainerByBarcode(barcode);
|
if (containerByBarcode == null) {
|
return false;
|
}
|
if (retrieveMissionmMergeReservoirAreaIsItAvailable(sourceCode)){
|
BasStation basStation = retrieveMissionmMergeSizeIsItAvailable(targetCode);
|
if (!Cools.isEmpty(basStation)){
|
return queryPathIsItAvailable(sourceCode, targetCode, containerByBarcode);
|
} else {
|
if (retrieveMissionmMergeReservoirAreaIsItAvailable(targetCode)){
|
return queryPathIsItAvailable(sourceCode, targetCode, containerByBarcode);
|
}
|
log.error("路径校验：根据起点:"+sourceCode+"、目标点:"+targetCode+"、容器规则：" +containerByBarcode.getCodeType()+ "判断是否存在路径==>终点类型未知！！！");
|
}
|
} else if (retrieveMissionmMergeReservoirAreaIsItAvailable(targetCode)){
|
BasStation basStation = retrieveMissionmMergeSizeIsItAvailable(sourceCode);
|
if (!Cools.isEmpty(basStation)){
|
return queryPathIsItAvailable(sourceCode, targetCode, containerByBarcode);
|
}
|
log.error("路径校验：根据起点:"+sourceCode+"、目标点:"+targetCode+"、容器规则：" +containerByBarcode.getCodeType()+ "判断是否存在路径==>起点类型未知！！！");
|
} else {
|
BasStation basStationS = retrieveMissionmMergeSizeIsItAvailable(sourceCode);
|
BasStation basStationT = retrieveMissionmMergeSizeIsItAvailable(targetCode);
|
if (!Cools.isEmpty(basStationS) && !Cools.isEmpty(basStationT)){
|
return queryPathIsItAvailable(sourceCode, targetCode, containerByBarcode);
|
}
|
log.error("路径校验：根据起点:"+sourceCode+"、目标点:"+targetCode+"、容器规则：" +containerByBarcode.getCodeType()+ "判断是否存在路径==>起点与终点类型未知！！！");
|
}
|
return false;
|
}
|
|
|
// 校验：根据起点\目标点\容器判断是否存在路径
|
private boolean queryPathIsItAvailable(String sourceCode, String targetCode, BasContainer containerByBarcode) {
|
try{
|
TaskPathTemplateMergeService taskPathTemplateMergeService = SpringUtils.getBean(TaskPathTemplateMergeService.class);
|
List<TaskPathTemplateMerge> taskPathTemplateMergeList = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>()
|
.eq(TaskPathTemplateMerge::getSourceType, sourceCode)
|
.eq(TaskPathTemplateMerge::getTargetType, targetCode)
|
.apply("container_type != '[]'") // 不是空数组
|
.apply("JSON_CONTAINS(container_type, {0}) = 1", containerByBarcode.getContainerType().toString())
|
);
|
if (Objects.isNull(taskPathTemplateMergeList) || taskPathTemplateMergeList.isEmpty()) {
|
List<TaskPathTemplateMerge> list = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>()
|
.eq(TaskPathTemplateMerge::getStepSize, 1)
|
.apply("container_type != '[]'") // 不是空数组
|
.apply("JSON_CONTAINS(container_type, {0}) = 1", containerByBarcode.getContainerType().toString())
|
);
|
if (!Cools.isEmpty(list)) {
|
List<String[]> stationList = new ArrayList<>();
|
list.forEach(taskPathTemplate -> {
|
stationList.add(taskPathTemplate.route());
|
});
|
List<Long> longs = RouteWmsStepFlow.routeGet(stationList, targetCode, sourceCode);
|
if (longs != null && !longs.isEmpty()) {
|
return true;
|
}
|
}
|
log.error("路径校验：根据起点:"+sourceCode+"、目标点:"+targetCode+"、容器规则：" +containerByBarcode.getCodeType()+ "判断是否存在路径==>未找到路径！！！");
|
} else {
|
return true;
|
}
|
} catch (Exception e) {
|
log.error("路径校验：根据起点:"+sourceCode+"、目标点:"+targetCode+"、容器规则：" +containerByBarcode.getCodeType()+ "判断是否存在路径==>异常:"+e.getMessage());
|
}
|
return false;
|
}
|
|
|
}
|
