新建德森项目分支

skyouc

2024-12-21 c635d78b479510ebe2556a420948effcd30a0731

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/utils/LocUtils.java

@@ -1,360 +1,360 @@
package com.zy.asrs.wms.utils;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.enums.LocStsType;
import com.zy.asrs.wms.asrs.entity.enums.LocTypeHeightType;
import com.zy.asrs.wms.asrs.entity.param.FieldParam;
import com.zy.asrs.wms.asrs.mapper.ViewLocDetlMapper;
import com.zy.asrs.wms.asrs.mapper.ViewTaskDetlMapper;
import com.zy.asrs.wms.asrs.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
public class LocUtils {

    @Autowired
    private TaskService taskService;
    @Autowired
    private LocService locService;
    @Autowired
    private SuggestLocRuleService suggestLocRuleService;
    @Autowired
    private LanewayRuleService lanewayRuleService;
    @Autowired
    private LocTypeService locTypeService;
    @Autowired
    private LocTypeBindService locTypeBindService;
    @Autowired
    private ViewLocDetlMapper viewLocDetlMapper;
    @Autowired
    private ViewTaskDetlMapper viewTaskDetlMapper;
    @Autowired
    private MatService matService;

    //从库存或任务中匹配相邻库位(满托盘)
    public Loc getNeighborLoc(Long taskType, Long matId, String batch, List<FieldParam> uniqueFields, Integer locTypeHeight) {
        //满托盘
        Mat mat = matService.getById(matId);
        if (mat == null) {
            return null;
        }

        //从任务中进行匹配
        List<Loc> locs = new ArrayList<>();
        List<Map<String, Object>> list = viewTaskDetlMapper.getList(mat.getMatnr(), batch, uniqueFields);
        for (Map<String, Object> map : list) {
            Task task = taskService.getById(map.get("taskId").toString());
            if (task == null) {
                continue;
            }

            String targetLoc = task.getTargetLoc();
            Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, targetLoc));
            if (one == null) {
                continue;
            }
            locs.add(one);
        }

        Loc loc = filterLoc(taskType, locs);
        if (loc != null) {
            return loc;
        }

        //从库存中进行匹配
        List<Loc> locs2 = new ArrayList<>();
        List<Map<String, Object>> list2 = viewLocDetlMapper.getList(mat.getMatnr(), batch, uniqueFields, null);
        for (Map<String, Object> map : list2) {
            Loc one = locService.getById(map.get("locId").toString());
            if (one == null) {
                continue;
            }
            locs2.add(one);
        }

        Loc loc2 = filterLoc(taskType, locs2);
        if (loc2 != null) {
            return loc2;
        }
        return null;
    }

    //获取推荐库位(满托盘)
    public List<Loc> getSuggestLoc(Long taskType, Long matId, String batch, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {
        //满托盘
        List<Loc> locs = new ArrayList<>();
        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);
        if (locTypeHeightType == null) {
            throw new CoolException("库位高度类型异常");
        }
        //获取库位高度
        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));
        //符合库位高度的库位集合
        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);

        LambdaQueryWrapper<SuggestLocRule> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SuggestLocRule::getLocType, 1);
        wrapper.eq(SuggestLocRule::getMatId, matId);
        if (!Cools.isEmpty(batch)) {
            wrapper.eq(SuggestLocRule::getBatch, batch);
        }
        List<SuggestLocRule> suggestLocRules = suggestLocRuleService.list(wrapper);
        for (SuggestLocRule suggestLocRule : suggestLocRules) {
            LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.ge(Loc::getRow1, suggestLocRule.getStartRow());
            queryWrapper.le(Loc::getRow1, suggestLocRule.getTargetRow());
            queryWrapper.ge(Loc::getBay1, suggestLocRule.getStartBay());
            queryWrapper.le(Loc::getBay1, suggestLocRule.getTargetBay());
            queryWrapper.ge(Loc::getLev1, suggestLocRule.getStartLev());
            queryWrapper.le(Loc::getLev1, suggestLocRule.getTargetLev());
            queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());
            queryWrapper.in(Loc::getId, locIdList);

            if (laneRowList != null && !laneRowList.isEmpty()) {
                queryWrapper.in(Loc::getRow1, laneRowList);
            }

            if (currentLev != null) {
                queryWrapper.eq(Loc::getLev1, currentLev);
            }

            List<Loc> list = locService.list(queryWrapper);
            if (!list.isEmpty()) {
                locs.addAll(list);
            }
        }
        return locs;
    }

    //获取全局库位(完整巷道)
    public List<Loc> getGlobalLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {
        List<Loc> locs = new ArrayList<>();
        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);
        if (locTypeHeightType == null) {
            throw new CoolException("库位高度类型异常");
        }
        //获取库位高度
        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));
        //符合库位高度的库位集合
        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);

        LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());
        queryWrapper.in(Loc::getId, locIdList);

        if (laneRowList != null && !laneRowList.isEmpty()) {
            queryWrapper.in(Loc::getRow1, laneRowList);
        }

        if (currentLev != null) {
            queryWrapper.eq(Loc::getLev1, currentLev);
        }

        List<Loc> list = locService.list(queryWrapper);
        if (!list.isEmpty()) {
            locs.addAll(list);
        }
        return locs;
    }

    //从库位集合中获取符合深浅的库位
    public Loc filterLoc(Long taskType, List<Loc> locs) {
        if (locs == null || locs.isEmpty()) {
            return null;
        }

        Loc defaultLoc = null;
        for (Loc loc : locs) {
            //获取库位所在巷道
            LanewayRule lanewayRule = lanewayRuleService.getLaneByLoc(loc);
            if(lanewayRule == null) {
                throw new CoolException("库位未配置巷道");
            }

            //获取库位方向
            List<Integer> direction = null;
            if (lanewayRule.getLaneX$().contains(loc.getRow1())) {
                direction = lanewayRule.getLaneX$();
            }else {
                direction = lanewayRule.getLaneY$();
            }

            for (Integer row : direction) {
                Loc one = locService.getOne(new LambdaQueryWrapper<Loc>()
                        .eq(Loc::getRow1, row)
                        .eq(Loc::getBay1, loc.getBay1())
                        .eq(Loc::getLev1, loc.getLev1()));
                if (one == null) {
                    continue;
                }

                if(one.getLocStsId() != LocStsType.O.val()) {
                    continue;
                }

                //当前库位是空库位
                defaultLoc = one;
                break;
            }

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

        return defaultLoc;
    }

    //从库位集合中获取完整空巷道
    public Loc filterAllLoc(List<Loc> locs) {
        if (locs == null || locs.isEmpty()) {
            return null;
        }

        Loc defaultLoc = null;
        for (Loc loc : locs) {
            //获取库位所在巷道
            LanewayRule lanewayRule = lanewayRuleService.getLaneByLoc(loc);
            if(lanewayRule == null) {
                throw new CoolException("库位未配置巷道");
            }

            //获取库位方向
            List<Integer> direction = null;
            if (lanewayRule.getLaneX$().contains(loc.getRow1())) {
                direction = lanewayRule.getLaneX$();
            }else {
                direction = lanewayRule.getLaneY$();
            }

            boolean flag = false;
            List<Loc> allLocs = new ArrayList<>();
            for (Integer row : direction) {
                Loc one = locService.getOne(new LambdaQueryWrapper<Loc>()
                        .eq(Loc::getRow1, row)
                        .eq(Loc::getBay1, loc.getBay1())
                        .eq(Loc::getLev1, loc.getLev1()));
                if (one == null) {
                    continue;
                }

                if(one.getLocStsId() != LocStsType.O.val()) {
                    flag = true;
                    break;
                }

                allLocs.add(one);
            }

            if (flag) {
                continue;
            }

            if (!allLocs.isEmpty()) {
                defaultLoc = allLocs.get(0);
                break;//找到一个完整空巷道
            }
        }

        return defaultLoc;
    }

    //从库存或任务中匹配相邻库位(空托盘)
    public Loc getNeighborEmptyLoc(Long taskType, Integer locTypeHeight) {
        //从任务中进行匹配
        List<Loc> locs = new ArrayList<>();
        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskType, 10));
        for (Task task : list) {
            String targetLoc = task.getTargetLoc();
            Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, targetLoc));
            if(one == null) {
                continue;
            }
            locs.add(one);
        }

        Loc loc = filterLoc(taskType, locs);
        if (loc != null) {
            return loc;
        }

        //从库存中进行匹配
        List<Loc> locs2 = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getLocStsId, LocStsType.D.val()));
        Loc loc2 = filterLoc(taskType, locs2);
        if (loc2 != null) {
            return loc2;
        }
        return null;
    }

    //获取推荐库位(空托盘)
    public List<Loc> getSuggestEmptyLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {
        List<Loc> locs = new ArrayList<>();
        //空托盘
        List<SuggestLocRule> suggestLocRules = suggestLocRuleService.list(new LambdaQueryWrapper<SuggestLocRule>().eq(SuggestLocRule::getLocType, 0));
        for (SuggestLocRule suggestLocRule : suggestLocRules) {
            LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.ge(Loc::getRow1, suggestLocRule.getStartRow());
            queryWrapper.le(Loc::getRow1, suggestLocRule.getTargetRow());
            queryWrapper.ge(Loc::getBay1, suggestLocRule.getStartBay());
            queryWrapper.le(Loc::getBay1, suggestLocRule.getTargetBay());
            queryWrapper.ge(Loc::getLev1, suggestLocRule.getStartLev());
            queryWrapper.le(Loc::getLev1, suggestLocRule.getTargetLev());
            queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());

            if (laneRowList != null && !laneRowList.isEmpty()) {
                queryWrapper.in(Loc::getRow1, laneRowList);
            }

            if (currentLev != null) {
                queryWrapper.eq(Loc::getLev1, currentLev);
            }

            List<Loc> list = locService.list(queryWrapper);
            if (!list.isEmpty()) {
                locs.addAll(list);
            }
        }
        return locs;
    }

    //获取全局库位(完整巷道)
    public List<Loc> getGlobalEmptyLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {
        List<Loc> locs = new ArrayList<>();
        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);
        if (locTypeHeightType == null) {
            throw new CoolException("库位高度类型异常");
        }
        //获取库位高度
        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));
        //符合库位高度的库位集合
        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);

        LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());
        queryWrapper.in(Loc::getId, locIdList);

        if (laneRowList != null && !laneRowList.isEmpty()) {
            queryWrapper.in(Loc::getRow1, laneRowList);
        }

        if (currentLev != null) {
            queryWrapper.eq(Loc::getLev1, currentLev);
        }

        List<Loc> list = locService.list(queryWrapper);
        if (!list.isEmpty()) {
            locs.addAll(list);
        }
        return locs;
    }

}
package com.zy.asrs.wms.utils;



