#

ytfl

2025-10-14 a516fec01d3af6fbd55fb8ec1177ff55f5b0f156

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

@@ -12,7 +12,11 @@
import com.zy.asrs.entity.param.FullStoreParam;
import com.zy.asrs.entity.param.LocDetlAdjustParam;
import com.zy.asrs.entity.param.StockOutParam;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.mapper.LocMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
import com.zy.asrs.utils.OrderInAndOutUtil;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.*;
import com.zy.common.model.enums.IoWorkType;
@@ -25,6 +29,7 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@@ -78,6 +83,27 @@
    @Autowired
    private WaitPakinService waitPakinService;

    @Autowired
    private LocOwnerService locOwnerService;

    @Autowired
    private ManLocDetlService manLocDetlService;

    @Resource
    private LocMastMapper locMastMapper;

    @Resource
    private OrderPakoutService orderPakOutService;

    @Autowired
    private InventoryCheckOrderService checkOrderService;

    @Autowired
    private InventoryCheckOrderDetlService checkOrderDetlService;

    @Resource
    private OrderDetlPakoutService orderDetlPakoutService;

    @Override
    @Transactional
    public String startupFullPutStore(FullStoreParam param, Long userId) {
@@ -90,8 +116,13 @@
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getDevpNo(), true);
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        List<String> matnrs = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatnr).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(), matnrs, locTypeDto, 0);
//        List<String> matnrs = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatnr).distinct().collect(Collectors.toList());
//        List<String> batchs = param.getList().stream().map(FullStoreParam.MatCodeStore::getBatch).distinct().collect(Collectors.toList());
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(param.getList().get(0));
        StartupDto dto = commonService.getLocNo(1, param.getDevpNo(), findLocNoAttributeVo, locTypeDto, param.getBarcode());
        if (Cools.isEmpty(dto)) {
            throw new CoolException("查询库位失败！！==》startupFullPutStore ==》 commonService.getLocNo");
        }
        // 生成工作号
        int workNo = dto.getWorkNo();
        // 生成工作档
@@ -122,9 +153,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.getBrand(), elem.getStandby1(), elem.getStandby2(), elem.getStandby3(), elem.getBoxType1(), elem.getBoxType2(), elem.getBoxType3(), elem.getAnfme());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch());
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch(), detlDto.getBrand(), detlDto.getStandby1(), detlDto.getStandby2(), detlDto.getStandby3(), detlDto.getBoxType1(), detlDto.getBoxType2(), detlDto.getBoxType3());
                assert detlDto1 != null;
                detlDto1.setAnfme(detlDto1.getAnfme() + detlDto.getAnfme());
            } else {
@@ -136,20 +167,20 @@
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiUser(userId);
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
        if (!basDevpService.updateById(sourceStaNo)) {
            throw new CoolException("更新源站失败");
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")){
        if (locMast.getLocSts().equals("O")) {
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
            throw new CoolException(dto.getLocNo() + "目标库位已被占用");
        }
        return dto.getLocNo();
    }
@@ -159,17 +190,30 @@
    public void startupFullTakeStore(StockOutParam param, Long userId) {
        // 目标站点状态检测
        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.getBrand()
                        , paramLocDetl.getStandby1(), paramLocDetl.getStandby2(), paramLocDetl.getStandby3(), paramLocDetl.getBoxType1(), paramLocDetl.getBoxType2(), paramLocDetl.getBoxType3());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            // 启动出库开始 101.出库
            stockOut(staNo, locDetlDtos, null, userId);
            // 库位号集合
            List<String> locNoList = param.getLocDetls().stream().map(StockOutParam.LocDetl::getLocNo).distinct().collect(Collectors.toList());
            String firstFrozenLocNo = locMastMapper.findFirstFrozenLocNo(locNoList);
            if (firstFrozenLocNo != null) {
                throw new CoolException(firstFrozenLocNo + "库位已被冻结!");
            }
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetlDtos.get(0).getLocDetl().getLocNo()));
            if (locMast.getLocSts().equals("F") || locMast.getLocSts().equals("D")) {
                // 启动出库开始 101.出库
                stockOut(staNo, locDetlDtos, null, userId, null, param.getItemId());
            } else {
                throw new CoolException("所选库位存在状态不为F、D的库位，库位号：" + locMast.getLocNo() + " 、当前状态：" + locMast.getLocSts() + "-" + locMast.getLocSts$());
            }
        } else {
            throw new CoolException("库存不存在");
        }
