#

luxiaotao1123

2023-02-02 c78a960e4b93f5074cbed9cda38a0aba103bbec4

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

@@ -10,6 +10,7 @@
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 lombok.extern.slf4j.Slf4j;
@@ -54,6 +55,10 @@
    private LocDetlService locDetlService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private MatService matService;
    @Autowired
    private LocRuleService locRuleService;

    /**
     * 生成工作号
@@ -110,16 +115,27 @@
     */
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto, LocTypeDto oldLocType, int times) {
        StartupDto startupDto = new StartupDto();
        int start;
        int end;
        Integer theCrnNo = null;
        switch (sourceStaNo) {
            case 108:
            case 103:
                whsType = 1;
                start = 1;
                end = 14;
//                if (null != wrkMastService.selectPakoutOfStaNo(104)) {
//                    start = 8;
//                    theCrnNo = 2;
//                }
                break;
            case 111:
            case 211:
            case 203:
                whsType = 2;
                break;
            case 208:
                whsType = 3;
                start = 8;
                end = 21;
//                if (null != wrkMastService.selectPakoutOfStaNo(204)) {
//                    end = 14;
//                    theCrnNo = 2;
//                }
                break;
            default:
                throw new CoolException("检索库位失败，请联系管理员");
@@ -140,18 +156,30 @@
        // 目标库位
        LocMast locMast = null;

        // 靠近摆放规则 --- 同天同规格物料
        boolean inoutEveryday = false;
        if (!Cools.isEmpty(matNos)) {
            List<String> locNos = locDetlService.getSameDetl(matNos.get(0), sRow, eRow);
            for (String matNo : matNos) {
                Mat mat = matService.selectByMatnr(matNo);
                if (mat.getInoutEveryday() != null && mat.getInoutEveryday()) {
                    inoutEveryday = true;
                    break;
                }
            }
        }

        // 靠近摆放规则 --- 同天同规格物料
        if (!Cools.isEmpty(matNos) && matNos.size() == 1) {
            List<String> locNos = locDetlService.getSameDetl(matNos.get(0), start, end);
            for (String locNo : locNos) {
                List<String> groupLoc = Utils.getGroupLoc(locNo);
                locMast = locMastService.findOutMost(groupLoc);
                if (null != locMast) {
                LocMast locMast0 = locMastService.findOutMost(groupLoc);
                if (null != locMast0) {
                    // 浅库位符合尺寸检测
                    if (VersionUtils.locMoveCheckLocType(locMast, locTypeDto)) {
                    if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                        // 浅库位对应堆垛机必须可用且无异常
                        if (basCrnpService.checkSiteError(locMast.getCrnNo(), true)) {
                            crnNo = locMast.getCrnNo();
                        if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                            crnNo = locMast0.getCrnNo();
                            locMast = locMast0;
                            break;
                        }
                    }
@@ -161,17 +189,19 @@

        // 靠近摆放规则 --- 空托
        if (staDescId == 10) {
            List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D").ge("row1", sRow).le("row1", eRow));
            List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                    .eq("loc_sts", "D").ge("row1", start).le("row1", end));
            if (locMasts.size() > 0) {
                for (LocMast loc : locMasts) {
                    List<String> groupLoc = Utils.getGroupLoc(loc.getLocNo());
                    locMast = locMastService.findOutMost(groupLoc);
                    if (null != locMast) {
                    LocMast locMast0 = locMastService.findOutMost(groupLoc);
                    if (null != locMast0) {
                        // 浅库位符合尺寸检测
                        if (VersionUtils.locMoveCheckLocType(locMast, locTypeDto)) {
                        if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                            // 浅库位对应堆垛机必须可用且无异常
                            if (basCrnpService.checkSiteError(locMast.getCrnNo(), true)) {
                                crnNo = locMast.getCrnNo();
                            if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                                crnNo = locMast0.getCrnNo();
                                locMast = locMast0;
                                break;
                            }
                        }
@@ -181,40 +211,79 @@
        }

        // 如果没有相近物料，则按规则轮询货架

        int currentRow = 1;
        if (null == locMast) {
            switch (whsType) {
                case 1:
                    if (curRow == 1) {
                        curRow = 7;
                    } else if (curRow == 7) {
                        curRow = 1;
                    }
                    crnNo = 1;
                    break;
                case 2:
                    if (curRow == 8) {
                        curRow = 14;
                    } else if (curRow == 14) {
                        curRow = 8;
                    }
                    crnNo = 2;
                    break;
                case 3:
                    if (curRow == 15) {
                        curRow = 21;
                    } else if (curRow == 21) {
                        curRow = 15;
                    }
                    crnNo = 3;
                    break;
                default:
            Shelves shelves = new Shelves(rowCount, crn_qty);
            for (int i = 0; i < shelves.group; i ++) {
                if (i > 0) {
                    curRow = currentRow;
                }
                curRow = shelves.start(curRow);
                if (curRow < 0) {
                    throw new CoolException("检索库位失败，请联系管理员");
                }
                currentRow = curRow;
                int crnNo1 = shelves.get(curRow);
                if (whsType == 1) {
                    switch (curRow) {
                        case 1:
                            curRow = 1;
                            if (null != theCrnNo) {
                                curRow = 8;
                                crnNo1 = crnNo1 + 1;
                            }
                            break;
                        case 2:
                            curRow = 7;
                            if (null != theCrnNo) {
                                curRow = 14;
                                crnNo1 = crnNo1 + 1;
                            }
                            break;
                        case 3:
                            curRow = 8;
                            break;
                        case 4:
                            curRow = 14;
                            break;
                        default:
                            throw new CoolException("检索库位失败，请联系管理员");
                    }
                } else {
                    switch (curRow) {
                        case 1:
                            curRow = 8;
                            break;
                        case 2:
                            curRow = 14;
                            break;
                        case 3:
                            curRow = 15;
                            if (null != theCrnNo) {
                                curRow = 8;
                                crnNo1 = crnNo1 - 1;
                            }
                            break;
                        case 4:
                            curRow = 21;
                            if (null != theCrnNo) {
                                curRow = 14;
                                crnNo1 = crnNo1 - 1;
                            }
                            break;
                        default:
                            throw new CoolException("检索库位失败，请联系管理员");
                    }
                    crnNo1 = crnNo1 + 1;
                }
                if (basCrnpService.checkSiteError(crnNo1, true)) {
                    crnNo = crnNo1;
                    break;
                }
            }
        }

        if (!basCrnpService.checkSiteError(crnNo, true)) {
            throw new CoolException("没有可用的堆垛机");
        }
        if (crnNo == 0) {
            throw new CoolException("没有可用的堆垛机");
        }
@@ -236,39 +305,113 @@
        }

        // 更新库位排号
        rowLastno.setCurrentRow(curRow);
        rowLastno.setCurrentRow(currentRow);
        rowLastnoService.updateById(rowLastno);

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

        // 1.当检索库排为浅库位排时，优先寻找当前库排的深库位排
        if (locMast == null) {
            List<Integer> rows;
            if (whsType == 2) {
                rows = FIRST_GROUP_ROW_LIST;
            } else if (whsType == 3) {
                rows = SECOND_GROUP_ROW_LIST;
            } else {
                switch (curRow) {
                    case 1:
                        rows = FIRST_GROUP_ROW_LIST;
                        break;
                    case 2:
                        rows = SECOND_GROUP_ROW_LIST;
                        break;
                    default:
                        throw new CoolException("入库逻辑故障【" + curRow + "】");

            // 库区锁定
            LocRule locRule = locRuleService.find(Cools.isEmpty(matNos) ? null : matNos.get(0), null, start, end);
            if (!Cools.isEmpty(locRule)) {
                List<Integer> rows = Utils.getGroupLoc(locRule.getRowBeg());
                List<LocMast> locMasts = locMastService.queryFreeLocMast1(rows, rows.size(), locTypeDto.getLocType1(), inoutEveryday
                        , locRule.getRowBeg(), locRule.getRowEnd(), locRule.getBayBeg(), locRule.getBayEnd(), locRule.getLevBeg(), locRule.getLevEnd());
                if (!Cools.isEmpty(locMasts)) {
                    Integer innermostRow = Utils.getInnermostRow(locMasts.get(0).getLocNo());
                    for (LocMast one : locMasts) {
                        if (one.getRow1().equals(innermostRow)) {
                            locMast = one;
                            break;
                        }
                    }
                }
            }

            locMast = locMastService.queryFreeLocMast(null, rows, locTypeDto.getLocType1());
            // 因库位移转、需预留空库位
            if (locMast == null) {
                List<Integer> rows = Utils.getGroupLoc(curRow);
                List<LocMast> locMasts = locMastService.queryFreeLocMast0(rows, rows.size(), locTypeDto.getLocType1(), inoutEveryday);
                if (!Cools.isEmpty(locMasts)) {
                    Integer innermostRow = Utils.getInnermostRow(locMasts.get(0).getLocNo());
                    for (LocMast one : locMasts) {
                        if (one.getRow1().equals(innermostRow)) {
                            locMast = one;
                            break;
                        }
                    }
                }
            }
//            LocMast locMast0 = locMastService.findOutMost(locMasts.stream().map(LocMast::getLocNo).distinct().collect(Collectors.toList()));
//            if (!Cools.isEmpty(locMast0)) {
//                locMast = locMast0;
//            }
            // 因库位移转、需预留空库位 todo:luxiaotao
//            if (!locMastService.checkEmptyCount(locMast)) {
//                locMast = null;
//            }
        }

        // 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
        // 2.无库位时，无视区域锁定，重新查找库位


        if (Cools.isEmpty(locMast)) {
            int sign = curRow;
            while (sign != 0) {
                List<LocMast> locMasts = locMastService.queryFreeLocMastEnd(sign, locTypeDto.getLocType1());
                for (LocMast loc : locMasts) {
                    // 同库位组对应其钱库位是否为 O.空库位
                    boolean success = true;
                    List<String> outerLoc = Utils.getGroupOuterLoc(loc.getLocNo());
                    for (String outerLocNo : outerLoc) {
                        if (!locMastService.selectById(outerLocNo).getLocSts().equals("O")) {
                            success = false; break;
                        }
                    }
                    if (success) {
                        locMast = loc;
                        break;
                    }
                }
                sign = getCurRow(sign);
            }
        }


//        if (Cools.isEmpty(locMast)){
//            List<LocMast> locMasts = locMastService.queryFreeLocMastEnd(curRow, locTypeDto.getLocType1());
//            int sign=curRow;
//            while (true){
//                if (locMasts.size()==0){
//                    sign = getCurRow(sign);
//                    if (sign != 0){
//                        locMasts = locMastService.queryFreeLocMastEnd(sign, locTypeDto.getLocType1());
//                    }else {
//                        break;
//                    }
//                }else {
//                    break;
//                }
//            }
//            for (LocMast locMast1 : locMasts){
//                List<LocMast> locMasts1 = locMastService.queryFreeLocMastEnd0(locMast1.getBay1(), locMast1.getLev1(),locMast1.getRow1(), locTypeDto.getLocType1());
//                Integer innermostRow = Utils.getInnermostRow(locMasts1.get(0).getLocNo());
//                for (LocMast locMast2:locMasts1){
//                    if (locMast2.getLocSts().equals("O")){
//                        locMast = locMast2;
//                        break;
//                    }else if (!locMast2.getLocSts().equals("F")){
//                        break;
//                    }
//                }
//                if (!Cools.isEmpty(locMast)){
//                    break;
//                }
//            }
//        }

        // 3.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
        if (Cools.isEmpty(locMast)) {
            // 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
            if (times < rowCount) {
@@ -310,4 +453,28 @@
        }
    }

    public int getCurRow(int curRow){
        switch (curRow){
            case 1:
            case 2:
            case 8:
            case 9:
            case 10:
            case 15:
            case 16:
            case 17:
                return curRow+1;
            case 5:
            case 6:
            case 7:
            case 13:
            case 14:
            case 20:
            case 21:
                return curRow-1;
            default:
                return 0;
        }
    }

}