import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.zy.asrs.framework.common.Cools;

import com.zy.asrs.framework.exception.CoolException;

import com.zy.asrs.wms.asrs.entity.*;

import com.zy.asrs.wms.asrs.entity.enums.LocStsType;

import com.zy.asrs.wms.asrs.entity.enums.LocTypeHeightType;

import com.zy.asrs.wms.asrs.entity.param.FieldParam;

import com.zy.asrs.wms.asrs.mapper.ViewLocDetlMapper;

import com.zy.asrs.wms.asrs.mapper.ViewTaskDetlMapper;

import com.zy.asrs.wms.asrs.service.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;



import java.util.ArrayList;

import java.util.List;

import java.util.Map;



@Component

public class LocUtils {



    @Autowired

    private TaskService taskService;

    @Autowired

    private LocService locService;

    @Autowired

    private SuggestLocRuleService suggestLocRuleService;

    @Autowired

    private LanewayRuleService lanewayRuleService;

    @Autowired

    private LocTypeService locTypeService;

    @Autowired

    private LocTypeBindService locTypeBindService;

    @Autowired

    private ViewLocDetlMapper viewLocDetlMapper;

    @Autowired

    private ViewTaskDetlMapper viewTaskDetlMapper;

    @Autowired

    private MatService matService;