@@ -177,7 +221,85 @@

    @Override
    @Transactional
    public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, IoWorkType ioWorkType, Long userId) {
    public void turnOverOut(EmptyPlateOutParam param, Long userId) {
        try {
            if (Cools.isEmpty(param.getOwnerId())) {
                throw new CoolException("客户名称不能为空");
            } else if (param.getLocDetls().size() <= 0) {
                throw new CoolException("请提取明细");
            }
            ArrayList<String> locNos = new ArrayList<>();
            String[][] locNos2 = new String[param.getLocDetls().size()][4];
            int i = 0;
            for (EmptyPlateOutParam.LocDetl locDetl : param.getLocDetls()) {
                if (!locNos.contains(locDetl.getLoc_no())) {
                    locNos.add(locDetl.getLoc_no());
                    locNos2[i][0] = locDetl.getLoc_no();
                    locNos2[i][1] = locDetl.getManu();
                    locNos2[i][2] = locDetl.getMatnr();
                    locNos2[i][3] = locDetl.getBatch();
                    i++;
                }
            }
            LocOwner locOwner = locOwnerService.selectById(param.getOwnerId());
            param.setOwner(locOwner.getOwner());
            String lgort = "";
            String owner = "";
            List<DetlDto> detlDtos = new ArrayList<>();
            for (String[] locNo1 : locNos2) {
                String locNo = locNo1[0];
                if (locNo1[1].equals("平库")) {
                    List<ManLocDetl> manLocDetls = new ArrayList<>();
                    if (locNo1[3] == null) {
                        manLocDetls = manLocDetlService.selectList(new EntityWrapper<ManLocDetl>().eq("loc_no", locNo).eq("matnr", locNo1[2]));
                    } else {
                        manLocDetls = manLocDetlService.selectList(new EntityWrapper<ManLocDetl>().eq("loc_no", locNo).eq("matnr", locNo1[2]).eq("batch", locNo1[3]));
                    }
                    for (ManLocDetl manLocDetl : manLocDetls) {
                        if (Cools.isEmpty(owner)) {
                            owner = manLocDetl.getOwner$();
                        }
//                        detlDtos.add(new DetlDto(manLocDetl.getMatnr(), manLocDetl.getBatch(),manLocDetl.getBrand(),
//                                manLocDetl.getStandby1(),manLocDetl.getStandby2(),manLocDetl.getStandby3(),
//                                manLocDetl.getBoxType1(),manLocDetl.getBoxType2(),manLocDetl.getBoxType3(), manLocDetl.getAnfme()));
                        manLocDetl.setOwner(param.getOwnerId());
                        try {
                            manLocDetlService.update(manLocDetl, new EntityWrapper<ManLocDetl>().eq("loc_no", locNo).eq("matnr", manLocDetl.getMatnr()));
                        } catch (Exception e) {
                            throw new Exception("更新库存明细拥有者字段信息出错了");
                        }
                    }
                } else if (locNo1[1].equals("立库")) {
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", locNo).eq("matnr", locNo1[2]).eq("batch", locNo1[3]));
                    for (LocDetl locDetl : locDetls) {
                        if (Cools.isEmpty(lgort)) {
                            lgort = locDetl.getOrigin();
                        }
                        if (Cools.isEmpty(owner)) {
                            owner = locDetl.getOwner$();
                        }
                        detlDtos.add(new DetlDto(locDetl.getMatnr(), locDetl.getBatch(), locDetl.getBrand(),
                                locDetl.getStandby1(), locDetl.getStandby2(), locDetl.getStandby3(),
                                locDetl.getBoxType1(), locDetl.getBoxType2(), locDetl.getBoxType3(), locDetl.getAnfme()));
                        locDetl.setOwner(param.getOwnerId());
                        try {
                            locDetlService.update(locDetl, new EntityWrapper<LocDetl>().eq("loc_no", locNo).eq("matnr", locDetl.getMatnr()));
                        } catch (Exception e) {
                            throw new Exception("更新库存明细拥有者字段信息出错了");
                        }
                    }
                } else {
                    throw new Exception("更新库位拥有者字段信息出错了");
                }
            }
        } catch (Exception e) {
            throw new CoolException("移交作业出错了：" + e);
        }
    }

    @Override
    @Transactional
    public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, IoWorkType ioWorkType, Long userId, String checkOrderNo, String itemId) {
        Date now = new Date();
        // 合并同类项
        Set<String> locNos = new HashSet<>();
@@ -208,10 +330,41 @@
            assert ioType != null;
            // 获取库位
            LocMast locMast = locMastService.selectById(dto.getLocNo());

            Integer outSta = staNo.getDevNo();
//            //2号堆垛机全板出库站指定为204站，拣料站指定为202
//            if(locMast.getCrnNo()==2){
//                outSta = ioType == 101 ? 204 : 202;
//            }

            // 获取路径
            StaDesc staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), staNo.getDevNo());
            List<StaDesc> staDescs = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), outSta);
            StaDesc staDesc = staDescs.get(0);
            Integer crnStn = staDesc.getCrnStn();
            if (locMast.getCrnNo() == 1) {
                if (locMast.getRow1() <= 3) {
                    crnStn = 1013;
                }else {
                    crnStn = 1016;
                }
            }

            // 生成工作号
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));

            if (ioType == 107) {
                if (Cools.isEmpty(checkOrderNo)) {
                    checkOrderNo = DateUtils.createTimeStamp() + "_" + workNo;
                    InventoryCheckOrder checkOrder = new InventoryCheckOrder();
                    checkOrder.setCreateBy(userId);
                    checkOrder.setStatus("1");
                    checkOrder.setArea(String.valueOf(workNo));
                    checkOrder.setCreateTime(new Date());
                    checkOrder.setOrderNo(checkOrderNo);
                    checkOrderService.insert(checkOrder);
                }
            }

            // 生成工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
@@ -220,7 +373,7 @@
            wrkMast.setIoType(ioType); // 入出库状态
            wrkMast.setIoPri(13D); // 优先级：13
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
            wrkMast.setSourceStaNo(crnStn); // 源站
            wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
            wrkMast.setSourceLocNo(dto.getLocNo()); // 源库位
            wrkMast.setFullPlt("Y"); // 满板：Y
