入库通知档上架区域显示

Junjie

2023-06-02 a810d82e6ff0d820da6c888ebd9af0dba655d595

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

@@ -2,24 +2,39 @@

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Arith;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.StartupDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.properties.SlaveProperties;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 货架核心功能
 * Created by vincent on 2020/6/11
 */
@Slf4j
@Service
public class CommonService {

    public static final List<Integer> FIRST_GROUP_ROW_LIST = new ArrayList<Integer>() {{
        add(2);add(3);add(4);add(5);add(6);add(7);add(8);add(9);add(10);
        add(11);add(12);add(13);add(14);add(15);add(16);add(17);
    }};
    public static final List<Integer> SECOND_GROUP_ROW_LIST = new ArrayList<Integer>() {{
        add(18);add(19);add(20);
        add(21);add(22);add(23);add(24);add(25);add(26);add(27);add(28);add(29);add(30);
    }};

    @Autowired
    private WrkMastService wrkMastService;
@@ -37,10 +52,16 @@
    private LocMastService locMastService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private MatService matService;
    @Autowired
    private LocRuleService locRuleService;

    /**
     * 生成工作号
     * @param wrkMk 0:入库 1 - 3000 ; 1:拣料/并板/盘点 3001 - 6000 ; 2: 出库 6001 -9000 ; 3:其他 9001 -9999
     * @param wrkMk 0:入出库 ; 1:其他
     * @return workNo(工作号)
     */
    public int getWorkNo(Integer wrkMk) {
@@ -48,25 +69,14 @@
        if (Cools.isEmpty(wrkLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }

        // 类型
        switch (wrkMk) {
            case 0:     // 入库 1 - 3000
                break;
            case 1:     // 拣料/并板/盘点 3001 - 6000
                break;
            case 2:     // 出库 6001 -9000
                break;
            case 3:     // 其他 9001 -9999
                break;
            default:
                break;
        }

        int workNo = wrkLastno.getWrkNo();
        int workNo = 0;
        // 入出库类型
        workNo = wrkLastno.getWrkNo();
        int sNo = wrkLastno.getSNo();
        int eNo = wrkLastno.getENo();

        workNo = workNo>=eNo ? sNo : workNo+1;

        while (true) {
            WrkMast wrkMast = wrkMastService.selectById(workNo);
            if (null != wrkMast) {
@@ -75,12 +85,10 @@
                break;
            }
        }
        // 修改序号记录
        if (workNo > 0){
            wrkLastno.setWrkNo(workNo);
            wrkLastnoService.updateById(wrkLastno);
        }
        // 检验
        if (workNo == 0) {
            throw new CoolException("生成工作号失败，请联系管理员");
        } else {
@@ -93,112 +101,344 @@

    /**
     * 检索库位号
     * @param whsType 类型 1:双深式货架
     * @param staDescId 路径ID
     * @param whsType     类型 1:双深式货架
     * @param staDescId   路径ID
     * @param sourceStaNo 源站
     * @param matNos 物料号集合
     * @param matNos      物料号集合
     * @return locNo 检索到的库位号
     */
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos) {
        StartupDto startupDto = new StartupDto();
        // 生成工作号
        int workNo = getWorkNo(WorkNoType.getWorkNoType(staDescId));
        startupDto.setWorkNo(workNo);
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto) {
        int start;
        int end;
        Integer matType = null;//物料类型
        //根据入库站，决定搜索指定堆垛机
        ArrayList<Integer> crnNos = new ArrayList<>();
        //根据入库站，找到库位组最内侧排
        ArrayList<Integer> rows = new ArrayList<>();
        switch (sourceStaNo) {
            case 103://103入库站
                whsType = 1;
                start = 1;
                end = 14;

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

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

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

                //分配8，14，15，21排
                rows.add(8);
                rows.add(14);
                rows.add(15);
                rows.add(21);
                break;
            default:
                throw new CoolException("检索库位失败，请联系管理员");
        }
        RowLastno rowLastno = rowLastnoService.selectById(whsType);
        if (Cools.isEmpty(rowLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }
        if (whsType == 1 || whsType == 2){
            int curRow = rowLastno.getCurrentRow();
            int sRow = rowLastno.getsRow();
            int eRow = rowLastno.geteRow();
            int crn_qty = rowLastno.getCrnQty();
            int rowCount = eRow - sRow + 1;
            // 目标堆垛机号
            int crnNo = 0;
            // 目标库位
            LocMast locMast = null;
        // 目标库位
        LocMast locMast = null;

            // 如果没有相近物料，则按规则轮询货架
            if (null == locMast) {
                // 获取目标站所在货架排号  todo:luxiaotao
                if (curRow == sRow) {
                    curRow = eRow;
                } else {
                    curRow = sRow;
        if (!Cools.isEmpty(matNos)) {
            for (String matNo : matNos) {
                Mat mat = matService.selectByMatnr(matNo);
                if (matType == null) {
                    matType = mat.getMatType();
                }
                crnNo = whsType;
//                Shelves shelves = new Shelves(rowCount, crn_qty);
//                curRow = shelves.start(curRow);
//                if (curRow < 0) {
//                    throw new CoolException("检索库位失败，请联系管理员");
//                }
//                for (List<Integer> node : shelves.nodes){
//                    if (node.contains(curRow)) {
//                        crnNo = shelves.nodes.indexOf(node) + 1;
//                        break;
//                    }
//                }
                if (matType != mat.getMatType()) {
                    throw new CoolException("混放物料类型不一致");
                }
            }

            basCrnpService.checkSiteStatus(crnNo);
            // 获取目标站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", staDescId)
                    .eq("stn_no", sourceStaNo)
                    .eq("crn_no", crnNo);
            StaDesc staDesc = staDescService.selectOne(wrapper);
            if (Cools.isEmpty(staDesc)) {
                throw new CoolException("入库路径不存在");
            if (matNos.size() > 1 && matType == 1) {
                //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
                throw new CoolException("物料类型和实际种类不一致");
            }
            BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
            int inQty = staNo.getInQty()==null?0:staNo.getInQty();
            if (staNo.getAutoing().equals("Y") && inQty<2) {
                // 查找库位
                if (locMast == null) {
                    locMast = locMastService.queryFreeLocMast(curRow);
                }
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("没有空库位");
                }
                String locNo = locMast.getLocNo();

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

                // 返回dto
                startupDto.setCrnNo(crnNo);
                startupDto.setSourceStaNo(sourceStaNo);
                startupDto.setStaNo(staNo.getDevNo());
                startupDto.setLocNo(locNo);
            } else {
                throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
            }
        } else {
            throw new CoolException(rowLastno.getWhsType()+"号库位排号分配规则不可用");
        }
        return startupDto;

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

        if (matType != null) {
            if (matType == 1) {//单品类型入库
                locMast = getLocNoStep2(locTypeDto, matNos, rows, crnNos);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                }
            } 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
                }
            } else if (matType == 3) {//低频混放类型
                locMast = getLocNoStep4(locTypeDto, crnNos);
                if (locMast != null) {
                    //找到库位，返回dto
                    return getLocNoFinalStep(staDescId, sourceStaNo, locMast);//返回dto
                }
            }
        }

        throw new CoolException("检索库位失败，请联系管理员");
    }

    public static void main(String[] args) {
        System.out.println(Arith.remainder(1, 4));
        System.out.println("0200201".substring(0, 2));
        String locNo = "0800201";
        int row = Integer.parseInt(locNo.substring(0, 2));
        double remainder = Arith.remainder(row, 4);
        int targetRow;
        if (remainder == 1) {
            // 得到当前库位的外围库位
            targetRow =  row + 1;
        } else if (remainder == 0) {
            // 得到当前库位的内围库位
            targetRow =  row - 1;
        } else {
            return;
    // 靠近摆放规则 --- 空托
    private LocMast getLocNoStep1(Integer staDescId, LocTypeDto locTypeDto,int start,int end) {
        LocMast locMast = null;
        if (staDescId == 10) {
            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 locMast0 = locMastService.findOutMost(groupLoc);
                    if (null != locMast0) {
                        // 浅库位符合尺寸检测
                        if (VersionUtils.locMoveCheckLocType(locMast0, locTypeDto)) {
                            // 浅库位对应堆垛机必须可用且无异常
                            if (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                                // 因库位移转、需预留空库位
                                if (locMastService.checkEmptyCount(locMast0, 10)) {
                                    locMast = locMast0;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        String zerofill = zerofill(String.valueOf(targetRow), 2)+locNo.substring(2);
        System.out.println(zerofill);

        return locMast;
    }

    //单品类型入库
    private LocMast getLocNoStep2(LocTypeDto locTypeDto, List<String> matNos, List<Integer> rows, List<Integer> crnNos) {
        LocMast locMast = null;
        //先找工作档
        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 (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                        // 因库位移转、需预留空库位
                        if (locMastService.checkEmptyCount(locMast0, 10)) {
                            locMast = locMast0;
                            break;
                        }
                    }
                }
            }
        }

        //找内侧空库位(非最外侧库位)
        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) {
            //随机可用堆垛机号
            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;
    }

    //高频类型入最外侧库位
    private LocMast getLocNoStep3(LocTypeDto locTypeDto, List<Integer> crnNos) {
        LocMast locMast = null;

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

        //找最外侧空库位
        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 (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;
                    }
                }
            }
        }

        return locMast;
    }

    //低频类型，直接找混放区域
    private LocMast getLocNoStep4(LocTypeDto locTypeDto, List<Integer> crnNos) {
        LocMast locMast = 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 (basCrnpService.checkSiteError(locMast0.getCrnNo(), true)) {
                    // 因库位移转、需预留空库位
                    if (locMastService.checkEmptyCount(locMast0, 10)) {
                        locMast = locMast0;
                    }
                }
            }
        }

        return locMast;
    }

    //返回dto
    private StartupDto getLocNoFinalStep(Integer staDescId, Integer sourceStaNo, LocMast locMast) {
        // 获取目标站
        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={}, crnNo={}", staDescId, sourceStaNo, locMast.getCrnNo());
            throw new CoolException("入库路径不存在");
        }

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

        String locNo = locMast.getLocNo();

        // 生成工作号
        int workNo = getWorkNo(0);

        // 返回dto
        StartupDto startupDto = new StartupDto();
        startupDto.setWorkNo(workNo);
        startupDto.setCrnNo(locMast.getCrnNo());
        startupDto.setSourceStaNo(sourceStaNo);
        startupDto.setStaNo(staNo.getDevNo());
        startupDto.setLocNo(locNo);
        return startupDto;
    }

    public static String zerofill(String msg, Integer count) {
@@ -215,4 +455,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;
        }
    }

}