*

lsh

昨天 ced2fc10af63b23402352f675f8b1e3c241c42ab

*

 src/main/java/com/zy/asrs/entity/param/OrderInspectionRollParam.java

New file
@@ -0,0 +1,12 @@
package com.zy.asrs.entity.param;

public class OrderInspectionRollParam {

    private String batchNo;//卷号

    public OrderInspectionRollParam() {}

    public OrderInspectionRollParam(String batchNo) {
        this.batchNo = batchNo;
    }
}

 src/main/java/com/zy/asrs/service/WorkService.java

@@ -32,6 +32,7 @@
     */
    void startupFullTakeStoreOrder(StockOutParam param, Long userId);
    void startupFullTakeStoreOrderPakout(StockOutParam param, Long userId);
    void startupFullTakeStoreOutGroupOrderForm(StockOutParam param, Long userId);
    void startupFullTakeStoreOrderGift(StockOutParam param, Long userId);

    /**

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

@@ -405,6 +405,108 @@

    @Override
    @Transactional
    public void startupFullTakeStoreOutGroupOrderForm(StockOutParam param, Long userId) {
        if (Cools.isEmpty(param) || Cools.isEmpty(param.getLocDetls())){
            throw new CoolException("参数为空");
        }
        if (Cools.isEmpty(param.getOrderNo())){
            throw new CoolException("订单号参数为空");
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderName(), Boolean.FALSE);
        Order order = orderService.selectByNo(param.getOrderNo());
        if (Cools.isEmpty(order)){
            Date now = new Date();
            order = new Order(
                    String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                    param.getOrderNo(),    // 订单编号
                    DateUtils.convert(now),    // 单据日期
                    docType.getDocId(),    // 单据类型
                    null,    // 项目编号
                    param.getGroupGoodsNo(),    //组货单号
                    null,    // 调拨项目编号
                    null,    // 初始票据号
                    null,    // 票据号
                    null,    // 客户编号
                    param.getCstmrName(),    // 客户
                    null,    // 联系方式
                    null,    // 操作人员
                    null,    // 合计金额
                    null,    // 优惠率
                    null,    // 优惠金额
                    null,    // 销售或采购费用合计
                    null,    // 实付金额
                    null,    // 付款类型
                    null,    // 业务员
                    null,    // 结算天数
                    null,    // 邮费支付类型
                    null,    // 邮费
                    null,    // 付款时间
                    null,    // 发货时间
                    null,    // 物流名称
                    null,    // 物流单号
                    2L,    // 订单状态
                    1,    // 状态
                    userId,    // 添加人员
                    now,    // 添加时间
                    userId,    // 修改人员
                    now,    // 修改时间
                    null    // 备注
            );
            if (!orderService.insert(order)) {
                throw new CoolException("保存订单主档失败");
            }
            // 单据明细档
            List<DetlDto> list = new ArrayList<>();
            List<StockOutParam.LocDetl> locDetls = param.getLocDetls();
            int i=0;
            for (StockOutParam.LocDetl locDetl : locDetls) {
                i++;
                Mat mat = matService.selectByMatnr(locDetl.getMatnr());
                if (Cools.isEmpty(mat)) {
                    throw new CoolException(locDetl.getMatnr() + "物料编码检索失败，请先添加商品");
                }
                OrderDetl orderDetl = new OrderDetl();
                orderDetl.sync(mat);
                orderDetl.setSuppCode(String.valueOf(i));  // 行号
                orderDetl.setManu(locDetl.getLocNo());  //库位号
                orderDetl.setBatch(locDetl.getBatch()); //木箱编码
                orderDetl.setAnfme(locDetl.getAnfme());//出库数量
                orderDetl.setModel(locDetl.getModel());//批次
                orderDetl.setSpecs(locDetl.getSpecs());//规格
                orderDetl.setBrand(locDetl.getBrand());//木箱类型
                orderDetl.setBarcode(locDetl.getZpallet());//木箱类型
                orderDetl.setDanger(locDetl.getDanger());//木箱类型
                orderDetl.setWeight(locDetl.getWeight());
//                orderDetl.setWorkQty(locDetl.getAnfme());
                orderDetl.setWorkQty(0.0);
                orderDetl.setOrderId(order.getId());
                orderDetl.setOrderNo(order.getOrderNo());
                orderDetl.setOrigin(locDetl.getOrigin());
                orderDetl.setCreateBy(userId);
                orderDetl.setCreateTime(now);
                orderDetl.setUpdateBy(userId);
                orderDetl.setUpdateTime(now);
                orderDetl.setStatus(1);
                orderDetl.setQty(0.0D);
                orderDetl.setMemo(locDetl.getMemo());
                if (!orderDetlService.insert(orderDetl)) {
                    throw new CoolException("生成单据明细失败，请联系管理员");
                }
            }

            List<StockOutParam> stockOutParams = OutboundAllocationUtil.OutboundClassification(param);
            for (StockOutParam stockOutParam : stockOutParams){
                startupFullTakeStore(stockOutParam,userId);
            }

        } else {
            throw new CoolException("订单号重复，订单"+param.getOrderNo()+"已存在！！！");
        }

    }

    @Override
    @Transactional
    public void startupFullTakeStoreOrderGift(StockOutParam param, Long userId) {
        if (Cools.isEmpty(param) || Cools.isEmpty(param.getLocDetls())){
            throw new CoolException("参数为空");

 src/main/java/com/zy/asrs/task/GroupOrderFormScheduler.java

@@ -28,38 +28,61 @@

    @Scheduled(cron = "0/5 * * * * ? ")
    public void abandonedGroupOrderForm(){
        String erpReport = Parameter.get().getErpReport();
        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<OrderPakout> orders = orderPakoutService.selectSettle(99L);
            for (OrderPakout order : orders) {
                try{
                    ReturnT<String> result = groupOrderFormHandler.abandoned(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                    }
                }catch (Exception e){
                    log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                    log.error("订单"+order+"处理失败，异常信息："+e);
        List<OrderPakout> orders = orderPakoutService.selectSettle(99L);//废弃
        if (orders.isEmpty()){
            return;
        }
        for (OrderPakout order : orders) {
            try{
                ReturnT<String> result = groupOrderFormHandler.abandoned(order);
                if (!result.isSuccess()) {
                    log.error("计划组货单[orderNo={}]废弃清除失败", order.getOrderNo());
                }
            }catch (Exception e){
                log.error("计划组货单[orderNo={}]废弃清除失败", order.getOrderNo());
                log.error("计划组货单"+order+"废弃清除失败，异常信息："+e);
            }
        }
    }

    @Scheduled(cron = "0/5 * * * * ? ")
    public void outGroupOrderForm(){
        String erpReport = Parameter.get().getErpReport();
        if (!Cools.isEmpty(erpReport) && erpReport.equals("true")) {
            List<OrderPakout> orders = orderPakoutService.selectSettle(11L);
            for (OrderPakout order : orders) {
                try{
                    ReturnT<String> result = groupOrderFormHandler.start(order);
                    if (!result.isSuccess()) {
                        log.error("单据[orderNo={}]上报erp失败", order.getOrderNo());
                    }
                }catch (Exception e){
                    log.error("计划组货单[orderNo={}]出库失败", order.getOrderNo());
                    log.error("订单"+order+"处理失败，异常信息："+e);
    @Scheduled(cron = "0/30 * * * * ? ")
    public void inspectionGroupOrderForm(){
        List<OrderPakout> orders = orderPakoutService.selectSettle(11L);//检验
        if (orders.isEmpty()){
            return;
        }
        for (OrderPakout order : orders) {
            try{
                ReturnT<String> result = groupOrderFormHandler.inspection(order);
                if (!result.isSuccess()) {
                    log.error("计划组货单[orderNo={}]查询卷号存在不合格", order.getOrderNo());
                } else {
                    orderPakoutService.updateSettle(order.getId(),12L,0L);//检验合格
                }
            }catch (Exception e){
                log.error("计划组货单[orderNo={}]查询卷号失败", order.getOrderNo());
                log.error("计划组货单"+order+"查询卷号失败，异常信息："+e);
            }
        }
    }

    @Scheduled(cron = "0/10 * * * * ? ")
    public void outGroupOrderForm(){
        List<OrderPakout> orders = orderPakoutService.selectSettle(12L);//出库
        if (orders.isEmpty()){
            return;
        }
        for (OrderPakout order : orders) {
            try{
                ReturnT<String> result = groupOrderFormHandler.start(order);
                if (!result.isSuccess()) {
                    log.error("计划组货单[orderNo={}]检验出库失败", order.getOrderNo());
                } else {
                    orderPakoutService.updateSettle(order.getId(),15L,0L);//检验合格
                }
            }catch (Exception e){
                log.error("计划组货单[orderNo={}]检验出库失败", order.getOrderNo());
                log.error("计划组货单"+order+"检验出库失败，异常信息："+e);
            }
        }
    }

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

@@ -1,18 +1,30 @@
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.core.common.R;
import com.core.common.SnowflakeIdWorker;
import com.zy.asrs.entity.OrderDetlPakout;
import com.zy.asrs.entity.OrderPakout;
import com.zy.asrs.service.OrderDetlPakoutService;
import com.zy.asrs.service.OrderDetlService;
import com.zy.asrs.service.OrderPakoutService;
import com.zy.asrs.service.OrderService;
import com.zy.asrs.entity.param.OrderCargoBookingNoteParam;
import com.zy.asrs.entity.param.OrderInspectionRollParam;
import com.zy.asrs.entity.param.OrderOutLocBoxCsUtilParam;
import com.zy.asrs.service.*;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.utils.CodeDetectionUtil;
import com.zy.asrs.utils.OrderOutBatchUtil;
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 java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
@@ -23,26 +35,188 @@
@Service
public class GroupOrderFormHandler extends AbstractHandler<String> {
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private OrderPakoutService orderPakoutService;
    @Autowired
    private OrderDetlPakoutService orderDetlPakoutService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;

    @Transactional
    public ReturnT<String> abandoned(OrderPakout orderPakout) {
        List<OrderDetlPakout> orderDetls = orderDetlPakoutService.selectByOrderId(orderPakout.getId());

        moveBoth(orderPakout,orderDetls);
        return SUCCESS;
    }

    private void moveBoth(OrderPakout order, List<OrderDetlPakout> orderDetls){
        Date now = new Date();
        if (!Cools.isEmpty(orderDetls)) {
            for (OrderDetlPakout orderDetl : orderDetls) {
                orderDetl.setUpdateBy(0L);
                orderDetl.setUpdateTime(now);
//                orderDetlPakoutService.addToLogTable(orderDetl);
                orderDetlPakoutService.delete(new EntityWrapper<OrderDetlPakout>()
                        .eq("id",orderDetl.getId()));
            }
        }
        if (!Cools.isEmpty(order)){
            order.setUpdateBy(0L);
            order.setUpdateTime(now);
//            orderPakoutService.addToLogTable(order);
            orderPakoutService.delete(new EntityWrapper<OrderPakout>()
                    .eq("id",order.getId()));
        }
    }

    @Transactional
    public ReturnT<String> inspection(OrderPakout orderPakout) {
        List<OrderDetlPakout> orderDetls = orderDetlPakoutService.selectByOrderId(orderPakout.getId());
        String memo = "";
        for (OrderDetlPakout orderDetl : orderDetls) {
            if (!CodeDetectionUtil.barcodeDetection(orderDetl.getManu(),7)){
                if (Cools.isEmpty(memo)){
                    memo = "无库存";
                }else {
                    memo = memo+";无库存";
                }
                continue;
            }
            if (Cools.isEmpty(orderDetl.getDanger$()) || orderDetl.getDanger()==1){//合格不需要检验
                continue;
            }
            OrderInspectionRollParam orderInspectionRollParam = new OrderInspectionRollParam(orderDetl.getModel());
            String response = "";
            boolean success = false;
            try {
                response = new HttpHandler.Builder()
                        .setUri(MesConstant.URL)
                        .setPath(MesConstant.PAKIN_URL)
                        .setJson(JSON.toJSONString(orderInspectionRollParam))
                        .build()
                        .doPost();
                JSONObject jsonObject = JSON.parseObject(response);
                if (jsonObject.getInteger("code").equals(200)) {
                    if (jsonObject.getBoolean("state")) {
                        String value = jsonObject.getString("value");
                        if (value.equals("合格")){
                            orderDetl.setDanger(1);
                            orderDetlPakoutService.updateById(orderDetl);
                        } else if (value.equals(orderDetl.getDanger$())){
                            if (Cools.isEmpty(memo)){
                                memo = "查询卷号结果："+jsonObject.getString("message");
                            }else {
                                memo = memo+";查询卷号结果："+jsonObject.getString("message");
                            }
                            continue;
                        } else {
                            if (Cools.isEmpty(memo)){
                                memo = "查询卷号结果："+jsonObject.getString("message");
                            }else {
                                memo = memo+";查询卷号结果："+jsonObject.getString("message");
                            }
                            if (value.equals("不合格")){
                                orderDetl.setDanger(2);
                                orderDetlPakoutService.updateById(orderDetl);
                            }
                            continue;
                        }
                    } else {
                        if (Cools.isEmpty(memo)){
                            memo = "查询卷号结果："+jsonObject.getString("message");
                        }else {
                            memo = memo+";查询卷号结果："+jsonObject.getString("message");
                        }
                    }
                    success = true;
                } else {
                    if (Cools.isEmpty(memo)){
                        memo = "查询卷号结果："+jsonObject.getString("message");
                    }else {
                        memo = memo+";查询卷号结果："+jsonObject.getString("message");
                    }
                    log.error("请求接口失败！！！url：{}；request：{}；response：{}", MesConstant.URL+MesConstant.PAKIN_URL, JSON.toJSONString(orderInspectionRollParam), response);
//                    throw new CoolException("查询卷号是否合格失败");
                }
            } catch (Exception e) {
                if (Cools.isEmpty(memo)){
                    memo = "查询卷号结果："+"异常"+e.getMessage();
                }else {
                    memo = memo+";查询卷号结果："+"异常"+e.getMessage();
                }
                log.error("fail", e);
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                return FAIL.setMsg(e.getMessage());
            } finally {
                try {
                    // 保存接口日志
                    apiLogService.save(
                            "查询卷号是否合格",
                            MesConstant.URL + MesConstant.PAKIN_URL,
                            null,
                            "127.0.0.1",
                            JSON.toJSONString(orderInspectionRollParam),
                            response,
                            success
                    );
                } catch (Exception e) { log.error("查询卷号是否合格保存接口日志异常", e); }
            }
        }
        if (Cools.isEmpty(memo)){
            return SUCCESS;
        }
        orderPakout.setSettle(13L);//检验存在不合格
        orderPakout.setMemo(memo);
        orderPakoutService.updateById(orderPakout);
        return FAIL;
    }

    @Transactional
    public ReturnT<String> start(OrderPakout orderPakout) {
        List<OrderDetlPakout> orderDetls = orderDetlPakoutService.selectByOrderId(orderPakout.getId());
        List<OrderDetlPakout> orderDetlPakoutList = orderDetlPakoutService.selectByOrderId(orderPakout.getId());
        if (orderDetlPakoutList.isEmpty()){
            orderPakout.setSettle(98L);
            orderPakout.setMemo("不存在明细！！！");
            orderPakoutService.updateById(orderPakout);
            return FAIL;
        }
        List<OrderOutLocBoxCsUtilParam> outLocBoxCs = new ArrayList<>();
        String orderNo = "ZH" + snowflakeIdWorker.nextId();
        for (OrderDetlPakout orderDetl : orderDetlPakoutList) {
            if (!CodeDetectionUtil.barcodeDetection(orderDetl.getManu(),7)){//无库存
                continue;
            }
            if (Cools.isEmpty(orderDetl.getDanger$()) || orderDetl.getDanger()!=1){//不合格不出库
                continue;
            }
            OrderOutLocBoxCsUtilParam outLocBox = new OrderOutLocBoxCsUtilParam();
            outLocBox.setBoxNo(orderDetl.getBatch());
            outLocBox.setRoll(orderDetl.getModel());
            outLocBox.setMemo(orderDetl.getMemo());
            outLocBox.setOrderOneNo(orderNo);
            outLocBox.setCstmrName(orderPakout.getCstmrName());
            outLocBox.setDanger(orderDetl.getDanger$());
            outLocBoxCs.add(outLocBox);
        }
        if (outLocBoxCs.isEmpty()){
            orderPakout.setSettle(98L);
            orderPakout.setMemo("不存在合格的物料明细！！！");
            orderPakoutService.updateById(orderPakout);
            return FAIL;
        }

        return SUCCESS;
        OrderOutBatchUtil orderOutBatchUtil = new OrderOutBatchUtil(orderNo,orderPakout.getCstmrName(),"","MES下发组货单","组货单",true,orderPakout.getItemName());
        R r = orderOutBatchUtil.outGroupOrderForm(outLocBoxCs);
        int code = Integer.parseInt(String.valueOf(r.get("code")));
        if (code==200){
            return SUCCESS;
        }
        String meg = String.valueOf(r.get("msg"));
        orderPakout.setSettle(98L);
        orderPakout.setMemo(meg);
        orderPakoutService.updateById(orderPakout);
        return FAIL;
    }

}

 src/main/java/com/zy/asrs/utils/CodeDetectionUtil.java

New file
@@ -0,0 +1,90 @@
package com.zy.asrs.utils;

import java.util.regex.Pattern;

public class CodeDetectionUtil {

    /**
     * 检测货架码
     */
    public static boolean barcodeDetection(String barcode, int code) {
        Pattern pattern = Pattern.compile("\\d{" + code + "}");//位数字
        return pattern.matcher(barcode).matches();
    }

    /**
     * 检测小车地码
     */
    public static boolean carCodeDetection(String carCode) {
        return carCode.contains("_");
    }

    /**
     * 检测数组最大值及其索引
     */
    public static int[] crnCodeDetectionMax(int[] arr) {
        int max = arr[0];
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
                index = i;
            }
        }
        return new int[]{index, max};
    }

    /**
     * 检测数组最大值及其索引
     */
    public static int[] crnCodeDetectionMaxT(int[] arr,Integer crnNoIndex) {
        int max = arr[0];
        if (crnNoIndex == 0){
            max = arr[1];
        }
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (crnNoIndex == i){
                continue;
            }
            if (arr[i] > max) {
                max = arr[i];
                index = i;
            }
        }
        return new int[]{index, max};
    }

    /**
     * 检测数组最小值及其索引
     */
    public static int[] crnCodeDetectionMin(int[] arr) {
        int min = arr[0];
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
                index = i;
            }
        }
        return new int[]{index, min};
    }


