#

lsh

2024-12-17 b9cd7d99e4916d5a6b721d43644b0ae080ddfd7c

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

@@ -9,22 +9,39 @@
import com.zy.common.model.enumUtils.OrderEnumVo;
import com.zy.common.model.enumUtils.OrderInAndOutType;
import com.zy.common.model.enumUtils.OrderMethodVo;
import org.apache.poi.ss.formula.functions.T;

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

/**
 * Created by IX on 2024/12/14
 */
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 +82,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:
@@ -85,6 +104,16 @@
                    return casual.getDeclaredMethod(OrderMethodVo.REMOVE.getCode(), Long.class);
                case SELECT_COMPLETE:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_COMPLETE.getCode());
                case SELECT_COMPLETE8:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_COMPLETE8.getCode());
                case ADD_TO_LOG_TABLE_ORDER:
                    return casual.getDeclaredMethod(OrderMethodVo.ADD_TO_LOG_TABLE_ORDER.getCode(), Order.class);
                case SELECT_ORDER_NO_L:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_ORDER_NO_L.getCode(), String.class);
                case SELECT_ORDER_MOVE_STATUS:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_ORDER_MOVE_STATUS.getCode());
                case SELECT_ORDER_MOVE_STATUS_INITIAL:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_ORDER_MOVE_STATUS_INITIAL.getCode());
                case SELECT_ITEM1:
                    return casual.getDeclaredMethod(OrderMethodVo.SELECT_ITEM1.getCode(), Long.class,String.class,String.class);
                case SELECT_ITEM2:
@@ -97,8 +126,8 @@
                    return casual.getDeclaredMethod(OrderMethodVo.DECREASE.getCode(), String.class,String.class,String.class,Double.class);
                case MODIFY_STATUS:
                    return casual.getDeclaredMethod(OrderMethodVo.MODIFY_STATUS.getCode(), Long.class,Integer.class);
                case ADD_TO_LOG_TABLE:
                    return casual.getDeclaredMethod(OrderMethodVo.ADD_TO_LOG_TABLE.getCode(), OrderDetl.class);
                case ADD_TO_LOG_TABLE_ORDERDETL:
                    return casual.getDeclaredMethod(OrderMethodVo.ADD_TO_LOG_TABLE_ORDERDETL.getCode(), OrderDetl.class);
                case INCREASE_QTY_BY_ORDER_NO:
                    return casual.getDeclaredMethod(OrderMethodVo.INCREASE_QTY_BY_ORDER_NO.getCode(), String.class,String.class,String.class,Double.class);
                case INCREASE_WORKING_QTY:
@@ -110,28 +139,90 @@
        throw new CoolException("未知异常");
    }

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

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

    public static Order selectByNo(boolean 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<OrderDetl> selectByOrderId(boolean sign,OrderMethodVo orderMethodVo,Long orderId){
    public static Order selectByNo(String sign,String orderNo){
        try{
            Object result = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId);
            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 {
@@ -142,11 +233,11 @@
        }
    }

    public static List<OrderDetl> selectWorkingDetls(boolean sign,OrderMethodVo orderMethodVo,Long orderId){
    public static List<OrderDetl> selectWorkingDetls(boolean sign,Long orderId){
        try{
            Object result = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId);
            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 {
@@ -157,70 +248,13 @@
        }
    }

    public static void checkComplete(boolean sign,OrderMethodVo orderMethodVo,String orderNo){
    public static List<OrderDetl> selectWorkingDetls(String sign,Long orderId){
        try{
            implement(orderMethodVo).invoke(getOrderInAndOutType(sign),orderNo);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

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

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

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

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

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

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

    public static List<Order> selectComplete(boolean sign,OrderMethodVo orderMethodVo){
        try{
            Object result = implement(orderMethodVo).invoke(getOrderInAndOutType(sign));
            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<Order>) result;
                return (List<OrderDetl>) result;
            } else {
                throw new CoolException("Unexpected return type");
            }
@@ -229,81 +263,420 @@
        }
    }

    public static OrderDetl selectItem(boolean sign,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch){
    public static void checkComplete(boolean sign,String orderNo){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, matnr, batch);
            implement(OrderMethodVo.CHECK_COMPLETE).invoke(getOrderInAndOutType(sign),orderNo);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    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);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

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

    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) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static void updateOrder(boolean 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 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) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

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

    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 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 {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static List<Order> selectComplete8(boolean 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 {
                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 {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static boolean addToLogTableOrder(boolean 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 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 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 {
                throw new CoolException("Unexpected return type");
            }
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static Order selectOrderMoveStatus(boolean 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 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);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    public static OrderDetl selectItem(boolean 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,OrderMethodVo orderMethodVo,String orderNo, String matnr, String batch){
    public static OrderDetl selectItem(String sign,Long orderId, String matnr, String batch){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch);
            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 findByLook(boolean sign,OrderMethodVo orderMethodVo,List<OrderDetl> orderDetls, Long orderId, String matnr, String batch){
    public static OrderDetl selectItem(boolean sign,String orderNo, String matnr, String batch){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderDetls, orderId, matnr, batch);
            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 boolean increase(boolean sign,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch, Double qty){
    public static OrderDetl selectItem(String sign,String orderNo, String matnr, String batch){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, qty);
            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 findByLook(boolean 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 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 decrease(boolean sign,OrderMethodVo orderMethodVo,String orderNo, String matnr, String batch, Double qty){
    public static boolean increase(String sign,Long orderId, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch, qty);
            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 modifyStatus(boolean sign,OrderMethodVo orderMethodVo,Long orderId, Integer status){
    public static boolean decrease(boolean sign,String orderNo, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, status);
            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 addToLogTable(boolean sign,OrderMethodVo orderMethodVo,OrderDetl orderDetl){
    public static boolean decrease(String sign,String orderNo, String matnr, String batch, Double qty){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderDetl);
            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 increaseQtyByOrderNo(boolean sign,OrderMethodVo orderMethodVo,String orderNo, String matnr, String batch, Double qty){
    public static boolean modifyStatus(boolean sign,Long orderId, Integer status){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderNo, matnr, batch, qty);
            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 increaseWorkQty(boolean sign,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch, Double workQty){
    public static boolean modifyStatus(String sign,Long orderId, Integer status){
        try{
            Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, workQty);
            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 addToLogTableOrderDetl(boolean 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 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);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    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);
            return aBoolean(invoke);
        } catch (Exception e) {
            throw new CoolException(e.getCause().getMessage());
        }
    }

    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());