#

luxiaotao1123

2021-01-02 9c0efa0805fe5522d5022efe185e92f9c9f96d66

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

@@ -7,10 +7,14 @@
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.Shelves;
import com.zy.common.model.StartupDto;
import com.zy.core.properties.SlaveProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@@ -36,11 +40,12 @@
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private LocDetlService locDetlService;

    /**
     * 生成工作号
     * @param wrkMk 0:入出库 ; 1:其他
     * @return workNo(工作号)
     */
    public int getWorkNo(Integer wrkMk) {
@@ -48,28 +53,25 @@
        if (Cools.isEmpty(wrkLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }
        int workNo = 0;
        // 入出库类型
        if (wrkLastno.getWrkMk() == 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) {
                    workNo = workNo>=eNo ? sNo : workNo+1;
                } else {
                    break;
                }
            }
            if (workNo > 0){
                wrkLastno.setWrkNo(workNo);
                wrkLastnoService.updateById(wrkLastno);
        int 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) {
                workNo = workNo>=eNo ? sNo : workNo+1;
            } else {
                break;
            }
        }
        // 修改序号记录
        if (workNo > 0){
            wrkLastno.setWrkNo(workNo);
            wrkLastnoService.updateById(wrkLastno);
        }
        // 检验
        if (workNo == 0) {
            throw new CoolException("生成工作号失败，请联系管理员");
        } else {
@@ -80,6 +82,7 @@
        return workNo;
    }


    /**
     * 检索库位号
     * @param whsType 类型 1:双深式货架
@@ -88,20 +91,24 @@
     * @param matNos 物料号集合
     * @return locNo 检索到的库位号
     */
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos) {
        if (sourceStaNo == 3) {
            whsType = 1;
        } else if (sourceStaNo == 7) {
            whsType = 2;
        } else {
            throw new CoolException("无效入库站");
        }
    @Transactional
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos, LocTypeDto locTypeDto) {
        StartupDto startupDto = new StartupDto();
        // 生成工作号
        int workNo = getWorkNo(0);
        if (sourceStaNo == 202) {
            whsType = 2;
        } else if (sourceStaNo == 205){
            whsType = 1;
        } else {
            throw new CoolException("库位排号分配");
        }
        startupDto.setWorkNo(workNo);
        RowLastno rowLastno = rowLastnoService.selectById(whsType);
        if (Cools.isEmpty(rowLastno)) {
            throw new CoolException("数据异常，请联系管理员");
        }
        if (rowLastno.getWhsType() == 1){
        if (whsType == 1 || whsType == 2){
            int curRow = rowLastno.getCurrentRow();
            int sRow = rowLastno.getsRow();
            int eRow = rowLastno.geteRow();
@@ -112,48 +119,77 @@
            // 目标库位
            LocMast locMast = null;

            // 同一天同规格货物靠近摆法规则
            // 靠近摆放规则 --- 同天同规格物料
            if (!Cools.isEmpty(matNos)) {
                List<String> locNos = locDetlService.getSameDetlToday(matNos.get(0));
                for (String locNo : locNos) {
                    // 获取排
                    int row = Integer.parseInt(locNo.substring(0, 2));
                    // 判断是否为深库位
                    double remainder = Arith.remainder(row, rowCount / crn_qty);
                    int targetRow;
                    if (remainder == 1) {
                        // 得到当前库位的外围库位
                        targetRow =  row + 1;
                    } else if (remainder == 0) {
                        // 得到当前库位的内围库位
                        targetRow =  row - 1;
                    } else {
                    if (Utils.isShallowLoc(slaveProperties, locNo)) {
                        continue;
                    }
                    String targetLocNo = zerofill(String.valueOf(targetRow), 2)+locNo.substring(2);
                    String shallowLocNo = Utils.getShallowLoc(slaveProperties, locNo);
                    // 检测目标库位是否为空库位
                    LocMast targetLocMast = locMastService.selectById(targetLocNo);
                    if (targetLocMast != null && targetLocMast.getLocSts().equals("O")) {
                        locMast = targetLocMast;
                    LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                    if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
                        locMast = shallowLoc;
                        crnNo = locMast.getCrnNo();
                        break;
                    }
                }
            }

            // 靠近摆放规则 --- 空托
            if (staDescId == 10) {
                List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D"));
                if (locMasts.size() > 0) {
                    for (LocMast loc : locMasts) {
                        if (Utils.isShallowLoc(slaveProperties, loc.getLocNo())) {
                            continue;
                        }
                        String shallowLocNo = Utils.getShallowLoc(slaveProperties,  loc.getLocNo());
                        // 检测目标库位是否为空库位
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        if (shallowLoc != null && shallowLoc.getLocSts().equals("O")) {
                            locMast = shallowLoc;
                            crnNo = locMast.getCrnNo();
                            break;
                        }
                    }
                }
            }

            // 如果没有相近物料，则按规则轮询货架
            if (null == locMast) {
                // 获取目标站所在货架排号
                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 (whsType == 1) {
                    // 获取目标站所在货架排号
                    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 (whsType == 2) {
                    // 获取目标站所在货架排号
                    Shelves shelves = new Shelves(rowCount, crn_qty);
                    curRow = shelves.start(curRow - 4);
                    if (curRow < 0) {
                        throw new CoolException("检索库位失败，请联系管理员");
                    }
                    for (List<Integer> node : shelves.nodes){
                        if (node.contains(curRow)) {
                            crnNo = shelves.nodes.indexOf(node) + 1;
                            break;
                        }
                    }
                    // 偏移量补偿
                    curRow = curRow + 4;
                    crnNo = crnNo + 1;
                }
            }

@@ -172,9 +208,20 @@
            if (staNo.getAutoing().equals("Y") && inQty<2) {
                // 查找库位
                if (locMast == null) {
                    locMast = locMastService.queryFreeLocMast(curRow);
                    if (Utils.isShallowLoc(slaveProperties, curRow)) {
                        Integer deepRow = Utils.getDeepRow(slaveProperties, curRow);
                        locMast = locMastService.queryFreeLocMast(deepRow, locTypeDto.getLocType1());
                    }
                    if (Cools.isEmpty(locMast)) {
                        locMast = locMastService.queryFreeLocMast(curRow, locTypeDto.getLocType1());
                    }
                }
                if (Cools.isEmpty(locMast)) {
                    // 轻货物找轻库位为空时，可以去找重库位仓
                    if (locTypeDto.getLocType1() == 1) {
                        locTypeDto.setLocType1((short) 2);
                        return getLocNo(1, staDescId, sourceStaNo, matNos, locTypeDto);
                    }
                    throw new CoolException("没有空库位");
                }
                String locNo = locMast.getLocNo();