    //从库存或任务中匹配相邻库位(满托盘)

    public Loc getNeighborLoc(Long taskType, Long matId, String batch, List<FieldParam> uniqueFields, Integer locTypeHeight) {

        //满托盘

        Mat mat = matService.getById(matId);

        if (mat == null) {

            return null;

        }



        //从任务中进行匹配

        List<Loc> locs = new ArrayList<>();

        List<Map<String, Object>> list = viewTaskDetlMapper.getList(mat.getMatnr(), batch, uniqueFields);

        for (Map<String, Object> map : list) {

            Task task = taskService.getById(map.get("taskId").toString());

            if (task == null) {

                continue;

            }



            String targetLoc = task.getTargetLoc();

            Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, targetLoc));

            if (one == null) {

                continue;

            }

            locs.add(one);

        }



        Loc loc = filterLoc(taskType, locs);

        if (loc != null) {

            return loc;

        }



        //从库存中进行匹配

        List<Loc> locs2 = new ArrayList<>();

        List<Map<String, Object>> list2 = viewLocDetlMapper.getList(mat.getMatnr(), batch, uniqueFields, null);

        for (Map<String, Object> map : list2) {

            Loc one = locService.getById(map.get("locId").toString());

            if (one == null) {

                continue;

            }

            locs2.add(one);

        }



        Loc loc2 = filterLoc(taskType, locs2);

        if (loc2 != null) {

            return loc2;

        }

        return null;

    }



    //获取推荐库位(满托盘)

    public List<Loc> getSuggestLoc(Long taskType, Long matId, String batch, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {

        //满托盘

        List<Loc> locs = new ArrayList<>();

        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);

        if (locTypeHeightType == null) {

            throw new CoolException("库位高度类型异常");

        }

        //获取库位高度

        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));

        //符合库位高度的库位集合

        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);



        LambdaQueryWrapper<SuggestLocRule> wrapper = new LambdaQueryWrapper<>();

        wrapper.eq(SuggestLocRule::getLocType, 1);

        wrapper.eq(SuggestLocRule::getMatId, matId);

        if (!Cools.isEmpty(batch)) {

            wrapper.eq(SuggestLocRule::getBatch, batch);

        }

        List<SuggestLocRule> suggestLocRules = suggestLocRuleService.list(wrapper);

        for (SuggestLocRule suggestLocRule : suggestLocRules) {

            LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();

            queryWrapper.ge(Loc::getRow1, suggestLocRule.getStartRow());

            queryWrapper.le(Loc::getRow1, suggestLocRule.getTargetRow());

            queryWrapper.ge(Loc::getBay1, suggestLocRule.getStartBay());

            queryWrapper.le(Loc::getBay1, suggestLocRule.getTargetBay());

            queryWrapper.ge(Loc::getLev1, suggestLocRule.getStartLev());

            queryWrapper.le(Loc::getLev1, suggestLocRule.getTargetLev());

            queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());

            queryWrapper.in(Loc::getId, locIdList);



            if (laneRowList != null && !laneRowList.isEmpty()) {

                queryWrapper.in(Loc::getRow1, laneRowList);

            }



            if (currentLev != null) {

                queryWrapper.eq(Loc::getLev1, currentLev);

            }



            List<Loc> list = locService.list(queryWrapper);

            if (!list.isEmpty()) {

                locs.addAll(list);

            }

        }

        return locs;

    }



    //获取全局库位(完整巷道)

    public List<Loc> getGlobalLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {

        List<Loc> locs = new ArrayList<>();

        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);

        if (locTypeHeightType == null) {

            throw new CoolException("库位高度类型异常");

        }

        //获取库位高度

        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));

        //符合库位高度的库位集合

        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);



        LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());

        queryWrapper.in(Loc::getId, locIdList);



        if (laneRowList != null && !laneRowList.isEmpty()) {

            queryWrapper.in(Loc::getRow1, laneRowList);

        }



        if (currentLev != null) {

            queryWrapper.eq(Loc::getLev1, currentLev);

        }



        List<Loc> list = locService.list(queryWrapper);

        if (!list.isEmpty()) {

            locs.addAll(list);

        }

        return locs;

    }



    //从库位集合中获取符合深浅的库位

    public Loc filterLoc(Long taskType, List<Loc> locs) {

        if (locs == null || locs.isEmpty()) {

            return null;

        }



        Loc defaultLoc = null;

        for (Loc loc : locs) {

            //获取库位所在巷道

            LanewayRule lanewayRule = lanewayRuleService.getLaneByLoc(loc);

            if(lanewayRule == null) {

                throw new CoolException("库位未配置巷道");

            }



            //获取库位方向

            List<Integer> direction = null;

            if (lanewayRule.getLaneX$().contains(loc.getRow1())) {

                direction = lanewayRule.getLaneX$();

            }else {

                direction = lanewayRule.getLaneY$();

            }



            for (Integer row : direction) {

                Loc one = locService.getOne(new LambdaQueryWrapper<Loc>()

                        .eq(Loc::getRow1, row)

                        .eq(Loc::getBay1, loc.getBay1())

                        .eq(Loc::getLev1, loc.getLev1()));

                if (one == null) {

                    continue;

                }



                if(one.getLocStsId() != LocStsType.O.val()) {

                    continue;

                }



                //当前库位是空库位

                defaultLoc = one;

                break;

            }



            if (defaultLoc != null) {

                break;

            }

        }



        return defaultLoc;

    }



    //从库位集合中获取完整空巷道

    public Loc filterAllLoc(List<Loc> locs) {

        if (locs == null || locs.isEmpty()) {

            return null;

        }



        Loc defaultLoc = null;

        for (Loc loc : locs) {

            //获取库位所在巷道

            LanewayRule lanewayRule = lanewayRuleService.getLaneByLoc(loc);

            if(lanewayRule == null) {

                throw new CoolException("库位未配置巷道");

            }



            //获取库位方向

            List<Integer> direction = null;

            if (lanewayRule.getLaneX$().contains(loc.getRow1())) {

                direction = lanewayRule.getLaneX$();

            }else {

                direction = lanewayRule.getLaneY$();

            }



            boolean flag = false;

            List<Loc> allLocs = new ArrayList<>();

            for (Integer row : direction) {

                Loc one = locService.getOne(new LambdaQueryWrapper<Loc>()

                        .eq(Loc::getRow1, row)

                        .eq(Loc::getBay1, loc.getBay1())

                        .eq(Loc::getLev1, loc.getLev1()));

                if (one == null) {

                    continue;

                }



                if(one.getLocStsId() != LocStsType.O.val()) {

                    flag = true;

                    break;

                }



                allLocs.add(one);

            }



            if (flag) {

                continue;

            }



            if (!allLocs.isEmpty()) {

                defaultLoc = allLocs.get(0);

                break;//找到一个完整空巷道

            }

        }



        return defaultLoc;

    }



    //从库存或任务中匹配相邻库位(空托盘)

    public Loc getNeighborEmptyLoc(Long taskType, Integer locTypeHeight) {

        //从任务中进行匹配

        List<Loc> locs = new ArrayList<>();

        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskType, 10));

        for (Task task : list) {

            String targetLoc = task.getTargetLoc();

            Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, targetLoc));

            if(one == null) {

                continue;

            }

            locs.add(one);

        }



        Loc loc = filterLoc(taskType, locs);

        if (loc != null) {

            return loc;

        }



        //从库存中进行匹配

        List<Loc> locs2 = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getLocStsId, LocStsType.D.val()));

        Loc loc2 = filterLoc(taskType, locs2);

        if (loc2 != null) {

            return loc2;

        }

        return null;

    }



    //获取推荐库位(空托盘)

    public List<Loc> getSuggestEmptyLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {

        List<Loc> locs = new ArrayList<>();

        //空托盘

        List<SuggestLocRule> suggestLocRules = suggestLocRuleService.list(new LambdaQueryWrapper<SuggestLocRule>().eq(SuggestLocRule::getLocType, 0));

        for (SuggestLocRule suggestLocRule : suggestLocRules) {

            LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();

            queryWrapper.ge(Loc::getRow1, suggestLocRule.getStartRow());

            queryWrapper.le(Loc::getRow1, suggestLocRule.getTargetRow());

            queryWrapper.ge(Loc::getBay1, suggestLocRule.getStartBay());

            queryWrapper.le(Loc::getBay1, suggestLocRule.getTargetBay());

            queryWrapper.ge(Loc::getLev1, suggestLocRule.getStartLev());

            queryWrapper.le(Loc::getLev1, suggestLocRule.getTargetLev());

            queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());



            if (laneRowList != null && !laneRowList.isEmpty()) {

                queryWrapper.in(Loc::getRow1, laneRowList);

            }



            if (currentLev != null) {

                queryWrapper.eq(Loc::getLev1, currentLev);

            }



            List<Loc> list = locService.list(queryWrapper);

            if (!list.isEmpty()) {

                locs.addAll(list);

            }

        }

        return locs;

    }



    //获取全局库位(完整巷道)

    public List<Loc> getGlobalEmptyLoc(Long taskType, Integer locTypeHeight, List<Integer> laneRowList, Integer currentLev) {

        List<Loc> locs = new ArrayList<>();

        LocTypeHeightType locTypeHeightType = LocTypeHeightType.get(locTypeHeight);

        if (locTypeHeightType == null) {

            throw new CoolException("库位高度类型异常");

        }

        //获取库位高度

        LocType locType = locTypeService.getOne(new LambdaQueryWrapper<LocType>().eq(LocType::getFlag, locTypeHeightType.flag));

        //符合库位高度的库位集合

        List<Long> locIdList = locTypeBindService.getLocIdListByType(locType);



        LambdaQueryWrapper<Loc> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(Loc::getLocStsId, LocStsType.O.val());

        queryWrapper.in(Loc::getId, locIdList);



        if (laneRowList != null && !laneRowList.isEmpty()) {

            queryWrapper.in(Loc::getRow1, laneRowList);

        }



        if (currentLev != null) {

            queryWrapper.eq(Loc::getLev1, currentLev);

        }



        List<Loc> list = locService.list(queryWrapper);

        if (!list.isEmpty()) {

            locs.addAll(list);

        }

        return locs;

    }



}