@@ -233,19 +386,24 @@
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(userId);
            wrkMast.setModiTime(now);
            wrkMast.setPacked(itemId);
            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，出库库位号："+dto.getLocNo());
                throw new CoolException("保存工作档失败，出库库位号：" + dto.getLocNo());
            }
            // 生成工作档明细
            for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
                if (detlDto.getCount()==null || detlDto.getCount() <= 0.0D) {continue;}
                if (detlDto.getCount() == null || detlDto.getCount() <= 0.0D) {
                    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();
                Double anfme = ioType == 101 ? detlDto.getLocDetl().getAnfme() : detlDto.getCount();
                Double weight = MatUtils.calcWeight(detlDto.getLocDetl().getMatnr(), anfme);
                wrkDetl.setAnfme(anfme); // 数量
                wrkDetl.setWeight(weight);
                wrkDetl.setAppeTime(now);
                wrkDetl.setAppeUser(userId);
                wrkDetl.setModiTime(now);
@@ -253,15 +411,37 @@
                if (!wrkDetlService.insert(wrkDetl)) {
                    throw new CoolException("保存工作档明细失败");
                }
                if (ioType == 107) {
                    List<InventoryCheckOrderDetl> checkOrderDetls = checkOrderDetlService.selectList(new EntityWrapper<InventoryCheckOrderDetl>()
                            .eq("order_no", checkOrderNo)
                            .eq("loc_no", dto.getLocNo())
                            .eq("batch", wrkDetl.getBatch())
                    );
                    if (checkOrderDetls != null && !checkOrderDetls.isEmpty()) {
                        throw new CoolException("该库位的盘点任务已经添加到了该库位中");
                    }
                    InventoryCheckOrderDetl checkOrderDetl = new InventoryCheckOrderDetl();
                    checkOrderDetl.setOrderNo(checkOrderNo);
                    checkOrderDetl.setMatnr(detlDto.getLocDetl().getMatnr());
                    checkOrderDetl.setMaktx(detlDto.getLocDetl().getMaktx());
                    checkOrderDetl.setBatch(detlDto.getLocDetl().getBatch());
                    checkOrderDetl.setLocNo(detlDto.getLocDetl().getLocNo());
                    checkOrderDetl.setAnfme(detlDto.getLocDetl().getAnfme());
                    checkOrderDetl.setArea(String.valueOf(workNo));
                    checkOrderDetl.setCwarehouseid(wrkDetl.getStandby1());
                    checkOrderDetl.setIoTime(new Date());
                    checkOrderDetl.setStatus("0");
                    checkOrderDetlService.insert(checkOrderDetl);
                }
            }
            // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
            locMast = locMastService.selectById(dto.getLocNo());
            if (locMast.getLocSts().equals("F")) {
                locMast.setLocSts(ioType==101?"R":"P");
                locMast.setLocSts(ioType == 101 ? "R" : "P");
                locMast.setModiUser(userId);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("预约库位状态失败，库位号："+dto.getLocNo());
                    throw new CoolException("预约库位状态失败，库位号：" + dto.getLocNo());
                }
            } else {
                throw new CoolException(dto.getLocNo() + "库位不是在库状态");
@@ -281,9 +461,20 @@
        }
        // 获取库位
        LocMast locMast = locMastService.selectById(taskDto.getLocNo());
        // 获取路径
        int ioType = taskDto.isAll() ? 101 : 103;
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), staNo.getDevNo());
        // 判断是否是盘点单
        String orderNo = taskDto.getLocDtos().get(0).getOrderNo();
        OrderPakout orderPakout = orderPakOutService.selectByNo(orderNo);
        int ioType = orderPakout.getDocType() == 8 ? 107 : (taskDto.isAll() ? 101 : 103);
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), staNo.getDevNo(),locMast.getRow1());
        Integer crnStn = staDesc.getCrnStn();
        if (locMast.getCrnNo() == 1) {
            if (locMast.getRow1() <= 3) {
                crnStn = 1013;
            }else {
                crnStn = 1016;
            }
        }

        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
        // 生成工作档
@@ -294,7 +485,7 @@
        wrkMast.setIoType(ioType); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        wrkMast.setSourceStaNo(crnStn); // 源站
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        wrkMast.setSourceLocNo(taskDto.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
@@ -308,17 +499,38 @@
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败，出库库位号："+taskDto.getLocNo());
            throw new CoolException("保存工作档失败，出库库位号：" + taskDto.getLocNo());
        }
        // 生成工作档明细
        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 || locDto.getAnfme() <= 0.0D) {
                continue;
            }
//            OrderDetl orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch());
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch(), locDto.getBrand()
                    , locDto.getStandby1(), locDto.getStandby2(), locDto.getStandby3(), locDto.getBoxType1(), locDto.getBoxType2(), locDto.getBoxType3());
            if (orderDetlPakout == null) {
                orderDetlPakout = orderDetlPakoutService.selectOne(new EntityWrapper<OrderDetlPakout>()
                        .eq("order_no", locDto.getOrderNo())
                        .eq("matnr", locDto.getMatnr())
                        .eq("standby1", locDto.getStandby1())
                );
            }

            Wrapper<LocDetl> wrapper = new EntityWrapper<LocDetl>()
                    .eq("loc_no", wrkMast.getSourceLocNo())
                    .eq("matnr", orderDetlPakout.getMatnr());
            if (!Cools.isEmpty(locDto.getBatch())) {
                wrapper.eq("batch", locDto.getBatch());
            }
            if (!Cools.isEmpty(orderDetlPakout.getSpecs())) {
                wrapper.eq("specs", orderDetlPakout.getSpecs());
            }

            LocDetl locDetl = locDetlService.selectOne(wrapper);

            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(orderDetl);
            wrkDetl.sync(orderDetlPakout);
            wrkDetl.setZpallet(wrkMast.getBarcode());
            wrkDetl.setIoTime(now);
            wrkDetl.setWrkNo(workNo);
