#

lsh

2024-12-12 c9647257d0b789f94c14977dfa767c47d61cb566

#

 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 {

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


 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

 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;