//    public static void main(String[] args) {
//        System.out.println("barcodeDetection:" + "22222222===>" + barcodeDetection("22222222", 7));
//        System.out.println("barcodeDetection:" + "222222===>" + barcodeDetection("222222", 7));
//        System.out.println("barcodeDetection:" + "111===>" + barcodeDetection("111", 7));
//        System.out.println("barcodeDetection:" + "DB_123ss===>" + barcodeDetection("DB_123ss", 7));
//        System.out.println("barcodeDetection:" + "12_1231===>" + barcodeDetection("12_1231", 7));
//        System.out.println("barcodeDetection:" + "DB_123456===>" + barcodeDetection("DB_123456", 7));
//
//        System.out.println("carCodeDetection:" + "22222222===>" + carCodeDetection("22222222"));
//        System.out.println("carCodeDetection:" + "222222===>" + carCodeDetection("222222"));
//        System.out.println("carCodeDetection:" + "111===>" + carCodeDetection("111"));
//        System.out.println("carCodeDetection:" + "DB_123ss===>" + carCodeDetection("DB_123ss"));
//        System.out.println("carCodeDetection:" + "12_1231===>" + carCodeDetection("12_1231"));
//        System.out.println("carCodeDetection:" + "DB_123456===>" + carCodeDetection("DB_123456"));
//    }

}

 src/main/java/com/zy/asrs/utils/OrderOutBatchUtil.java

