#

lsh

2024-12-13 939f5e7b56eb28d2630e2791860612819be73c45

#

 src/main/java/com/zy/asrs/entity/Order.java

@@ -269,6 +269,13 @@
    @TableField("move_status")
    private Integer moveStatus;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public Order() {}

    public Order(String uuid,String orderNo,String orderTime,Long docType,Long itemId,String itemName,Long allotItemId,String defNumber,String number,Long cstmr,String cstmrName,String tel,String operMemb,Double totalFee,Double discount,Double discountFee,Double otherFee,Double actFee,Integer payType,String salesman,Integer accountDay,Integer postFeeType,Double postFee,Date payTime,Date sendTime,String shipName,String shipCode,Long settle,Integer status,Long createBy,Date createTime,Long updateBy,Date updateTime,String memo) {

 src/main/java/com/zy/asrs/entity/OrderDetl.java

@@ -295,6 +295,13 @@
    @ApiModelProperty(value= "备注")
    private String memo;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public OrderDetl() {}

    public OrderDetl(Long orderId, String orderNo, Double anfme, Double qty, String matnr, String maktx, String batch, String specs, String model, String color, String brand, String unit, Double price, String sku, Double units, String barcode, String origin, String manu, String manuDate, String itemNum, Double safeQty, Double weight, Double length, Double volume, String threeCode, String supp, String suppCode, Integer beBatch, String deadTime, Integer deadWarn, Integer source, Integer inspect, Integer danger, Integer status, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {

 src/main/java/com/zy/asrs/entity/OrderDetlPakin.java

@@ -295,6 +295,13 @@
    @ApiModelProperty(value= "备注")
    private String memo;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public OrderDetlPakin() {}

    public OrderDetlPakin(Long orderId, String orderNo, Double anfme, Double qty, String matnr, String maktx, String batch, String specs, String model, String color, String brand, String unit, Double price, String sku, Double units, String barcode, String origin, String manu, String manuDate, String itemNum, Double safeQty, Double weight, Double length, Double volume, String threeCode, String supp, String suppCode, Integer beBatch, String deadTime, Integer deadWarn, Integer source, Integer inspect, Integer danger, Integer status, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {

 src/main/java/com/zy/asrs/entity/OrderDetlPakout.java

@@ -295,6 +295,13 @@
    @ApiModelProperty(value= "备注")
    private String memo;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public OrderDetlPakout() {}

    public OrderDetlPakout(Long orderId, String orderNo, Double anfme, Double qty, String matnr, String maktx, String batch, String specs, String model, String color, String brand, String unit, Double price, String sku, Double units, String barcode, String origin, String manu, String manuDate, String itemNum, Double safeQty, Double weight, Double length, Double volume, String threeCode, String supp, String suppCode, Integer beBatch, String deadTime, Integer deadWarn, Integer source, Integer inspect, Integer danger, Integer status, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {

 src/main/java/com/zy/asrs/entity/OrderPakin.java

@@ -269,6 +269,13 @@
    @TableField("move_status")
    private Integer moveStatus;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public OrderPakin() {}

    public OrderPakin(String uuid, String orderNo, String orderTime, Long docType, Long itemId, String itemName, Long allotItemId, String defNumber, String number, Long cstmr, String cstmrName, String tel, String operMemb, Double totalFee, Double discount, Double discountFee, Double otherFee, Double actFee, Integer payType, String salesman, Integer accountDay, Integer postFeeType, Double postFee, Date payTime, Date sendTime, String shipName, String shipCode, Long settle, Integer status, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {

 src/main/java/com/zy/asrs/entity/OrderPakout.java

@@ -269,6 +269,13 @@
    @TableField("move_status")
    private Integer moveStatus;

    /**
     * 状态 1: 进行中  0: 初始  2:已完成
     */
    @ApiModelProperty(value= "入出库类型（0：未知，1：入库，2：出库）")
    @TableField("pakin_pakout_status")
    private Integer pakinPakoutStatus;

    public OrderPakout() {}

    public OrderPakout(String uuid, String orderNo, String orderTime, Long docType, Long itemId, String itemName, Long allotItemId, String defNumber, String number, Long cstmr, String cstmrName, String tel, String operMemb, Double totalFee, Double discount, Double discountFee, Double otherFee, Double actFee, Integer payType, String salesman, Integer accountDay, Integer postFeeType, Double postFee, Date payTime, Date sendTime, String shipName, String shipCode, Long settle, Integer status, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {

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

@@ -54,7 +54,7 @@
    @Transactional
    public void pakinOrderCreate(OpenOrderPakinParam param) {

        OrderInAndOutUtil.query(Boolean.TRUE,param.getOrderNo());
        OrderInAndOutUtil.query(Boolean.TRUE? "Y":"N",param.getOrderNo());

        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        Date now = new Date();
@@ -164,7 +164,11 @@
            }
        } else {
            // 所有订单
            List<Order> orders = orderService.selectBySettle(4L);
//            List<Order> orders = orderService.selectBySettle(4L);
            List<Order> orders = OrderInAndOutUtil.selectBySettle(null, 4L);
            if (orders.isEmpty()){
                orders = new ArrayList<>();
            }
            for (Order order : orders) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);

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

@@ -12,19 +12,34 @@
import org.apache.poi.ss.formula.functions.T;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class OrderInAndOutUtil {

    public static String enumUtil(boolean sign) {
       if (sign){
        if (sign){
           return OrderEnumVo.PAKIN.getCode();
       }
       return OrderEnumVo.PAKOUT.getCode();
        }
        return OrderEnumVo.PAKOUT.getCode();
    }
    public static String enumUtil(String sign) {
        if (Cools.isEmpty(sign)){
            return OrderEnumVo.PAKALL.getCode();
        } else if (sign.equals("Y")){
            return OrderEnumVo.PAKIN.getCode();
        } else if (sign.equals("N")){
            return OrderEnumVo.PAKOUT.getCode();
        }
        return OrderEnumVo.PAKALL.getCode();
    }

    public static OrderInAndOutType getOrderInAndOutType(String sign) {
        return OrderInAndOutType.valueOf(enumUtil(sign));
    }

    public static OrderInAndOutType getOrderInAndOutType(boolean sign) {
       return OrderInAndOutType.valueOf(enumUtil(sign));
        return OrderInAndOutType.valueOf(enumUtil(sign));
    }

    public static boolean aBoolean(Object object){
@@ -65,6 +80,8 @@
                    return casual.getDeclaredMethod(OrderMethodVo.QUERY.getCode(), String.class);
                case SELECT_BY_NO:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_BY_NO.getCode(), String.class);
                case SELECT_SETTLE:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_SETTLE.getCode(), Long.class);
                case SELECT_BY_ORDER_ID:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_BY_ORDER_ID.getCode(), Long.class);
                case SELECT_WORKING_DETLS:
@@ -120,7 +137,15 @@
        throw new CoolException("未知异常");
    }

    public static void query(boolean sign,String orderNo){
    public static void query(Boolean sign,String orderNo){
        try{
            implement(OrderMethodVo.QUERY).invoke(getOrderInAndOutType(sign),orderNo);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void query(String sign,String orderNo){
        try{
            implement(OrderMethodVo.QUERY).invoke(getOrderInAndOutType(sign),orderNo);
        } catch (Exception e) {
@@ -137,11 +162,65 @@
        }
    }

    public static Order selectByNo(String sign,String orderNo){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_BY_NO).invoke(getOrderInAndOutType(sign), orderNo);
            return aOrder(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectBySettle(boolean sign,long settle){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_SETTLE).invoke(getOrderInAndOutType(sign), settle);
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectBySettle(String sign,long settle){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_SETTLE).invoke(getOrderInAndOutType(sign), settle);
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<OrderDetl> selectByOrderId(boolean sign,Long orderId){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_BY_ORDER_ID).invoke(getOrderInAndOutType(sign), orderId);
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<OrderDetl>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<OrderDetl> selectByOrderId(String sign,Long orderId){
        try{
            Object result = implement(OrderMethodVo.SELECT_BY_ORDER_ID).invoke(getOrderInAndOutType(sign), orderId);
            if (Cools.isEmpty(result)){
                return null;
                return new ArrayList<>();
            } else if (result instanceof List) {
                return (List<OrderDetl>) result;
            } else {
@@ -156,7 +235,22 @@
        try{
            Object result = implement(OrderMethodVo.SELECT_WORKING_DETLS).invoke(getOrderInAndOutType(sign), orderId);
            if (Cools.isEmpty(result)){
                return null;
                return new ArrayList<>();
            } else if (result instanceof List) {
                return (List<OrderDetl>) result;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<OrderDetl> selectWorkingDetls(String sign,Long orderId){
        try{
            Object result = implement(OrderMethodVo.SELECT_WORKING_DETLS).invoke(getOrderInAndOutType(sign), orderId);
            if (Cools.isEmpty(result)){
                return new ArrayList<>();
            } else if (result instanceof List) {
                return (List<OrderDetl>) result;
            } else {
@@ -175,7 +269,24 @@
        }
    }

    public static void checkComplete(String sign,String orderNo){
        try{
            implement(OrderMethodVo.CHECK_COMPLETE).invoke(getOrderInAndOutType(sign),orderNo);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean saveHandlerOrder(boolean sign,Boolean pakin, WrkMast wrkMast, List<WrkDetl> wrkDetls){
        try{
            Object invoke = implement(OrderMethodVo.SAVE_HANDLER_ORDER).invoke(getOrderInAndOutType(sign), pakin, wrkMast, wrkDetls);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean saveHandlerOrder(String sign,Boolean pakin, WrkMast wrkMast, List<WrkDetl> wrkDetls){
        try{
            Object invoke = implement(OrderMethodVo.SAVE_HANDLER_ORDER).invoke(getOrderInAndOutType(sign), pakin, wrkMast, wrkDetls);
            return aBoolean(invoke);
@@ -192,7 +303,23 @@
        }
    }

    public static void insertOrder(String sign,Order order){
        try{
            implement(OrderMethodVo.INSERT_ORDER).invoke(getOrderInAndOutType(sign),order);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void insertOrderDetl(boolean sign,Order order, OrderDetl orderDetl){
        try{
            implement(OrderMethodVo.INSERT_ORDERDETL).invoke(getOrderInAndOutType(sign),order,orderDetl);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void insertOrderDetl(String sign,Order order, OrderDetl orderDetl){
        try{
            implement(OrderMethodVo.INSERT_ORDERDETL).invoke(getOrderInAndOutType(sign),order,orderDetl);
        } catch (Exception e) {
@@ -208,7 +335,23 @@
        }
    }

    public static void updateOrder(String sign,Long id, Long settle, Long userId){
        try{
            implement(OrderMethodVo.UPDATE_ORDER).invoke(getOrderInAndOutType(sign),id,settle,userId);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void updateOrderDetl(boolean sign,Order order, OrderDetl orderDetl){
        try{
            implement(OrderMethodVo.UPDATE_ORDERDETL).invoke(getOrderInAndOutType(sign),order,orderDetl);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void updateOrderDetl(String sign,Order order, OrderDetl orderDetl){
        try{
            implement(OrderMethodVo.UPDATE_ORDERDETL).invoke(getOrderInAndOutType(sign),order,orderDetl);
        } catch (Exception e) {
@@ -224,11 +367,34 @@
        }
    }

    public static void remove(String sign,Long orderId){
        try{
            implement(OrderMethodVo.REMOVE).invoke(getOrderInAndOutType(sign),orderId);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectComplete(boolean sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_COMPLETE).invoke(getOrderInAndOutType(sign));
            if (Cools.isEmpty(invoke)){
                return null;
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectComplete(String sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_COMPLETE).invoke(getOrderInAndOutType(sign));
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
@@ -243,7 +409,22 @@
        try{
            Object invoke = implement(OrderMethodVo.SELECT_COMPLETE8).invoke(getOrderInAndOutType(sign));
            if (Cools.isEmpty(invoke)){
                return null;
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectComplete8(String sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_COMPLETE8).invoke(getOrderInAndOutType(sign));
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
@@ -263,11 +444,35 @@
        }
    }

    public static boolean addToLogTableOrder(String sign,Order order){
        try{
            Object invoke = implement(OrderMethodVo.ADD_TO_LOG_TABLE_ORDER).invoke(getOrderInAndOutType(sign), order);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectOrderNoL(boolean sign,String orderNo){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ORDER_NO_L).invoke(getOrderInAndOutType(sign),orderNo);
            if (Cools.isEmpty(invoke)){
                return null;
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectOrderNoL(String sign,String orderNo){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ORDER_NO_L).invoke(getOrderInAndOutType(sign),orderNo);
            if (Cools.isEmpty(invoke)){
                return new ArrayList<>();
            } else if (invoke instanceof List) {
                return (List<Order>) invoke;
            } else {
@@ -287,7 +492,25 @@
        }
    }

    public static Order selectOrderMoveStatus(String sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ORDER_MOVE_STATUS).invoke(getOrderInAndOutType(sign));
            return aOrder(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static Order selectOrderMoveStatusInitial(boolean sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ORDER_MOVE_STATUS_INITIAL).invoke(getOrderInAndOutType(sign));
            return aOrder(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static Order selectOrderMoveStatusInitial(String sign){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ORDER_MOVE_STATUS_INITIAL).invoke(getOrderInAndOutType(sign));
            return aOrder(invoke);
@@ -305,7 +528,25 @@
        }
    }

    public static OrderDetl selectItem(String sign,Long orderId, String matnr, String batch){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ITEM1).invoke(getOrderInAndOutType(sign), orderId, matnr, batch);
            return aOrderDetl(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static OrderDetl selectItem(boolean sign,String orderNo, String matnr, String batch){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ITEM2).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch);
            return aOrderDetl(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static OrderDetl selectItem(String sign,String orderNo, String matnr, String batch){
        try{
            Object invoke = implement(OrderMethodVo.SELECT_ITEM2).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch);
            return aOrderDetl(invoke);
@@ -323,7 +564,25 @@
        }
    }

    public static OrderDetl findByLook(String sign,List<OrderDetl> orderDetls, Long orderId, String matnr, String batch){
        try{
            Object invoke = implement(OrderMethodVo.FIND_BY_LOOK).invoke(getOrderInAndOutType(sign), orderDetls, orderId, matnr, batch);
            return aOrderDetl(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean increase(boolean sign,Long orderId, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, qty);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean increase(String sign,Long orderId, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, qty);
            return aBoolean(invoke);
@@ -341,7 +600,25 @@
        }
    }

    public static boolean decrease(String sign,String orderNo, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(OrderMethodVo.DECREASE).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch, qty);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean modifyStatus(boolean sign,Long orderId, Integer status){
        try{
            Object invoke = implement(OrderMethodVo.MODIFY_STATUS).invoke(getOrderInAndOutType(sign), orderId, status);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean modifyStatus(String sign,Long orderId, Integer status){
        try{
            Object invoke = implement(OrderMethodVo.MODIFY_STATUS).invoke(getOrderInAndOutType(sign), orderId, status);
            return aBoolean(invoke);
@@ -359,6 +636,15 @@
        }
    }

    public static boolean addToLogTableOrderDetl(String sign,OrderDetl orderDetl){
        try{
            Object invoke = implement(OrderMethodVo.ADD_TO_LOG_TABLE_ORDERDETL).invoke(getOrderInAndOutType(sign), orderDetl);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean increaseQtyByOrderNo(boolean sign,String orderNo, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE_QTY_BY_ORDER_NO).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch, qty);
@@ -368,6 +654,15 @@
        }
    }

    public static boolean increaseQtyByOrderNo(String sign,String orderNo, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE_QTY_BY_ORDER_NO).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch, qty);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean increaseWorkQty(boolean sign,Long orderId, String matnr, String batch, Double workQty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE_WORKING_QTY).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, workQty);
@@ -377,5 +672,14 @@
        }
    }

    public static boolean increaseWorkQty(String sign,Long orderId, String matnr, String batch, Double workQty){
        try{
            Object invoke = implement(OrderMethodVo.INCREASE_WORKING_QTY).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, workQty);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }


}

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

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

import com.zy.asrs.entity.*;

import java.util.ArrayList;
import java.util.List;

public class OrderTransFormationUtil {

    public static Order transformationOrderPakin(OrderPakin orderPakin){
        Order order = new Order();
        order.sync(orderPakin);
        return order;
    }
    public static List<Order> transformationOrderListPakin(List<OrderPakin> orderPakinList){
        List<Order> orderList = new ArrayList<>();
        for (OrderPakin orderPakin : orderPakinList){
            Order order = new Order();
            order.sync(orderPakin);
            orderList.add(order);
        }
        return orderList;
    }
    public static OrderDetl transformationOrderDetlPakin(OrderDetlPakin orderDetlPakin){
        OrderDetl orderDetl = new OrderDetl();
        orderDetl.sync(orderDetlPakin);
        return orderDetl;
    }
    public static List<OrderDetl> transformationOrderDetlListPakin(List<OrderDetlPakin> orderDetlPakinList){
        List<OrderDetl> orderDetlList = new ArrayList<>();
        for (OrderDetlPakin orderDetlPakin : orderDetlPakinList){
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(orderDetlPakin);
            orderDetlList.add(orderDetl);
        }
        return orderDetlList;
    }

    public static OrderPakin transformationPakin(Order order){
        OrderPakin orderPakin = new OrderPakin();
        orderPakin.sync(order);
        return orderPakin;
    }
    public static List<OrderPakin> transformationListPakin(List<Order> orderList){
        List<OrderPakin> orderPakinList = new ArrayList<>();
        for (Order order : orderList){
            OrderPakin orderPakin = new OrderPakin();
            orderPakin.sync(order);
            orderPakinList.add(orderPakin);
        }
        return orderPakinList;
    }
    public static OrderDetlPakin transformationDetlPakin(OrderDetl orderDetl){
        OrderDetlPakin orderDetlPakin = new OrderDetlPakin();
        orderDetlPakin.sync(orderDetl);
        return orderDetlPakin;
    }
    public static List<OrderDetlPakin> transformationDetlListPakin(List<OrderDetl> orderDetlList){
        List<OrderDetlPakin> orderDetlPakinList = new ArrayList<>();
        for (OrderDetl orderDetl : orderDetlList){
            OrderDetlPakin orderDetlPakin = new OrderDetlPakin();
            orderDetlPakin.sync(orderDetl);
            orderDetlPakinList.add(orderDetlPakin);
        }
        return orderDetlPakinList;
    }

    public static Order transformationOrderPakout(OrderPakout orderPakout){
        Order order = new Order();
        order.sync(orderPakout);
        return order;
    }
    public static List<Order> transformationOrderListPakout(List<OrderPakout> orderPakoutList){
        List<Order> orderList = new ArrayList<>();
        for (OrderPakout orderPakout : orderPakoutList){
            Order order = new Order();
            order.sync(orderPakout);
            orderList.add(order);
        }
        return orderList;
    }
    public static OrderDetl transformationOrderDetlPakout(OrderDetlPakout orderDetlPakout){
        OrderDetl orderDetl = new OrderDetl();
        orderDetl.sync(orderDetlPakout);
        return orderDetl;
    }
    public static List<OrderDetl> transformationOrderDetlListPakout(List<OrderDetlPakout> orderDetlPakoutList){
        List<OrderDetl> orderDetlList = new ArrayList<>();
        for (OrderDetlPakout orderDetlPakout : orderDetlPakoutList){
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(orderDetlPakout);
            orderDetlList.add(orderDetl);
        }
        return orderDetlList;
    }

    public static OrderPakout transformationPakout(Order order){
        OrderPakout orderPakout = new OrderPakout();
        orderPakout.sync(order);
        return orderPakout;
    }
    public static List<OrderPakout> transformationListPakout(List<Order> orderList){
        List<OrderPakout> orderPakoutList = new ArrayList<>();
        for (Order order : orderList){
            OrderPakout orderPakout = new OrderPakout();
            orderPakout.sync(order);
            orderPakoutList.add(orderPakout);
        }
        return orderPakoutList;
    }
    public static OrderDetlPakout transformationDetlPakout(OrderDetl orderDetl){
        OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
        orderDetlPakout.sync(orderDetl);
        return orderDetlPakout;
    }
    public static List<OrderDetlPakout> transformationDetlListPakout(List<OrderDetl> orderDetlList){
        List<OrderDetlPakout> orderDetlPakoutList = new ArrayList<>();
        for (OrderDetl orderDetl : orderDetlList){
            OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
            orderDetlPakout.sync(orderDetl);
            orderDetlPakoutList.add(orderDetlPakout);
        }
        return orderDetlPakoutList;
    }

    public static Order transformationOrder(OrderPakin orderPakin,OrderPakout orderPakout){
        Order order = new Order();
        if (orderPakin!=null){
            order.sync(orderPakin);
        } else if (orderPakout!=null){
            order.sync(orderPakout);
        } else {
            return null;
        }
        return order;
    }
    public static List<Order> transformationOrderList(List<OrderPakin> orderPakinList,List<OrderPakout> orderPakoutList){
        List<Order> orderList = transformationOrderListPakin(orderPakinList);
        for (OrderPakout orderPakout : orderPakoutList){
            Order order = new Order();
            order.sync(orderPakout);
            orderList.add(order);
        }
        return orderList;
    }
    public static OrderDetl transformationOrderDetl(OrderDetlPakin orderDetlPakin,OrderDetlPakout orderDetlPakout){
        OrderDetl orderDetl = new OrderDetl();
        if (orderDetlPakin!=null){
            orderDetl.sync(orderDetlPakin);
        } else if (orderDetlPakout!=null){
            orderDetl.sync(orderDetlPakout);
        } else {
            return null;
        }
        return orderDetl;
    }
    public static List<OrderDetl> transformationOrderDetlList(List<OrderDetlPakin> orderDetlPakinList,List<OrderDetlPakout> orderDetlPakoutList){
        List<OrderDetl> orderDetlList = transformationOrderDetlListPakin(orderDetlPakinList);
        for (OrderDetlPakout orderDetlPakout : orderDetlPakoutList){
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(orderDetlPakout);
            orderDetlList.add(orderDetl);
        }
        return orderDetlList;
    }
}

 src/main/java/com/zy/common/model/enumUtils/OrderEnumVo.java

@@ -2,7 +2,9 @@

public enum OrderEnumVo {
    PAKIN("PAKIN"),
    PAKOUT("PAKOUT");
    PAKOUT("PAKOUT"),
    PAKALL("PAKALL"),
    ;

    private String code;


 src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java

@@ -7,6 +7,7 @@
import com.zy.asrs.service.OrderDetlPakoutService;
import com.zy.asrs.service.OrderPakinService;
import com.zy.asrs.service.OrderPakoutService;
import com.zy.asrs.utils.OrderTransFormationUtil;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -35,22 +36,22 @@
            if (Cools.isEmpty(orderPakin)) {
                return null;
            }
            return transformationOrder(orderPakin);
            return OrderTransFormationUtil.transformationOrderPakin(orderPakin);
        }
        @Transactional
        public List<Order> selectBySettle(Long settle) {
            List<OrderPakin> orderPakinList = orderPakinService.selectBySettle(settle);
            return transformationOrderList(orderPakinList);
            return OrderTransFormationUtil.transformationOrderListPakin(orderPakinList);
        }
        @Transactional
        public List<OrderDetl> selectByOrderId(Long orderId) {
            List<OrderDetlPakin> orderDetlPakinList = orderDetlPakinService.selectByOrderId(orderId);
            return transformationOrderDetlList(orderDetlPakinList);
            return OrderTransFormationUtil.transformationOrderDetlListPakin(orderDetlPakinList);
        }
        @Transactional
        public List<OrderDetl> selectWorkingDetls(Long orderId) {
            List<OrderDetlPakin> orderDetlPakinList = orderPakinService.selectWorkingDetls(orderId);
            return transformationOrderDetlList(orderDetlPakinList);
            return OrderTransFormationUtil.transformationOrderDetlListPakin(orderDetlPakinList);
        }
        @Transactional
        public void checkComplete(String orderNo) {
@@ -107,56 +108,56 @@
        @Transactional
        public List<Order> selectComplete() {
            List<OrderPakin> orderPakinList = orderPakinService.selectComplete();
            return transformationOrderList(orderPakinList);
            return OrderTransFormationUtil.transformationOrderListPakin(orderPakinList);
        }

        @Transactional
        public List<Order> selectComplete8() {
            List<OrderPakin> orderPakinList = orderPakinService.selectComplete8();
            return transformationOrderList(orderPakinList);
            return OrderTransFormationUtil.transformationOrderListPakin(orderPakinList);
        }

        @Transactional
        public boolean addToLogTableOrder(Order order) {
            OrderPakin orderPakin = transformation(order);
            OrderPakin orderPakin = OrderTransFormationUtil.transformationPakin(order);
            return orderPakinService.addToLogTable(orderPakin);
        }

        @Transactional
        public List<Order> selectOrderNoL(String orderNo) {
            List<OrderPakin> orderPakinList = orderPakinService.selectorderNoL(orderNo);
            return transformationOrderList(orderPakinList);
            return OrderTransFormationUtil.transformationOrderListPakin(orderPakinList);
        }

        @Transactional
        public Order selectOrderMoveStatus() {
            OrderPakin orderPakin = orderPakinService.selectOrderMoveStatus();
            return transformationOrder(orderPakin);
            return OrderTransFormationUtil.transformationOrderPakin(orderPakin);
        }

        @Transactional
        public Order selectOrderMoveStatusInitial() {
            OrderPakin orderPakin = orderPakinService.selectOrderMoveStatusInitial();
            return transformationOrder(orderPakin);
            return OrderTransFormationUtil.transformationOrderPakin(orderPakin);
        }

        @Transactional
        public OrderDetl selectItem(Long orderId, String matnr, String batch) {
            OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderId, matnr, batch);
            return transformationOrderDetl(orderDetlPakin);
            return OrderTransFormationUtil.transformationOrderDetlPakin(orderDetlPakin);
        }

        @Transactional
        public OrderDetl selectItem(String orderNo, String matnr, String batch) {
            OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderNo, matnr, batch);
            return transformationOrderDetl(orderDetlPakin);
            return OrderTransFormationUtil.transformationOrderDetlPakin(orderDetlPakin);
        }

        @Transactional
        public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
            List<OrderDetlPakin> orderDetlPakins = transformationDetlList(orderDetls);
            List<OrderDetlPakin> orderDetlPakins = OrderTransFormationUtil.transformationDetlListPakin(orderDetls);
            OrderDetlPakin orderDetlPakin = orderDetlPakinService.findByLook(orderDetlPakins, orderId, matnr,batch);
            return transformationOrderDetl(orderDetlPakin);
            return OrderTransFormationUtil.transformationOrderDetlPakin(orderDetlPakin);
        }
        @Transactional
        public boolean increase(Long orderId, String matnr, String batch, Double qty) {
@@ -172,7 +173,7 @@
        }
        @Transactional
        public boolean addToLogTableOrderDetl(OrderDetl orderDetl) {
            OrderDetlPakin orderDetlPakin = transformationDetl(orderDetl);
            OrderDetlPakin orderDetlPakin = OrderTransFormationUtil.transformationDetlPakin(orderDetl);
            return orderDetlPakinService.addToLogTable(orderDetlPakin);
        }
        @Transactional
@@ -182,65 +183,6 @@
        @Transactional
        public boolean increaseWorkQty(Long orderId, String matnr, String batch, Double workQty) {
            return orderDetlPakinService.increaseWorkQty(orderId, matnr, batch, workQty);
        }


        public Order transformationOrder(OrderPakin orderPakin){
            Order order = new Order();
            order.sync(orderPakin);
            return order;
        }
        public List<Order> transformationOrderList(List<OrderPakin> orderPakinList){
            List<Order> orderList = new ArrayList<>();
            for (OrderPakin orderPakin : orderPakinList){
                Order order = new Order();
                order.sync(orderPakin);
                orderList.add(order);
            }
            return orderList;
        }
        public OrderDetl transformationOrderDetl(OrderDetlPakin orderDetlPakin){
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(orderDetlPakin);
            return orderDetl;
        }
        public List<OrderDetl> transformationOrderDetlList(List<OrderDetlPakin> orderDetlPakinList){
            List<OrderDetl> orderDetlList = new ArrayList<>();
            for (OrderDetlPakin orderDetlPakin : orderDetlPakinList){
                OrderDetl orderDetl = new OrderDetl();
                orderDetl.sync(orderDetlPakin);
                orderDetlList.add(orderDetl);
            }
            return orderDetlList;
        }

        public OrderPakin transformation(Order order){
            OrderPakin orderPakin = new OrderPakin();
            orderPakin.sync(order);
            return orderPakin;
        }
        public List<OrderPakin> transformationList(List<Order> orderList){
            List<OrderPakin> orderPakinList = new ArrayList<>();
            for (Order order : orderList){
                OrderPakin orderPakin = new OrderPakin();
                orderPakin.sync(order);
                orderPakinList.add(orderPakin);
            }
            return orderPakinList;
        }
        public OrderDetlPakin transformationDetl(OrderDetl orderDetl){
            OrderDetlPakin orderDetlPakin = new OrderDetlPakin();
            orderDetlPakin.sync(orderDetl);
            return orderDetlPakin;
        }
        public List<OrderDetlPakin> transformationDetlList(List<OrderDetl> orderDetlList){
            List<OrderDetlPakin> orderDetlPakinList = new ArrayList<>();
            for (OrderDetl orderDetl : orderDetlList){
                OrderDetlPakin orderDetlPakin = new OrderDetlPakin();
                orderDetlPakin.sync(orderDetl);
                orderDetlPakinList.add(orderDetlPakin);
            }
            return orderDetlPakinList;
        }
    },
    PAKOUT{
@@ -260,22 +202,22 @@
            if (Cools.isEmpty(orderPakout)) {
                return null;
            }
            return transformationOrder(orderPakout);
            return OrderTransFormationUtil.transformationOrderPakout(orderPakout);
        }
        @Transactional
        public List<Order> selectBySettle(Long settle) {
            List<OrderPakout> orderPakoutList = orderPakoutService.selectBySettle(settle);
            return transformationOrderList(orderPakoutList);
            return OrderTransFormationUtil.transformationOrderListPakout(orderPakoutList);
        }
        @Transactional
        public List<OrderDetl> selectByOrderId(Long orderId) {
            List<OrderDetlPakout> orderDetlPakoutList = orderDetlPakoutService.selectByOrderId(orderId);
            return transformationOrderDetlList(orderDetlPakoutList);
            return OrderTransFormationUtil.transformationOrderDetlListPakout(orderDetlPakoutList);
        }
        @Transactional
        public List<OrderDetl> selectWorkingDetls(Long orderId) {
            List<OrderDetlPakout> orderDetlPakoutList = orderPakoutService.selectWorkingDetls(orderId);
            return transformationOrderDetlList(orderDetlPakoutList);
            return OrderTransFormationUtil.transformationOrderDetlListPakout(orderDetlPakoutList);
        }
        @Transactional
        public void checkComplete(String orderNo) {
@@ -334,56 +276,56 @@
        @Transactional
        public List<Order> selectComplete8() {
            List<OrderPakout> orderPakoutList = orderPakoutService.selectComplete8();
            return transformationOrderList(orderPakoutList);
            return OrderTransFormationUtil.transformationOrderListPakout(orderPakoutList);
        }

        @Transactional
        public boolean addToLogTableOrder(Order order) {
            OrderPakout orderPakout = transformation(order);
            OrderPakout orderPakout = OrderTransFormationUtil.transformationPakout(order);
            return orderPakoutService.addToLogTable(orderPakout);
        }

        @Transactional
        public List<Order> selectOrderNoL(String orderNo) {
            List<OrderPakout> orderPakoutList = orderPakoutService.selectorderNoL(orderNo);
            return transformationOrderList(orderPakoutList);
            return OrderTransFormationUtil.transformationOrderListPakout(orderPakoutList);
        }

        @Transactional
        public Order selectOrderMoveStatus() {
            OrderPakout orderPakout = orderPakoutService.selectOrderMoveStatus();
            return transformationOrder(orderPakout);
            return OrderTransFormationUtil.transformationOrderPakout(orderPakout);
        }

        @Transactional
        public Order selectOrderMoveStatusInitial() {
            OrderPakout orderPakout = orderPakoutService.selectOrderMoveStatusInitial();
            return transformationOrder(orderPakout);
            return OrderTransFormationUtil.transformationOrderPakout(orderPakout);
        }

        @Transactional
        public List<Order> selectComplete() {
            List<OrderPakout> orderPakoutList = orderPakoutService.selectComplete();
            return transformationOrderList(orderPakoutList);
            return OrderTransFormationUtil.transformationOrderListPakout(orderPakoutList);
        }

        @Transactional
        public OrderDetl selectItem(Long orderId, String matnr, String batch) {
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderId, matnr, batch);
            return transformationOrderDetl(orderDetlPakout);
            return OrderTransFormationUtil.transformationOrderDetlPakout(orderDetlPakout);
        }

        @Transactional
        public OrderDetl selectItem(String orderNo, String matnr, String batch) {
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderNo, matnr, batch);
            return transformationOrderDetl(orderDetlPakout);
            return OrderTransFormationUtil.transformationOrderDetlPakout(orderDetlPakout);
        }

        @Transactional
        public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
            List<OrderDetlPakout> orderDetlPakouts = transformationDetlList(orderDetls);
            List<OrderDetlPakout> orderDetlPakouts = OrderTransFormationUtil.transformationDetlListPakout(orderDetls);
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.findByLook(orderDetlPakouts, orderId, matnr,batch);
            return transformationOrderDetl(orderDetlPakout);
            return OrderTransFormationUtil.transformationOrderDetlPakout(orderDetlPakout);
        }
        @Transactional
        public boolean increase(Long orderId, String matnr, String batch, Double qty) {
@@ -399,7 +341,7 @@
        }
        @Transactional
        public boolean addToLogTableOrderDetl(OrderDetl orderDetl) {
            OrderDetlPakout orderDetlPakout = transformationDetl(orderDetl);
            OrderDetlPakout orderDetlPakout = OrderTransFormationUtil.transformationDetlPakout(orderDetl);
            return orderDetlPakoutService.addToLogTable(orderDetlPakout);
        }
        @Transactional
@@ -412,64 +354,164 @@
        }


        public Order transformationOrder(OrderPakout orderPakout){
            Order order = new Order();
            order.sync(orderPakout);
            return order;
        }
        public List<Order> transformationOrderList(List<OrderPakout> orderPakoutList){
            List<Order> orderList = new ArrayList<>();
            for (OrderPakout orderPakout : orderPakoutList){
                Order order = new Order();
                order.sync(orderPakout);
                orderList.add(order);

    },
    PAKALL{
        @Transactional
        public void implement() {}

        @Transactional
        public void query(String orderNo) {
            OrderPakout orderPakout = orderPakoutService.selectByNo(orderNo);
            if (!Cools.isEmpty(orderPakout)) {
                throw new CoolException(orderNo + "单据已存在，请勿重复提交");
            }
            return orderList;
        }
        public OrderDetl transformationOrderDetl(OrderDetlPakout orderDetlPakout){
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(orderDetlPakout);
            return orderDetl;
        }
        public List<OrderDetl> transformationOrderDetlList(List<OrderDetlPakout> orderDetlPakoutList){
            List<OrderDetl> orderDetlList = new ArrayList<>();
            for (OrderDetlPakout orderDetlPakout : orderDetlPakoutList){
                OrderDetl orderDetl = new OrderDetl();
                orderDetl.sync(orderDetlPakout);
                orderDetlList.add(orderDetl);
        @Transactional
        public Order selectByNo(String orderNo) {
            OrderPakin orderPakin = orderPakinService.selectByNo(orderNo);
            if (Cools.isEmpty(orderPakin)) {
                OrderPakout orderPakout = orderPakoutService.selectByNo(orderNo);
                if (Cools.isEmpty(orderPakout)) {
                    return null;
                }
                return OrderTransFormationUtil.transformationOrder(null,orderPakout);
            }
            return orderDetlList;
            return OrderTransFormationUtil.transformationOrder(orderPakin,null);

        }
        @Transactional
        public List<Order> selectBySettle(Long settle) {
            List<OrderPakin> orderPakinList = orderPakinService.selectBySettle(settle);
            List<OrderPakout> orderPakoutList = orderPakoutService.selectBySettle(settle);
            return OrderTransFormationUtil.transformationOrderList(orderPakinList,orderPakoutList);
        }
        @Transactional
        public List<OrderDetl> selectByOrderId(Long orderId) {
            List<OrderDetlPakin> orderDetlPakinList = orderDetlPakinService.selectByOrderId(orderId);
            List<OrderDetlPakout> orderDetlPakoutList = orderDetlPakoutService.selectByOrderId(orderId);
            return OrderTransFormationUtil.transformationOrderDetlList(orderDetlPakinList,orderDetlPakoutList);
        }
        @Transactional
        public List<OrderDetl> selectWorkingDetls(Long orderId) {
            List<OrderDetlPakin> orderDetlPakinList = orderPakinService.selectWorkingDetls(orderId);
            List<OrderDetlPakout> orderDetlPakoutList = orderPakoutService.selectWorkingDetls(orderId);
            return OrderTransFormationUtil.transformationOrderDetlList(orderDetlPakinList,orderDetlPakoutList);
        }
        @Transactional
        public void checkComplete(String orderNo) {
            throw new CoolException("此方法无用！请好好写程序！！！403");
        }
        @Transactional
        public boolean saveHandlerOrder(Boolean Pakout, WrkMast wrkMast, List<WrkDetl> wrkDetls) {
            throw new CoolException("此方法无用！请好好写程序！！！407");
        }
        @Transactional
        public void insertOrder(Order order) {
            throw new CoolException("此方法无用！请好好写程序！！！411");
        }
        @Transactional
        public void insertOrderDetl(Order order, OrderDetl orderDetl) {
            throw new CoolException("此方法无用！请好好写程序！！！415");
        }
        @Transactional
        public void updateOrder(Long id, Long settle, Long userId) {
            throw new CoolException("此方法无用！请好好写程序！！！419");
        }
        @Transactional
        public void updateOrderDetl(Order order, OrderDetl orderDetl) {
            throw new CoolException("此方法无用！请好好写程序！！！423");
        }
        @Transactional
        public void remove(Long orderId) {
            throw new CoolException("此方法无用！请好好写程序！！！427");
        }

        public OrderPakout transformation(Order order){
            OrderPakout orderPakout = new OrderPakout();
            orderPakout.sync(order);
            return orderPakout;

        @Transactional
        public List<Order> selectComplete8() {
            List<OrderPakin> orderPakinList = orderPakinService.selectComplete8();
            List<OrderPakout> orderPakoutList = orderPakoutService.selectComplete8();
            return OrderTransFormationUtil.transformationOrderList(orderPakinList,orderPakoutList);
        }
        public List<OrderPakout> transformationList(List<Order> orderList){
            List<OrderPakout> orderPakoutList = new ArrayList<>();
            for (Order order : orderList){
                OrderPakout orderPakout = new OrderPakout();
                orderPakout.sync(order);
                orderPakoutList.add(orderPakout);
            }
            return orderPakoutList;

        @Transactional
        public boolean addToLogTableOrder(Order order) {
            throw new CoolException("此方法无用！请好好写程序！！！440");
        }
        public OrderDetlPakout transformationDetl(OrderDetl orderDetl){
            OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
            orderDetlPakout.sync(orderDetl);
            return orderDetlPakout;

        @Transactional
        public List<Order> selectOrderNoL(String orderNo) {
            List<OrderPakin> orderPakinList = orderPakinService.selectorderNoL(orderNo);
            List<OrderPakout> orderPakoutList = orderPakoutService.selectorderNoL(orderNo);
            return OrderTransFormationUtil.transformationOrderList(orderPakinList,orderPakoutList);
        }
        public List<OrderDetlPakout> transformationDetlList(List<OrderDetl> orderDetlList){
            List<OrderDetlPakout> orderDetlPakoutList = new ArrayList<>();
            for (OrderDetl orderDetl : orderDetlList){
                OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
                orderDetlPakout.sync(orderDetl);
                orderDetlPakoutList.add(orderDetlPakout);
            }
            return orderDetlPakoutList;

        @Transactional
        public Order selectOrderMoveStatus() {
            OrderPakin orderPakin = orderPakinService.selectOrderMoveStatus();
            OrderPakout orderPakout = orderPakoutService.selectOrderMoveStatus();
            return OrderTransFormationUtil.transformationOrder(orderPakin,orderPakout);
        }
    };

        @Transactional
        public Order selectOrderMoveStatusInitial() {
            OrderPakin orderPakin = orderPakinService.selectOrderMoveStatusInitial();
            OrderPakout orderPakout = orderPakoutService.selectOrderMoveStatusInitial();
            return OrderTransFormationUtil.transformationOrder(orderPakin,orderPakout);
        }

        @Transactional
        public List<Order> selectComplete() {
            List<OrderPakin> orderPakinList = orderPakinService.selectComplete();
            List<OrderPakout> orderPakoutList = orderPakoutService.selectComplete();
            return OrderTransFormationUtil.transformationOrderList(orderPakinList,orderPakoutList);
        }

        @Transactional
        public OrderDetl selectItem(Long orderId, String matnr, String batch) {
            OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderId, matnr, batch);
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderId, matnr, batch);
            return OrderTransFormationUtil.transformationOrderDetl(orderDetlPakin,orderDetlPakout);
        }

        @Transactional
        public OrderDetl selectItem(String orderNo, String matnr, String batch) {
            OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderNo, matnr, batch);
            OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderNo, matnr, batch);
            return OrderTransFormationUtil.transformationOrderDetl(orderDetlPakin,orderDetlPakout);
        }

        @Transactional
        public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
            throw new CoolException("此方法无用！请好好写程序！！！487");
        }
        @Transactional
        public boolean increase(Long orderId, String matnr, String batch, Double qty) {
            throw new CoolException("此方法无用！请好好写程序！！！491");
        }
        @Transactional
        public boolean decrease(String orderNo, String matnr, String batch, Double qty) {
            throw new CoolException("此方法无用！请好好写程序！！！495");
        }
        @Transactional
        public boolean modifyStatus(Long orderId, Integer status) {
            throw new CoolException("此方法无用！请好好写程序！！！499");
        }
        @Transactional
        public boolean addToLogTableOrderDetl(OrderDetl orderDetl) {
            throw new CoolException("此方法无用！请好好写程序！！！503");
        }
        @Transactional
        public boolean increaseQtyByOrderNo(String orderNo, String matnr, String batch, Double qty) {
            throw new CoolException("此方法无用！请好好写程序！！！507");
        }
        @Transactional
        public boolean increaseWorkQty(Long orderId, String matnr, String batch, Double workQty) {
            throw new CoolException("此方法无用！请好好写程序！！！511");
        }
    },
    ;

    public abstract void implement();

@@ -477,6 +519,8 @@

    public abstract Order selectByNo(String orderNo);

    public abstract List<Order> selectBySettle(Long settle);

    public abstract List<OrderDetl> selectByOrderId(Long orderId);

    public abstract List<OrderDetl> selectWorkingDetls(Long orderId);

 src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java

@@ -8,6 +8,7 @@
    IMPLEMENT("implement"),
    QUERY("query"),
    SELECT_BY_NO("selectByNo"),
    SELECT_SETTLE("selectSettle"),
    SELECT_BY_ORDER_ID("selectByOrderId"),
    SELECT_WORKING_DETLS("selectWorkingDetls"),
    CHECK_COMPLETE("checkComplete"),

 src/main/resources/mapper/OrderDetlMapper.xml

@@ -45,6 +45,7 @@
        <result column="update_by" property="updateBy" />
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>


 src/main/resources/mapper/OrderDetlPakinMapper.xml

@@ -45,6 +45,7 @@
        <result column="update_by" property="updateBy" />
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>


 src/main/resources/mapper/OrderDetlPakoutMapper.xml

@@ -45,6 +45,7 @@
        <result column="update_by" property="updateBy" />
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>


 src/main/resources/mapper/OrderMapper.xml

@@ -40,6 +40,7 @@
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="move_status" property="moveStatus" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>


 src/main/resources/mapper/OrderPakinMapper.xml

@@ -40,6 +40,7 @@
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="move_status" property="moveStatus" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>


 src/main/resources/mapper/OrderPakoutMapper.xml

@@ -40,6 +40,7 @@
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />
        <result column="move_status" property="moveStatus" />
        <result column="pakin_pakout_status" property="pakinPakoutStatus" />

    </resultMap>