优化订单同步逻辑及库位查找

zhangc

2024-12-25 ab14726215678ac69adfeafbd845ebc5b0776ea2

 src/main/java/com/zy/asrs/service/impl/AgvMobileServiceImpl.java

@@ -5,10 +5,12 @@
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.CombParam;
import com.zy.asrs.entity.param.MobileAdjustParam;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CodeDetectionUtil;
import com.zy.common.model.DetlDto;
import com.zy.common.service.AgvCommonService;
import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -18,6 +20,7 @@
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
@@ -42,6 +45,18 @@
    private AgvLocDetlService agvLocDetlService;
    @Autowired
    private AgvWrkMastService agvWrkMastService;
    @Autowired
    private AgvWorkService agvWorkService;
    @Autowired
    private AgvWrkDetlService agvWrkDetlService;
    @Autowired
    private AgvLocMastService agvLocMastService;
    @Autowired
    private AgvCommonService agvCommonService;
    @Autowired
    private AgvWrkMastLogService agvWrkMastLogService;
    @Autowired
    private AgvWrkDetlLogService agvWrkDetlLogService;


    /*
@@ -53,59 +68,161 @@
        if (Cools.isEmpty(param.getBarcode(), param.getCombMats())) {
            throw new CoolException(BaseRes.PARAM);
        }
        if (!CodeDetectionUtil.barcodeDetection(param.getBarcode())) {
            throw new CoolException(param.getBarcode() + "货架码有误，请正确扫码！！！");
        }
        param.setContainerType(Short.valueOf(param.getBarcode().substring(0, 2)));

        //检查是否已存在相同的托盘条码，存在则抛出异常
        if (agvWaitPakinService.selectCount(new EntityWrapper<AgvWaitPakin>().eq("supp_code", param.getBarcode())) > 0) {
            throw new CoolException(param.getBarcode() + "料想码已存在AGV入库通知档中");
//        //检查是否已存在相同的货架条码，存在则抛出异常
//        if (agvWaitPakinService.selectCount(new EntityWrapper<AgvWaitPakin>().eq("supp_code", param.getBarcode())) > 0) {
//            throw new CoolException(param.getBarcode() + "料想码已存在AGV入库通知档中");
//        }

        //检查库存是否有相同货架，存在则抛出异常
        if (!Cools.isEmpty(agvLocDetlService.selectOne(new EntityWrapper<AgvLocDetl>().eq("supp_code", param.getBarcode())))) {
            throw new CoolException(param.getBarcode() + "货架码已存在AGV库存明细中");
        }

        //检查库存是否有相同料箱，存在则抛出异常
        if(!Cools.isEmpty(agvLocDetlService.selectOne(new EntityWrapper<AgvLocDetl>().eq("supp_code",param.getBarcode())))){
            throw new CoolException(param.getBarcode() + "料箱码已存在AGV库存明细中");
        //检查库存是否有相同货架，存在则抛出异常
        if (!Cools.isEmpty(agvLocMastService.selectOne(new EntityWrapper<AgvLocMast>().eq("barcode", param.getBarcode())))) {
            throw new CoolException(param.getBarcode() + "货架码已存在AGV库存主档中");
        }

        //查看工作档是否有相同料箱，存在则抛出异常
        if(!Cools.isEmpty(agvWrkMastService.selectByContainerCode(param.getBarcode()))){
            throw new CoolException(param.getBarcode() + "料箱码已存在AGV工作档中");
        //查看工作档是否有相同货架，存在则抛出异常
        if (!Cools.isEmpty(agvWrkMastService.selectByContainerCode(param.getBarcode()))) {
            throw new CoolException(param.getBarcode() + "货架码已存在AGV工作档中");
        }

        if (Cools.isEmpty(param.getOrderNo())) {
            //无单组托
            NoOrderComb(param,userId);
        }else {
            NoOrderComb(param, userId);
        } else {
            //有单组托
            OrderComb(param,userId);
            OrderComb(param, userId);
        }

        if(StringUtils.isEmpty(param.getLocno())){
        if (StringUtils.isEmpty(param.getLocno())) {
            return "组托成功";
        }else {
            combBinding(param.getBarcode(),param.getLocno());
        } else {
            combBinding(param.getBarcode(), param.getLocno(), param.getContainerType());
            return "组托成功，绑定站点成功";
        }

    }

    /*
    再次拣料
     */
    @Override
    @Transactional
    public synchronized String pickAgain(PickParam pickParams, Long userId) {
        Date now = new Date();
        List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", pickParams.getLocNo()));

        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("wrk_no", pickParams.getWrkNo()));

        if (Cools.isEmpty(agvWrkMast)) {
            return "失败，未查到工作主档，工作号：" + pickParams.getWrkNo();
        }
        for (PickParam.Pick pick : pickParams.getPicks()) {
            if (pick.getCount().equals(0D)) continue;

            Double count = 0.0D;
            AgvWrkDetl agvWrkDetl = agvWrkDetlService.selectOne(new EntityWrapper<AgvWrkDetl>().eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()).eq("supp_code", pick.getSuppCode()));

            if (Cools.isEmpty(agvWrkDetl)) {
                agvWrkDetl = new AgvWrkDetl();
                Mat mat = matService.selectByMatnr(pick.getMatnr());
                if (Cools.isEmpty(mat)) {
                    throw new CoolException(pick.getMatnr() + "商品不存在");
                }
                agvWrkDetl.sync(mat);
                agvWrkDetl.setWrkNo(pickParams.getWrkNo());
                agvWrkDetl.setOrderNo(pick.getOrderNo());
                agvWrkDetl.setIoTime(agvWrkMast.getIoTime());
                agvWrkDetl.setAnfme(pick.getCount()); // 数量
                agvWrkDetl.setSuppCode(pick.getSuppCode()); // 货架条码
                agvWrkDetl.setAppeUser(userId);
                agvWrkDetl.setAppeTime(now);
                agvWrkDetl.setModiUser(userId);
                agvWrkDetl.setModiTime(now);
                agvWrkDetl.setThreeCode(pick.getThreeCode());
                agvWrkDetlService.insert(agvWrkDetl);
            } else {
                Double anfme = agvWrkDetl.getAnfme() + pick.getCount();
                agvWrkDetl.setIoTime(agvWrkMast.getIoTime());
                agvWrkDetl.setAnfme(anfme);
                agvWrkDetl.setModiTime(now);
                agvWrkDetlService.update(agvWrkDetl, new EntityWrapper<AgvWrkDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("supp_code", pick.getSuppCode()));

            }
            // 库存校验
            Optional<AgvLocDetl> first = agvLocDetls.stream().filter(agvLocDetl -> agvLocDetl.getThreeCode().equals(pick.getThreeCode()))
                    .filter(agvLocDetl -> agvLocDetl.getMatnr().equals(pick.getMatnr())).findFirst();
            if (first.isPresent()) {
                AgvLocDetl agvLocDetl = first.get();
                if (agvLocDetl.getAnfme() < agvWrkDetl.getAnfme()) {
                    throw new CoolException("拣料数量不能大于库存数量");
                }
            } else {
                throw new CoolException("拣料数量不能大于库存数量,存库不存在");
            }

            // 更新订单
            OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("order_no", pick.getOrderNo()).eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()));
            orderDetl.setQty(orderDetl.getQty() + pick.getCount());
            if (!orderDetlService.update(orderDetl, new EntityWrapper<OrderDetl>().eq("order_no", pick.getOrderNo()).eq("matnr", pick.getMatnr()).eq("three_code", pick.getThreeCode()))) {
                throw new CoolException("修改订单明细失败，请联系管理员" + pick.getOrderNo() + pick.getMatnr());
            }
            Order order = orderService.selectByNo(orderDetl.getOrderNo());
            if (order.getSettle() == 1) {
                if (!orderService.updateSettle(order.getId(), 2L, userId)) {
                    throw new CoolException("再次拣料：更新订单状态失败！");
                }
            }
        }
        //  确认是否全部出库
        double totleWrkdetl = 0.0;
        double totleLocdetl = 0.0;
        List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", pickParams.getWrkNo()));
        for (AgvLocDetl agvLocDetl : agvLocDetls) {
            totleLocdetl = totleLocdetl + agvLocDetl.getAnfme();
        }
        for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
            totleWrkdetl = totleWrkdetl + agvWrkDetl.getAnfme();
        }
        if (totleWrkdetl >= totleLocdetl) {
            agvWrkMast.setIoType(101);
            agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", pickParams.getWrkNo()));

        }