@@ -329,23 +541,39 @@
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            wrkDetl.setThreeCode(orderDetlPakout.getId() + "");
            wrkDetl.setSupp(orderPakout.getCstmrName());
            wrkDetl.setStockNum(locDetl.getAnfme());//库存
            wrkDetl.setStockNum2(locDetl.getWeight());//辅库存
            wrkDetl.setKpCstmrName(orderPakout.getKpCstmrName());
            wrkDetl.setCstateid(locDetl.getCstateid());

            //计算辅数量
            Double weight = MatUtils.calcWeight(wrkDetl.getMatnr(), wrkDetl.getAnfme());
            wrkDetl.setWeight(weight);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
            // 修改订单明细
            if (!orderDetlService.increase(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");
            }
            orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
//            // 修改订单明细
//            if (!orderDetlService.increaseWorkQty(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme())) {
//                throw new CoolException("修改订单明细数量失败");
//            }
//            orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
            orderDetlPakoutService.increaseWorkQtyById(orderDetlPakout.getId(), locDto.getAnfme());
//            OrderInAndOutUtil.increaseWorkQty(Boolean.FALSE, orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(),
//                    orderDetl.getBrand(), orderDetl.getStandby1(), orderDetl.getStandby2(), orderDetl.getStandby3(),
//                    orderDetl.getBoxType1(), orderDetl.getBoxType2(), orderDetl.getBoxType3()
//                    ,locDto.getAnfme() );
            OrderInAndOutUtil.updateOrder(Boolean.FALSE, orderDetlPakout.getOrderId(), 2L, userId);
        }
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        locMast = locMastService.selectById(taskDto.getLocNo());
        if (locMast.getLocSts().equals("F")) {
            locMast.setLocSts(ioType==101?"R":"P");
            locMast.setLocSts(ioType == 101 ? "R" : "P");
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("预约库位状态失败，库位号："+taskDto.getLocNo());
                throw new CoolException("预约库位状态失败，库位号：" + taskDto.getLocNo());
            }
        } else {
            throw new CoolException(taskDto.getLocNo() + "库位不是在库状态");
@@ -359,7 +587,9 @@
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, null, locTypeDto, 0);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNo(10, devpNo, findLocNoAttributeVo, locTypeDto, null);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
@@ -392,20 +622,20 @@
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiUser(userId);
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
        if (!basDevpService.updateById(sourceStaNo)) {
            throw new CoolException("更新源站失败");
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")){
        if (locMast.getLocSts().equals("O")) {
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
            throw new CoolException(dto.getLocNo() + "目标库位已被占用");
        }
        return dto.getLocNo();
    }