@@ -415,4 +415,181 @@
        }
        return R.error(requert);
    }


    public R outGroupOrderForm(List<OrderOutLocBoxCsUtilParam>  OutLocBoxCs) {
        int total = OutLocBoxCs.size();
        if (!Cools.isEmpty(OutLocBoxCs) && !OutLocBoxCs.isEmpty()) {
            LocDetlService locDetlService = SpringUtils.getBean(LocDetlService.class);
            LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
            SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
            WorkService workService = SpringUtils.getBean(WorkService.class);
            List<LocDto> locDtos = new ArrayList<>();
            List<OrderOutLocBoxCsUtilParam> outLocBoxCList = new ArrayList<>();
            List<String> outLocBoxCNew = new ArrayList<>();
            List<String> outLocRollListOld = new ArrayList<>();
            List<String> outLocRollListNew = new ArrayList<>();
            for (OrderOutLocBoxCsUtilParam outLocBoxC : OutLocBoxCs) {
                if (!outLocRollListOld.contains(outLocBoxC.getRoll())) {
                    outLocRollListOld.add(outLocBoxC.getRoll());
                }
            }
            for (OrderOutLocBoxCsUtilParam outLocBoxC : OutLocBoxCs) {
                total--;
                LocDetl locDetlSou = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("batch", outLocBoxC.getBoxNo()).eq("model",outLocBoxC.getRoll()));
                if (Cools.isEmpty(locDetlSou)) {
                    locDetlSou = new LocDetl();
                    locDetlSou.setBatch(outLocBoxC.getBoxNo());
                    locDetlSou.setModel(outLocBoxC.getRoll());
                    locDetlSou.setLocNo("无库存");
//                    sign = false;
                    errorMsgOrderLoc = errorMsgOrderLoc + "[===》" + "箱号：" + outLocBoxC.getBoxNo() + "卷号：" + outLocBoxC.getRoll() + " 未查询到数据！！！《===]";
//                    continue;
                }
                if (signDanger){
                    if (!locDetlSou.getDanger$().equals(outLocBoxC.getDanger())) {
                        sign = false;
                        errorMsgOrderLoc = errorMsgOrderLoc + "[===》" + "箱号：" + outLocBoxC.getBoxNo() + "卷号：" + outLocBoxC.getRoll() +  " ==》出库输入待判状态：" + outLocBoxC.getDanger() + "、库存状态：" + locDetlSou.getDanger$() + "。状态不匹配《===]";
                        continue;
                    }
                }
                if (!outLocBoxCNew.contains(outLocBoxC.getBoxNo()) && !locDetlSou.getLocNo().equals("无库存")) {
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetlSou.getLocNo()));
                    if (Cools.isEmpty(locMast)) {
//                        sign = false;
                        errorMsgOrderLoc = errorMsgOrderLoc + "[===》" + "箱号：" + outLocBoxC.getBoxNo() + "卷号：" + outLocBoxC.getRoll() +  " 所在库位不满足出库条件！！！未查询到此箱号所在库位" + "《===]";
//                        continue;
                    } else if (!locMast.getLocSts().equals("F")) {
//                        sign = false;
                        errorMsgOrderLoc = errorMsgOrderLoc + "[===》" + "箱号：" + outLocBoxC.getBoxNo() + "卷号：" + outLocBoxC.getRoll() +  " 所在库位不满足出库条件！！！库位状态不为F！！！库位状态：" + locMast.getLocSts$() + "《===]";
//                        continue;
                    } else {
                        // 目标库位 ===>> 浅库位
                        if (Utils.isShallowLoc(slaveProperties, locMast.getLocNo())) {
                            String shallowLoc = Utils.getDeepLoc(slaveProperties, locMast.getLocNo());
                            LocMast locMast2 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc));
                            if (!Cools.isEmpty(locMast2)) {
                                if (locMast2.getLocSts().equals("P") || locMast2.getLocSts().equals("R")) {
                                    errorMsgOrderLoc = errorMsgOrderLoc + "[===》" + "箱号：" + outLocBoxC.getBoxNo() +  "卷号：" + outLocBoxC.getRoll() + " 所在库位满足出库条件！！！但是相邻库位在出库中！！！因此会夹杂在前边订单执行！！！" + "《===]";
                                }
                            }
                        }
                    }
                }
                if (sign && !outLocRollListNew.contains(outLocBoxC.getRoll()) && !locDetlSou.getLocNo().equals("无库存")) {
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>()
                            .eq("loc_no", locDetlSou.getLocNo()).eq("origin", locDetlSou.getOrigin()));
                    for (LocDetl locDetl : locDetls) {
                        if (!outLocRollListNew.contains(locDetl.getModel())){
                            if (!outLocRollListOld.contains(locDetl.getModel())){
                                total++;
                                OrderOutLocBoxCsUtilParam orderOutLocBoxCsUtilParam = new OrderOutLocBoxCsUtilParam(locDetl.getBatch(),locDetl.getModel(), outLocBoxC);
                                orderOutLocBoxCsUtilParam.setMemo("附带出库");
                                orderOutLocBoxCsUtilParam.setDanger(locDetl.getDanger$());
                                outLocBoxCList.add(orderOutLocBoxCsUtilParam);
                                outLocBoxCNew.add(outLocBoxC.getBoxNo());
                                outLocRollListNew.add(outLocBoxC.getRoll());
                            } else {
                                if (locDetlSou.getBatch().equals(locDetl.getBatch()) && locDetlSou.getModel().equals(locDetl.getModel())) {
                                    total++;
                                    outLocBoxCList.add(outLocBoxC);
                                    outLocBoxCNew.add(outLocBoxC.getBoxNo());
                                    outLocRollListNew.add(outLocBoxC.getRoll());
                                }
                            }
                        }
                    }
                } else if (sign && !outLocRollListNew.contains(outLocBoxC.getRoll()) && locDetlSou.getLocNo().equals("无库存")) {
                    if (!outLocRollListNew.contains(locDetlSou.getModel())){
                        total++;
                        outLocBoxCList.add(outLocBoxC);
                        outLocBoxCNew.add(outLocBoxC.getBoxNo());
                        outLocRollListNew.add(outLocBoxC.getRoll());
                    }
                }
            }
            for (OrderOutLocBoxCsUtilParam outLocBoxC : outLocBoxCList) {
                LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("batch", outLocBoxC.getBoxNo()).eq("model", outLocBoxC.getRoll()));
                if (Cools.isEmpty(locDetl)) {
//                    total--;
//                    continue;
                    locDetl = new LocDetl();
                    locDetl.setBatch(outLocBoxC.getBoxNo());
                    locDetl.setModel(outLocBoxC.getRoll());
                    locDetl.setLocNo("无库存");
                }

                if (!Cools.isEmpty(outLocBoxC.getMemo())) {
                    if (Cools.isEmpty(locDetl.getMemo())) {
                        locDetl.setMemo(DateUtils.convert(new Date(), DateUtils.yyyyMMdd_C) + "备注：" + outLocBoxC.getMemo());
                    } else {
                        String memo = Cools.isEmpty(locDetl.getMemo()) ? "" : locDetl.getMemo() + "，";
                        locDetl.setMemo(memo + DateUtils.convert(new Date(), DateUtils.yyyyMMdd_C) + "备注：" + outLocBoxC.getMemo());
                    }
                }
                LocDto locDto = new LocDto(locDetl);
                locDtos.add(locDto);
            }

            StockOutParam param = new StockOutParam();
            ArrayList<StockOutParam.LocDetl> locDetls = new ArrayList<>();
            List<LocDto> locDtosList = new ArrayList<>();
            List<String> batchList = new ArrayList<>();
            for (LocDto locDto : locDtos) {
                if (!batchList.contains(locDto.getBatch())) {
                    batchList.add(locDto.getBatch());
                    locDtosList.add(locDto);
                }
            }
            for (LocDto locDto : locDtosList) {
                StockOutParam.LocDetl locDetl = new StockOutParam.LocDetl();
                locDetl.setBrand(locDto.getBrand());
                locDetl.setLocNo(locDto.getLocNo());
                locDetl.setAnfme(locDto.getAnfme());
                locDetl.setMatnr(locDto.getMatnr());
                locDetl.setBatch(locDto.getBatch());
                locDetl.setModel(locDto.getModel());
                locDetl.setSpecs(locDto.getSpecs());
                locDetl.setZpallet(locDto.getZpallet());
                locDetl.setOrigin(locDto.getOrigin());
                locDetl.setWeight(locDto.getWeight());
                locDetl.setMemo(locDto.getMemo());
                locDetl.setDanger(locDto.getDanger());

                locDetls.add(locDetl);
            }
            param.setLocDetls(locDetls);
            param.setOrderNo(orderOneNo);
            param.setCstmrName(cstmrName);
            param.setOrderName(orderName);
            param.setGroupGoodsNo(groupGoodsNo);

            if (sign && total > 0) {
                workService.startupFullTakeStoreOutGroupOrderForm(param, 9999L);
            }

            try {
                OperateLogService operateLogService = SpringUtils.getBean(OperateLogService.class);
                // 记录操作日志
                OperateLog operateLog = new OperateLog();
                operateLog.setAction(action);
                operateLog.setIp(ip);
                operateLog.setUserId(9999L);
                operateLog.setRequest("单号：" + orderOneNo + "、客户名：" + cstmrName);
                operateLog.setResponse(errorMsgOrderLoc.equals("") ? "正常" : (sign && total > 0) ? "成功:" + errorMsgOrderLoc : "失败:" + errorMsgOrderLoc);
                operateLogService.insert(operateLog);
            } catch (Exception e) {
                log.error("记录操作日志失败！" + e.getMessage());
            }

        }

        log.info("出库{}条箱号！", total);

        String requert = errorMsgOrderLoc.equals("") ? "正常" : (sign && total > 0) ? "成功:" + errorMsgOrderLoc : "失败:" + errorMsgOrderLoc;
        if (sign && total > 0) {
            return R.ok(requert.equals("正常")? "成功":requert);
        }
        return R.error(requert);
    }
}

 src/main/webapp/views/orderPakout/order.html

@@ -113,10 +113,13 @@
<!--        <a class="layui-btn layui-btn-danger layui-btn-xs btn-delete" lay-event="del">删除</a>-->
    {{# } }}
    {{# if (d.settle == 10) { }}
        <a class="layui-btn layui-btn-primary layui-border-blue layui-btn-xs btn-complete" lay-event="complete">出库</a>
        <a class="layui-btn layui-btn-primary layui-border-blue layui-btn-xs btn-complete" lay-event="complete">检验出库</a>
    {{# } }}
    {{# if (d.settle == 13 || d.settle == 98) { }}
    <a class="layui-btn layui-btn-primary layui-border-blue layui-btn-xs btn-complete" lay-event="inspection">出库合格品</a>
    {{# } }}
    {{# if (d.settle == 98) { }}
        <a class="layui-btn layui-btn-primary layui-border-blue layui-btn-xs btn-complete" lay-event="complete">重新出库</a>
        <a class="layui-btn layui-btn-primary layui-border-blue layui-btn-xs btn-complete" lay-event="complete">重新检验出库</a>
    {{# } }}
</script>
<!-- 表格操作列 -->