#

tzsk

2024-04-28 6b87b1634b7a99b54ffcc98775839604cd06e6bf

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

@@ -1,5 +1,8 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.BaseRes;
@@ -19,8 +22,10 @@
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.properties.SlaveProperties;
import com.zy.common.service.CommonService;
import com.zy.common.web.BaseController;
import com.zy.common.web.WcsController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -75,6 +80,10 @@
    private RowLastnoService rowLastnoService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private AgvWaitPakinService agvWaitPakinService;

    @Override
    @Transactional
@@ -98,8 +107,9 @@
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setOutMost(locMastService.isOutMost(dto.getLocNo())?1:0);;
        Double ioPri = wrkMastService.getIoPri(1, dto.getLocNo());
        wrkMast.setIoPri(ioPri); // 优先级：13
        wrkMast.setOutMost(locMastService.isOutMost(dto.getLocNo(), true)?1:0);;
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
@@ -121,9 +131,9 @@
        // 生成工作档明细
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getList().forEach(elem -> {
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getAnfme());
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getAnfme(), elem.getCsocode(), elem.getIsoseq(),elem.getContainerCode());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch());
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch(),detlDto.getCsocode(),detlDto.getIsoseq(),detlDto.getContainerCode());
                assert detlDto1 != null;
                detlDto1.setAnfme(detlDto1.getAnfme() + detlDto.getAnfme());
            } else {
@@ -156,13 +166,64 @@
    @Override
    @Transactional
    public void startupFullTakeStore(StockOutParam param, Long userId) {
        ArrayList<String> locNos = new ArrayList<>();
        for (StockOutParam.LocDetl locDetl:param.getLocDetls()){
            if (!locNos.contains(locDetl.getLocNo())){
                locNos.add(locDetl.getLocNo());
            }
        }
        //检测是否为浅库位
        boolean sign=false;
        String th = "";
        for (String locNo:locNos){
            if (sign){
                break;
            }

            //检测出库的货物中是否有状态为禁止的货物。
            for (LocDetl locDetl : locDetlService.selectByLocNo(locNo)) {
                if (locDetl.getStockFreeze() == 0) {
                    th="库位号："+locNo+" 有禁止出库的货物！";
                    throw new CoolException("出库失败；"+th);
                }

                Mat mat = matService.selectByMatnr(locDetl.getMatnr());
                if (mat == null) {
                    continue;
                }
                if (mat.getStatus() == 0) {
                    th="库位号："+locNo+" 有禁止出库的货物！";
                    throw new CoolException("出库失败；"+th);
                }
            }

            List<String> groupOuterLoc = Utils.getGroupOuterLoc(locNo);
            if (!Cools.isEmpty(groupOuterLoc)) {
                for (String outerLoc : groupOuterLoc) {
                    if (locNos.contains(outerLoc)){
                        continue;
                    }
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", outerLoc));
                    if (locMast != null) {
                        if (!locMast.getLocSts().equals("O") && !locMast.getLocSts().equals("R")){
                            sign=true;
                            th="库位号："+locNo+" 浅库位有非空库位！";
                            break;
                        }
                    }
                }
            }
        }
        if (sign){
            throw new CoolException("出库失败；"+th);
        }
        // 目标站点状态检测
        BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
        // 获取库位明细
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch(), paramLocDetl.getSuppCode());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
@@ -172,6 +233,33 @@
        } else {
            throw new CoolException("库存不存在");
        }
    }
    /**
     * 通过库位号获取 排
     */
    public static int getRow(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(0, 2));
        }
        throw new RuntimeException("库位解析异常");
    }
    /**
     * 通过库位号获取 列
     */
    public static int getBay(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(2, 5));
        }
        throw new RuntimeException("库位解析异常");
    }
    /**
     * 通过库位号获取 层
     */
    public static int getLev(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(5, 7));
        }
        throw new RuntimeException("库位解析异常");
    }

    @Override