@@ -416,13 +646,23 @@
        if (Cools.isEmpty(param.getOutSite())) {
            throw new CoolException("站点不存在");
        }

        // 库位冻结不能出库
        String firstFrozenLocNo = locMastMapper.findFirstFrozenLocNo(param.getLocNos());
        if (firstFrozenLocNo != null) {
            throw new CoolException(firstFrozenLocNo + "库位已被冻结!");
        }

        for (String locNo : param.getLocNos()) {
            // 获取工作号
            int workNo = commonService.getWorkNo(WorkNoType.PAKOUT.type);
            // 获取库位
            LocMast locMast = locMastService.selectById(locNo);
            if (Cools.isEmpty(locMast)) {
                throw new CoolException(locNo+"库位不存在");
                throw new CoolException(locNo + "库位不存在");
            }
            if (!locMast.getLocSts().equals("D")) {
                throw new CoolException("所选库位存在状态不为D的库位，库位号：" + locMast.getLocNo() + " 、当前状态：" + locMast.getLocSts() + "-" + locMast.getLocSts$());
            }
            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
@@ -434,6 +674,14 @@
            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败");
            }
            if (locMast.getCrnNo() == 1) {
                if (locMast.getRow1() <= 3) {
                    sourceStaNo = 1013;
                }else {
                    sourceStaNo = 1016;
                }
            }

            Date now = new Date();
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
@@ -460,7 +708,7 @@
                throw new CoolException("保存工作档失败");
            }
            // 更新库位状态 D.空板 -> R.出库预约
            if (locMast.getLocSts().equals("D")){
            if (locMast.getLocSts().equals("D")) {
                locMast.setLocSts("R");
                locMast.setModiUser(userId);
                locMast.setModiTime(now);
@@ -473,6 +721,78 @@

    @Override
    @Transactional
    public WrkMast emptyPlateOut(EmptyPlateOutParam param) {
        WrkMast wrkMast = new WrkMast();
        if (Cools.isEmpty(param.getOutSite())) {
            throw new CoolException("站点不存在");
        }
        for (String locNo : param.getLocNos()) {
            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            // 获取库位
            LocMast locMast = locMastService.selectById(locNo);
            if (Cools.isEmpty(locMast)) {
                throw new CoolException(locNo + "库位不存在");
            }
            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
                    .eq("stn_no", param.getOutSite())
                    .eq("crn_no", locMast.getCrnNo());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            Integer sourceStaNo = staDesc.getCrnStn();
            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败");
            }
            if (locMast.getCrnNo() == 1) {
                if (locMast.getRow1() <= 3) {
                    sourceStaNo = 1013;
                }else {
                    sourceStaNo = 1016;
                }
            }

            Date now = new Date();
            // 保存工作档

            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(110); // 入出库状态： 110.空板出库
            wrkMast.setIoPri(10D);
            wrkMast.setSourceStaNo(sourceStaNo); // 源站
            wrkMast.setStaNo(param.getOutSite()); // 目标站
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceLocNo(locNo); // 源库位
            wrkMast.setFullPlt("N"); // 满板：Y
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk("Y"); // 空板
            wrkMast.setLinkMis("N");
            wrkMast.setAppeUser(1L);
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(1L);
            wrkMast.setModiTime(now);
            wrkMast.setMemo("生成自动空板出库");
            boolean res = wrkMastService.insert(wrkMast);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }
            // 更新库位状态 D.空板 -> R.出库预约
            if (locMast.getLocSts().equals("D")) {
                locMast.setLocSts("R");
                locMast.setModiUser(1L);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("更新库位状态失败");
                }
            }
        }
        return wrkMast;
    }

    @Override
    @Transactional
    public void locCheckOut(StockOutParam param, Long userId) {
        // 目标站点状态检测
        BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
@@ -480,13 +800,25 @@
        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.getBrand()
                        , paramLocDetl.getStandby1(), paramLocDetl.getStandby2(), paramLocDetl.getStandby3(), paramLocDetl.getBoxType1(), paramLocDetl.getBoxType2(), paramLocDetl.getBoxType3());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            // 启动出库开始 107.盘点出库
            stockOut(staNo, locDetlDtos, IoWorkType.CHECK_OUT, userId);
            // 库位号集合
            List<String> locNoList = param.getLocDetls().stream().map(StockOutParam.LocDetl::getLocNo).distinct().collect(Collectors.toList());
            String firstFrozenLocNo = locMastMapper.findFirstFrozenLocNo(locNoList);
            if (firstFrozenLocNo != null) {
                throw new CoolException(firstFrozenLocNo + "库位已被冻结!");
            }
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetlDtos.get(0).getLocDetl().getLocNo()));
            if (locMast.getLocSts().equals("F")) {
                // 启动出库开始 107.盘点出库
                stockOut(staNo, locDetlDtos, IoWorkType.CHECK_OUT, userId, param.getCheckId(), null);
            } else {
                throw new CoolException("所选库位存在状态不为F的库位，库位号：" + locMast.getLocNo() + " 、当前状态：" + locMast.getLocSts() + "-" + locMast.getLocSts$());
            }
        } else {
            throw new CoolException("库位物料不存在");
        }
