1

ZY

2025-03-29 c65db22f67af8018ae7105ea00d8743e42835e13

 src/main/java/com/zy/asrs/task/handler/AutoMoveHandler.java

@@ -1,16 +1,17 @@
package com.zy.asrs.task.handler;


import com.baomidou.mybatisplus.enums.SqlLike;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.AgvLocDetlService;
import com.zy.asrs.service.AgvWrkDetlService;
import com.zy.asrs.service.AgvWrkMastService;
import com.zy.asrs.service.*;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
import com.zy.common.service.AgvCommonService;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -29,46 +30,136 @@
    @Autowired
    private AgvCommonService agvCommonService;
    @Autowired
    private AgvLocMastService agvLocMastService;
    @Autowired
    private AgvLocDetlService agvLocDetlService;
    @Autowired
    private AgvWrkDetlService agvWrkDetlService;
    @Autowired
    AgvBasDevpService agvBasDevpService;
    @Autowired
    private ConfigService configService;

    public ReturnT<String> start(AgvLocMast agvLocMast) {
//    public ReturnT<String> start(AgvLocMast agvLocMast) {
//        // locType 1. 自动， 2. 手动
//        if (agvLocMast.getLocType().equals("1")) {
//            return doAutoMove(agvLocMast);
//        } else if (agvLocMast.getLocType().equals("2")) {
//            return doHandMove(agvLocMast);
//        }
//        return SUCCESS;
//    }

    public ReturnT<String> start2(AgvWrkMast agvWrkMast) {
        // locType 1. 自动， 2. 手动
        if (agvLocMast.getLocType().equals("1")) {
            return doAutoMove(agvLocMast);
        } else if (agvLocMast.getLocType().equals("2")) {
            return doHandMove(agvLocMast);
        }
        doAutoMove2(agvWrkMast);
        return SUCCESS;
    }

    private ReturnT<String> doAutoMove(AgvLocMast agvLocMast) {
    public ReturnT<String> start3(AgvWrkMast agvWrkMast) {
        // locType 1. 自动， 2. 手动
        doHandMove2(agvWrkMast);
        return SUCCESS;
    }

    public ReturnT<String> start4(AgvWrkMast agvWrkMast) {
        // locType 1. 自动， 2. 手动
        doAutoMove3(agvWrkMast);
        return SUCCESS;
    }
    //根据库位的loctype值发送任务--弃用
//    private ReturnT<String> doAutoMove(AgvLocMast agvLocMast) {
//        Date now = new Date();
//        //查询工作档
//        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
//        if(!Cools.isEmpty(agvWrkMast)){
//            throw new CoolException("当前"+agvLocMast.getBarcode()+"货架码已在工作档中");
//        }
//        //检索库位，选择合适的库位
//        AgvLocMast LocMast = agvCommonService.getLocNo(3,agvLocMast.getLocType3(),false,true);
//        //生成工作档
//        AgvWrkMast mast = new AgvWrkMast();
//        //工作状态
//        mast.setWrkSts(201L);
//        //入出库类型
//        mast.setIoType(108);
//        mast.setIoTime(now);
//        //优先级
//        mast.setIoPri(300.0);
//        //源站点
//        mast.setSourceLocNo(agvLocMast.getLocNo());
//        //目标站点
//        mast.setLocNo(LocMast.getLocNo());
//        //货架编码
//        mast.setBarcode(agvLocMast.getBarcode());
//        //货架类型
//        mast.setWhsType(30);
//
//        mast.setAppeUser(9527L);
//        mast.setAppeTime(now);
//        mast.setModiUser(9527L);
//        mast.setModiTime(now);
//        mast.setLogErrMemo("doAutoMove");
//        if (!agvWrkMastService.insertByIncrease(mast)) {
//            throw new CoolException("保存工作档失败");
//        }
//
//        AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", LocMast.getLocNo()).eq("source_loc_no",agvLocMast.getLocNo()));
//        //生成工作档明细
//        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
//        agvLocDetls.forEach(agvLocDetl -> {
//            AgvWrkDetl wrkDetl = new AgvWrkDetl();
//            wrkDetl.setWrkNo(mast1.getWrkNo());
//            wrkDetl.sync(agvLocDetl);
//            wrkDetl.setSpecs("1-" + agvLocMast.getLocType3());
//            wrkDetl.setSuppCode(agvLocDetl.getSuppCode());
//            wrkDetl.setIoTime(now);
//            wrkDetl.setAppeUser(9527L);
//            wrkDetl.setAppeTime(now);
//            wrkDetl.setModiUser(9527L);
//            wrkDetl.setModiTime(now);
//            if (!agvWrkDetlService.insert(wrkDetl)) {
//                throw new CoolException("保存工作明细失败");
//            }
//        });
//        //更新目标库位状态
//        updateAgvLocMast(agvLocMast,"R");
//        updateAgvLocMast(LocMast,"S");
//
//        return SUCCESS;
//    }

    private ReturnT<String> doHandMove(AgvLocMast agvLocMast) {
        Date now = new Date();
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if(!Cools.isEmpty(agvWrkMast)){
            throw new CoolException("当前"+agvLocMast.getBarcode()+"货架码已在工作档中");
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        //检索库位，选择合适的库位
        AgvLocMast LocMast = agvCommonService.getLocNo(3,agvLocMast.getLocType3());
//        //检索库位，选择合适的库位
//        AgvLocMast LocMast = agvCommonService.getLocNo(3,agvLocMast.getLocType3());
        // 检索agv接驳位
        AgvBasDevp devpNo = agvCommonService.getDevpNo(3, 1);
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(201L);
        mast.setWrkSts(21L);
        //入出库类型
        mast.setIoType(108);
        mast.setIoType(111);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(LocMast.getLocNo());
        //容器编码
        mast.setLocNo(devpNo.getDevNo());
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //容器类型
        mast.setWhsType(30);
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));

        // 目标楼层
        mast.setPauseMk(agvLocMast.getLocType3().toString());

        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
@@ -78,7 +169,555 @@
            throw new CoolException("保存工作档失败");
        }

        AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", LocMast.getLocNo()).eq("source_loc_no",agvLocMast.getLocNo()));
        AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", devpNo.getDevNo()).eq("source_loc_no", agvLocMast.getLocNo()));
        //生成工作档明细
        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
        agvLocDetls.forEach(agvLocDetl -> {
            AgvWrkDetl wrkDetl = new AgvWrkDetl();
            wrkDetl.setWrkNo(mast1.getWrkNo());
            wrkDetl.sync(agvLocDetl);
            wrkDetl.setSpecs("1-" + agvLocMast.getLocType3());
            wrkDetl.setSuppCode(agvLocDetl.getSuppCode());
            wrkDetl.setIoTime(now);
            wrkDetl.setAppeUser(9527L);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiUser(9527L);
            wrkDetl.setModiTime(now);
            if (!agvWrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        });
        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        updateAgvBasDevp(devpNo, "S", null, agvLocMast.getBarcode());
        return SUCCESS;
    }


    private ReturnT<String> doAutoMove2(AgvWrkMast agvWrkMast) {
        Date now = new Date();
        String barcode = agvWrkMast.getBarcode();
        AgvLocMast locMast;
        if (Integer.parseInt(barcode.substring(0, 2)) == 31) {
            //检索库位，选择合适的库位
            locMast = agvCommonService.getLocByLocRule(6, 2, 1);
        } else {
            //检索库位，选择合适的库位
            locMast = agvCommonService.getLocNo(3, agvWrkMast.getCrnNo(), false, true);
        }

        if (Cools.isEmpty(locMast)) {
            log.info("暂无库位");
            return FAIL;
            //throw new CoolException("暂无库位");
        }
        AgvWrkMast workingMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", locMast.getLocNo()));
        if (!Cools.isEmpty(workingMast)) {
            log.info("当前库位正在进行入库，进行下一次轮询");
            return FAIL;
            //throw new CoolException("当前库位正在进行入库，进行下一次轮询");
        }
        agvWrkMast.setWrkSts(201L);
        agvWrkMast.setModiTime(new Date());
        agvWrkMast.setLocNo(locMast.getLocNo());
        agvWrkMast.setLogErrMemo("start2-doAutoMove2");
        agvWrkMastService.updateById(agvWrkMast);
        //更新目标库位状态
        updateAgvLocMast(locMast, "S");
        AgvLocMast locMast1 = agvLocMastService.selectOne(new EntityWrapper<AgvLocMast>().eq("loc_no", locMast.getLocNo()));
        log.info("自动调拨任务 ==> 源库位：{}，目标库位：{},库位状态{}", agvWrkMast.getSourceLocNo(), agvWrkMast.getLocNo(), locMast1.getLocSts());

        return SUCCESS;
    }

    private ReturnT<String> doAutoMove3(AgvWrkMast agvWrkMast) {
        Date now = new Date();
        //检索库位，选择合适的库位
        AgvLocMast locMast = agvCommonService.getLocNo(3, agvWrkMast.getCrnNo(), false, false);
        if (Cools.isEmpty(locMast)) {
            log.info("暂无库位");
            return FAIL;
            //throw new CoolException("暂无库位");
        }
        agvWrkMast.setWrkSts(201L);
        agvWrkMast.setLocNo(locMast.getLocNo());
        agvWrkMast.setLogErrMemo("start2-doAutoMove2");
        agvWrkMast.setModiTime(new Date());
        agvWrkMastService.updateById(agvWrkMast);
        //更新目标库位状态
        updateAgvLocMast(locMast, "S");

        return SUCCESS;
    }

    private ReturnT<String> doHandMove2(AgvWrkMast agvWrkMast) {
        Date now = new Date();
        String lev1 = agvWrkMast.getSourceLocNo().substring(agvWrkMast.getSourceLocNo().length() - 4).substring(0, 2);
        AgvBasDevp devpNo = new AgvBasDevp();
        if ("01".equals(lev1)) {
            devpNo = agvCommonService.getDevpNo(3, 1, "Y", "Y");
        } else {
            devpNo = agvCommonService.getDevpNo(3, 4, "Y", "Y");
        }

        if (Cools.isEmpty(devpNo)) {
            log.info("暂无空闲接驳位");
            return FAIL;
            //throw new CoolException("暂无空闲接驳位");
        }
        agvWrkMast.setWrkSts(201L);
        agvWrkMast.setLocNo(devpNo.getDevNo());
        agvWrkMast.setModiTime(new Date());
        agvWrkMast.setLogErrMemo("start3-doHandMove2");
        agvWrkMastService.updateById(agvWrkMast);
        agvWrkMast.setModiTime(new Date());
        updateAgvBasDevp(devpNo, "S", null, agvWrkMast.getBarcode());
        return SUCCESS;
    }

    /*
    更新目标库位信息
     */
    private void updateAgvLocMast(AgvLocMast locMast, String locSts) {
        locMast.setLocSts(locSts);
        agvLocMastService.updateById(locMast);
    }

    /*
    更新源站点信息
     */
    private void updateAgvBasDevp(AgvBasDevp agvBasDevp, String locSts) {
        if (!Cools.isEmpty(agvBasDevp)) {
            agvBasDevp.setLocSts(locSts);
            agvBasDevpService.updateById(agvBasDevp);
        }
    }

    private void updateAgvBasDevp(AgvBasDevp agvBasDevp, String locSts, Short continerType, String containerCode) {
        if (!Cools.isEmpty(agvBasDevp)) {
            agvBasDevp.setLocSts(locSts);
            agvBasDevp.setBarcode(containerCode);
            agvBasDevpService.updateById(agvBasDevp);
        }
    }

    public ReturnT<String> autoEmptyBack(AgvLocMast agvLocMast) {
        Date now = new Date();
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        //检索空闲接驳位，选择合适的接驳位
        AgvBasDevp devpNo = agvCommonService.getDevpNo(3, agvLocMast.getFloor());
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(21L);
        //入出库类型
        mast.setIoType(109);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(devpNo.getDevNo());
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));


        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("autoEmptyBack");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }

        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        updateAgvBasDevp(devpNo, "S", agvLocMast.getLocType2(), agvLocMast.getBarcode());
        return SUCCESS;
    }

    public ReturnT<String> autoEmptyBack3(AgvWrkMast agvWrkMast) {
        Date now = new Date();
        AgvBasDevp agvBasDevp = agvBasDevpService.selectByDevNo(agvWrkMast.getSourceLocNo());
        //检索空闲接驳位，选择合适的接驳位
        AgvLocMast locMast = agvCommonService.getLocNo(3, 1, true, true);
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("1楼暂无空库位");
        }
        //目标站点
        agvWrkMast.setWrkSts(201L);
        agvWrkMast.setLocNo(locMast.getLocNo());
        agvWrkMast.setModiUser(9527L);
        agvWrkMast.setModiTime(now);
        agvWrkMast.setLogErrMemo("autoEmptyBack3");
        if (!agvWrkMastService.updateById(agvWrkMast)) {
            throw new CoolException("保存工作档失败");
        }
        //更新目标库位状态
        updateAgvLocMast(locMast, "S");
        updateAgvBasDevp(agvBasDevp, "R");
        return SUCCESS;
    }