@@ -195,7 +283,76 @@
                dtos.add(new OutLocDto(locNo, locDetlDto));
            }
        }

        for (OutLocDto dto : dtos) {
            dto.sortLocDetlDtos();
        }


        ArrayList<String> outerLocs = new ArrayList<>();
        //检测是否为浅库位
        boolean sign=false;
        String th = "";
        for (String locNo : locNos) {
            if (sign) {
                break;
            }

            List<String> groupOuterLoc = Utils.getGroupOuterLoc(locNo);
            if (!Cools.isEmpty(groupOuterLoc)) {
                for (String outerLoc : groupOuterLoc) {
                    if (locNos.contains(outerLoc)) {
                        continue;
                    }
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", outerLoc));
                    if (locMast != null) {
                        if (!locMast.getLocSts().equals("O") && !locMast.getLocSts().equals("R")) {
//                            sign = true;
//                            th = "库位号：" + locNo + " 浅库位有非空库位！";
//                            break;

                            OutLocDto outLocDto = new OutLocDto();
                            outLocDto.setLocNo(locMast.getLocNo());
                            List<LocDetlDto> locDetlDtos1 = new ArrayList<>();
                            for (LocDetl locDetl : locDetlService.selectByLocNo(locMast.getLocNo())) {
                                LocDetlDto locDetlDto = new LocDetlDto();
                                locDetlDto.setLocDetl(locDetl);
                                locDetlDto.setCount(locDetl.getAnfme());
                                locDetlDtos1.add(locDetlDto);
                            }
                            outLocDto.setLocDetlDtos(locDetlDtos1);
                            if (!outerLocs.contains(locMast.getLocNo())) {
                                dtos.add(outLocDto);
                                outerLocs.add(locMast.getLocNo());
                            }
                        }
                    }
                }
            }
        }
//        if (sign){
//            throw new CoolException("出库失败；"+th);
//        }

        //**************325、331、333、339站点额外逻辑代码**************
        HashMap<String, Object> tmpMap = new HashMap<>();
        if (staNo.getDevNo() == 325 || staNo.getDevNo() == 331 || staNo.getDevNo() == 333 || staNo.getDevNo() == 339) {
            int[] data = {325,331,333,339};
            for (String locNo : locNos) {
                List<String> groupOuterLoc = Utils.getGroupDeepLoc(locNo);
                if (groupOuterLoc.isEmpty()) {
                    continue;
                }
                int index = 0;
                for (String loc : groupOuterLoc) {
                    tmpMap.put(loc, data[index++]);
                }
            }
        }
        //**************325、331、333、339站点额外逻辑代码**************

        Integer ioType = null;
        List<String> excludeLocNos = dtos.stream().map(OutLocDto::getLocNo).distinct().collect(Collectors.toList());
        // 生成工作档
        for (OutLocDto dto : dtos) {
            // 如果为深库位，且对应浅库位为X.禁用，则略过此库位
@@ -216,20 +373,45 @@
            // 获取库位
            LocMast locMast = locMastService.selectById(dto.getLocNo());
            // 获取路径
            StaDesc staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), staNo.getDevNo());
            Boolean outMost = locMastService.isOutMost(dto.getLocNo(), false);
            Integer outCrnNo = locMastService.getOutCrnNo(locMast);
            StaDesc staDesc = staDescService.queryCrnStn(ioType, outCrnNo, staNo.getDevNo());
            // 生成工作号
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));

            Integer stnNo = staDesc.getStnNo();//目标站
            Integer sourceStaNo = staDesc.getCrnStn();//源站
            if (stnNo == 325 || stnNo == 331 || stnNo == 333 || stnNo == 339) {
                stnNo = staDesc.getCrnStn();
                sourceStaNo = staDesc.getStnNo();

                //**************325、331、333、339站点额外逻辑代码**************
                Object autoStnNo = tmpMap.get(dto.getLocNo());//获取系统自动分配站点
                if (autoStnNo != null) {
                    sourceStaNo = Integer.parseInt(autoStnNo.toString());
                }
                //**************325、331、333、339站点额外逻辑代码**************
            }

            int lev = Utils.getLev(dto.getLocNo());
            if (lev == 1 || lev == 2) {
                if (!(stnNo == 100 || stnNo == 103 || stnNo == 105)) {
                    throw new CoolException("1、2层货物仅允许在一楼进行出库");
                }
            }

            // 生成工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setWrkSts(21L); // 工作状态：21.生成出库任务
            wrkMast.setIoType(ioType); // 入出库状态
            wrkMast.setIoPri(13D); // 优先级：13
            wrkMast.setOutMost(locMastService.isOutMost(dto.getLocNo())?1:0);;
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
            wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
            Double ioPri = wrkMastService.getIoPri(ioType, dto.getLocNo());
            wrkMast.setIoPri(ioPri); // 优先级：13
            wrkMast.setOutMost(outMost?1:0);;
            wrkMast.setCrnNo(outMost?outCrnNo:locMast.getCrnNo());
            wrkMast.setSourceStaNo(sourceStaNo); // 源站
            wrkMast.setStaNo(stnNo); // 目标站
            wrkMast.setSourceLocNo(dto.getLocNo()); // 源库位
            wrkMast.setFullPlt("Y"); // 满板：Y
            wrkMast.setPicking("N"); // 拣料