@@ -497,12 +829,54 @@
    public void locMove(String sourceLocNo, String locNo, Long userId) {
        LocMast sourceLoc = locMastService.selectById(sourceLocNo);
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
        if (Cools.isEmpty(sourceLoc)){
        if (Cools.isEmpty(sourceLoc)) {
            throw new CoolException("未找到库位");
        }

        if (Utils.isDeepLoc(slaveProperties, sourceLocNo)) {
            String shallowLoc = Utils.getShallowLoc(slaveProperties, sourceLocNo);
            LocMast locMast = locMastService.selectById(shallowLoc);
            if (locMast == null) {
                throw new CoolException(shallowLoc + "浅库位不存在");
            }

            if(!locMast.getLocSts().equals("O")) {
                throw new CoolException(shallowLoc + "浅库位状态不为空");
            }
        }

        LocMast loc = locMastService.selectById(locNo);
        if (Cools.isEmpty(loc)){
        if (Cools.isEmpty(loc)) {
            throw new CoolException("未找到库位");
        }

        if (Utils.isDeepLoc(slaveProperties, locNo)) {
            String shallowLoc = Utils.getShallowLoc(slaveProperties, locNo);
            LocMast locMast = locMastService.selectById(shallowLoc);
            if (locMast == null) {
                throw new CoolException(shallowLoc + "浅库位不存在");
            }

            if(!locMast.getLocSts().equals("O")) {
                throw new CoolException(shallowLoc + "浅库位有货，无法移转");
            }
        }

        // 判断库位是否冻结
        String sourceLocFrozen = locMastMapper.findFirstFrozenLocNo(Arrays.asList(sourceLoc.getLocNo(), loc.getLocNo()));
        if (sourceLocFrozen != null) {
            throw new CoolException(sourceLocFrozen + "库位已被冻结!");
        }

        // 判断库存是否冻结
        Optional<LocDetl> first = locDetls.stream().filter(locDetl -> locDetl.getFrozen() == 1).findFirst();
        if (first.isPresent()) {
            LocDetl locDetl = first.get();
            throw new CoolException(locDetl.getLocNo() + "," + locDetl.getMatnr() + "," + locDetl.getBatch() + "库存明细已被冻结!");
        }

        if (!loc.getLocSts().equals("O") || (!sourceLoc.getLocSts().equals("F") && !sourceLoc.getLocSts().equals("D"))) {
            throw new CoolException("库位状态已改变");
        }
        if (!sourceLoc.getCrnNo().equals(loc.getCrnNo())) {
            throw new CoolException("移转库位属于不同堆垛机");
@@ -520,16 +894,17 @@
        wrkMast.setCrnNo(sourceLoc.getCrnNo());
        wrkMast.setSourceLocNo(sourceLocNo); // 源库位
        wrkMast.setLocNo(locNo); // 目标库位
        wrkMast.setFullPlt(Cools.isEmpty(locDetls)?"N":"Y"); // 满板：Y
        wrkMast.setFullPlt(Cools.isEmpty(locDetls) ? "N" : "Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D")?"Y":"N"); // 空板
        wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
        wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        wrkMast.setMemo("人工手动移库");
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
@@ -554,11 +929,11 @@
            sourceLoc.setLocSts("R"); // R.出库预约
            sourceLoc.setModiUser(userId);
            sourceLoc.setModiTime(now);
            if (!locMastService.updateById(sourceLoc)){
            if (!locMastService.updateById(sourceLoc)) {
                throw new CoolException("更新源库位状态失败");
            }
        } else {
            throw new CoolException("源库位出库失败，状态："+sourceLoc.getLocSts$());
            throw new CoolException("源库位出库失败，状态：" + sourceLoc.getLocSts$());
        }
        // 修改目标库位状态
        if (loc.getLocSts().equals("O")) {
@@ -569,7 +944,7 @@
                throw new CoolException("更新目标库位状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态："+loc.getLocSts$());
            throw new CoolException("移转失败，目标库位状态：" + loc.getLocSts$());
        }
    }

@@ -577,16 +952,16 @@
    @Transactional
    public void completeWrkMast(String workNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException(workNo + "工作档不存在");
        }
        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 14) {
            throw new CoolException("当前工作档已完成");
        }
        // 入库 + 库位转移
        if (wrkMast.getWrkSts() < 4 || (wrkMast.getWrkSts() > 10 && wrkMast.getIoType()==11)) {
        if (wrkMast.getWrkSts() < 4 || (wrkMast.getWrkSts() > 10 && wrkMast.getIoType() == 11)) {
            wrkMast.setWrkSts(4L);
        // 出库
            // 出库
        } else if (wrkMast.getWrkSts() > 10) {
            wrkMast.setWrkSts(14L);
        }
@@ -619,6 +994,31 @@

        List<LocDetlAdjustParam.LocDetlAdjust> list = param.getList();

        // 添加历史工作主档
        WrkMastLog wrkMast = new WrkMastLog();
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(5);
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceLocNo(locMast.getLocNo());
        wrkMast.setLocNo(locMast.getLocNo());
        wrkMast.setBarcode(locMast.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setAppeUser(userId);
        wrkMast.setModiUser(userId);

        // 增删改只创建一次工作主档
        boolean updateFlag = true;
        boolean deleteFlag = true;
        boolean addFlag = true;

        // 修改数量
        Iterator<LocDetl> iterator = locDetls.iterator();
        while (iterator.hasNext()) {
@@ -627,12 +1027,15 @@
            Iterator<LocDetlAdjustParam.LocDetlAdjust> iterator1 = list.iterator();
            while (iterator1.hasNext()) {
                LocDetlAdjustParam.LocDetlAdjust adjust = iterator1.next();
                if (adjust.getCount() == 0) { continue; }
                if (adjust.getCount() == 0) {
                    continue;
                }
                if (locDetl.getMatnr().equals(adjust.getMatnr()) && Cools.eq(locDetl.getBatch(), adjust.getBatch())) {
                    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.getBrand(),
                                adjust.getStandby1(), locDetl.getStandby2(), locDetl.getStandby3(), locDetl.getBoxType1(), locDetl.getBoxType2(), locDetl.getBoxType3())) {
                            throw new CoolException(locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "批号修改数量失败");
                        }
                        // 保存调整记录
@@ -647,6 +1050,30 @@
                        adjDetl.setAppeTime(now);
                        adjDetl.setAppeUser(userId);
                        adjDetlService.save(adjDetl, userId);

                        if (updateFlag) {
                            wrkMast.setWrkNo(commonService.getWorkNo(3));
                            wrkMast.setIoType(23);
                            boolean res = wrkMastLogService.insert(wrkMast);
                            if (!res) {
                                throw new CoolException("库存调整-修改 保存工作档失败");
                            }
                            updateFlag = false;
                        }

                        // 添加历史工作明细
                        WrkDetlLog wrkDetl = new WrkDetlLog();
                        wrkDetl.sync(locDetl);
                        wrkDetl.setWrkNo(wrkMast.getWrkNo());
                        wrkDetl.setIoTime(wrkMast.getIoTime());
                        wrkDetl.setAnfme(adjust.getCount());
                        wrkDetl.setAppeTime(now);
                        wrkDetl.setModiTime(now);
                        wrkMast.setAppeUser(userId);
                        wrkMast.setModiUser(userId);
                        if (!wrkDetlLogService.insert(wrkDetl)) {
                            throw new CoolException("保存工作明细失败");
                        }
                    }
                    iterator.remove();
                    iterator1.remove();
@@ -657,7 +1084,8 @@
        // 删除库存
        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.getBrand(),
                    locDetl.getStandby1(), locDetl.getStandby2(), locDetl.getStandby3(), locDetl.getBoxType1(), locDetl.getBoxType2(), locDetl.getBoxType3())) {
                throw new CoolException("删除" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "批号库存明细失败");
            }
            // 保存调整记录
@@ -672,16 +1100,43 @@
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);

            if (deleteFlag) {
                wrkMast.setWrkNo(commonService.getWorkNo(3));
                wrkMast.setIoType(22);
                boolean res = wrkMastLogService.insert(wrkMast);
                if (!res) {
                    throw new CoolException("库存调整-删除 保存工作档失败");
                }
                deleteFlag = false;
            }

            // 添加历史工作明细
            WrkDetlLog wrkDetl = new WrkDetlLog();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setAnfme(0.0);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            wrkMast.setAppeUser(userId);
            wrkMast.setModiUser(userId);
            if (!wrkDetlLogService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        }

        // 添加库存
        for (LocDetlAdjustParam.LocDetlAdjust adjust : list) {
            if (adjust.getCount() == 0.0D) { continue; }
            if (adjust.getCount() == 0.0D) {
                continue;
            }
            Mat mat = matService.selectByMatnr(adjust.getMatnr());
            LocDetl locDetl = new LocDetl();
            locDetl.sync(mat);
            locDetl.setBatch(adjust.getBatch());
            locDetl.setLocNo(locMast.getLocNo());
            locDetl.setZpallet(locMast.getBarcode());
            locDetl.setAnfme(adjust.getCount()); // 数量
            locDetl.setModiUser(userId); // 操作人员信息
            locDetl.setModiTime(now);
@@ -702,6 +1157,30 @@
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);

            if (addFlag) {
                wrkMast.setWrkNo(commonService.getWorkNo(3));
                wrkMast.setIoType(21);
                boolean res = wrkMastLogService.insert(wrkMast);
                if (!res) {
                    throw new CoolException("库存调整-新增 保存工作档失败");
                }
                addFlag = false;
            }

            // 添加历史工作明细
            WrkDetlLog wrkDetl = new WrkDetlLog();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setAnfme(adjust.getCount());
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            wrkMast.setAppeUser(userId);
            wrkMast.setModiUser(userId);
            if (!wrkDetlLogService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        }
        // 修改库位状态
        int count = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("loc_no", locMast.getLocNo()));
