3077,3106只有合格能出,2041 只有待判能出

pang.jiabao

6 天以前 e012a72a5660566d698c93ca4f29b6e5ffe997b0

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

@@ -1,22 +1,36 @@
package com.zy.asrs.task.handler;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.GwmsGenerateInventoryDto;
import com.zy.asrs.mapper.LocDetlMapper;
import com.zy.asrs.mapper.OrderDetlMapper;
import com.zy.asrs.mapper.OrderMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
import com.zy.common.constant.MesConstant;
import com.zy.common.utils.HttpHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.Date;
import java.util.List;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Created by vincent on 2020/7/4
 */
@Slf4j
@Service
@Transactional
public class WorkMastHandler extends AbstractHandler {
public class WorkMastHandler extends AbstractHandler<String> {

    @Autowired
    private WrkMastService wrkMastService;
@@ -28,314 +42,694 @@
    private LocDetlService locDetlService;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Resource
    private OrderDetlMapper orderDetlMapper;

    public void start() {
        List<WrkMast> wrkMasts = wrkMastService.selectToBeCompleteData();
        if (wrkMasts.isEmpty()) {
            return;
    @Resource
    private LocDetlMapper locDetlMapper;

    @Resource
    private ApiLogService apiLogService;

    @Resource
    private OrderMapper orderMapper;
    public ReturnT<String> start(WrkMast wrkMast) {
        // 4.入库完成
        if (wrkMast.getWrkSts() == 4) {
            return doIn(wrkMast);
        // 14.出库完成
        } else  if (wrkMast.getWrkSts() == 14) {
            return doOut(wrkMast);
        }
        for (WrkMast wrkMast : wrkMasts) {
            // 4.入库完成
            if (wrkMast.getWrkSts() == 4) {
                doIn(wrkMast);
            // 14.出库完成
            } else  if (wrkMast.getWrkSts() == 14) {
                doOut(wrkMast);
            }
        }
        return SUCCESS;
    }

    private void doIn(WrkMast wrkMast){
    private ReturnT<String> doIn(WrkMast wrkMast){
        Date now = new Date();
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        if (null == locMast) {
            exceptionHandle(""); // todo
            return;
        try {
            if (null == locMast && wrkMast.getIoType() != 3) {
//                exceptionHandle("工作档[workNo={0}]库位号错误[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return FAIL.setMsg("工作档[workNo=" + wrkMast.getWrkNo() + "]库位号错误[locNo=" + wrkMast.getLocNo() + "]");
            }
            assert locMast != null;
            switch (wrkMast.getIoType()) {
                // 空板入库
                case 10:
                    // 修改库位状态=D
                    if (locMast.getLocSts().equals("S") || locMast.getLocSts().equals("Q")) {
                        if (!Cools.isEmpty(wrkMast.getBarcode())) {
                            locMast.setBarcode(wrkMast.getBarcode());
                        }
                        locMast.setLocSts("D");
                        locMast.setIoTime(now);
                        locMast.setModiTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("空板入库 ===>> 修改库位状态失败;[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("空板入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    break;
                // 全板入库
                case 1:
                    // 清除所属库位之前的库存明细
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getLocNo()));
                    if (!locDetls.isEmpty()) {
                        locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getLocNo()));
                    }
                    // 根据工作号，查询工作明细档
                    List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls.isEmpty()) {
//                        exceptionHandle("全板入库 ===>> 工作明细档不存在；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("全板入库 ===>> 工作明细档不存在; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    // 遍历工作明细，更新库存明细和入库通知档
                    for (WrkDetl wrkDetl : wrkDetls) {

//                        LocDetl locDetl = locDetlService.selectItem(locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        if (null != locDetl) {
//                            if (!locDetlService.updateAnfme(wrkDetl.getAnfme(), wrkMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch())) {
////                                exceptionHandle("全板入库 ===>> 更新库存明细失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                return FAIL.setMsg("全板入库 ===>> 更新库存明细失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
//                            }
//                        } else {
                        LocDetl locDetl = new LocDetl();
                            locDetl.sync(wrkDetl);
                            locDetl.setLocNo(wrkMast.getLocNo()); // 库位号
                            locDetl.setAnfme(wrkDetl.getAnfme()); // 数量
                            locDetl.setZpallet(wrkMast.getBarcode()); // 托盘条码
                            locDetl.setBarcode(wrkMast.getBarcode());
                            locDetl.setModiTime(now);
                            locDetl.setAppeTime(now);
//                            locDetl.setBatch("");
                            if (!locDetlService.insert(locDetl)) {
//                                exceptionHandle("全板入库 ===>> 添加库存明细失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                return FAIL.setMsg("全板入库 ===>> 添加库存明细失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                            }
//                        }

                        // 更新订单完成数量
                        OrderDetl orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                        if (orderDetl==null){
                            orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                        }
                        try {
                            if(!Cools.isEmpty(orderDetl)){
                                if(!orderDetlService.increaseQtyByOrderNo(wrkDetl.getOrderNo(), wrkDetl.getMatnr(),
                                        orderDetl.getBatch(),wrkDetl.getAnfme())){
//                                    exceptionHandle("全板入库 ===>> 更新订单完成数量失败；[workNo={0}],[locNo={1}]",
//                                            wrkMast.getWrkNo(), wrkMast.getLocNo());
                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                    return FAIL.setMsg("全板入库 ===>> 更新订单完成数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                                }
                            }
                        } catch (Exception ignore){}

                    }
                    // 修改库位状态 S ====>> F
                    if (locMast.getLocSts().equals("S")) {
                        locMast.setLocSts("F");
                        locMast.setBarcode(wrkMast.getBarcode());
                        locMast.setSheetNo("0");
                        locMast.setIoTime(now);
                        locMast.setModiTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("全板入库 ===>> 修改库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("全板入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    // 入库完成上报mes
                    inBoundCompletePushMes(wrkMast,wrkDetls);
                    break;
                // 拣料入库
                case 53:
                    // 根据工作号，查询工作明细档
                    List<WrkDetl> wrkDetls53 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls53.isEmpty()) {
//                        exceptionHandle("拣料入库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("拣料入库 ===>> 工作明细档为空; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    for (WrkDetl wrkDetl : wrkDetls53) {

//                        LocDetl locDetl = locDetlService.selectItem(locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                        // 箱号+卷号
                        LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("batch",wrkDetl.getBatch())
                                .eq("model",wrkDetl.getModel()));
                        if (null != locDetl) {

//                            if (!locDetlService.updateAnfme(locDetl.getAnfme() - wrkDetl.getAnfme(), locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch())) {
                            if (!locDetlService.updateAnfme2(locDetl.getAnfme() - wrkDetl.getAnfme(), locMast.getLocNo(), wrkDetl.getModel(), wrkDetl.getBatch())) {
//                                exceptionHandle("拣料入库 ===>> 修改库存明细数量失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                return FAIL.setMsg("拣料入库 ===>> 修改库存明细数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                            }
                        }

                        // 更新订单完成数量
//                        OrderDetl orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        if (orderDetl==null){
//                            orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        }
//                        try {
//                            if(!Cools.isEmpty(orderDetl)){
//                                if(!orderDetlService.increaseQtyByOrderNo(wrkDetl.getOrderNo(), wrkDetl.getMatnr(),
//                                        orderDetl.getBatch(),wrkDetl.getAnfme())){
////                                    exceptionHandle("拣料入库 ===>> 更新订单完成数量失败；[workNo={0}],[locNo={1}]",
////                                            wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                    return FAIL.setMsg("拣料入库 ===>> 更新订单完成数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
//                                }
//                            }
//                        } catch (Exception ignore){}

                    }

                    // 修改捡料入库的库存明细的理货状态为待理货
                    locDetlMapper.updateLhStsByLocNo(wrkMast.getLocNo(),0);

                    // 修改库位状态 Q ====>> F
                    if (locMast.getLocSts().equals("Q")) {
                        locMast.setLocSts("F");
                        locMast.setBarcode(wrkMast.getBarcode());
                        locMast.setSheetNo("0");
                        locMast.setIoTime(now);
                        locMast.setModiTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("拣料入库 ===>> 修改库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("拣料入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    break;
                // 并板入库
                case 54:
                    // 根据工作号，查询工作明细档
                    List<WrkDetl> wrkDetls54 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls54.isEmpty()) {
//                        exceptionHandle("并板入库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("并板入库 ===>> 工作明细档为空; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    // 修改库存明细数量，如无库存，曾新增
                    for (WrkDetl wrkDetl:wrkDetls54) {

                        LocDetl locDetl = locDetlService.selectItem(locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                        if (null != locDetl) {
                            if (!locDetlService.updateAnfme(wrkDetl.getAnfme(), locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch())) {
//                                exceptionHandle("并板入库 ===>> 修改库存明细数量失败；[workNo={0}],[matnr={1}]", wrkMast.getWrkNo(), wrkDetl.getMatnr());
                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                return FAIL.setMsg("并板入库 ===>> 修改库存明细数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                            }
                        } else {
                            locDetl = new LocDetl();
                            locDetl.sync(wrkDetl);
                            locDetl.setLocNo(wrkMast.getLocNo()); // 库位号
                            locDetl.setAnfme(wrkDetl.getAnfme()); // 数量
                            locDetl.setZpallet(wrkDetl.getZpallet()); // 托盘条码
                            locDetl.setModiTime(now);
                            locDetl.setAppeTime(now);
                            if (!locDetlService.insert(locDetl)) {
//                                exceptionHandle("并板入库 ===>> 新增库存明细失败；[workNo={0}],[matnr={1}]", wrkMast.getWrkNo(), wrkDetl.getMatnr());
                                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                return FAIL.setMsg("并板入库 ===>> 新增库存明细失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                            }
                        }
                    }
                    // 修改库位状态 Q ====>> F
                    if (locMast.getLocSts().equals("Q")) {
                        locMast.setLocSts("F");
                        locMast.setBarcode(wrkMast.getBarcode());
                        locMast.setSheetNo("0");
                        locMast.setIoTime(now);
                        locMast.setModiTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("并板入库 ===>> 修改库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("并板入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    break;
                // 盘点入库
                case 57:
                    // 根据工作号，查询工作明细档
                    List<WrkDetl> wrkDetls57 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls57.isEmpty()) {
//                        exceptionHandle("盘点入库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("盘点入库 ===>> 工作明细档为空; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    for(WrkDetl wrkDetl : wrkDetls57) {
                        if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                            // 更新订单完成数量
                            orderDetlMapper.updateOrderDetlQtyByGroupNo(wrkDetl.getOrderNo(), wrkDetl.getBrand());
                        }
//                        OrderDetl orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        if (orderDetl==null){
//                            orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        }
//                        try {
//                            if(!Cools.isEmpty(orderDetl)){
//                                if(!orderDetlService.increaseQtyByOrderNo(wrkDetl.getOrderNo(), wrkDetl.getMatnr(),
//                                        orderDetl.getBatch(),wrkDetl.getAnfme())){
////                                    exceptionHandle("全板入库 ===>> 更新订单完成数量失败；[workNo={0}],[locNo={1}]",
////                                            wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                    return FAIL.setMsg("全板入库 ===>> 更新订单完成数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
//                                }
//                            }
//                        } catch (Exception ignore){}
                    }
                    // 修改库位状态 Q ====>> F
                    if (locMast.getLocSts().equals("Q")) {
                        locMast.setLocSts(wrkMast.getFullPlt().equals("Y")?"F":"D");
                        locMast.setBarcode(wrkMast.getBarcode());
                        locMast.setSheetNo("0");
                        locMast.setIoTime(now);
                        locMast.setModiTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("盘点入库 ===>> 修改库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("盘点入库 ===>> 修改库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    break;
                // 库位移转
                case 11:
                    // 默认目标库位是空板
                    String locSts = "D";
                    // 库位移转判断是否为空板移转
                    if (wrkMast.getEmptyMk().equals("N")) {
                        locSts = "F";
                        // 转移库存明细数据: 库存号 由工作档源库位变为目标库位
                        if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
//                            exceptionHandle("库位移转 ===>> 转移库存明细数据失败；[源库位={0}],[目标库位={1}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("库位移转 ===>> 转移库存明细数据失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    // 备货，更新订单明细及订单状态
                    List<WrkDetl> wrkDetlList = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (!wrkDetlList.isEmpty()) {
                        List<String> brands = wrkDetlList.stream().map(WrkDetl::getBrand).distinct().collect(Collectors.toList());
                        // 查询订单明细
                        List<OrderDetl> orderDetlList = orderDetlMapper.selectList(new EntityWrapper<OrderDetl>().in("brand", brands));
                        if (!orderDetlList.isEmpty()) {
                            // 更新明细为已备货
                            orderDetlMapper.updateOrderDetlStatusByPackageNo(brands,2);
                            // 获取订单号
                            String orderNo = orderDetlList.get(0).getOrderNo();
                            // 判断该订单明细是否全部已备货
                            Integer selectCount = orderDetlMapper.selectCount(new EntityWrapper<OrderDetl>().eq("order_no", orderNo).ne("inspect", 2));
                            if (selectCount == 0) {
                                // 更新订单为备货完成
                                orderMapper.updateStatusByOrderNo(orderNo,2,29);
                            }
                        }
                    }

                    // 修改源库位状态 ==> O
                    LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                    if (null != sourceLoc) {
                        sourceLoc.setBarcode("");
                        sourceLoc.setLocSts("O");
                        sourceLoc.setSheetNo("0");
                        sourceLoc.setModiTime(now);
                        sourceLoc.setIoTime(now);
                        if (!locMastService.updateById(sourceLoc)) {
//                            exceptionHandle("库位移转 ===>> 修改源库位状态失败；[workNo={0}],[sourceLoc={1}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("库位移转 ===>> 修改源库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    // 修改目标库位状态 ==> .locSts
                    locMast.setLocSts(locSts);
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setSheetNo("0");
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
//                        exceptionHandle("库位移转 ===>> 修改目标库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("库位移转 ===>> 修改目标库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    break;
                // 跨巷道库位移转完成
                case 12:
                    // 默认目标库位是空板
                    String locSts2 = "D";
                    // 库位移转判断是否为空板移转
                    if (wrkMast.getEmptyMk().equals("N")) {
                        locSts2 = "F";
                        // 转移库存明细数据: 库存号 由工作档源库位变为目标库位
                        if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
//                            exceptionHandle("库位移转 ===>> 转移库存明细数据失败；[源库位={0}],[目标库位={1}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("库位移转 ===>> 转移库存明细数据失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    // 跨巷道移库，更新订单明细及订单状态
                    List<WrkDetl> wrkDetlList2 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (!wrkDetlList2.isEmpty()) {
                        // 判断有无单据编号
                        Optional<WrkDetl> any = wrkDetlList2.stream().filter(wrkDetl -> wrkDetl.getOrderNo() != null).findAny();
                        if (any.isPresent()) {
                            String orderNo = any.get().getOrderNo();
                            // 根据单据编号和库位号查询单据明细
                            List<OrderDetl> orderDetlList = orderDetlMapper.selectList(new EntityWrapper<OrderDetl>().in("order_no",orderNo).eq("specs",wrkMast.getSourceLocNo()));
                            // 更新单据明细的移库状态
                            for(OrderDetl orderDetl: orderDetlList) {
                                orderDetl.setDanger(2);
                                orderDetl.setUpdateTime(now);
                                orderDetlMapper.updateById(orderDetl);
                            }
                            // 判断单据明细是不是全部移库完成
                            Integer count = orderDetlMapper.selectCount(new EntityWrapper<OrderDetl>().lt("danger", 2).eq("order_no", orderNo));
                            if (count == 0) {
                                // 更新单据为已完成
                                // 直接更新为6已上报，方便转储历史
                                orderMapper.updateSettleByOrderNo(orderNo,6,null);
                            }
                        }
                    } else { // 空板转移没有工作明细,但是要更新单据明细状态

                        // 只有一条作业中的移库单据
                        List<Order> orderList = orderMapper.selectList(new EntityWrapper<Order>().eq("doc_type", 24).le("settle", 3));
                        if(orderList.isEmpty()) {
                            log.error("没有获取到正在执行中的移库单据");
                        } else {
                            Order order = orderList.get(0);
                            // 根据单据编号和库位号查询单据明细
                            List<OrderDetl> orderDetlList = orderDetlMapper.selectList(new EntityWrapper<OrderDetl>().in("order_no",order.getOrderNo()).eq("specs",wrkMast.getSourceLocNo()));
                            // 更新单据明细的移库状态
                            for(OrderDetl orderDetl: orderDetlList) {
                                orderDetl.setDanger(2);
                                orderDetl.setUpdateTime(now);
                                orderDetlMapper.updateById(orderDetl);
                            }
                            // 判断单据明细是不是全部移库完成
                            Integer count = orderDetlMapper.selectCount(new EntityWrapper<OrderDetl>().lt("danger", 2).eq("order_no", order.getOrderNo()));
                            if (count == 0) {
                                // 更新单据为已完成
                                orderMapper.updateSettleByOrderNo(order.getOrderNo(),6,null);
                            }
                        }

                    }

                    // 修改源库位状态 ==> O
                    LocMast sourceLoc2 = locMastService.selectById(wrkMast.getSourceLocNo());
                    if (null != sourceLoc2) {
                        sourceLoc2.setBarcode("");
                        sourceLoc2.setLocSts("O");
                        sourceLoc2.setSheetNo("0");
                        sourceLoc2.setModiTime(now);
                        sourceLoc2.setIoTime(now);
                        if (!locMastService.updateById(sourceLoc2)) {
//                            exceptionHandle("库位移转 ===>> 修改源库位状态失败；[workNo={0}],[sourceLoc={1}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("库位移转 ===>> 修改源库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                        }
                    }
                    // 修改目标库位状态 ==> .locSts
                    locMast.setLocSts(locSts2);
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setSheetNo("0");
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
//                        exceptionHandle("库位移转 ===>> 修改目标库位状态失败；[workNo={0}],[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("库位移转 ===>> 修改目标库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
                    }
                    break;
                // 空闲理货入库
                case 59:

                    // 修改库位状态 S ====>> F
                    if (locMast.getLocSts().equals("S")) {
                        locMast.setLocSts("F");
                        locMast.setModiTime(now);
                        locMastService.updateById(locMast);
                    }

                    // 修改空闲理货入库的库存明细的理货状态为待理货
                    locDetlMapper.updateLhStsByLocNo(wrkMast.getLocNo(),0);
                    break;
                default:
                    break;
            }
            // 修改工作主档状态
            wrkMast.setWrkSts(5L);
            wrkMast.setModiTime(now);
            if (!wrkMastService.updateById(wrkMast)) {
//                exceptionHandle("更新入库完成状态失败;[workNo={0}]", wrkMast.getWrkNo());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return FAIL.setMsg("更新入库完成状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
            }
        } catch (Exception e) {
            log.error("fail", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return FAIL.setMsg(e.getMessage());
        }
        switch (wrkMast.getIoType()) {
            // 空板入库
            case 10:
                // 修改库位状态=D
                if (locMast.getLocType().equals("S") || locMast.getLocType().equals("Q")) {
                    locMast.setLocType("D");
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
        return SUCCESS;
    }

    private void inBoundCompletePushMes(WrkMast wrkMast, List<WrkDetl> wrkDetls) {
        GwmsGenerateInventoryDto gwmsGenerateInventoryDto = new GwmsGenerateInventoryDto();
        gwmsGenerateInventoryDto.setWarehouseType(4);
        gwmsGenerateInventoryDto.setBarcode(wrkMast.getBarcode());
        gwmsGenerateInventoryDto.setPalletizingNo(wrkMast.getStaNo());
        gwmsGenerateInventoryDto.setGroupOrderNumber(wrkMast.getMemo());
        List<GwmsGenerateInventoryDto.MatList> matLists = new ArrayList<>();
        for (WrkDetl wrkDetl : wrkDetls) {
            boolean flag = true;
            for (GwmsGenerateInventoryDto.MatList matList : matLists) {
                if (matList.getPackageGroupNo().equals(wrkDetl.getBrand())) {
                    matList.getRolls().add(new GwmsGenerateInventoryDto.Rolls(wrkDetl.getModel(),
                            wrkDetl.getUnit(), wrkDetl.getMaktx(), wrkDetl.getLength(),
                            Integer.parseInt(wrkDetl.getSpecs()), wrkDetl.getWeight(), wrkDetl.getVolume(),
                            wrkDetl.getManuDate()));
                    flag = false;
                    break;
                }
                break;
            // 全板入库
            case 1:
                // 清除所属库位之前的库存明细
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getLocNo()));
                if (!locDetls.isEmpty()) {
                    locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getLocNo()));
                }
                // 根据工作号，查询工作明细档
                List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls.isEmpty()) {
                    exceptionHandle(""); // todo
                }
                // 遍历工作明细，更新库存明细和入库通知档
                for (WrkDetl wrkDetl : wrkDetls) {
                    LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getLocNo()).eq("matnr", wrkDetl.getMatnr()));
                    if (null != locDetl) {
                        boolean res = locDetlService.updateAnfme(wrkDetl.getAnfme(), wrkMast.getLocNo(), wrkDetl.getMatnr());
                        if (!res) {
                            exceptionHandle(""); // todo
                        }
                    } else {
                        locDetl = new LocDetl(
                                wrkMast.getLocNo(), // 库位号
                                wrkDetl.getMatnr(), // 物料号
                                null,    // 仓库号
                                null,    // 转储请求编号
                                null,    // 行项目
                                null,    // 物料标签ID
                                wrkDetl.getMaktx(),    // 物料描述
                                null,    // 工厂
                                wrkDetl.getAnfme(),    // 数量
                                wrkDetl.getAltme(),    // 单位
                                wrkDetl.getZpallet(),    // 托盘条码
                                null,    // 用户ID
                                null,    // 备注
                                null,    // 修改人员
                                now,    // 修改时间
                                null,    // 创建者
                                now    // 添加时间
                        );
                        if (!locDetlService.insert(locDetl)) {
                            exceptionHandle(""); // todo
                        }
                    }
                    // 更新入库通知档 status ===>> Y
                    WaitPakin setParam = new WaitPakin();
                    setParam.setStatus("Y");
                    boolean updateRes = waitPakinService.update(setParam
                            , new EntityWrapper<WaitPakin>().eq("barcode", wrkDetl.getZpallet())
                                    .eq("matnr", wrkDetl.getMatnr())
                                    .eq("anfme", wrkDetl.getAnfme()));
                    if (!updateRes) {
                        exceptionHandle(""); // todo
                    }
                }
                // 修改库位状态 S ====>> F
                if (locMast.getLocType().equals("S")) {
                    locMast.setLocType("F");
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
                }
                break;
            // 拣料入库
            case 53:
                // 根据工作号，查询工作明细档
                List<WrkDetl> wrkDetls53 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls53.isEmpty()) {
                    exceptionHandle(""); // todo
                }
                for (WrkDetl wrkDetl:wrkDetls53) {
                    // 修改库存明细数量，如果工作明细数量为0时，删除库存明细
                    LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", locMast.getLocNo()).eq("matnr", wrkDetl.getMatnr()));
                    if (null != locDetl) {
                        if (!locDetlService.updateAnfme(wrkDetl.getAnfme(), locMast.getLocNo(), wrkDetl.getMatnr())) {
                            exceptionHandle(""); // todo
                        }
                        // todo:luxiaotao 3)修改出库通知档 status ==> Y
                    }
                }
                // 修改库位状态 Q ====>> F
                if (locMast.getLocType().equals("Q")) {
                    locMast.setLocType("F");
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
                }
                break;
            // 并板入库
            case 54:
                // 根据工作号，查询工作明细档
                List<WrkDetl> wrkDetls54 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls54.isEmpty()) {
                    exceptionHandle(""); // todo
                }
                // 修改库存明细数量，如无库存，曾新增
                for (WrkDetl wrkDetl:wrkDetls54) {
                    LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("loc_no", locMast.getLocNo()).eq("matnr", wrkDetl.getMatnr()));
                    if (null != locDetl) {
                        if (!locDetlService.updateAnfme(wrkDetl.getAnfme(), locMast.getLocNo(), wrkDetl.getMatnr())) {
                            exceptionHandle(""); // todo
                        }
                    } else {
                        locDetl = new LocDetl(
                                wrkMast.getLocNo(), // 库位号
                                wrkDetl.getMatnr(), // 物料号
                                null,    // 仓库号
                                null,    // 转储请求编号
                                null,    // 行项目
                                null,    // 物料标签ID
                                wrkDetl.getMaktx(),    // 物料描述
                                null,    // 工厂
                                wrkDetl.getAnfme(),    // 数量
                                wrkDetl.getAltme(),    // 单位
                                wrkDetl.getZpallet(),    // 托盘条码
                                null,    // 用户ID
                                null,    // 备注
                                null,    // 修改人员
                                now,    // 修改时间
                                null,    // 创建者
                                now    // 添加时间
                        );
                        if (!locDetlService.insert(locDetl)) {
                            exceptionHandle(""); // todo
                        }
                    }
                    // todo:luxiaotao 3)修改出库通知档 status ==> Y
                }
                // 修改库位状态 Q ====>> F
                if (locMast.getLocType().equals("Q")) {
                    locMast.setLocType("F");
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
                }
                break;
            // 盘点入库
            case 57:
                // 根据工作号，查询工作明细档
                List<WrkDetl> wrkDetls57 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls57.isEmpty()) {
                    exceptionHandle(""); // todo
                }
                // todo:luxiaotao 3)修改盘点通知档 status ==> Y
                // 修改库位状态 Q ====>> F
                if (locMast.getLocType().equals("Q")) {
                    locMast.setLocType("F");
                    locMast.setBarcode(wrkMast.getBarcode());
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
                }
                break;
            // 库位移转
            case 11:
                // 默认目标库位是空板
                String locType = "D";
                // 库位移转判断是否为空板移转
                if (wrkMast.getEmptyMk().equals("N")) {
                    locType = "F";
                    // 转移库存明细数据: 库存号 由工作档源库位变为目标库位
                    if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
                        exceptionHandle(""); // todo
                    }
                }
                // todo:luxiaotao 3)修改盘点通知档 status ==> Y
                // 修改源库位状态 ==> O
                LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                if (null != sourceLoc) {
                    sourceLoc.setBarcode("");
                    sourceLoc.setLocType("O");
                    sourceLoc.setModiTime(now);
                    sourceLoc.setIoTime(now);
                    if (!locMastService.updateById(sourceLoc)) {
                        exceptionHandle(""); // todo
                    }
                }
                // 修改目标库位状态 ==> .locType
                locMast.setLocType(locType);
                locMast.setBarcode(wrkMast.getBarcode());
                locMast.setIoTime(now);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    exceptionHandle(""); // todo
                }
                break;
            default:
                break;
            }
            if (flag) {
                GwmsGenerateInventoryDto.MatList matList = new GwmsGenerateInventoryDto.MatList();
                matList.setBoxPos(wrkDetl.getOrigin());
                matList.setPackageGroupNo(wrkDetl.getBrand());
                matList.setOutOrIn("in");
                matList.setStockType(wrkMast.getWhsType() == 1 ? "返修入库" : "成品入库");
                matList.setBoxType(wrkDetl.getColor());
                matList.setRollType(wrkDetl.getManu());
                matList.setWideInWidth(wrkDetl.getSku());
                matList.setThickness(wrkDetl.getItemNum());
                List<GwmsGenerateInventoryDto.Rolls> rollsList = new ArrayList<>();
                GwmsGenerateInventoryDto.Rolls roll = new GwmsGenerateInventoryDto.Rolls(wrkDetl.getModel(),
                        wrkDetl.getUnit(), wrkDetl.getMaktx(), wrkDetl.getLength(),
                        Integer.parseInt(wrkDetl.getSpecs()), wrkDetl.getWeight(), wrkDetl.getVolume(),
                        wrkDetl.getManuDate());
                rollsList.add(roll);
                matList.setRolls(rollsList);
                matLists.add(matList);
            }
        }
        // 修改工作主档状态
        wrkMast.setWrkSts(5L);
        wrkMast.setModiTime(now);
        if (!wrkMastService.updateById(wrkMast)) {
            exceptionHandle(""); // todo
        gwmsGenerateInventoryDto.setMatList(matLists);


        boolean success = false;
        // 获取请求头
        Map<String, Object> headers = new HashMap<>();
        headers.put("Content-Type", "application/json;charset=UTF-8");

        // 构造请求体
        String body = JSON.toJSONString(gwmsGenerateInventoryDto);
        String response = "";
        try {
            response = new HttpHandler.Builder()
                    .setUri(MesConstant.MES_CC_IP_PORT)
                    .setPath(MesConstant.MES_CC_FXRK_URL)
                    .setHeaders(headers)
                    .setJson(body)
                    .build()
                    .doPost();
            if (!Cools.isEmpty(response)) {
                JSONObject jsonObject1 = JSONObject.parseObject(response);
                int code = (int) jsonObject1.get("code");
                boolean state = jsonObject1.getBoolean("state");
                if (code == 200 && state) {
                    success = true;
                }
            } else {
                log.error("入库完成推送mes失败！！！url：{}；request：{}；response：{}", MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_FXRK_URL, body, response);
            }
        } catch (Exception e) {
            log.error("入库完成推送mes异常：{}", e.getMessage());
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        "入库完成推送mes",
                        MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_FXRK_URL,
                        null,
                        "127.0.0.1",
                        body,
                        response,
                        success
                );
            } catch (Exception e) {
                log.error("", e);
            }
        }
    }

    private void doOut(WrkMast wrkMast){
    private ReturnT<String> doOut(WrkMast wrkMast){
        Date now = new Date();
        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == locMast) {
            exceptionHandle(""); // todo
            return;
        }
        switch (wrkMast.getIoType()) {
            // 全板出库
            case 101:
                // 根据工作号，查询工作明细档
                List<WrkDetl> wrkDetls101 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                if (wrkDetls101.isEmpty()) {
                    exceptionHandle(""); // todo
                }
                for (WrkDetl wrkDetl : wrkDetls101) {
                    // todo:luxiaotao 3)修改出库通知档 status ==> Y
                }
                // 删除工作档源库位的库存明细
                if (!locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()))) {
                    exceptionHandle(""); // todo
                }
                // 修改库位状态 R ===>> O
                if (locMast.getLocType().equals("R")) {
                    locMast.setLocType("O");
                    locMast.setBarcode("");
                    locMast.setModiTime(now);
                    locMast.setIoTime(now);
                    if (!locMastService.updateById(locMast)) {
                        exceptionHandle(""); // todo
                    }
                }
                break;
            // 空板出库
            case 110:

                break;
            default:
                break;
        }
    }




    public static void main(String[] args) {
        for (int i = 0;i<10;i++) {

            try {

                System.out.println("====" + i);
                if (i == 5){
                    throw new Exception("dsa");
                }
                System.out.println("----" + i);

            } catch (Exception e) {
                e.printStackTrace();
        try {
            if (null == locMast) {
//                exceptionHandle("工作档[workNo={0}]库位号错误[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return FAIL.setMsg("工作档库位号错误; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
            }



            assert locMast != null;
            switch (wrkMast.getIoType()) {
                // 全板出库
                case 101:
//                    // 出库确认信号位
//                    if (Cools.isEmpty(wrkMast.getInvWh()) || wrkMast.getInvWh().equals("N")) {
//                        return SUCCESS;
//                    }
                    // 根据工作号，查询工作明细档
                    List<WrkDetl> wrkDetls101 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls101.isEmpty()) {
//                        exceptionHandle("全板出库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("全板出库 ===>> 工作明细档为空; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
                    }
                    for (WrkDetl wrkDetl : wrkDetls101) {
                        if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                            // 更新订单完成数量
                            orderDetlMapper.updateOrderDetlQtyByGroupNo(wrkDetl.getOrderNo(), wrkDetl.getBrand());
                        }
                        // 更新订单完成数量
//                        OrderDetl orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        if (orderDetl==null){
//                            orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), null);
//                        }
//                        // 箱号+卷号
//                        OrderDetl orderDetl = orderDetlService.selectOne(new EntityWrapper<OrderDetl>().eq("batch",wrkDetl.getBatch())
//                                .eq("model",wrkDetl.getModel()));
//
//                        try {
//                            if(!Cools.isEmpty(orderDetl)){
//                                // 更新订单完成数量
////                                orderDetlService.update(null,new EntityWrapper<OrderDetl>().eq("order_no",orderDetl.getOrderNo())
////                                        .eq("batch",orderDetl.getBatch()).eq("model", orderDetl.getModel()));
//                                if(!orderDetlService.increaseQtyByOrderNo(wrkDetl.getOrderNo(), orderDetl.getModel(),
//                                        orderDetl.getBatch(),wrkDetl.getAnfme())){
////                                    exceptionHandle("全板出库 ===>> 更新订单完成数量失败；[workNo={0}],[locNo={1}]",
////                                            wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                    return FAIL.setMsg("全板出库 ===>> 更新订单完成数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
//                                }
//                            }
//                        } catch (Exception ignore){}
                    }
                    // 删除工作档源库位的库存明细
                    if (!locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()))) {
//                        exceptionHandle("全板出库 ===>> 删除库存明细失败；[workNo={0}],[sourceLocNo={1}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("全板出库 ===>> 删除库存明细失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
                    }
                    // 修改源库位状态 R ===>> O
                    if (locMast.getLocSts().equals("R")) {
                        locMast.setLocSts("O");
                        locMast.setBarcode("");
                        locMast.setSheetNo("0");
                        locMast.setModiTime(now);
                        locMast.setIoTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("全板出库 ===>> 修改源库位状态失败；[workNo={0}],[sourceLocNo={1}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("全板出库 ===>> 修改源库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
                        }
                    }
                    break;
                // 空板出库
                case 110:
                    // 修改库位状态 R ===>> O
                    if (locMast.getLocSts().equals("R")) {
                        locMast.setLocSts("O");
                        locMast.setBarcode("");
                        locMast.setModiTime(now);
                        locMast.setIoTime(now);
                        if (!locMastService.updateById(locMast)) {
//                            exceptionHandle("空板出库 ===>> 修改源库位状态失败；[workNo={0}],[sourceLocNo={1}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return FAIL.setMsg("空板出库 ===>> 修改源库位状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
                        }
                    }
                    break;
                // 理货贴标出库
                case 111:
                    List<WrkDetl> wrkDetls111 = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
                    if (wrkDetls111.isEmpty()) {
//                        exceptionHandle("全板出库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return FAIL.setMsg("全板出库 ===>> 工作明细档为空; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
                    }
                    for (WrkDetl wrkDetl : wrkDetls111) {
                        // 更新订单完成数量
                        if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                            // 更新订单完成数量
                            orderDetlMapper.updateOrderDetlQtyByGroupNo(wrkDetl.getOrderNo(), wrkDetl.getBrand());
                        }
//                        OrderDetl orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        if (orderDetl == null) {
//                            orderDetl = orderDetlService.selectItem(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
//                        }
//                        try {
//                            if (!Cools.isEmpty(orderDetl)) {
//                                if (!orderDetlService.increaseQtyByOrderNo(wrkDetl.getOrderNo(), wrkDetl.getMatnr(),
//                                        orderDetl.getBatch(), wrkDetl.getAnfme())) {
////                                    exceptionHandle("拣料入库 ===>> 更新订单完成数量失败；[workNo={0}],[locNo={1}]",
////                                            wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                                    return FAIL.setMsg("拣料入库 ===>> 更新订单完成数量失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getLocNo() + "]");
//                                }
//                            }
//                        } catch (Exception ignore) {
//                        }
                    }
                    break;
                default:
                    break;
            }
            // 修改工作主档状态
            wrkMast.setWrkSts(15L);
            wrkMast.setModiTime(now);
            if (!wrkMastService.updateById(wrkMast)) {
//                exceptionHandle("更新出库完成状态失败;[workNo={0}]", wrkMast.getWrkNo());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return FAIL.setMsg("更新出库完成状态失败; [workNo=" + wrkMast.getWrkNo() + "],[locNo=" + wrkMast.getSourceLocNo() + "]");
            }
        } catch (Exception e) {
            log.error("fail", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return FAIL.setMsg(e.getMessage());
        }
        return SUCCESS;
    }

}