@@ -246,14 +428,15 @@
            }
            // 生成工作档明细
            for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
                if (detlDto.getCount()==null || detlDto.getCount() <= 0.0D) {continue;}
                if (detlDto.getCount()==null) {continue;}
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(detlDto.getLocDetl());
                wrkDetl.setOrderNo(""); // 手动出库不需要带出库存中的单据编号
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setIoTime(now);
                Double anfme = ioType==101?detlDto.getLocDetl().getAnfme():detlDto.getCount();
                wrkDetl.setAnfme(anfme); // 数量
                wrkDetl.setAnfme(anfme); // 作业数量
                wrkDetl.setStock(detlDto.getLocDetl().getAnfme());
                wrkDetl.setAppeTime(now);
                wrkDetl.setAppeUser(userId);
                wrkDetl.setModiTime(now);
@@ -281,6 +464,7 @@
    @Transactional
    public void stockOut(BasDevp staNo, TaskDto taskDto, Long userId) {
        Date now = new Date();
        taskDto.sortLocDtos();
        List<LocDto> locDtos = taskDto.getLocDtos();
        for (LocDto locDto : locDtos) {
            if (!taskDto.getLocNo().equals(locDto.getLocNo()) && !taskDto.getStaNo().equals(locDto.getStaNo())) {
@@ -291,20 +475,42 @@
        LocMast locMast = locMastService.selectById(taskDto.getLocNo());
        // 获取路径
        int ioType = taskDto.isAll() ? 101 : 103;
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), staNo.getDevNo());
        Boolean outMost = locMastService.isOutMost(taskDto.getLocNo(), false);
        Integer outCrnNo = locMastService.getOutCrnNo(locMast);
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, outCrnNo, staNo.getDevNo());
        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));

        Integer stnNo = staDesc.getStnNo();//目标站
        Integer sourceStaNo = staDesc.getCrnStn();//源站
        if (stnNo == 325 || stnNo == 331 || stnNo == 333 || stnNo == 339) {
            stnNo = staDesc.getCrnStn();
            sourceStaNo = staDesc.getStnNo();
        }

        int lev = Utils.getLev(taskDto.getLocNo());
        if (lev == 1 || lev == 2) {
            if (!(stnNo == 100 || stnNo == 103 || stnNo == 105)) {
                throw new CoolException("1、2层货物仅允许在一楼进行出库");
            }
        }

        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setWrkSts(21L); // 工作状态：21.生成出库任务
        wrkMast.setIoType(ioType); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setOutMost(locMastService.isOutMost(taskDto.getLocNo())?1:0);;
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        Double ioPri = wrkMastService.getIoPri(ioType, taskDto.getLocNo());
        wrkMast.setIoPri(ioPri); // 优先级：13
        wrkMast.setOutMost(outMost?1:0);;
        wrkMast.setCrnNo(outMost?outCrnNo:locMast.getCrnNo());
        wrkMast.setSourceStaNo(sourceStaNo); // 源站
        wrkMast.setStaNo(stnNo); // 目标站
        if(ioType == 101 && taskDto.getStaNo()>=300){
            wrkMast.setSourceStaNo(346); // 源站
            wrkMast.setStaNo(346); // 目标站
        }
        wrkMast.setSourceLocNo(taskDto.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
@@ -321,31 +527,109 @@
        }
        // 生成工作档明细
        for (LocDto locDto : taskDto.getLocDtos()) {
            if (locDto.getAnfme()==null || locDto.getAnfme() <= 0.0D) { continue; }
            OrderDetl orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch());
            if (orderDetl == null) {
                orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), null);
            if (locDto.getAnfme()==null) { continue; }
            LocDetl locDetl = locDetlService.selectItem(locDto.getLocNo(), locDto.getMatnr(), locDto.getBatch(), locDto.getContainerCode());
            if (locDetl == null || locDetl.getAnfme() < locDto.getAnfme()) {
                throw new CoolException(locDto.getLocNo() + "库位中" + locDto.getMatnr() + "商品库存不足！");
            }
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(orderDetl);
            wrkDetl.setZpallet(wrkMast.getBarcode());
            wrkDetl.setIoTime(now);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setBatch(locDto.getBatch());
            wrkDetl.setOrderNo(locDto.getOrderNo());
            wrkDetl.setAnfme(locDto.getAnfme()); // 数量
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            Mat mat = matService.selectByMatnr(locDto.getMatnr());
            assert mat != null;

            if (locDto.getStock() < locDto.getAnfme()) {
                //总库存小于作业数量，异常数据
                throw new CoolException("库存不足，请稍后重试");
            }
            // 修改订单明细
            if (!orderDetlService.increase(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");

            if (!BaseController.isJSON(locDto.getOrderNo())) {
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(mat);
                wrkDetl.setZpallet(wrkMast.getBarcode());
                wrkDetl.setIoTime(now);
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setBatch(locDto.getBatch());
                wrkDetl.setOrderNo(locDto.getOrderNo());
                wrkDetl.setAnfme(locDto.getAnfme()); // 作业数量
                wrkDetl.setStock(locDto.getStock());//总库存
                wrkDetl.setAppeTime(now);
                wrkDetl.setAppeUser(userId);
                wrkDetl.setModiTime(now);
                wrkDetl.setModiUser(userId);
                wrkDetl.setSuppCode(locDto.getContainerCode());
                wrkDetl.setThreeCode(locDto.getCsocode());
                wrkDetl.setDeadTime(locDto.getIsoseq());
                if (!wrkDetlService.insert(wrkDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }
                //补货单则生成AGV入库通知档
                generateAgvWaitpakin(wrkDetl);
            }else {
                List<OrderDto> orderDtoList = JSON.parseArray(locDto.getOrderNo(), OrderDto.class);
                orderDtoList.forEach(orderDto -> {
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(mat);
                    wrkDetl.setZpallet(wrkMast.getBarcode());
                    wrkDetl.setIoTime(now);
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setBatch(locDto.getBatch());
                    wrkDetl.setOrderNo(orderDto.getOrderNo());
                    wrkDetl.setAnfme(orderDto.getAnfme()); // 数量
                    wrkDetl.setStock(locDto.getStock());//总库存
                    wrkDetl.setAppeTime(now);
                    wrkDetl.setAppeUser(userId);
                    wrkDetl.setModiTime(now);
                    wrkDetl.setModiUser(userId);
                    wrkDetl.setSuppCode(locDto.getContainerCode());
                    wrkDetl.setThreeCode(locDto.getCsocode());
                    wrkDetl.setDeadTime(locDto.getIsoseq());
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作档明细失败");
                    }
                    //补货单则生成AGV入库通知档
                    generateAgvWaitpakin(wrkDetl);
                });
            }
            orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);

            if (locDto.getAnfme() > 0) {
                // 修改订单明细
                if (!BaseController.isJSON(locDto.getOrderNo())) {
                    OrderDetl orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch(),locDto.getCsocode(),locDto.getIsoseq());
                    if (orderDetl == null) {
                        orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), null,locDto.getCsocode(),locDto.getIsoseq());
                    }
                    if (!orderDetlService.increase(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme(),locDto.getCsocode(),locDto.getIsoseq())) {
                        throw new CoolException("修改订单明细数量失败");
                    }
                    orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
                } else {
                    // 订单合并出库
                    List<OrderDto> orderDtoList = JSON.parseArray(locDto.getOrderNo(), OrderDto.class);

                    //实际出库数量
                    Double locAnfme = locDto.getAnfme();
                    //订单实际出库数量
                    Double orderAnfme;

                    for (OrderDto orderDto : orderDtoList) {
                        OrderDetl orderDetl = orderDetlService.selectItem(orderDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch(),locDto.getCsocode(),locDto.getIsoseq());
                        if (orderDetl == null) {
                            orderDetl = orderDetlService.selectItem(orderDto.getOrderNo(), locDto.getMatnr(), null,locDto.getCsocode(),locDto.getIsoseq());
                        }

                        orderAnfme = orderDetl.getAnfme() - orderDetl.getQty();

                        if(locAnfme > orderAnfme){
                            locAnfme -= orderAnfme;
                        }else {
                            orderAnfme = locAnfme;
                        }

                        if (!orderDetlService.increase(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), orderAnfme,orderDetl.getThreeCode(),orderDetl.getDeadTime())) {
                            throw new CoolException("修改订单明细数量失败");
                        }
                        orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
                    }
                }
            }
        }
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        locMast = locMastService.selectById(taskDto.getLocNo());
@@ -376,8 +660,9 @@
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
        wrkMast.setIoType(10); // 入出库状态：10.空板入库
        wrkMast.setIoPri(10D); // 优先级：10
        wrkMast.setOutMost(locMastService.isOutMost(dto.getLocNo())?1:0);;
        Double ioPri = wrkMastService.getIoPri(10, dto.getLocNo());
        wrkMast.setIoPri(ioPri); // 优先级：10
        wrkMast.setOutMost(locMastService.isOutMost(dto.getLocNo(), true)?1:0);;
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
@@ -422,6 +707,34 @@
    @Override
    @Transactional
    public void emptyPlateOut(EmptyPlateOutParam param, Long userId) {
        List<String> locNos = param.getLocNos();
        //检测是否为浅库位
        boolean sign=false;
        String th = "";
        for (String locNo:locNos){
            if (sign){
                break;
            }
            List<String> groupInnerLoc = Utils.getGroupInnerLoc(locNo);
            if (!Cools.isEmpty(groupInnerLoc)) {
                for (String insideLoc : groupInnerLoc) {
                    if (locNos.contains(insideLoc)){
                        continue;
                    }
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", insideLoc));
                    if (locMast != null) {
                        if (!locMast.getLocSts().equals("O") && !locMast.getLocSts().equals("R")){
                            sign=true;
                            th="库位号："+locNo+" 浅库位有非空库位！";
                            break;
                        }
                    }
                }
            }
        }
        if (sign){
            throw new CoolException("出库失败；"+th);
        }
        if (Cools.isEmpty(param.getOutSite())) {
            throw new CoolException("站点不存在");
        }
@@ -440,12 +753,16 @@
            if (Cools.isEmpty(locMast)) {
                throw new CoolException(locNo+"库位不存在");
            }
            Boolean outMost = locMastService.isOutMost(locNo, false);
            Integer outCrnNo = locMastService.getOutCrnNo(locMast);
            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
                    .eq("stn_no", param.getOutSite())
                    .eq("crn_no", locMast.getCrnNo());
                    .eq("stn_no", param.getOutSite());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            if (Cools.isEmpty(staDesc)) {
                throw new CoolException("非法路径！");
            }
            Integer sourceStaNo = staDesc.getCrnStn();
            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败");
@@ -454,13 +771,14 @@
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(new Date());
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setWrkSts(21L); // 工作状态：21.生成出库任务
            wrkMast.setIoType(110); // 入出库状态： 110.空板出库
            wrkMast.setIoPri(10D);
            Double ioPri = wrkMastService.getIoPri(110, locNo);
            wrkMast.setIoPri(ioPri);
            wrkMast.setSourceStaNo(sourceStaNo); // 源站
            wrkMast.setStaNo(param.getOutSite()); // 目标站
            wrkMast.setOutMost(locMastService.isOutMost(locNo)?1:0);;
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setOutMost(outMost?1:0);;
            wrkMast.setCrnNo(outMost?outCrnNo:locMast.getCrnNo());
            wrkMast.setSourceLocNo(locNo); // 源库位
            wrkMast.setFullPlt("N"); // 满板：Y
            wrkMast.setPicking("N"); // 拣料
@@ -496,7 +814,7 @@
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch(),paramLocDetl.getSuppCode());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
@@ -521,18 +839,19 @@
            throw new CoolException("未找到库位");
        }
        if (!sourceLoc.getCrnNo().equals(loc.getCrnNo())) {
            throw new CoolException("移转库位属于不同堆垛机");
//            throw new CoolException("移转库位属于不同堆垛机");   todo:luxiaotao
        }
        Date now = new Date();
        // 获取工作号
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        // 保存工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(21L); // 工作状态：21.生成出库任务
        wrkMast.setIoType(11); // 入出库状态： 11.库格移载
        wrkMast.setIoPri(10D);
        wrkMast.setOutMost(locMastService.isOutMost(locNo)?1:0);;
        wrkMast.setOutMost(locMastService.isOutMost(locNo, false)?1:0);;
        wrkMast.setCrnNo(sourceLoc.getCrnNo());
        wrkMast.setSourceLocNo(sourceLocNo); // 源库位
        wrkMast.setLocNo(locNo); // 目标库位