@@ -722,13 +1201,16 @@
        }
    }


    @Override
    @Transactional
    public void cancelWrkMast(String workNo, Long userId) {
        Date now = new Date();
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException(workNo + "工作档不存在");
        }
        if (wrkMast.getWrkSts() ==14|| wrkMast.getWrkSts() == 15) {
            throw new CoolException(workNo + "工作档已完成不允许取消");
        }
        String locNo = ""; // 待修改目标库位
        String locSts = ""; // 待修改目标库位状态
@@ -742,32 +1224,32 @@
                // 库位转移：源库位
                LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，源库位不存在:"+ wrkMast.getSourceLocNo());
                    throw new CoolException("取消库位转移失败，源库位不存在:" + wrkMast.getSourceLocNo());
                }
                locMast.setLocSts(wrkMast.getFullPlt().equalsIgnoreCase("N")?"D":"F");
                locMast.setModiTime(new Date());
                locMast.setLocSts(wrkMast.getFullPlt().equalsIgnoreCase("N") ? "D" : "F");
                locMast.setModiTime(now);
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
        // 出库取消（修改源库位）
            // 出库取消（修改源库位）
        } else if (wrkMast.getWrkSts() > 10 && wrkMast.getWrkSts() != 14) {
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() > 100 && wrkMast.getIoType() != 110) {
                locSts = "F";
            // 空板出库 ===>> D.空桶/空栈板
                // 空板出库 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 110) {
                locSts = "D";
            // 库位转移 ===>> D.空桶/空栈板
                // 库位转移 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 11) {
                locSts = wrkMast.getFullPlt().equalsIgnoreCase("N")?"D":"F";
                locSts = wrkMast.getFullPlt().equalsIgnoreCase("N") ? "D" : "F";
                // 库位转移：目标库位
                LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，目标库位不存在:"+ wrkMast.getSourceLocNo());
                    throw new CoolException("取消库位转移失败，目标库位不存在:" + wrkMast.getSourceLocNo());
                }
                locMast.setLocSts("O");
                locMast.setModiTime(new Date());
                locMast.setModiTime(now);
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
@@ -776,24 +1258,58 @@
        }

        //取消入库工作档时，查询组托表，如果有将状态改为待处理
        if(wrkMast.getIoType() == 1) {
            WaitPakin waitPakin = waitPakinService.selectOne(new EntityWrapper<WaitPakin>().eq("zpallet", wrkMast.getBarcode()));
            if (!Cools.isEmpty(waitPakin)) {
                waitPakin.setIoStatus("N");
                waitPakinService.update(waitPakin, new EntityWrapper<WaitPakin>().eq("zpallet", wrkMast.getBarcode()));
        if (wrkMast.getIoType() == 1) {
            List<WaitPakin> waitPakins = waitPakinService.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", wrkMast.getBarcode()));
            for (WaitPakin waitPakin : waitPakins) {
                if (!Cools.isEmpty(waitPakin)) {
                    waitPakin.setIoStatus("N");
                    waitPakin.setLocNo("");
                    waitPakinService.update(waitPakin, new EntityWrapper<WaitPakin>()
//                            .eq("order_no", waitPakin.getOrderNo())
                            .eq("zpallet", waitPakin.getZpallet())
                            .eq("matnr", waitPakin.getMatnr())
                            .eq("batch", waitPakin.getBatch()));
                }
            }
        }

        if(wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103) {
//            OrderDetl orderDetl = orderDetlService.selectItem()
        //取消出库工作档时，查询单据管理表，回滚作业中数量
        if (wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103) {
            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 (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
//                        throw new CoolException("订单数据回滚失败");
//                    }
                    OrderInAndOutUtil.decrease(Boolean.FALSE, wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getBrand(),
                            wrkDetl.getStandby1(), wrkDetl.getStandby2(), wrkDetl.getStandby3(),
                            wrkDetl.getBoxType1(), wrkDetl.getBoxType2(), wrkDetl.getBoxType3(), wrkDetl.getAnfme());

                    //修改订单主表状态,没有作业数量时才可以修改
                    boolean flag = true;
//                    List<OrderDetl> orderDetls = orderDetlService.selectList(new EntityWrapper<OrderDetl>().eq("order_no",wrkDetl.getOrderNo()));
                    Order order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, wrkDetl.getOrderNo());
                    List<OrderDetl> orderDetls = OrderInAndOutUtil.selectByOrderId(Boolean.FALSE, order.getId());
                    for (OrderDetl orderDetl : orderDetls) {
                        if (orderDetl.getWorkQty() > 0) {
                            flag = false;
                        }
                    }
                    if (flag) {
//                        Order order = orderService.selectOne(new EntityWrapper<Order>().eq("order_no",wrkDetl.getOrderNo()));
                        if (!Cools.isEmpty(order) && order.getSettle() == 2) {
                            order.setSettle(1L);
                            order.setUpdateBy(userId);
                            order.setUpdateTime(now);
                        }
//                        if(!orderService.update(order,new EntityWrapper<Order>().eq("order_no",wrkDetl.getOrderNo()))){
//                            throw new CoolException("修改订单状态失败");
//                        }
                        OrderInAndOutUtil.updateOrder(Boolean.FALSE, order.getId(), order.getSettle(), userId);
                    }
                }
            }

        }

//        // 订单关联
@@ -807,11 +1323,13 @@
////                        stockOutRe(wrkMast, wrkDetls);
//            }
//        }

        if (wrkMast.getIoType() == 107) {
            checkOrderDetlService.delete(new EntityWrapper<InventoryCheckOrderDetl>().eq("loc_no", locNo));
        }
        // 取消操作人员记录
        wrkMast.setManuType("手动取消");
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(new Date());
        wrkMast.setModiTime(now);
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("取消工作档失败");
        }
