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 +++++++++++++++++++++++-
src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java | 340 +++++++++++++++++++++++++++---
src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java | 20 +
src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java | 18 +
4 files changed, 596 insertions(+), 57 deletions(-)
diff --git a/src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java
index 9dfd548..f3b6c85 100644
--- a/src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java
@@ -104,7 +104,7 @@
null // 澶囨敞
);
try{
- OrderInAndOutUtil.insert(Boolean.TRUE,OrderMethodVo.INSERT_ORDER,order);
+ OrderInAndOutUtil.insertOrder(Boolean.TRUE,OrderMethodVo.INSERT_ORDER,order);
} catch (Exception e) {
throw new CoolException(e.getMessage());
}
@@ -139,7 +139,7 @@
orderDetl.setStatus(1);
orderDetl.setQty(0.0D);
try{
- OrderInAndOutUtil.insert(Boolean.TRUE,OrderMethodVo.INSERT_ORDERDETL,order,orderDetl);
+ OrderInAndOutUtil.insertOrderDetl(Boolean.TRUE,OrderMethodVo.INSERT_ORDERDETL,order,orderDetl);
} catch (Exception e) {
throw new CoolException(e.getMessage());
}
@@ -152,22 +152,28 @@
List<OpenOrderCompeteResult> results = new ArrayList<>();
if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
// 鎸囧畾璁㈠崟
- Order order = orderService.selectByNo(param.getOrderNo());
+// Order order = orderService.selectByNo(param.getOrderNo());
+
+ Order order = OrderInAndOutUtil.selectByNo(Boolean.TRUE,OrderMethodVo.SELECT_BY_NO,param.getOrderNo());
+
if (null != order) {
OpenOrderCompeteResult result = new OpenOrderCompeteResult();
results.add(result);
result.setOrderNo(order.getOrderNo());
result.setOrderTime(order.getOrderTime());
result.setOrderType(order.getDocType$());
- List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
+// List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
+ List<OrderDetl> orderDetls = OrderInAndOutUtil.selectByOrderId(Boolean.TRUE, OrderMethodVo.SELECT_BY_NO, order.getId());
+
for (OrderDetl orderDetl : orderDetls) {
result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
}
if (order.getSettle() == 4L) {
// 淇敼璁㈠崟鐘舵�� 4.瀹屾垚 ===>> 6.宸蹭笂鎶�
- if (!orderService.updateSettle(order.getId(), 6L, null)) {
- throw new CoolException("鏈嶅姟鍣ㄥ唴閮ㄩ敊璇紝璇疯仈绯荤鐞嗗憳");
- }
+// if (!orderService.updateSettle(order.getId(), 6L, null)) {
+// throw new CoolException("鏈嶅姟鍣ㄥ唴閮ㄩ敊璇紝璇疯仈绯荤鐞嗗憳");
+// }
+ OrderInAndOutUtil.updateOrder(Boolean.TRUE, OrderMethodVo.SELECT_BY_NO,order.getId(), 6L, null);
}
}
} else {
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());
}
}
diff --git a/src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java b/src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java
index d6c3745..9610b67 100644
--- a/src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java
+++ b/src/main/java/com/zy/common/model/enumUtils/OrderInAndOutType.java
@@ -8,7 +8,6 @@
import com.zy.asrs.service.OrderPakinService;
import com.zy.asrs.service.OrderPakoutService;
import lombok.Setter;
-import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -21,9 +20,8 @@
public enum OrderInAndOutType {
PAKIN{
@Transactional
- public void implement(Class<T> tClass, Object param) {
+ public void implement() {}
- }
@Transactional
public void query(String orderNo) {
OrderPakin orderPakin = orderPakinService.selectByNo(orderNo);
@@ -32,27 +30,30 @@
}
}
@Transactional
- public Order selectOrder(String orderNo) {
+ public Order selectByNo(String orderNo) {
OrderPakin orderPakin = orderPakinService.selectByNo(orderNo);
if (Cools.isEmpty(orderPakin)) {
return null;
}
- Order order = new Order();
- order.sync(orderPakin);
- return order;
+ return transformationOrder(orderPakin);
}
@Transactional
- public List<OrderDetl> selectOrderDetl(Long orderId) {
- List<OrderDetl> orderDetlList = new ArrayList<>();
+ public List<OrderDetl> selectByOrderId(Long orderId) {
List<OrderDetlPakin> orderDetlPakinList = orderDetlPakinService.selectByOrderId(orderId);
- if (!orderDetlPakinList.isEmpty()) {
- for (OrderDetlPakin orderDetlPakin : orderDetlPakinList){
- OrderDetl orderDetl = new OrderDetl();
- orderDetl.sync(orderDetlPakin);
- orderDetlList.add(orderDetl);
- }
- }
- return orderDetlList;
+ return transformationOrderDetlList(orderDetlPakinList);
+ }
+ @Transactional
+ public List<OrderDetl> selectWorkingDetls(Long orderId) {
+ List<OrderDetlPakin> orderDetlPakinList = orderPakinService.selectWorkingDetls(orderId);
+ return transformationOrderDetlList(orderDetlPakinList);
+ }
+ @Transactional
+ public void checkComplete(String orderNo) {
+ orderPakinService.checkComplete(orderNo);
+ }
+ @Transactional
+ public boolean saveHandlerOrder(Boolean pakin, WrkMast wrkMast, List<WrkDetl> wrkDetls) {
+ return orderPakinService.saveHandlerOrder(pakin,wrkMast,wrkDetls);
}
@Transactional
public void insertOrder(Order order) {
@@ -90,12 +91,127 @@
throw new CoolException("鐢熸垚鍗曟嵁鏄庣粏澶辫触锛岃鑱旂郴绠＄悊鍛�");
}
}
+ @Transactional
+ public void remove(Long orderId) {
+ try{
+ orderPakinService.remove(orderId);
+ } catch (Exception e){
+ throw new CoolException("鍒犻櫎鍗曟嵁澶辫触");
+ }
+ }
+ @Transactional
+ public List<Order> selectComplete() {
+ List<OrderPakin> orderPakinList = orderPakinService.selectComplete();
+ return transformationOrderList(orderPakinList);
+ }
+
+ @Transactional
+ public OrderDetl selectItem(Long orderId, String matnr, String batch) {
+ OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderId, matnr, batch);
+ return transformationOrderDetl(orderDetlPakin);
+ }
+
+ @Transactional
+ public OrderDetl selectItem(String orderNo, String matnr, String batch) {
+ OrderDetlPakin orderDetlPakin = orderDetlPakinService.selectItem(orderNo, matnr, batch);
+ return transformationOrderDetl(orderDetlPakin);
+ }
+
+ @Transactional
+ public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
+ List<OrderDetlPakin> orderDetlPakins = transformationDetlList(orderDetls);
+ OrderDetlPakin orderDetlPakin = orderDetlPakinService.findByLook(orderDetlPakins, orderId, matnr,batch);
+ return transformationOrderDetl(orderDetlPakin);
+ }
+ @Transactional
+ public boolean increase(Long orderId, String matnr, String batch, Double qty) {
+ return orderDetlPakinService.increase(orderId, matnr, batch, qty);
+ }
+ @Transactional
+ public boolean decrease(String orderNo, String matnr, String batch, Double qty) {
+ return orderDetlPakinService.decrease(orderNo, matnr, batch, qty);
+ }
+ @Transactional
+ public boolean modifyStatus(Long orderId, Integer status) {
+ return orderDetlPakinService.modifyStatus(orderId, status);
+ }
+ @Transactional
+ public boolean addToLogTable(OrderDetl orderDetl) {
+ OrderDetlPakin orderDetlPakin = transformationDetl(orderDetl);
+ return orderDetlPakinService.addToLogTable(orderDetlPakin);
+ }
+ @Transactional
+ public boolean increaseQtyByOrderNo(String orderNo, String matnr, String batch, Double qty) {
+ return orderDetlPakinService.increaseQtyByOrderNo(orderNo, matnr, batch, qty);
+ }
+ @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{
@Transactional
- public void implement(Class<T> tClass, Object param) {
+ public void implement() {}
- }
@Transactional
public void query(String orderNo) {
OrderPakout orderPakout = orderPakoutService.selectByNo(orderNo);
@@ -104,27 +220,30 @@
}
}
@Transactional
- public Order selectOrder(String orderNo) {
+ public Order selectByNo(String orderNo) {
OrderPakout orderPakout = orderPakoutService.selectByNo(orderNo);
if (Cools.isEmpty(orderPakout)) {
return null;
}
- Order order = new Order();
- order.sync(orderPakout);
- return order;
+ return transformationOrder(orderPakout);
}
@Transactional
- public List<OrderDetl> selectOrderDetl(Long orderId) {
- List<OrderDetl> orderDetlList = new ArrayList<>();
+ public List<OrderDetl> selectByOrderId(Long orderId) {
List<OrderDetlPakout> orderDetlPakoutList = orderDetlPakoutService.selectByOrderId(orderId);
- if (!orderDetlPakoutList.isEmpty()) {
- for (OrderDetlPakout orderDetlPakout : orderDetlPakoutList){
- OrderDetl orderDetl = new OrderDetl();
- orderDetl.sync(orderDetlPakout);
- orderDetlList.add(orderDetl);
- }
- }
- return orderDetlList;
+ return transformationOrderDetlList(orderDetlPakoutList);
+ }
+ @Transactional
+ public List<OrderDetl> selectWorkingDetls(Long orderId) {
+ List<OrderDetlPakout> orderDetlPakoutList = orderPakoutService.selectWorkingDetls(orderId);
+ return transformationOrderDetlList(orderDetlPakoutList);
+ }
+ @Transactional
+ public void checkComplete(String orderNo) {
+ orderPakoutService.checkComplete(orderNo);
+ }
+ @Transactional
+ public boolean saveHandlerOrder(Boolean Pakout, WrkMast wrkMast, List<WrkDetl> wrkDetls) {
+ return orderPakoutService.saveHandlerOrder(Pakout,wrkMast,wrkDetls);
}
@Transactional
public void insertOrder(Order order) {
@@ -162,15 +281,168 @@
throw new CoolException("鐢熸垚鍗曟嵁鏄庣粏澶辫触锛岃鑱旂郴绠＄悊鍛�");
}
}
+ @Transactional
+ public void remove(Long orderId) {
+ try{
+ orderPakoutService.remove(orderId);
+ } catch (Exception e){
+ throw new CoolException("鍒犻櫎鍗曟嵁澶辫触");
+ }
+ }
+ @Transactional
+ public List<Order> selectComplete() {
+ List<OrderPakout> orderPakoutList = orderPakoutService.selectComplete();
+ return transformationOrderList(orderPakoutList);
+ }
+
+ @Transactional
+ public OrderDetl selectItem(Long orderId, String matnr, String batch) {
+ OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderId, matnr, batch);
+ return transformationOrderDetl(orderDetlPakout);
+ }
+
+ @Transactional
+ public OrderDetl selectItem(String orderNo, String matnr, String batch) {
+ OrderDetlPakout orderDetlPakout = orderDetlPakoutService.selectItem(orderNo, matnr, batch);
+ return transformationOrderDetl(orderDetlPakout);
+ }
+
+ @Transactional
+ public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
+ List<OrderDetlPakout> orderDetlPakouts = transformationDetlList(orderDetls);
+ OrderDetlPakout orderDetlPakout = orderDetlPakoutService.findByLook(orderDetlPakouts, orderId, matnr,batch);
+ return transformationOrderDetl(orderDetlPakout);
+ }
+ @Transactional
+ public boolean increase(Long orderId, String matnr, String batch, Double qty) {
+ return orderDetlPakoutService.increase(orderId, matnr, batch, qty);
+ }
+ @Transactional
+ public boolean decrease(String orderNo, String matnr, String batch, Double qty) {
+ return orderDetlPakoutService.decrease(orderNo, matnr, batch, qty);
+ }
+ @Transactional
+ public boolean modifyStatus(Long orderId, Integer status) {
+ return orderDetlPakoutService.modifyStatus(orderId, status);
+ }
+ @Transactional
+ public boolean addToLogTable(OrderDetl orderDetl) {
+ OrderDetlPakout orderDetlPakout = transformationDetl(orderDetl);
+ return orderDetlPakoutService.addToLogTable(orderDetlPakout);
+ }
+ @Transactional
+ public boolean increaseQtyByOrderNo(String orderNo, String matnr, String batch, Double qty) {
+ return orderDetlPakoutService.increaseQtyByOrderNo(orderNo, matnr, batch, qty);
+ }
+ @Transactional
+ public boolean increaseWorkQty(Long orderId, String matnr, String batch, Double workQty) {
+ return orderDetlPakoutService.increaseWorkQty(orderId, matnr, batch, workQty);
+ }
+
+
+ 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);
+ }
+ 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);
+ }
+ return orderDetlList;
+ }
+
+ public OrderPakout transformation(Order order){
+ OrderPakout orderPakout = new OrderPakout();
+ orderPakout.sync(order);
+ return orderPakout;
+ }
+ 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;
+ }
+ public OrderDetlPakout transformationDetl(OrderDetl orderDetl){
+ OrderDetlPakout orderDetlPakout = new OrderDetlPakout();
+ orderDetlPakout.sync(orderDetl);
+ return orderDetlPakout;
+ }
+ 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;
+ }
};
- public abstract void implement(Class<T> tClass, Object param);
+ public abstract void implement();
+
public abstract void query(String orderNo);
+
+ public abstract Order selectByNo(String orderNo);
+
+ public abstract List<OrderDetl> selectByOrderId(Long orderId);
+
+ public abstract List<OrderDetl> selectWorkingDetls(Long orderId);
+
+ public abstract void checkComplete(String orderNo);
+
+ public abstract boolean saveHandlerOrder(Boolean pakin, WrkMast wrkMast, List<WrkDetl> wrkDetls);
+
public abstract void insertOrder(Order order);
+
public abstract void insertOrderDetl(Order order, OrderDetl orderDetl);
+
public abstract void updateOrder(Long id, Long settle, Long userId);
+
public abstract void updateOrderDetl(Order order, OrderDetl orderDetl);
+ public abstract void remove(Long orderId);
+
+ public abstract List<Order> selectComplete();
+
+ public abstract OrderDetl selectItem(Long orderId, String matnr, String batch);
+
+ public abstract OrderDetl selectItem(String orderNo, String matnr, String batch);
+
+ public abstract OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch);
+
+ public abstract boolean increase(Long orderId, String matnr, String batch, Double qty);
+
+ public abstract boolean decrease(String orderNo, String matnr, String batch, Double qty);
+
+ public abstract boolean modifyStatus(Long orderId, Integer status);
+
+ public abstract boolean addToLogTable(OrderDetl orderDetl);
+
+ public abstract boolean increaseQtyByOrderNo(String orderNo, String matnr, String batch, Double qty);
+
+ public abstract boolean increaseWorkQty(Long orderId, String matnr, String batch, Double workQty);
+
@Setter
OrderPakinService orderPakinService;
@Setter
diff --git a/src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java b/src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java
index 8a98d90..0b982eb 100644
--- a/src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java
+++ b/src/main/java/com/zy/common/model/enumUtils/OrderMethodVo.java
@@ -3,10 +3,26 @@
public enum OrderMethodVo {
IMPLEMENT("implement"),
QUERY("query"),
+ SELECT_BY_NO("selectByNo"),
+ SELECT_BY_ORDER_ID("selectByOrderId"),
+ SELECT_WORKING_DETLS("selectWorkingDetls"),
+ CHECK_COMPLETE("checkComplete"),
+ SAVE_HANDLER_ORDER("saveHandlerOrder"),
INSERT_ORDER("insertOrder"),
INSERT_ORDERDETL("insertOrderDetl"),
UPDATE_ORDER("updateOrder"),
- UPDATE_ORDERDETL("updateOrderDetl");
+ UPDATE_ORDERDETL("updateOrderDetl"),
+ REMOVE("remove"),
+ SELECT_COMPLETE("selectComplete"),
+ SELECT_ITEM1("selectItem"),
+ SELECT_ITEM2("selectItem"),
+ FIND_BY_LOOK("findByLook"),
+ INCREASE("increase"),
+ DECREASE("decrease"),
+ MODIFY_STATUS("modifyStatus"),
+ ADD_TO_LOG_TABLE("addToLogTable"),
+ INCREASE_QTY_BY_ORDER_NO("increaseQtyByOrderNo"),
+ INCREASE_WORKING_QTY("increaseWorkQty");
private String code;
--
Gitblit v1.9.1