From c9647257d0b789f94c14977dfa767c47d61cb566 Mon Sep 17 00:00:00 2001
From: lsh <lsh@163.com>
Date: 星期四, 12 十二月 2024 13:16:20 +0800
Subject: [PATCH] #
---
src/main/java/com/zy/asrs/utils/OrderInAndOutUtil.java | 275 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 260 insertions(+), 15 deletions(-)
diff --git a/src/main/java/com/zy/asrs/utils/OrderInAndOutUtil.java b/src/main/java/com/zy/asrs/utils/OrderInAndOutUtil.java
index 5a2bc65..db697d7 100644
--- a/src/main/java/com/zy/asrs/utils/OrderInAndOutUtil.java
+++ b/src/main/java/com/zy/asrs/utils/OrderInAndOutUtil.java
@@ -1,14 +1,18 @@
package com.zy.asrs.utils;
+import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.Order;
import com.zy.asrs.entity.OrderDetl;
+import com.zy.asrs.entity.WrkDetl;
+import com.zy.asrs.entity.WrkMast;
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.List;
public class OrderInAndOutUtil {
@@ -19,49 +23,290 @@
return OrderEnumVo.PAKOUT.getCode();
}
- public static Method implement(boolean sign,OrderMethodVo orderMethodVo){
+ public static OrderInAndOutType getOrderInAndOutType(boolean sign) {
+ return OrderInAndOutType.valueOf(enumUtil(sign));
+ }
+
+ public static boolean aBoolean(Object object){
+ if (Cools.isEmpty(object)){
+ throw new CoolException("null");
+ } else if (object instanceof Boolean) {
+ return (boolean) object;
+ } else {
+ throw new CoolException("Unexpected return type");
+ }
+ }
+
+ public static Order aOrder(Object object){
+ if (Cools.isEmpty(object)){
+ return null;
+ } else if (object instanceof Order) {
+ return (Order) object;
+ } else {
+ throw new CoolException("Unexpected return type");
+ }
+ }
+
+ public static OrderDetl aOrderDetl(Object object){
+ if (Cools.isEmpty(object)){
+ return null;
+ } else if (object instanceof OrderDetl) {
+ return (OrderDetl) object;
+ } else {
+ throw new CoolException("Unexpected return type");
+ }
+ }
+
+ public static Method implement(OrderMethodVo orderMethodVo){
Class<OrderInAndOutType> casual = OrderInAndOutType.class;
try{
switch (orderMethodVo){
case QUERY:
return casual.getDeclaredMethod(OrderMethodVo.QUERY.getCode(), String.class);
+ case SELECT_BY_NO:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_BY_NO.getCode(), String.class);
+ case SELECT_BY_ORDER_ID:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_BY_ORDER_ID.getCode(), Long.class);
+ case SELECT_WORKING_DETLS:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_WORKING_DETLS.getCode(), Long.class);
+ case CHECK_COMPLETE:
+ return casual.getDeclaredMethod(OrderMethodVo.CHECK_COMPLETE.getCode(), String.class);
+ case SAVE_HANDLER_ORDER:
+ return casual.getDeclaredMethod(OrderMethodVo.SAVE_HANDLER_ORDER.getCode(), Boolean.class, WrkMast.class, List.class);
case INSERT_ORDER:
return casual.getDeclaredMethod(OrderMethodVo.INSERT_ORDER.getCode(), Order.class);
case INSERT_ORDERDETL:
return casual.getDeclaredMethod(OrderMethodVo.INSERT_ORDERDETL.getCode(), Order.class, OrderDetl.class);
- case IMPLEMENT:
- return casual.getDeclaredMethod(OrderMethodVo.IMPLEMENT.getCode(), Object.class,Object.class);
+ case UPDATE_ORDER:
+ return casual.getDeclaredMethod(OrderMethodVo.UPDATE_ORDER.getCode(), Long.class,Long.class,Long.class);
+ case UPDATE_ORDERDETL:
+ return casual.getDeclaredMethod(OrderMethodVo.UPDATE_ORDERDETL.getCode(), Order.class,OrderDetl.class);
+ case REMOVE:
+ return casual.getDeclaredMethod(OrderMethodVo.REMOVE.getCode(), Long.class);
+ case SELECT_COMPLETE:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_COMPLETE.getCode());
+ case SELECT_ITEM1:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_ITEM1.getCode(), Long.class,String.class,String.class);
+ case SELECT_ITEM2:
+ return casual.getDeclaredMethod(OrderMethodVo.SELECT_ITEM2.getCode(), String.class,String.class,String.class);
+ case FIND_BY_LOOK:
+ return casual.getDeclaredMethod(OrderMethodVo.FIND_BY_LOOK.getCode(), List.class, Long.class,String.class,String.class);
+ case INCREASE:
+ return casual.getDeclaredMethod(OrderMethodVo.INCREASE.getCode(), Long.class,String.class,String.class,Double.class);
+ case DECREASE:
+ 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 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:
+ return casual.getDeclaredMethod(OrderMethodVo.INCREASE_WORKING_QTY.getCode(), Long.class,String.class,String.class,Double.class);
}
} catch (Exception e) {
- throw new CoolException(e.getMessage());
+ throw new CoolException(e.getCause().getMessage());
}
throw new CoolException("鏈煡寮傚父");
}
public static void query(boolean sign,OrderMethodVo orderMethodVo,String orderNo){
- OrderInAndOutType orderInAndOutType = OrderInAndOutType.valueOf(enumUtil(sign));
try{
- implement(sign, orderMethodVo).invoke(orderInAndOutType,orderNo);
+ implement(orderMethodVo).invoke(getOrderInAndOutType(sign),orderNo);
} catch (Exception e) {
- throw new CoolException(e.getMessage());
+ throw new CoolException(e.getCause().getMessage());
}
}
- public static void insert(boolean sign,OrderMethodVo orderMethodVo,Order order){
- OrderInAndOutType orderInAndOutType = OrderInAndOutType.valueOf(enumUtil(sign));
+ public static Order selectByNo(boolean sign,OrderMethodVo orderMethodVo,String orderNo){
try{
- implement(sign, orderMethodVo).invoke(orderInAndOutType,order);
+ Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderNo);
+ return aOrder(invoke);
} catch (Exception e) {
- throw new CoolException(e.getMessage());
+ throw new CoolException(e.getCause().getMessage());
}
}
- public static void insert(boolean sign,OrderMethodVo orderMethodVo,Order order,OrderDetl orderDetl){
- OrderInAndOutType orderInAndOutType = OrderInAndOutType.valueOf(enumUtil(sign));
+ public static List<OrderDetl> selectByOrderId(boolean sign,OrderMethodVo orderMethodVo,Long orderId){
try{
- implement(sign, orderMethodVo).invoke(orderInAndOutType,order,orderDetl);
+ Object result = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId);
+ if (Cools.isEmpty(result)){
+ return null;
+ } else if (result instanceof List) {
+ return (List<OrderDetl>) result;
+ } else {
+ throw new CoolException("Unexpected return type");
+ }
} catch (Exception e) {
- throw new CoolException(e.getMessage());
+ throw new CoolException(e.getCause().getMessage());
+ }
+ }
+
+ public static List<OrderDetl> selectWorkingDetls(boolean sign,OrderMethodVo orderMethodVo,Long orderId){
+ try{
+ Object result = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId);
+ if (Cools.isEmpty(result)){
+ return null;
+ } 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 void checkComplete(boolean sign,OrderMethodVo orderMethodVo,String orderNo){
+ 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));
+ if (Cools.isEmpty(result)){
+ return null;
+ } else if (result instanceof List) {
+ return (List<Order>) result;
+ } else {
+ throw new CoolException("Unexpected return type");
+ }
+ } catch (Exception e) {
+ throw new CoolException(e.getCause().getMessage());
+ }
+ }
+
+ public static OrderDetl selectItem(boolean sign,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch){
+ try{
+ Object invoke = implement(orderMethodVo).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){
+ try{
+ Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderNo, 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){
+ try{
+ Object invoke = implement(orderMethodVo).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,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch, Double qty){
+ try{
+ Object invoke = implement(orderMethodVo).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){
+ try{
+ Object invoke = implement(orderMethodVo).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,OrderMethodVo orderMethodVo,Long orderId, Integer status){
+ try{
+ Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, status);
+ return aBoolean(invoke);
+ } catch (Exception e) {
+ throw new CoolException(e.getCause().getMessage());
+ }
+ }
+
+ public static boolean addToLogTable(boolean sign,OrderMethodVo orderMethodVo,OrderDetl orderDetl){
+ try{
+ Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderDetl);
+ 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){
+ try{
+ Object invoke = implement(orderMethodVo).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,OrderMethodVo orderMethodVo,Long orderId, String matnr, String batch, Double workQty){
+ try{
+ Object invoke = implement(orderMethodVo).invoke(getOrderInAndOutType(sign), orderId, matnr, batch, workQty);
+ return aBoolean(invoke);
+ } catch (Exception e) {
+ throw new CoolException(e.getCause().getMessage());
}
}
--
Gitblit v1.9.1