no message

skyouc

昨天 6efbf154b3ed88d376763b9d9807256c7bd5eaeb

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

@@ -9,10 +9,11 @@
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.enums.CheckStatusEnum;
import com.zy.asrs.enums.OrderTypeEnum;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
import com.zy.asrs.utils.OrderInAndOutUtil;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.NodeUtils;
import lombok.extern.slf4j.Slf4j;
@@ -49,17 +50,24 @@
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;
    @Autowired
    private CheckOrderService checkOrderService;
    @Autowired
    private CheckOrderDetlService checkOrderDetlService;



    @Override
    @Transactional
    public void pakinOrderCreate(OpenOrderPakinParam param) {

        OrderInAndOutUtil.query(Boolean.TRUE,param.getOrderNo());

        Order order = orderService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order)) {
            throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        Date now = new Date();
        // 单据主档
        Order order = new Order(
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                DateUtils.convert(now),    // 单据日期
@@ -95,9 +103,9 @@
                now,    // 修改时间
                null    // 备注
        );

        OrderInAndOutUtil.insertOrder(Boolean.TRUE,order);

        if (!orderService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<DetlDto> orderDetails = param.getOrderDetails();
@@ -128,7 +136,9 @@
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            OrderInAndOutUtil.insertOrderDetl(Boolean.TRUE,order,orderDetl);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

@@ -138,54 +148,41 @@
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
//            Order order = orderService.selectByNo(param.getOrderNo());

            Order order = OrderInAndOutUtil.selectByNo(Boolean.TRUE,param.getOrderNo());

            Order order = orderService.selectByNo(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 = OrderInAndOutUtil.selectByOrderId(order.getPakinPakoutStatus$(), order.getId());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(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("服务器内部错误，请联系管理员");
//                    }
                    OrderInAndOutUtil.updateOrder(order.getPakinPakoutStatus$(),order.getId(), 6L, null);
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
//            List<Order> orders = orderService.selectBySettle(4L);
            List<Order> orders = OrderInAndOutUtil.selectBySettle(null, 4L);
            if (orders.isEmpty()){
                orders = new ArrayList<>();
            }
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
                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 = OrderInAndOutUtil.selectByOrderId(order.getPakinPakoutStatus$(), order.getId());

                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
//                // 修改订单状态 4.完成 ===>> 6.已上报
//                if (!orderService.updateSettle(order.getId(), 6L, null)) {
//                    throw new CoolException("服务器内部错误，请联系管理员");
//                }
                OrderInAndOutUtil.updateOrder(order.getPakinPakoutStatus$(),order.getId(),6L,null);

                // 修改订单状态 4.完成 ===>> 6.已上报
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
@@ -194,15 +191,13 @@
    @Override
    @Transactional
    public void pakoutOrderCreate(OpenOrderPakoutParam param) {
//        Order order = orderService.selectByNo(param.getOrderNo());
        Order order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, param.getOrderNo());
        Order order = orderService.selectByNo(param.getOrderNo());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
            }
//            orderService.remove(order.getId());
            OrderInAndOutUtil.remove(Boolean.FALSE,order.getId());
            orderService.remove(order.getId());
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
        Date now = new Date();
@@ -243,10 +238,9 @@
                now,    // 修改时间
                null    // 备注
        );
//        if (!orderService.insert(order)) {
//            throw new CoolException("生成单据主档失败，请联系管理员");
//        }
        OrderInAndOutUtil.insertOrder(Boolean.FALSE,order);
        if (!orderService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<DetlDto> orderDetails = param.getOrderDetails();
@@ -277,10 +271,9 @@
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
//            if (!orderDetlService.insert(orderDetl)) {
//                throw new CoolException("生成单据明细失败，请联系管理员");
//            }
            OrderInAndOutUtil.insertOrderDetl(Boolean.FALSE,order,orderDetl);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

@@ -289,47 +282,41 @@
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
//            Order order = orderService.selectByNo(param.getOrderNo());
            Order order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, param.getOrderNo());
            Order order = orderService.selectByNo(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 = OrderInAndOutUtil.selectByOrderId(order.getPakinPakoutStatus$(),order.getId());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(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("服务器内部错误，请联系管理员");
//                    }
                    OrderInAndOutUtil.updateOrder(order.getPakinPakoutStatus$(),order.getId(),6L,null);
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
//            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            List<Order> orders = OrderInAndOutUtil.selectBySettle(null, 4L);
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
                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 = OrderInAndOutUtil.selectByOrderId(order.getPakinPakoutStatus$(), order.getId());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
                // 修改订单状态 4.完成 ===>> 6.已上报
//                if (!orderService.updateSettle(order.getId(), 6L, null)) {
//                    throw new CoolException("服务器内部错误，请联系管理员");
//                }
                OrderInAndOutUtil.updateOrder(order.getPakinPakoutStatus$(),order.getId(),6L,null);
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
@@ -456,6 +443,65 @@
        }
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public void adjustmentOrderCreate(OpenAdjustmentOrderParam param) {
        if(Cools.isEmpty(param.getOrderNo())){
            String prefix = "";
            DocType docType = docTypeService.selectById(param.getOrderNo());
            if(!Cools.isEmpty(docType)){
                prefix = "Adjust";
            }
            param.setOrderNo(prefix + snowflakeIdWorker.nextId());
        }
        CheckOrder checkOrder = checkOrderService.selectOne(new EntityWrapper<CheckOrder>().eq("order_no", param.getOrderNo()) );
        if (checkOrder != null) {
            throw new CoolException("单据已存在");
        }
        Date now = new Date();
        checkOrder = new CheckOrder();
        checkOrder.setOrderNo(param.getOrderNo());
        checkOrder.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        checkOrder.setOrderTime( DateUtils.convert(now));
        checkOrder.setDocType(Long.valueOf(OrderTypeEnum.ADJUSTMENT.type));
        checkOrder.setSettle(1L);
        checkOrder.setCreateBy(9527L);
        checkOrder.setCreateTime(now);
        checkOrder.setUpdateBy(9527L);
        checkOrder.setUpdateTime(now);
        checkOrder.setStatus(1);

        if (!checkOrderService.insert(checkOrder)) {
            throw new CoolException("保存调整单主单失败");
        }
        for (CheckOrderDetl checkOrderDetl1 : param.getOrderDetails()) {
            LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>()
                    .eq("matnr", checkOrderDetl1.getMatnr())
                    .eq("loc_no", checkOrderDetl1.getLocNo())
                    .eq("batch", checkOrderDetl1.getBatch())
            );
            if (Cools.isEmpty(locDetl)) {
                throw new CoolException("未找到库存明细,请检查库存");
            }
            CheckOrderDetl checkOrderDetl = new CheckOrderDetl();
            checkOrderDetl.sync(locDetl);
            checkOrderDetl.setLocDetlId(locDetl.getId());
            checkOrderDetl.setOrderId(checkOrder.getId());
            checkOrderDetl.setOrderNo(checkOrder.getOrderNo());
            checkOrderDetl.setAnfme(checkOrderDetl1.getAnfme());
            checkOrderDetl.setDiffQty(checkOrderDetl1.getDiffQty());
            checkOrderDetl.setWorkQty(checkOrderDetl1.getWorkQty());
            checkOrderDetl.setStatus(checkOrderDetl1.getStatus().equals(1)? CheckStatusEnum.ALLOW.type:CheckStatusEnum.FORBID.type);
            checkOrderDetl.setZpallet(locDetl.getZpallet());
            checkOrderDetl.setCreateTime(now);
            checkOrderDetl.setUpdateTime(now);
            if (!checkOrderDetlService.insert(checkOrderDetl)) {
                throw new CoolException("保存调整单明细失败");
            }
        }
    }

    @Override
    @Transactional
    public void syncMat(MatSyncParam param) {