//    public ReturnT<String> autoEmptyBack2(AgvLocMast agvLocMast) {
//        Date now = new Date();
//        //查询工作档
//        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
//        if(!Cools.isEmpty(agvWrkMast)){
//            throw new CoolException("当前"+agvLocMast.getBarcode()+"货架码已在工作档中");
//        }
//        //检索库位，选择合适的库位
//        AgvLocMast LocMast = agvCommonService.getLocNo(3,1,true,true);
//        //生成工作档
//        AgvWrkMast mast = new AgvWrkMast();
//        //工作状态
//        mast.setWrkSts(201L);
//        //入出库类型
//        mast.setIoType(109);
//        mast.setIoTime(now);
//        //优先级
//        mast.setIoPri(300.0);
//        //源站点
//        mast.setSourceLocNo(agvLocMast.getLocNo());
//        //目标站点
//        mast.setLocNo(LocMast.getLocNo());
//        //货架编码
//        mast.setBarcode(agvLocMast.getBarcode());
//        //货架类型
//        mast.setWhsType(30);
//
//        mast.setAppeUser(9527L);
//        mast.setAppeTime(now);
//        mast.setModiUser(9527L);
//        mast.setModiTime(now);
//        mast.setLogErrMemo("autoEmptyBack2");
//        if (!agvWrkMastService.insertByIncrease(mast)) {
//            throw new CoolException("保存工作档失败");
//        }
//
//        //更新目标库位状态
//        updateAgvLocMast(agvLocMast,"R");
//        updateAgvLocMast(LocMast,"S");
//        return SUCCESS;
//    }

    public ReturnT<String> autoEmptyBack4(AgvLocMast agvLocMast) {
        Date now = new Date();
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        String floor = "";
        String locNo = "";
        Long wrkSts = 0L;
        Integer ioType = 0;
        AgvLocMast locMast = new AgvLocMast();
        if (agvLocMast.getFloor() == 3) {
            floor = "F3";
        } else if (agvLocMast.getFloor() == 2) {
            floor = "F2";
        } else if (agvLocMast.getFloor() == 1 && agvLocMast.getLev1() == 2) {
            floor = "02F1";
        }
        List<AgvWrkMast> agvWrkMasts = agvWrkMastService.selectList(new EntityWrapper<AgvWrkMast>().eq("io_type", 109).like("barcode", "30",SqlLike.RIGHT).like("source_loc_no", floor).or().eq("io_type", 113));
        if (agvWrkMasts.size() >= 5) {
            //log.error("暂停回流");
            return FAIL;
            //throw new CoolException("暂停回流");
        }
        //检索空闲可入接驳位 没有空闲可入接驳位 直接找库位
        AgvBasDevp devpNo = agvCommonService.getDevpNo(3, agvLocMast.getFloor(), "Y", "Y");
        if (!Cools.isEmpty(devpNo)) {
            locNo = devpNo.getDevNo();
            wrkSts = 21L;
            ioType = 109;
        } else {
            //检索库位，选择合适的库位
            locMast = agvCommonService.getLocNo(3, 1, true, true);
            locNo = locMast.getLocNo();
            wrkSts = 201L;
            ioType = 109;
        }

        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(wrkSts);
        //入出库类型
        mast.setIoType(ioType);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(locNo);
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));


        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("autoEmptyBack4");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }

        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        if (wrkSts == 21L) {
            updateAgvBasDevp(devpNo, "S", agvLocMast.getLocType2(), agvLocMast.getBarcode());
        } else {
            updateAgvLocMast(locMast, "S");
        }


        return SUCCESS;
    }


    public ReturnT<String> autoEmptyBackSiqi(AgvLocMast agvLocMast) {
        Date now = new Date();
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        String floor = "";
        String locNo = "";
        Long wrkSts = 0L;
        Integer ioType = 0;
        AgvLocMast locMast = new AgvLocMast();
        if (agvLocMast.getFloor() == 3) {
            floor = "F3";
        } else if (agvLocMast.getFloor() == 2) {
            floor = "F2";
        }
        List<AgvWrkMast> agvWrkMasts = agvWrkMastService.selectList(new EntityWrapper<AgvWrkMast>().eq("io_type", 109).like("barcode", "31", SqlLike.RIGHT).like("source_loc_no", floor).or().eq("io_type", 113));
        Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "RETURN_6_MAX"));
        if (config != null && !Cools.isEmpty(config.getValue())) {
            if (agvWrkMasts.size() >= Integer.parseInt(config.getValue())) {
                return FAIL;
            }
        } else {
            if (agvWrkMasts.size() >= 5) {
                return FAIL;
            }
        }
        //检索空闲可入接驳位 没有空闲可入接驳位 直接找库位
        AgvBasDevp devpNo = agvCommonService.getDevpNo(6, agvLocMast.getFloor(), "Y", "Y");
        if (!Cools.isEmpty(devpNo)) {
            locNo = devpNo.getDevNo();
            wrkSts = 21L;
            ioType = 109;
        } else {
            //检索库位，选择合适的库位
            locMast = agvCommonService.getLocByFloorAndLev1(6, 1, 2);
            locNo = locMast.getLocNo();
            wrkSts = 201L;
            ioType = 109;
        }
        if (locMast == null) {
            throw new CoolException("没有可用的库位");
        }
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(wrkSts);
        //入出库类型
        mast.setIoType(ioType);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(locNo);
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));


        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("autoEmptyBackSiqi");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }

        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        if (wrkSts == 21L) {
            updateAgvBasDevp(devpNo, "S", agvLocMast.getLocType2(), agvLocMast.getBarcode());
        } else {
            updateAgvLocMast(locMast, "S");
        }


        return SUCCESS;
    }


    public ReturnT<String> autoEmptyBack5(AgvBasDevp agvBasDevp) {
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvBasDevp.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvBasDevp.getBarcode() + "货架码已在工作档中");
        }
        Date now = new Date();
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvBasDevp.getDevNo());
        //货架编码
        mast.setBarcode(agvBasDevp.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvBasDevp.getBarcode().substring(0, 2)));

        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("autoEmptyBack5");
        // 判断 接驳点是否自动
        if ("Y".equals(agvBasDevp.getAutoing())) {
            //工作状态
            mast.setWrkSts(201L);
            //入出库类型
            mast.setIoType(109);
            //检索库位，选择合适的库位
            AgvLocMast locMast = agvCommonService.getLocNo(3, 1, true, true);
            mast.setLocNo(locMast.getLocNo());
            updateAgvLocMast(locMast, "S");
        } else {
            //工作状态
            mast.setWrkSts(212L);
            //入出库类型
            mast.setIoType(113);
            //目标站点
            mast.setLocNo("");
        }
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }
        //更新目标库位状态
        updateAgvBasDevp(agvBasDevp, "R");


        return SUCCESS;
    }

    public ReturnT<String> autoEmptyBack6(AgvBasDevp agvBasDevp) {
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvBasDevp.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvBasDevp.getBarcode() + "货架码已在工作档中");
        }
        Date now = new Date();
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(214L);
        //入出库类型
        mast.setIoType(113);
        //目标站点
        mast.setLocNo("");
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvBasDevp.getDevNo());
        //货架编码
        mast.setBarcode(agvBasDevp.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvBasDevp.getBarcode().substring(0, 2)));

        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("autoEmptyBack6");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }
        //更新目标库位状态
        updateAgvBasDevp(agvBasDevp, "R");


        return SUCCESS;
    }

    public ReturnT<String> autoTransfers(AgvLocMast agvLocMast, Integer maxTansk) {
        Date now = new Date();
        List<AgvLocDetl> locDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
        locDetls.forEach(agvLocDetl -> {
            if (agvLocDetl.getProcessSts().equals(1)) {
                throw new CoolException("当前库位有库存未加工");
            }
        });
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        //检索库位，选择合适的库位
        AgvLocMast LocMast = agvCommonService.getLocNo(3, 1, false, false);
        if (LocMast.getLev1() != 2) {
            //throw new CoolException("目标楼层不是吸塑二楼");
            return FAIL;
        }
        List<AgvWrkMast> agvWrkMasts = agvWrkMastService.selectList(new EntityWrapper<AgvWrkMast>().like("loc_no", "02F1").like("source_loc_no", "F1").eq("io_type", 12));
        if (agvWrkMasts.size() >= maxTansk) {
            throw new CoolException("自动移库任务已到设定最大值：" + maxTansk);
        }
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(201L);
        //入出库类型
        mast.setIoType(12);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(LocMast.getLocNo());
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));


        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("doAutoMove");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }

        AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", LocMast.getLocNo()).eq("source_loc_no", agvLocMast.getLocNo()));
        //生成工作档明细
        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
        agvLocDetls.forEach(agvLocDetl -> {
@@ -95,12 +734,93 @@
                throw new CoolException("保存工作明细失败");
            }
        });

        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        updateAgvLocMast(LocMast, "S");

        return SUCCESS;
    }

    private ReturnT<String> doHandMove(AgvLocMast agvLocMast) {
    /**
     * 四期，跨层移库，1楼到2楼，2楼到1楼
     *
     * @param agvLocMast
     * @param maxTansk
     * @return
     */
    public ReturnT<String> autoTransfersV2(AgvLocMast agvLocMast, Integer maxTansk) {
        Date now = new Date();
        List<AgvLocDetl> locDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
        locDetls.forEach(agvLocDetl -> {
            if (agvLocDetl.getProcessSts().equals(1)) {
                throw new CoolException("当前库位有库存未加工");
            }
        });
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        AgvLocMast LocMast;
        if (agvLocMast.getLev1() == 1) {
            //检索库位，选择合适的库位
            LocMast = agvCommonService.getLocByLocRule2(3, 1, 2);
        } else {
            LocMast = agvCommonService.getLocByLocRule2(3, 1, 1);
        }
        List<AgvWrkMast> agvWrkMasts = agvWrkMastService.selectList(new EntityWrapper<AgvWrkMast>().eq("io_type", 12));
        if (agvWrkMasts.size() >= maxTansk) {
            throw new CoolException("自动移库任务已到设定最大值：" + maxTansk);
        }
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        mast.setWrkSts(201L);
        //入出库类型
        mast.setIoType(12);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(LocMast.getLocNo());
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(Integer.parseInt(agvLocMast.getBarcode().substring(0, 2)));


        mast.setAppeUser(9527L);
        mast.setAppeTime(now);
        mast.setModiUser(9527L);
        mast.setModiTime(now);
        mast.setLogErrMemo("doAutoMoveV4");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }

        AgvWrkMast mast1 = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", LocMast.getLocNo()).eq("source_loc_no", agvLocMast.getLocNo()));
        //生成工作档明细
        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
        agvLocDetls.forEach(agvLocDetl -> {
            AgvWrkDetl wrkDetl = new AgvWrkDetl();
            wrkDetl.setWrkNo(mast1.getWrkNo());
            wrkDetl.sync(agvLocDetl);
            wrkDetl.setSuppCode(agvLocDetl.getSuppCode());
            wrkDetl.setIoTime(now);
            wrkDetl.setAppeUser(9527L);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiUser(9527L);
            wrkDetl.setModiTime(now);
            if (!agvWrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        });
        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "R");
        updateAgvLocMast(LocMast, "S");

        return SUCCESS;
    }
}