#

whycq

2024-07-29 3521070a2fda24b1d534e21018ce8017e01f595a

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

@@ -7,7 +7,6 @@
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.result.KeyValueVo;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
@@ -20,10 +19,6 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;

/**
@@ -123,10 +118,200 @@
    }

    /**
     * 双深找库位
     */
    @Transactional
    public StartupDto getLocNo(Integer staDescId, Integer sourceStaNo,LocTypeDto locTypeDto,int times) {

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

        StartupDto startupDto = new StartupDto();
        RowLastno rowLastno = rowLastnoService.selectById(1);
        int sRow = rowLastno.getsRow();
        int eRow = rowLastno.geteRow();
        int crn_qty = rowLastno.getCrnQty();
        int rowCount = eRow - sRow + 1;
        if (Cools.isEmpty(rowLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }
        // ===============>>>> 开始执行

        curRow = rowLastno.getCurrentRow();

        // 如果没有相近物料，则按规则轮询货架
        if (Cools.isEmpty(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("检索库位失败，请联系管理员");
                }
                Integer crnNo1 = shelves.get(curRow);
                crnNo1 = crnNo1 + divides*1;
                if (basCrnpService.checkSiteError(crnNo1, true)) {
                    crnNo = crnNo1;
                    curRow = curRow + divides*4;
                    break;
                }
            }
        }

        if (crnNo == 0) {
            throw new CoolException("没有可用的堆垛机");
        }

        // 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;
                }
            }
            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;
                    }
                }
                // 目标库位 ===>> 深库位， 则校验其浅库位是否为 O
                if (null != locMast && Utils.isDeepLoc(slaveProperties, locMast.getLocNo())) {
                    LocMast shallowLoc = locMastService.selectById(Utils.getShallowLoc(slaveProperties, locMast.getLocNo()));
                    if (!Cools.isEmpty(shallowLoc)) {
                        if (!shallowLoc.getLocSts().equals("O")) {
                            locMast = null;
                        }
                    }


                }
            }
        }
        // 更新库位排号
        rowLastno.setCurrentRow(curRow);
        rowLastnoService.updateById(rowLastno);
        // 2.库位当前所属尺寸无空库位时，调整尺寸参数，向上兼容检索库位
        if (Cools.isEmpty(locMast)) {
            // 当前巷道无空库位时，递归调整至下一巷道，检索全部巷道无果后，跳出递归
            if (times < rowCount) {
                times = times + 1;
                return getLocNo(staDescId, sourceStaNo, locTypeDto, times);
            }
            log.error("系统没有空库位！！！ 尺寸规格： {}， 轮询次数：{}", JSON.toJSONString(locTypeDto), times);
            throw new CoolException("没有空库位");
        }


//        // 搜索空托
//        locMast = getLocNoStep4(staDescId, sourceStaNo);
//        if (locMast != null) {
//            //找到库位，返回dto
//            return getLocNoStep6(staDescId, sourceStaNo, locMast);//返回dto
//        }
        if (locMast == null) {
            //搜索整个空库位组
            locMast = getLocNoStepSingle(locTypeDto);
        }

        if (locMast != null) {
            //找到库位，返回dto
            return getLocNoStep6(staDescId, sourceStaNo, locMast);//返回dto
        }

       //找不到库位，抛出异常
        throw new CoolException("没有空库位");
    }
    // 搜索单品(整个库位组)
    private LocMast getLocNoStepSingle(LocTypeDto locTypeDto) {
        LocMast locMast = null;
        //单品
        List<LocMast> locMasts = locMastService.selectAreaEmpty(locTypeDto.getLocType1());//搜索货物

        for (LocMast mast : locMasts) {
            List<String> groupLoc = Utils.getGroupLocNo(mast.getLocNo(), true);
//            if (!locMastService.checkAllLocEmpty(groupLoc)) {
//                continue;
//            }

            LocMast tmp = null;
            for (String loc : groupLoc) {
                LocMast locMast1 = locMastService.selectByLoc(loc);
                if (locMast1 == null) {
                    continue;
                }

                if (!locMast1.getLocSts().equals("O")) {
                    continue;
                }

                tmp = locMast1;
                break;
            }

            //预留空库位
            if (tmp != null && locMastService.checkEmptyCount(mast, 10)) {
                locMast = tmp;
                break;
            }
        }

        return locMast;
    }

    //返回dto
    private StartupDto getLocNoStep6(Integer staDescId, Integer sourceStaNo, LocMast locMast) {
        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("入库路径不存在, staDescId={}, sourceStaNo={}", staDescId, sourceStaNo);
            throw new CoolException("入库路径不存在");
        }

        // 检测目标站
        BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
        if (!staNo.getAutoing().equals("Y")) {
            throw new CoolException("目标站" + staDesc.getCrnStn() + "不可用");
        }

        // 生成工作号
        int workNo = getWorkNo(0);
        // 返回dto
        startupDto.setWorkNo(workNo);
        startupDto.setSourceStaNo(sourceStaNo);
        startupDto.setStaNo(staNo.getDevNo());
        startupDto.setLocNo(locMast.getLocNo());
        startupDto.setCrnNo(locMast.getCrnNo());
        return startupDto;
    }
    /**
     * 检索库位号
     *
     * @param whsType     类型 1:双深式货架
     * @param staDescId   路径ID
     * @param staDescId   入库类型
     * @param sourceStaNo 源站
     * @param matnr       物料号集合
     * @return locNo 检索到的库位号