#

LSH

2023-06-07 1af3b14449eb33792e606185c55643bca53efbb7

 src/main/java/com/zy/common/service/CommonService.java

@@ -4,6 +4,7 @@
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
@@ -17,6 +18,7 @@

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

/**
 * 货架核心功能
@@ -118,27 +120,29 @@
            case 103://103入库站
                whsType = 1;
                start = 1;
                end = 11;
                end = 14;

                //103站分配1，2堆垛机
                crnNos.add(1);
                crnNos.add(2);

                //分配1，7，8排
                //分配1，7，8，14排
                rows.add(1);
                rows.add(7);
                rows.add(8);
                rows.add(14);
                break;
            case 203://203入库站
                whsType = 2;
                start = 12;
                start = 8;
                end = 21;

                //203站分配3，4堆垛机
                //203站分配2，3堆垛机
                crnNos.add(2);
                crnNos.add(3);
                crnNos.add(4);

                //分配14，15，21排
                //分配8，14，15，21排
                rows.add(8);
                rows.add(14);
                rows.add(15);
                rows.add(21);
@@ -153,51 +157,92 @@
        // 目标库位
        LocMast locMast = null;

        if (!Cools.isEmpty(matNos)) {
            for (String matNo : matNos) {
                Mat mat = matService.selectByMatnr(matNo);
                if (matType == null) {
                    matType = mat.getMatType();
                }
                if (matType != mat.getMatType()) {
                    throw new CoolException("混放物料类型不一致");
                }
            }

            if (matNos.size() > 1 && matType == 1) {
                //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
                throw new CoolException("物料类型和实际种类不一致");
            }
        }
        boolean sign = false;

        // 靠近摆放规则 --- 空托
        locMast = getLocNoStep1(staDescId, locTypeDto, start, end);
        if (locMast != null) {
            //找到库位，返回dto
            return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
            sign=true;
        }

        if (matType != null) {
        if (!sign && matType != null) {
            if (matType == 1) {//单品类型入库
                locMast = getLocNoStep2(locTypeDto, matNos, rows);
                locMast = getLocNoStep2(locTypeDto, matNos, rows, crnNos);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                    sign=true;
                }
            } else if (matType == 2) {//高频类型入最外侧库位
                locMast = getLocNoStep3(locTypeDto, crnNos);
                if (locMast == null) {
                    //高频没有找到库位，找低频混放区域库位
                    locMast = getLocNoStep4(locTypeDto, crnNos);
                }
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                    sign=true;
                }
            } else if (matType == 3) {//低频混放类型
                locMast = getLocNoStep4(locTypeDto);
                locMast = getLocNoStep4(locTypeDto, crnNos);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                    sign=true;
                }
            }
        }



        if (!sign){
            //----------------2023.06.02兼容代码，后期库位规则符合要求后可删除------------------------
            //如果以上都找不到库位，则强制搜索1、2堆垛机空库位进行入库，保障3号堆垛机库位都是符合要求的
            EntityWrapper<LocMast> wrapper = new EntityWrapper<>();
            wrapper.eq("loc_type1", locTypeDto.getLocType1());
            wrapper.in("crn_no", "2");
            wrapper.eq("loc_sts", "O");
            List<LocMast> locMasts = locMastService.selectList(wrapper);
            for (LocMast mast : locMasts) {
                //检测当前库位内侧其他库位是否为D、F、X
                if (Utils.checkInsideLocIsDFX(mast.getLocNo())) {
                    //内侧其他库位不是D、F、X。不能选取该库位
                    continue;
                }
                if(sourceStaNo==103 && mast.getRow1()>7)
                {
                    continue;
                }
                if(sourceStaNo==203 && mast.getRow1()<8)
                {
                    continue;
                }
                //找到库位，返回dto
                locMast=mast;
                sign = true;
            }
        }

        if (sign){
            //3号可以入库前必须打开控制
            if (!Cools.isEmpty(matNos) && locMast.getCrnNo()==3) {
                for (String matNo : matNos) {
                    Mat mat = matService.selectByMatnr(matNo);
                    if (matType == null) {
                        matType = mat.getMatType();
                    }
                    if (!matType.equals(mat.getMatType())) {
                        throw new CoolException("混放物料类型不一致");
                    }
                }

                if (matNos.size() > 1 && matType == 1) {
                    //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
                    throw new CoolException("物料类型和实际种类不一致");
                }
            }
            return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
        }
        //----------------2023.06.02兼容代码end---------------------

        throw new CoolException("检索库位失败，请联系管理员");
    }
@@ -233,18 +278,26 @@
    }

    //单品类型入库
    private LocMast getLocNoStep2(LocTypeDto locTypeDto, List<String> matNos, List<Integer> rows) {
    private LocMast getLocNoStep2(LocTypeDto locTypeDto, List<String> matNos, List<Integer> rows, List<Integer> crnNos) {
        LocMast locMast = null;
        //找内侧空库位(非最外侧库位)
        List<String> locNos = locDetlService.getSameDetl(matNos.get(0));
        for (String locNo : locNos) {
            List<String> groupLoc = Utils.getGroupLoc(locNo);
            LocMast locMast0 = locMastService.findEmptyLocMastByLocNos(locTypeDto.getLocType1(), groupLoc);
            if (null != locMast0) {
        //先找工作档
        List<WrkMast> wrkMasts = wrkMastService.selectSameWrkMast(matNos.get(0));
        for (WrkMast wrkMast : wrkMasts) {
            List<String> groupLoc = Utils.getGroupLoc(wrkMast.getLocNo());
            //随机可用堆垛机号
            Integer randomCrnNo = Utils.getRandomCrnNo(crnNos, locTypeDto.getLocType1());
            List<LocMast> locMasts = locMastService.findEmptyLocMastByLocNos(locTypeDto.getLocType1(), groupLoc, randomCrnNo);
            for (LocMast locMast0 : locMasts) {
                //检测当前库位内侧其他库位是否为D、F、X、S
                if (Utils.checkInsideLocIsDFXS(locMast0.getLocNo())) {
                    //内侧其他库位不是D、F、X、S。不能选取该库位
                    continue;
                }

                // 浅库位符合尺寸检测
                if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                    // 浅库位对应堆垛机必须可用且无异常
                    if (true || basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                        // 因库位移转、需预留空库位
                        if (locMastService.checkEmptyCount(locMast0, 10)) {
                            locMast = locMast0;
@@ -255,9 +308,58 @@
            }
        }

        //找内侧空库位(非最外侧库位)
        if (locMast == null) {
            List<String> locNos = locDetlService.getSameDetl(matNos.get(0));
            for (String locNo : locNos) {
                List<String> groupLoc = Utils.getGroupLoc(locNo);
                List<LocMast> locMasts = locMastService.findEmptyLocMastByLocNos(locTypeDto.getLocType1(), groupLoc, null);
                for (LocMast locMast0 : locMasts) {
                    //检测当前库位内侧其他库位是否为D、F、X
                    if (Utils.checkInsideLocIsDFX(locMast0.getLocNo())) {
                        //内侧其他库位不是D、F、X。不能选取该库位
                        continue;
                    }

                    // 浅库位符合尺寸检测
                    if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                        // 浅库位对应堆垛机必须可用且无异常
                        if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                            // 因库位移转、需预留空库位
                            if (locMastService.checkEmptyCount(locMast0, 10)) {
                                locMast = locMast0;
                                break;
                            }
                        }
                    }
                }
            }
        }

        //未找到巷道，找一条新的空巷道
        if (locMast == null) {
            locMast = locMastService.findInEmptyLocMast(locTypeDto.getLocType1(), rows);//找一条新的空巷道
            //随机可用堆垛机号
            Integer randomCrnNo = Utils.getRandomCrnNo(crnNos, locTypeDto.getLocType1());
            List<LocMast> locMasts = locMastService.findInEmptyLocMast(locTypeDto.getLocType1(), rows, randomCrnNo);//找一条新的空巷道
            for (LocMast locMast0 : locMasts) {
                //检测当前库位内侧其他库位是否为D、F、X
                if (Utils.checkInsideLocIsDFX(locMast0.getLocNo())) {
                    //内侧其他库位不是D、F、X。不能选取该库位
                    continue;
                }

                // 浅库位符合尺寸检测
                if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                    // 浅库位对应堆垛机必须可用且无异常
                    if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                        // 因库位移转、需预留空库位
                        if (locMastService.checkEmptyCount(locMast0, 10)) {
                            locMast = locMast0;
                            break;
                        }
                    }
                }
            }
        }

        return locMast;
@@ -266,13 +368,28 @@
    //高频类型入最外侧库位
    private LocMast getLocNoStep3(LocTypeDto locTypeDto, List<Integer> crnNos) {
        LocMast locMast = null;

        //随机可用堆垛机号
        Integer randomCrnNo = Utils.getRandomCrnNo(crnNos, locTypeDto.getLocType1());
        if (randomCrnNo == null) {
            return locMast;
        }
        ArrayList<Integer> randomCrnNos = new ArrayList<>();
        randomCrnNos.add(randomCrnNo);

        //找最外侧空库位
        LocMast locMast0 = locMastService.findOutMast(locTypeDto.getLocType1(), crnNos);
        if (locMast0 != null) {
        List<LocMast> locMasts = locMastService.findOutMast(locTypeDto.getLocType1(), randomCrnNos);
        for (LocMast locMast0 : locMasts) {
            //检测当前库位内侧其他库位是否为D、F、X
            if (Utils.checkInsideLocIsDFX(locMast0.getLocNo())) {
                //内侧其他库位不是D、F、X。不能选取该库位
                continue;
            }

            // 浅库位符合尺寸检测
            if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                // 浅库位对应堆垛机必须可用且无异常
                if (true||basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;
@@ -285,14 +402,41 @@
    }

    //低频类型，直接找混放区域
    private LocMast getLocNoStep4(LocTypeDto locTypeDto) {
    private LocMast getLocNoStep4(LocTypeDto locTypeDto, List<Integer> crnNos) {
        LocMast locMast = null;
        LocMast locMast0 = locMastService.findEmptyLowFrequencyLocMast(locTypeDto.getLocType1());
        if (locMast0 != null) {

        //随机可用堆垛机号
        Integer randomCrnNo = Utils.getRandomCrnNo(crnNos, locTypeDto.getLocType1());

        List<LocMast> locMasts = locMastService.findEmptyLowFrequencyLocMast(locTypeDto.getLocType1(), randomCrnNo);
        for (LocMast locMast0 : locMasts) {
            //检测当前库位内侧其他库位是否为D、F、X
            if (Utils.checkInsideLocIsDFX(locMast0.getLocNo())) {
                //内侧其他库位不是D、F、X。不能选取该库位
                continue;
            }

            //检测当前库位外侧库位是否为O(空库位)
            boolean flag = false;
            List<String> outerLoc = Utils.getGroupOuterLoc(locMast0.getLocNo());
            if (outerLoc.size() > 0) {
                List<LocMast> outerLocMast = locMastService.selectByLocNos(outerLoc);
                for (LocMast mast : outerLocMast) {
                    if (!mast.getLocSts().equals("O")) {
                        //不是空库位，找下一个
                        flag = true;
                        break;
                    }
                }
            }
            if (flag) {
                continue;
            }

            // 浅库位符合尺寸检测
            if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                // 浅库位对应堆垛机必须可用且无异常
                if (true||basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;