@@ -834,10 +1352,10 @@
        // 修改库位状态
        LocMast locMast = locMastService.selectById(locNo);
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("取消工作档失败，库位不存在:"+ locNo);
            throw new CoolException("取消工作档失败，库位不存在:" + locNo);
        }
        locMast.setLocSts(locSts);
        locMast.setModiTime(new Date());
        locMast.setModiTime(now);
        locMast.setModiUser(userId);
        boolean locMastRes = locMastService.updateById(locMast);
        if (!wrkMastRes || !locMastRes) {
@@ -849,8 +1367,8 @@
    @Transactional
    public void pickWrkMast(String workNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        if (Cools.isEmpty(wrkMast)) {
            throw new CoolException(workNo + "工作档不存在");
        }
        // 入出库类型判断
        if (wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) {
@@ -928,7 +1446,7 @@
        // 目标库位
        LocMast targetLoc = null;

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

            if (Utils.isShallowLoc(slaveProperties, curRow)) {
                Integer deepRow = Utils.getDeepRow(slaveProperties, curRow);
@@ -987,15 +1505,15 @@
            throw new CoolException("修改工作档失败");
        }
        // 修改库位状态 O ===>>> S
        if (targetLoc.getLocSts().equals("O")){
        if (targetLoc.getLocSts().equals("O")) {
            targetLoc.setLocSts("S"); // S.入库预约
            targetLoc.setModiUser(userId);
            targetLoc.setModiTime(now);
            if (!locMastService.updateById(targetLoc)){
            if (!locMastService.updateById(targetLoc)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(targetLoc.getLocNo()+"目标库位已被占用");
            throw new CoolException(targetLoc.getLocNo() + "目标库位已被占用");
        }
        // 禁用异常库位
//        locMast.setLocSts("X"); // X.禁用
@@ -1007,4 +1525,31 @@
        return targetLoc.getLocNo();
    }

    @Override
    @Transactional
    public void turnMatLocDetl(EmptyPlateOutParam param, Long userId) {
        Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("id", param.getMatId()));
        if (Cools.isEmpty(mat)) {
            throw new CoolException("目标库位商品编码有误！");
        }
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("matnr", param.getLocDetls().get(0).getMatnr()));
        if (Cools.isEmpty(locDetls) || locDetls.size() < 1) {
            throw new CoolException("待修改商品无库存，无需修改！  品号：" + param.getLocDetls().get(0).getMatnr());
        }
        try {
            locDetlService.updateMatTurn(param.getLocDetls().get(0).getMatnr(), mat.getMatnr());
        } catch (Exception e) {
            throw new CoolException("对数据库修改出错！");
        }
        for (LocDetl locDetl : locDetls) {
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locDetl.getLocNo());
            adjDetl.setMatnr(mat.getMatnr());
            adjDetl.setMatnrOld(param.getLocDetls().get(0).getMatnr());
            adjDetl.setAdjQty(locDetl.getAnfme());
            adjDetlService.save(adjDetl, userId);
        }
    }

}