@@ -543,9 +862,9 @@
        wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(new Date());
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(new Date());
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
@@ -555,11 +874,11 @@
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(new Date());
            wrkDetl.setIoTime(now);
            wrkDetl.setAnfme(locDetl.getAnfme());
            wrkDetl.setAppeTime(new Date());
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(new Date());
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
@@ -569,17 +888,17 @@
        if (sourceLoc.getLocSts().equals("D") || sourceLoc.getLocSts().equals("F")) {
            sourceLoc.setLocSts("R"); // R.出库预约
            sourceLoc.setModiUser(userId);
            sourceLoc.setModiTime(new Date());
            sourceLoc.setModiTime(now);
            if (!locMastService.updateById(sourceLoc)){
                throw new CoolException("更新源库位状态失败");
            }
        } else {
            throw new CoolException("源库位出库失败，状态："+sourceLoc.getLocSts$());
            throw new CoolException(sourceLoc.getLocNo() + "源库位出库失败，状态："+sourceLoc.getLocSts$());
        }
        // 修改目标库位状态
        if (loc.getLocSts().equals("O")) {
            loc.setLocSts("S"); // S.入库预约
            loc.setModiTime(new Date());
            loc.setModiTime(now);
            loc.setModiUser(userId);
            if (!locMastService.updateById(loc)) {
                throw new CoolException("更新目标库位状态失败");
@@ -596,15 +915,22 @@
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        if (wrkMast.getWrkSts() == 9 || wrkMast.getWrkSts() == 17) {

        if (wrkMast.getIoType() == 200) {
            //小车移库任务，直接删除工作档
            wrkMastService.deleteById(wrkMast);
            return;
        }

        if (wrkMast.getWrkSts() == 9 || wrkMast.getWrkSts() == 29) {
            throw new CoolException("当前工作档已完成");
        }
        // 入库 + 库位转移
        if (wrkMast.getWrkSts() < 9 || (wrkMast.getWrkSts() > 10 && wrkMast.getIoType()==11)) {
            wrkMast.setWrkSts(9L);
            // 出库
        } else if (wrkMast.getWrkSts() > 10) {
            wrkMast.setWrkSts(17L);
        } else if (wrkMast.getWrkSts() > 20) {
            wrkMast.setWrkSts(29L);
        }
        Date now = new Date();
        wrkMast.setCrnStrTime(DateUtils.calculate(now, 1L, TimeUnit.SECONDS, true));
@@ -644,11 +970,11 @@
            while (iterator1.hasNext()) {
                LocDetlAdjustParam.LocDetlAdjust adjust = iterator1.next();
                if (adjust.getCount() == 0) { continue; }
                if (locDetl.getMatnr().equals(adjust.getMatnr()) && Cools.eq(locDetl.getBatch(), adjust.getBatch())) {
                if (locDetl.getMatnr().equals(adjust.getMatnr()) && Cools.eq(locDetl.getBatch(), adjust.getBatch()) && Cools.eq(locDetl.getSuppCode(),adjust.getSuppCode()) && Cools.eq(locDetl.getThreeCode(),adjust.getThreeCode()) && Cools.eq(locDetl.getDeadTime(),adjust.getDeadTime())) {
                    if (!locDetl.getAnfme().equals(adjust.getCount())) {
                        // todo 盘点记录
                        // 修改库存
                        if (!locDetlService.updateAnfme(adjust.getCount(), locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
                        if (!locDetlService.updateAnfme(adjust.getCount(), locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch(),locDetl.getSuppCode(),locDetl.getThreeCode(),locDetl.getDeadTime())) {
                            throw new CoolException(locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码修改数量失败");
                        }
                        // 保存调整记录
@@ -662,6 +988,10 @@
                        adjDetl.setModiUser(userId);
                        adjDetl.setAppeTime(now);
                        adjDetl.setAppeUser(userId);
                        adjDetl.setOrderNo(Utils.generateAdjustOrderNo());
                        adjDetl.setCsocode(locDetl.getThreeCode());
                        adjDetl.setIsoseq(locDetl.getDeadTime());

                        adjDetlService.save(adjDetl, userId);
                    }
                    iterator.remove();
@@ -673,7 +1003,7 @@
        // 删除库存
        for (LocDetl locDetl : locDetls) {
            // todo 盘点记录
            if (!locDetlService.updateAnfme(-1.0D, locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
            if (!locDetlService.updateAnfme(-1.0D, locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch(),locDetl.getSuppCode(),locDetl.getThreeCode(),locDetl.getDeadTime())) {
                throw new CoolException("删除" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码库存明细失败");
            }
            // 保存调整记录
@@ -687,6 +1017,7 @@
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetl.setOrderNo(Utils.generateAdjustOrderNo());
            adjDetlService.save(adjDetl, userId);
        }

@@ -703,6 +1034,8 @@
            locDetl.setModiTime(now);
            locDetl.setAppeUser(userId);
            locDetl.setAppeTime(now);
            locDetl.setThreeCode(adjust.getThreeCode());
            locDetl.setDeadTime(adjust.getDeadTime());
            if (!locDetlService.insert(locDetl)) {
                throw new CoolException("添加" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码库存明细失败");
            }
@@ -717,6 +1050,10 @@
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetl.setCsocode(locDetl.getThreeCode());
            adjDetl.setIsoseq(locDetl.getDeadTime());
            adjDetl.setOrderNo(Utils.generateAdjustOrderNo());

            adjDetlService.save(adjDetl, userId);
        }
        // 修改库位状态
@@ -746,10 +1083,17 @@
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }

        if (wrkMast.getIoType() == 200) {
            //小车移库任务，直接删除工作档
            wrkMastService.deleteById(wrkMast);
            return;
        }

        String locNo = ""; // 待修改目标库位
        String locSts = ""; // 待修改目标库位状态
        // 入库取消（修改目标库位）
        if (wrkMast.getWrkSts() < 4) {
        if (wrkMast.getWrkSts() < 9) {
            locNo = wrkMast.getLocNo();
            locSts = "O";

@@ -766,7 +1110,7 @@
                locMastService.updateById(locMast);
            }
        // 出库取消（修改源库位）
        } else if (wrkMast.getWrkSts() > 10 && wrkMast.getWrkSts() != 14) {
        } else if (wrkMast.getWrkSts() > 20) {
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() > 100 && wrkMast.getIoType() != 110) {
@@ -794,11 +1138,33 @@
        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
        for (WrkDetl wrkDetl : wrkDetls) {
            if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                if (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
                    throw new CoolException("订单数据回滚失败");
                if (!BaseController.isJSON(wrkDetl.getOrderNo())) {
                    if (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme(),wrkDetl.getThreeCode(),wrkDetl.getDeadTime())) {
                        throw new CoolException("订单数据回滚失败");
                    }
                } else {
                    // 订单合并出库

                    //实际取消的出库数量
                    Double wrkDetlAnfme = wrkDetl.getAnfme();
                    //订单实际出库数量
                    Double orderAnfme;

                    List<OrderDto> orderDtoList = JSON.parseArray(wrkDetl.getOrderNo(), OrderDto.class);
                    for (OrderDto orderDto : orderDtoList) {

                        if(wrkDetlAnfme > orderDto.getAnfme()){
                            orderAnfme = orderDto.getAnfme();
                            wrkDetlAnfme -= orderAnfme;
                        }else {
                            orderAnfme = wrkDetlAnfme;
                        }

                        if (!orderDetlService.decrease(orderDto.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), orderAnfme,wrkDetl.getThreeCode(),wrkDetl.getDeadTime())) {
                            throw new CoolException("订单数据回滚失败");
                        }
                    }
                }
                // 生成新的出库作业
//                        stockOutRe(wrkMast, wrkDetls);
            }
        }
        // 取消操作人员记录
@@ -896,107 +1262,45 @@

    @Override
    public StartupDto createWaitPainWrkMastStart(List<WaitPakin> list, Long userId) {
        if (Cools.isEmpty(list)) {
            throw new CoolException("入库通知档不能为空");
        }
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 1);
        return wcsController.startupFullPutStore(301, list.get(0).getZpallet(), locTypeDto, list);
        return null;
    }

    @Override
    @Transactional
    public String dealPreHaveStart(Integer wrkNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(wrkNo);
        if (wrkMast == null) {
            throw new CoolException("任务已失效");
        if (true) {
            throw new CoolException("功能停用");
        }
        String locNo = wrkMast.getLocNo();
        LocMast locMast = locMastService.selectById(locNo);
        assert locMast != null;
        RowLastno rowLastno = rowLastnoService.findBySection(locMast.getRow1());
        assert rowLastno != null;
        return "";
    }

        // 目标库位
        LocMast targetLoc = null;
    private void generateAgvWaitpakin(WrkDetl wrkDetl){
        if (wrkDetl.getAnfme() <= 0D) {
            return;
        }

        for (int curRow = rowLastno.getsRow(); curRow<=rowLastno.geteRow(); curRow++) {

            if (Utils.isShallowLoc(slaveProperties, curRow)) {
                Integer deepRow = Utils.getDeepRow(slaveProperties, curRow);
                targetLoc = locMastService.queryFreeLocMast(deepRow, locMast.getLocType1());
                // 因库位移转、需预留空库位
                if (!locMastService.checkEmptyCount(targetLoc)) {
                    continue;
                }
            }
            if (Cools.isEmpty(targetLoc)) {
                targetLoc = locMastService.queryFreeLocMast(curRow, locMast.getLocType1());
                // 因库位移转、需预留空库位
                if (!locMastService.checkEmptyCount(targetLoc)) {
                    continue;
                }
                // 目标库位 ===>> 浅库位， 则校验其深库位是否为 F D X
                if (null != targetLoc && Utils.isShallowLoc(slaveProperties, targetLoc.getLocNo())) {
                    LocMast deepLoc = locMastService.selectById(Utils.getDeepLoc(slaveProperties, targetLoc.getLocNo()));
                    if (!deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("X")) {
                        continue;
                    }
                }
                // 目标库位 ===>> 深库位， 则校验其浅库位是否为 O
                if (null != targetLoc && Utils.isDeepLoc(slaveProperties, targetLoc.getLocNo())) {
                    LocMast shallowLoc = locMastService.selectById(Utils.getShallowLoc(slaveProperties, targetLoc.getLocNo()));
                    if (!shallowLoc.getLocSts().equals("O")) {
                        continue;
                    }
        String orderNo = wrkDetl.getOrderNo();
        if(orderNo.contains("{")){
            JSONArray orderArray = JSON.parseArray(orderNo);
            for (Object o : orderArray){
                JSONObject jsonobject = (JSONObject) o;
                Order order = orderService.selectByNo(jsonobject.get("orderNo").toString());
                DocType docType = docTypeService.selectById(order.getDocType());
                if("人工补货单".equals(docType.getDocName())){
                    throw new CoolException("合并单据中包含人工补货单，单据为: " + jsonobject.get("orderNo"));
                }
            }

            if (!Cools.isEmpty(targetLoc)) {
                break;
        }else {
            Order order = orderService.selectByNo(orderNo);
            DocType docType = docTypeService.selectById(order.getDocType());
            if("人工补货单".equals(docType.getDocName())){
                AgvWaitPakin agvWaitPakin = new AgvWaitPakin();
                BeanUtils.copyProperties(wrkDetl,agvWaitPakin);
                agvWaitPakinService.insert(agvWaitPakin);
            }

        }

        if (targetLoc == null) {
            throw new CoolException("操作失败，当前仓库找不到空库位");
        }

        Date now = new Date();
        // 修改工作档
        StaDesc staDesc = staDescService.queryCrnStn(targetLoc.getCrnNo());
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }
        wrkMast.setWrkSts(2L);
        wrkMast.setLocNo(targetLoc.getLocNo());
        wrkMast.setStaNo(staDesc.getCrnStn());
        wrkMast.setCrnNo(targetLoc.getCrnNo());
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setPreHave("N");
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("修改工作档失败");
        }
        // 修改库位状态 O ===>>> S
        if (targetLoc.getLocSts().equals("O")){
            targetLoc.setLocSts("S"); // S.入库预约
            targetLoc.setModiUser(userId);
            targetLoc.setModiTime(now);
            if (!locMastService.updateById(targetLoc)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(targetLoc.getLocNo()+"目标库位已被占用");
        }
        // 禁用异常库位
//        locMast.setLocSts("X"); // X.禁用
//        locMast.setModiUser(userId);
//        locMast.setModiTime(now);
//        if (!locMastService.updateById(locMast)){
//            throw new CoolException("改变库位状态失败");
//        }
        return targetLoc.getLocNo();
    }

}