//        agvLocDetls.size() == 1


        return "拣料成功";
    }

    /*
    AGV无单组托
     */
    private void NoOrderComb(CombParam param, Long userId){
        List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param,null);
    private void NoOrderComb(CombParam param, Long userId) {
        List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param, null);

        //用于统一一个托盘下的入库通知档的生成时间
        //用于统一一个货架下的入库通知档的生成时间
        Date now = new Date();
        detlDtos.forEach(detlDto -> {
            syncWaitPakin(detlDto,"",param.getBarcode(),userId,now);
            syncWaitPakin(detlDto, "", param.getBarcode(), userId, now);
        });
    }


    /*
    AGV有单组托
     */
    private void OrderComb(CombParam param, Long userId){
    private void OrderComb(CombParam param, Long userId) {
        //关联组托
        Order order = orderService.selectByNo(param.getOrderNo());
        if(Cools.isEmpty(order)){
        if (Cools.isEmpty(order)) {
            throw new CoolException("单据编号不存在");
        }
        //订单状态2以上为完成或者取消的订单
@@ -113,12 +230,12 @@
            throw new CoolException("单据编号已过期");
        }
        // 用于生成入库通知档所需参数
        List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param,order);
        //用于统一一个托盘下的入库通知档的生成时间
        List<DetlDto> detlDtos = mappingDetlDtoByCombMat(param, order);
        //用于统一一个货架下的入库通知档的生成时间
        Date now = new Date();
        for (DetlDto detlDto : detlDtos) {
            //同步生成入库通知档
            syncWaitPakin(detlDto,order.getOrderNo(),param.getBarcode(),userId,now);
            syncWaitPakin(detlDto, order.getOrderNo(), param.getBarcode(), userId, now);
        }
        //修改单据状态为2.作业中
        orderService.updateSettle(order.getId(), 2L, userId);
@@ -127,19 +244,19 @@
    /*
    根据PDA扫码所传的物料信息参数映射为DetlDto
     */
    private List<DetlDto> mappingDetlDtoByCombMat(CombParam param, Order order){
    private List<DetlDto> mappingDetlDtoByCombMat(CombParam param, Order order) {
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getCombMats().forEach(combMat -> {

            if(!Cools.isEmpty(order)){
            if (!Cools.isEmpty(order)) {
                //检查入库数量
                checkOrderQty(order,combMat);
                checkOrderQty(order, combMat);
            }

            DetlDto detlDto = new DetlDto(combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(), combMat.getIsoseq(),combMat.getContainerCode());
            //同一托盘下相同物料信息和批号转为一个入库通知档
            DetlDto detlDto = new DetlDto(combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(), combMat.getIsoseq(), combMat.getContainerCode(), param.getLocType(), combMat.getProcessSts());
            //同一货架下相同物料信息和批号转为一个入库通知档
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto one = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch(), detlDto.getCsocode(), detlDto.getIsoseq(),null);
                DetlDto one = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch(), detlDto.getCsocode(), detlDto.getIsoseq(), detlDto.getContainerCode());
                assert one != null;
                one.setAnfme(one.getAnfme() + detlDto.getAnfme());
            } else {
@@ -153,17 +270,17 @@
    /*
    检查入库数量是否小于等于单据数量，合理则修改OrderDetl作业数量信息，否则抛出异常
     */
    private void checkOrderQty(Order order, CombParam.CombMat combMat){
    private void checkOrderQty(Order order, CombParam.CombMat combMat) {
        // 订单明细数量校验，如果作业数量大于单据数量则抛出异常
        OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getCsocode(),combMat.getIsoseq());
        if(Cools.isEmpty(orderDetl)){
        OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getCsocode(), combMat.getIsoseq());
        if (Cools.isEmpty(orderDetl)) {
            throw new CoolException("未匹配到该单据下的物料");
        }
        if (combMat.getAnfme() > orderDetl.getEnableQty()) {
            throw new CoolException(orderDetl.getMatnr() + "入库数量不合法");
        }
        // 修改订单明细数量
        if (!orderDetlService.increase(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(),combMat.getIsoseq())) {
        if (!orderDetlService.increase(order.getId(), combMat.getMatnr(), combMat.getBatch(), combMat.getAnfme(), combMat.getCsocode(), combMat.getIsoseq())) {
            throw new CoolException("修改单据明细数量失败");
        }
    }
@@ -171,17 +288,22 @@
    /*
    同步生成AGV入库通知档数据
     */
    private void syncWaitPakin(DetlDto detlDto, String orderNo, String zpallet, Long userId, Date now ){
    private void syncWaitPakin(DetlDto detlDto, String orderNo, String zpallet, Long userId, Date now) {
        Mat mat = matService.selectByMatnr(detlDto.getMatnr());
        if (Cools.isEmpty(mat)) {
            throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
        }
        OrderDetl orderDetl = orderDetlService.selectItem(orderNo, mat.getMatnr(), detlDto.getBatch(), detlDto.getCsocode());
        AgvWaitPakin waitPakin = new AgvWaitPakin();
        waitPakin.sync(mat);
        if (orderDetl != null) {
            waitPakin.setWeight(orderDetl.getWeight());
            waitPakin.setVolume(orderDetl.getVolume());
        }
        waitPakin.setOrderNo(orderNo);   // 单据编号
        waitPakin.setBatch(detlDto.getBatch());     // 序列码
        //waitPakin.setZpallet(zpallet);   // 托盘码
        waitPakin.setSuppCode(zpallet);   // 托盘码
        //waitPakin.setZpallet(zpallet);   // 货架码
        waitPakin.setSuppCode(zpallet);   // 货架码
        waitPakin.setIoStatus("N");     // 入出状态
        waitPakin.setAnfme(detlDto.getAnfme());  // 数量
        waitPakin.setStatus("Y");    // 状态
@@ -190,6 +312,10 @@
        waitPakin.setThreeCode(detlDto.getCsocode());
        //销售订单行号
        waitPakin.setDeadTime(detlDto.getIsoseq());

        waitPakin.setLocType(detlDto.getLocType());

        waitPakin.setProcessSts(detlDto.getProcessSts());


        waitPakin.setAppeUser(userId);
@@ -215,42 +341,603 @@
    }

    @Override
    public void combBinding(String barcode, String stationCode) {
    public void combBinding(String barcode, String stationCode, Short containerType) {

        if(Cools.isEmpty(agvWaitPakinService.selectByContainerCode(barcode))){
            throw new CoolException("该料箱未组托，无法绑定站点");
        AgvBasDevp agvBasDevp = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("dev_no", stationCode));

        if (Cools.eq(agvBasDevp.getBarcode(), barcode)) {
            return;
        }

        AgvBasDevp agvBasDevp = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("barcode", barcode));

        if(!Cools.isEmpty(agvBasDevp)){
            throw new CoolException(barcode + "已经绑定在"+ agvBasDevp.getDevNo() +"站点");
        if (Cools.isEmpty(agvWaitPakinService.selectByContainerCode(barcode))) {
            throw new CoolException("该货架未组托，无法绑定站点");
        }

        agvBasDevp = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("dev_no",stationCode));
        if(agvBasDevp == null){
        AgvBasDevp agvBasDevp1 = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>().eq("barcode", barcode));

        if (!Cools.isEmpty(agvBasDevp1)) {
            throw new CoolException(barcode + "已经绑定在" + agvBasDevp.getDevNo() + "站点");
        }

        if (agvBasDevp == null) {
            throw new CoolException(stationCode + "站点信息错误");
        }
        if(!"O".equals(agvBasDevp.getLocSts())){
        if (!"O".equals(agvBasDevp.getLocSts())) {
            throw new CoolException(stationCode + "该站点货位状态非空");
        }
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", agvBasDevp.getDevNo()));
        if(!Cools.isEmpty(agvWrkMast)){
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException(stationCode + "该站点已被工作号为" + agvWrkMast.getWrkNo() + "占用，无法绑定");
        }

        agvBasDevp.setBarcode(barcode);
        agvBasDevp.setLocSts("F");
        agvBasDevpService.update(agvBasDevp,(new EntityWrapper<AgvBasDevp>().eq("dev_no",stationCode)));
        agvBasDevp.setLocType2(containerType);
        agvBasDevpService.update(agvBasDevp, (new EntityWrapper<AgvBasDevp>().eq("dev_no", stationCode)));
    }

    public List<AgvBasDevp> getAgvBasDevpByFloor(int floor) {
        EntityWrapper<AgvBasDevp> wrapper = new EntityWrapper<>();
        wrapper.eq("floor",floor).eq("cache_shelves","Y").eq("loc_sts","F");
        wrapper.eq("floor", floor).eq("cache_shelves", "Y").eq("loc_sts", "F");
        List<AgvBasDevp> agvBasDevpList = agvBasDevpService.selectList(wrapper);
        return agvBasDevpList.stream().filter(agvBasDevp -> {
            return !Cools.isEmpty(agvWaitPakinService.selectByContainerCode(agvBasDevp.getBarcode()));
        }).collect(Collectors.toList());
    }

    @Override
    public void pakinEmpty(String devNo, boolean pakin) {
        //当前站点信息
        AgvBasDevp agvBasDevp = agvBasDevpService.selectById(devNo);
        //寻找相同类型的库位

        //生成空盘工作档

        //更改库位状态以及站点状态
    }

    @Override
    public void pakoutEmpty(String devNo) {

    }

    /*
       手动移库
    */
    @Override
    @Transactional
    public String handControlLocMove(LocMoveParam param, Long userId) {
        String fl = String.valueOf(param.getFloor());
        short floor = (short) Integer.parseInt(fl.substring(0, 1));
        switch (param.getFloor()) {
            case "1F01":
                floor = 1;
                break;
            case "1F02":
                floor = 4;
                break;
            case "2F":
                floor = 2;
                break;
            case "3F":
                floor = 3;
                break;
        }
        Integer ioType = 0;
        AgvLocMast agvLocMast = agvLocMastService.selectOne(new EntityWrapper<AgvLocMast>().eq("loc_no", param.getLocNo()));
        if (Cools.isEmpty(agvLocMast)) {
            throw new CoolException("当前库位为空，请检查库位！");
        }
//        if (agvLocMast.getLocSts() == "F") {
//            return R.error("当前库位不为在库，或者空货架，不支持移库");

        // 校验楼层
        if (agvLocMast.getLocType1() != 3) { // 不为箱壳区域
            if (agvLocMast.getFloor() != floor) {
                throw new CoolException("当前库位不支持跨楼层转移");
            } else {
                ioType = 11;
            }
        } else {
            if (agvLocMast.getFloor() != floor) {
                if (agvLocMast.getFloor() == 1 && (floor == 2 || floor == 3)) {
                    throw new CoolException("当前库位请选择调拨单调拨！");
                } else if ((agvLocMast.getFloor() == 2 || agvLocMast.getFloor() == 3) && (floor == 1 || floor == 4)) {
                    throw new CoolException("当前库位请选择调拨回流单回退！");
                } else {
                    ioType = 12;
                }
            } else {
                if (agvLocMast.getFloor() == 1) {
                    if (agvLocMast.getLev1() == 1 && floor == 1) {
                        ioType = 11;
                    } else {
                        ioType = 12;
                    }
                } else {
                    ioType = 11;
                }
            }
        }
        Date now = new Date();
        //查询工作档
        AgvWrkMast agvWrkMast = agvWrkMastService.selectByContainerCode(agvLocMast.getBarcode());
        if (!Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("当前" + agvLocMast.getBarcode() + "货架码已在工作档中");
        }
        //检索库位，选择合适的库位
        AgvLocMast locMast = null;
        if (floor == 1) {
            locMast = agvCommonService.getLocNo(agvLocMast.getLocType1(), floor, true, false);
        } else {
            locMast = agvCommonService.getLocNo(agvLocMast.getLocType1(), floor, false, false);
        }

        // 目标楼层去 吸塑2楼
        if (floor == 4) {
            if (locMast.getLev1() == 1) {
                throw new CoolException("吸塑一楼没有空库位可以移库！");
            }

        }

        if (Cools.isEmpty(locMast)) {
            throw new CoolException("当前楼层没有空库位");
        }
        //生成工作档
        AgvWrkMast mast = new AgvWrkMast();
        //工作状态
        if (ioType == 121) {
            mast.setWrkSts(11L);
        } else {
            mast.setWrkSts(201L);
        }
        //入出库类型
        mast.setIoType(ioType);
        mast.setIoTime(now);
        //优先级
        mast.setIoPri(300.0);
        //源站点
        mast.setSourceLocNo(agvLocMast.getLocNo());
        //目标站点
        mast.setLocNo(locMast.getLocNo());
        //货架编码
        mast.setBarcode(agvLocMast.getBarcode());
        //货架类型
        mast.setWhsType(30);

        mast.setAppeUser(userId);
        mast.setAppeTime(now);
        mast.setModiUser(userId);
        mast.setModiTime(now);
        mast.setLogErrMemo("handControlLocMove");
        if (!agvWrkMastService.insertByIncrease(mast)) {
            throw new CoolException("保存工作档失败");
        }
        if (agvLocMast.getLocSts().equals("F")) {
            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("保存工作明细失败");
                }
            });
        }

//        // 如果当前任务是箱壳二三楼回退一楼的 回滚调拨单
//        if (ioType == 12 && locMast.getFloor() == 1 && floor != 4 && agvLocMast.getFloor() != 1) {
//            List<AgvLocDetl> agvLocDetls = agvLocDetlService.selectList(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvLocMast.getLocNo()));
//            for (AgvLocDetl agvLocDetl : agvLocDetls) {
//                OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("three_code", agvLocDetl.getThreeCode()).eq("matnr", agvLocDetl.getMatnr()).eq("source", 33));
//                if (Cools.isEmpty(orderDetl)) {
//                    throw new CoolException("当前物料的调拨单不存在！");
//                }
//                Order order = orderService.selectByNo(orderDetl.getOrderNo());
//                if (Cools.isEmpty(order)) {
//                    throw new CoolException("当前物料的调拨单不存在！");
//                }
//                if (order.getSettle() == 4L) {
//                    if (!orderService.updateSettle(order.getId(),2L,userId)) {
//                        throw new CoolException("调拨单回滚异常!");
//                    }
//                }
//                orderDetl.setQty(orderDetl.getQty() - agvLocDetl.getAnfme());
//                if (!orderDetlService.updateById(orderDetl)) {
//                    throw new CoolException("保存工作明细失败");
//                }
//            }
//        }
        //更新目标库位状态
        updateAgvLocMast(agvLocMast, "P");
        updateAgvLocMast(locMast, "Q");
        return "ok";
    }

    /*
       调拨离场
    */
    @Override
    @Transactional
    @Synchronized
    public String allocationOut(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        if (Cools.isEmpty(param.getBarcode())) {
            throw new CoolException("请输入货架码");
        }
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", param.getDevNo()));
        Integer oldWrkNo = agvWrkMast.getWrkNo();
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("工作档中没有此站点任务");
        }
        if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
            throw new CoolException("当前货架码与任务不匹配");
        }
        if (!agvWrkMast.getWrkSts().equals(207L) && !agvWrkMast.getWrkSts().equals(205L)) {
            throw new CoolException("当前工作状态:" + agvWrkMast.getWrkSts$() + "不符合离场条件");
        }
        if (agvWrkMast.getWrkSts().equals(205L)) {
            // 库位 -- 接驳位 / 库位
            if (agvWrkMast.getLocNo().substring(0, 2).equals("DB")) {
                agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getLocNo(), "F", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
                // 接驳位 -- 库位
            } else {
                agvLocMastService.updateLocStsByLocNo(agvWrkMast.getLocNo(), "D", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
            }

            // 接驳位 -- 库位
            if (agvWrkMast.getSourceLocNo().substring(0, 2).equals("DB")) {
                agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getSourceLocNo(), "O", "", (short) 0);
                // 库位 -- 接驳位 / 库位
            } else {
                //修改源库位状态为O
                agvLocMastService.updateLocStsByLocNo(agvWrkMast.getSourceLocNo(), "O", "", agvWrkMast.getWhsType().shortValue(), "", (short) 0);
                //更新目标库位明细 101.出库 删除源库位库存明细
                agvLocDetlService.delete(new EntityWrapper<AgvLocDetl>().eq("loc_no", agvWrkMast.getSourceLocNo()));
            }
        }

        //生成AGV工作历史档 + 生成AGV工作明细历史档
        agvWrkMastLogService.save(agvWrkMast);
        agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
        //删除AGV工作档
        agvWrkMastService.deleteById(agvWrkMast);
        //生成工作档
        AgvWrkMast wrkMast = createWrkMast(111, 210L, "", "", agvWrkMast.getBarcode(), now, userId, 30, agvWrkMast.getCrnNo());
        // 更新工作明细
        List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", agvWrkMast.getBarcode()));
        for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
            agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
            // 保持工作档明细
            agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
            agvWrkDetl.setModiUser(userId);
            agvWrkDetl.setModiTime(now);
            agvWrkDetl.setIoTime(now);
            if (!agvWrkDetlService.insert(agvWrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        }
        // 更新站点状态
//        agvLocMastService.updateLocStsByLocNo(agvWrkMast.getSourceLocNo(),"O","",null);
        // 更新源库位状态
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvWrkMast.getLocNo(), "O", "", agvWrkMast.getWhsType().shortValue());

        //删除AGV工作明细档
        agvWrkDetlService.delete(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", oldWrkNo));
        return "ok";
    }

    /*
       调拨进场
    */
    @Override
    @Transactional
    public String allocationIn(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()));
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("暂无当前货架码的任务");
        }
        if (agvWrkMast.getIoType() != 111) {
            throw new CoolException("非手动调拨任务，不支持次功能");
        }
        if (!Cools.isEmpty(agvWrkMast.getSourceLocNo())) {
            throw new CoolException("当前货架码任有源库位，请确认");
        }
        AgvBasDevp agvBasDevp = agvBasDevpService.selectByDevNo(param.getDevNo());
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("工作档中没有此货架任务");
        }
        if (agvWrkMast.getCrnNo() != agvBasDevp.getFloor()) {
            throw new CoolException("请移动到->" + agvWrkMast.getCrnNo() + "楼入库点入库");
        }
        AgvLocMast locNo = agvCommonService.getLocNo(3, 1, false, true);
        //工作状态
        agvWrkMast.setWrkSts(211L);
        //入出库类型
        agvWrkMast.setIoType(112);
        agvWrkMast.setSourceLocNo(param.getDevNo());
        agvWrkMast.setModiUser(userId);
        agvWrkMast.setModiTime(now);
        if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
            throw new CoolException("更新工作档失败");
        }
        //
        agvLocMastService.updateLocStsByLocNo(locNo.getLocNo(), "S", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
        // 更新源库位状态
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "R", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
        //删除AGV工作档
        return "ok";
    }

    /*
       空架离场
    */
    @Override
    @Transactional
    @Synchronized
    public String empOut(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        if (Cools.isEmpty(param.getBarcode())) {
            throw new CoolException("请输入货架码");
        }
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
        Integer oldWrkNo = agvWrkMast.getWrkNo();
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("工作档中没有此站点任务");
        }
        if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
            throw new CoolException("当前货架码与任务不匹配");
        }
        agvWrkMast.setModiTime(new Date());
        agvWrkMast.setWrkSts(213L);
        agvWrkMast.setSourceLocNo("");
        if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
            throw new CoolException("更新工作档失败");
        }
        // 更新源库位状态
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "O", "", agvWrkMast.getWhsType().shortValue());
        return "ok";
    }

    /*
       空架进场
    */
    @Override
    @Transactional
    @Synchronized
    public String empIn(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()));
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("工作档中没有此站点任务");
        }
        if (agvWrkMast.getIoType() != 113) {
            throw new CoolException("当前工作类型不能空架进场");
        }
        if (agvWrkMast.getWrkSts() != 213) {
            throw new CoolException("当前工作类型不能空架进场");
        }
        agvWrkMast.setWrkSts(214L);
        agvWrkMast.setModiTime(new Date());
        agvWrkMast.setSourceLocNo(param.getDevNo());
        if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
            throw new CoolException("更新工作档失败");
        }
        // 更新源库位状态
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "F", param.getBarcode(), agvWrkMast.getWhsType().shortValue());
        return "ok";
    }

    /*
     * 转手动回流
     */
    @Override
    @Transactional
    public String handBack(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
        agvWrkMast.setIoType(113);
        agvWrkMast.setModiUser(userId);
        agvWrkMast.setModiTime(now);
        if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
            throw new CoolException("更新工作档失败");
        }
        return "ok";
    }

    /*
     * 确认加工完成
     */
    @Override
    @Transactional
    public String processed(AgvMobileStartPakin param, Long userId) {
        Date now = new Date();
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("barcode", param.getBarcode()).eq("loc_no", param.getDevNo()));
        if (Cools.isEmpty(agvWrkMast)) {
            throw new CoolException("暂无当前货架的工作档");
        }
        if (agvWrkMast.getWrkSts() != 205) {
            throw new CoolException("当前任务未完成，请确认");
        }
        //生成AGV工作历史档 + 生成AGV工作明细历史档
        agvWrkMastLogService.save(agvWrkMast);
        agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
        String sourceLocNo = agvWrkMast.getSourceLocNo();
        AgvLocMast newLocMast = agvCommonService.getLocNo(3, 1, false, false);
        agvWrkMast.setSourceLocNo(agvWrkMast.getLocNo());
        agvWrkMast.setLocNo(newLocMast.getLocNo());
        agvWrkMast.setIoType(57);
        agvWrkMast.setWrkSts(201L);
        agvWrkMast.setModiUser(userId);
        agvWrkMast.setModiTime(now);
        agvWrkMast.setIoTime(now);


        if (!agvWrkMastService.update(agvWrkMast, new EntityWrapper<AgvWrkMast>().eq("wrk_no", agvWrkMast.getWrkNo()))) {
            throw new CoolException("更新工作档失败");
        }

        // 更新源站点 + 目标库位状态 + 历史源库位
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(param.getDevNo(), "R", param.getBarcode(), agvWrkMast.getWhsType().shortValue());
        agvLocMastService.updateLocStsByLocNo(newLocMast.getLocNo(), "S", agvWrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
        agvLocMastService.updateLocStsByLocNo(sourceLocNo, "O", "", (short) 30);
        agvLocDetlService.delete(new EntityWrapper<AgvLocDetl>().eq("loc_no", sourceLocNo));

        List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", param.getBarcode()));
        agvWrkDetls.forEach(agvWrkDetl -> {
            for (AgvWrkDetl wrkDetl : param.getWrkDetls()) {
                if (wrkDetl.getMatnr().equals(agvWrkDetl.getMatnr()) && wrkDetl.getThreeCode().equals(agvWrkDetl.getThreeCode())) {
                    agvWrkDetl.setAnfme(wrkDetl.getAnfme());
                    break;
                }
            }
            agvWrkDetl.setProcessSts(2);
            agvWrkDetl.setOrderNo(agvWrkDetl.getOrderNo().substring(2));
            agvWrkDetl.setModiUser(userId);
            agvWrkDetl.setModiTime(now);
            agvWrkDetl.setIoTime(now);
            if (!agvWrkDetlService.update(agvWrkDetl, new EntityWrapper<AgvWrkDetl>()
                    .eq("matnr", agvWrkDetl.getMatnr())
                    .eq("three_code", agvWrkDetl.getThreeCode())
                    .eq("supp_code", param.getBarcode()))) {
                throw new CoolException("更新工作明细失败");
            }
        });
        return "ok";
    }


    /*
     * 站点回退
     */
    @Override
    @Transactional
    public String doBack(AgvMobileStartPakin param, Long userId) {
        if (Cools.isEmpty(param.getBarcode()) || !CodeDetectionUtil.barcodeDetection(param.getBarcode())) {
            throw new CoolException(param.getBarcode() + "货架码有误，请正确扫码！！！");
        }
        if (Cools.isEmpty(param.getDevNo()) || !CodeDetectionUtil.carCodeDetection(param.getDevNo())) {
            throw new CoolException(param.getDevNo() + "小车地码有误，请正确扫码！！！");
        }
        Date now = new Date();
        AgvWrkMast agvWrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", param.getDevNo()));
        AgvWrkMast agvWrkMastSource = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("source_loc_no", param.getDevNo()));
        if (!Cools.isEmpty(agvWrkMastSource)) {
            throw new CoolException("当前站点已有退库任务");
        }
        Integer oldWrkNo = agvWrkMast.getWrkNo();
        if (!agvWrkMast.getBarcode().equals(param.getBarcode())) {
            throw new CoolException("回退任务的货架码与当前货架码不一致!");
        }
        if (agvWrkMast.getWrkSts() != 205) {
            throw new CoolException("出库任务未完成!");
        }
        // 新建回退工作档
        AgvWrkMast wrkMast = createWrkMast(58, 201L, agvWrkMast.getLocNo(), agvWrkMast.getSourceLocNo(), agvWrkMast.getBarcode(), now, userId, agvWrkMast.getWhsType(), 0);
        // 更新接驳位，更新库位状态
        agvLocMastService.updateLocStsByLocNo(wrkMast.getLocNo(), "S", wrkMast.getBarcode(), wrkMast.getWhsType().shortValue());
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(wrkMast.getSourceLocNo(), "R", wrkMast.getBarcode(), agvWrkMast.getWhsType().shortValue());
        // 更新工作明细
        List<AgvWrkDetl> agvWrkDetls = agvWrkDetlService.selectList(new EntityWrapper<AgvWrkDetl>().eq("supp_code", agvWrkMast.getBarcode()));
        for (AgvWrkDetl agvWrkDetl : agvWrkDetls) {
            agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
            // 保持工作档明细
            agvWrkDetl.setWrkNo(wrkMast.getWrkNo());
            agvWrkDetl.setIoTime(now);
            agvWrkDetl.setModiUser(userId);
            agvWrkDetl.setModiTime(now);
            if (!agvWrkDetlService.insert(agvWrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
            // 同步订单数量
            //OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("order_no", agvWrkDetl.getOrderNo()).in("source", 18, 31, 34));
            List<OrderDetl> orderDetls = orderDetlService.selectList(new EntityWrapper<OrderDetl>().eq("matnr", agvWrkDetl.getMatnr()).eq("three_code", agvWrkDetl.getThreeCode()).eq("order_no", agvWrkDetl.getOrderNo()));
            OrderDetl orderDetl = null;
            if (orderDetls.isEmpty()) {
                throw new CoolException("订单明细不存在");
            } else if (orderDetls.size() > 1) {
                for (OrderDetl detl : orderDetls) {
                    if (Cools.isEmpty(agvWrkDetl.getBatch()) && Cools.isEmpty(detl.getBatch())) {
                        orderDetl = detl;
                    } else if (!Cools.isEmpty(agvWrkDetl.getBatch()) && !Cools.isEmpty(detl.getBatch()) && agvWrkDetl.getBatch().equals(detl.getBatch())) {
                        orderDetl = detl;
                    }
                }
                if (orderDetl == null) {
                    throw new CoolException("订单明细不匹配");
                }
            } else {
                orderDetl = orderDetls.get(0);
            }
            orderDetl.setQty(orderDetl.getQty() - agvWrkDetl.getAnfme());
            if (!orderDetlService.updateById(orderDetl)) {
                throw new CoolException("修改订单明细失败，请联系管理员" + orderDetl.getOrderNo() + orderDetl.getMatnr());
            }
        }

        //生成AGV工作历史档 + 生成AGV工作明细历史档
        agvWrkMastLogService.save(agvWrkMast);
        agvWrkDetlLogService.save(agvWrkMast.getWrkNo());
        //删除AGV工作档
        agvWrkMastService.deleteById(agvWrkMast);
        //删除AGV工作明细档
        agvWrkDetlService.delete(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", oldWrkNo));
        return "ok";
    }

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

    /*
   生成工作档
    */
    private AgvWrkMast createWrkMast(int ioType, long wrkSts, String sourceLocNo, String locNo, String barcode, Date now, Long userId, int containerType, int floor) {
        AgvWrkMast wrkMast = new AgvWrkMast();
        //工作状态
        wrkMast.setWrkSts(wrkSts);
        //入出库类型
        wrkMast.setIoType(ioType);
        wrkMast.setIoTime(now);
        //优先级
        wrkMast.setIoPri(300.0);
        //源站点
        wrkMast.setSourceLocNo(sourceLocNo);
        //目标站点
        wrkMast.setLocNo(locNo);
        //货架编码
        wrkMast.setBarcode(barcode);
        //货架类型
        wrkMast.setWhsType(containerType);
        // 目标楼层
        wrkMast.setCrnNo(floor);

        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        wrkMast.setLogErrMemo("doBack");
        if (!agvWrkMastService.insertByIncrease(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }

        wrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", locNo).eq("source_loc_no", sourceLocNo).eq("barcode", barcode).orderBy("modi_time", false));

        return wrkMast;
    }

}