no message

skyouc

2025-07-10 87d66c61fc5047fb5708d609f4a5f1f868cd646c

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/impl/MobileServiceImpl.java

@@ -76,22 +76,27 @@
    @Autowired

    private OrderDetlMapper orderDetlMapper;

    @Autowired

    private WaveSeedMapper waveSeedMapper;

    private WaveSeedService waveSeedMapper;

    @Autowired

    private WaveSeedLogService waveSeedLogService;

    @Autowired

    private OrderDetlLogService orderDetlLogService;



    @Autowired

    private PlatformDetlService platformDetlService;

    @Autowired

    private PlatformDetlLogService platformDetlLogService;







    @Override

    @Transactional(rollbackFor = Exception.class)

    public boolean batchMergeOrders(BatchMergeOrdersParam ordersParam) {

        Loc locServiceOne = locService.getOne(new LambdaQueryWrapper<Loc>()

                .eq(Loc::getLocStsId, 1)

                .eq(Loc::getBarcode, ordersParam.getMergeNo()), false);

        if (!Objects.isNull(locServiceOne)) {

            throw new CoolException("托盘已入库，不能再组托！！");

        }



        Order order = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, ordersParam.getOrderNo()));

        if (Objects.isNull(order)) {

            throw new CoolException("订单不存在！！");

@@ -170,7 +175,6 @@
        if (!locService.updateById(loc)) {

            throw new CoolException("库位更新失败！！");

        }



        List<WaitPakin> waitPakins = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getBarcode, shelvesParams.getBarcode()));

        if (waitPakins.isEmpty()) {

            throw new CoolException("当前拖盘没有组拖档!!");

@@ -198,6 +202,16 @@
            }

            //修改状态为入库中

            pakin.setIoStatus(1);



            OrderDetl detl = orderDetlService.getById(pakin.getDetlId());

            if (Objects.isNull(detl)) {

                throw new CoolException("数据错误：单据明细不存在！！");

            }

            Double qty = Math.round((detl.getQty() + pakin.getAnfme()) * 1000) / 1000.0;

            detl.setQty(qty);

            if (!orderDetlService.updateById(detl)) {

                throw new CoolException("单据明细修改失败！！");

            }

        });



        //删除组拖档，加入历史组拖档

@@ -211,53 +225,63 @@
            }

        });



        if (!waitPakinService.removeBatchByIds(waitPakins)) {

            throw new CoolException("组拖档删除失败！！");

        }

        //通过组拖订单ID获取订单，并删除原单据，加入单据历史档

        Set<Long> list = waitPakins.stream().map(WaitPakin::getOrderId).collect(Collectors.toSet());

        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getId, list));

        //订单入历史档

        orders.forEach(order -> {

            if (order.getOrderType() != OrderType.PK_IN_ORDER.id) {

                throw new CoolException("当前订单类型:" + order.getOrderType() + ",不可做平库上架操作！！");

            }

            //修改订单状态为已完成

            order.setOrderSettle(OrderSettleType.COMPLETE.val());

            OrderLog orderLog = new OrderLog();

            BeanUtils.copyProperties(order, orderLog);

            orderLog.setId(null);

            if (!orderLogService.save(orderLog)) {

                throw new CoolException("历史单据更新失败！！");

            List<OrderDetl> detls = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().eq(OrderDetl::getOrderId, order.getId()));

            Double sum = detls.stream().mapToDouble(OrderDetl::getQty).sum();

            Double summed = detls.stream().mapToDouble(OrderDetl::getWorkQty).sum();

            Double v = Math.round((sum + summed) * 1000) / 1000.0;

            Double anfme = detls.stream().mapToDouble(OrderDetl::getAnfme).sum();

            if (v.compareTo(anfme) == 0.0) {

                order.setOrderSettle(OrderSettleType.COMPLETE.val());

                if (! orderService.updateById(order)) {

                    throw new CoolException("单据状态修改失败！！");

                }

            }

        });



        //删除订单数据

        if (!orderService.removeBatchByIds(orders)) {

            throw new CoolException("订单删除失败！！");

//        //订单入历史档

//        orders.forEach(order -> {

////            if (order.getOrderType() != OrderType.PK_IN_ORDER.id) {

////                throw new CoolException("当前订单类型:" + order.getOrderType() + ",不可做平库上架操作！！");

////            }

//            //修改订单状态为已完成

//            order.setOrderSettle(OrderSettleType.COMPLETE.val());

//            OrderLog orderLog = new OrderLog();

//            BeanUtils.copyProperties(order, orderLog);

//            orderLog.setId(null);

//            if (!orderLogService.save(orderLog)) {

//                throw new CoolException("历史单据更新失败！！");

//            }

//        });

//        //删除订单数据

//        if (!orderService.removeBatchByIds(orders)) {

//            throw new CoolException("订单删除失败！！");

//        }

//        List<OrderDetl> detls = orderDetlMapper.selectList(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));

//        List<OrderDetlLog> detlLogs = new ArrayList<>();

//        detls.forEach(delt ->{

//            OrderDetlLog detlLog = new OrderDetlLog();

//            BeanUtils.copyProperties(delt, detlLog);

//            detlLog.setQty(delt.getWorkQty());

//            detlLog.setWorkQty(0.0);

//            detlLog.setId(null);

//            detlLogs.add(detlLog);

//        });

//        //订单明细转历史档

//        if (!orderDetlLogService.saveBatch(detlLogs)) {

//            throw new CoolException("订单明细转历史失败！！");

//        }

//

//        //删除订单明细数据

//        if (!orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list))) {

//            throw new CoolException("订单明细删除失败！！");

//        }

        if (!waitPakinService.removeBatchByIds(waitPakins)) {

            throw new CoolException("组拖档删除失败！！");

        }



        List<OrderDetl> detls = orderDetlMapper.selectList(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));

        List<OrderDetlLog> detlLogs = new ArrayList<>();

        detls.forEach(delt ->{

            OrderDetlLog detlLog = new OrderDetlLog();

            BeanUtils.copyProperties(delt, detlLog);

            detlLog.setQty(delt.getWorkQty());

            detlLog.setWorkQty(0.0);

            detlLog.setId(null);

            detlLogs.add(detlLog);

        });



        //订单明细转历史档

        if (!orderDetlLogService.saveBatch(detlLogs)) {

            throw new CoolException("订单明细转历史失败！！");

        }



        //删除订单明细数据

        if (!orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list))) {

            throw new CoolException("订单明细删除失败！！");

        }



        return true;

    }



@@ -401,15 +425,14 @@
                    .setOrderId(order.getId())

                    .setSiteStatus(CacheSiteStatusType.R.id)

                    .setBarcode(param.get("barcode").toString());

            if (cacheSiteMapper.updateById(siteNo) < 1) {

            if (!cacheSiteService.saveOrUpdate(siteNo)) {

                throw new CoolException("订单播种位绑定失败！！" );

            }



            int update = waveSeedMapper.update(new LambdaUpdateWrapper<WaveSeed>()

            if (!waveSeedMapper.update(new LambdaUpdateWrapper<WaveSeed>()

                    .eq(WaveSeed::getOrderNo, order.getOrderNo())

                    .set(WaveSeed::getSiteId, siteNo.getId())

                    .set(WaveSeed::getSiteNo, siteNo.getSiteNo()));

            if (update < 1) {

                    .set(WaveSeed::getSiteNo, siteNo.getSiteNo()))) {

                throw new CoolException("播种站点更新失败！！");

            }

        } else {

@@ -491,14 +514,14 @@
                    throw new CoolException("订单明细不存在！！");

                }

            } else { //部分拣货

                byId.setQty(order.getWorkQty() + byId.getQty());

                byId.setQty(Math.round((order.getWorkQty() + byId.getQty()) * 1000) / 1000.0);

                byId.setWorkQty(0.0);

                if (!orderDetlService.updateById(byId)) {

                    throw new CoolException("部分拣料明细更新失败！！");

                }

            }



            List<WaveSeed> waveSeeds = waveSeedMapper.selectList(new LambdaQueryWrapper<WaveSeed>().eq(WaveSeed::getOrderDetlId, order.getId()));

            List<WaveSeed> waveSeeds = waveSeedMapper.list(new LambdaQueryWrapper<WaveSeed>().eq(WaveSeed::getOrderDetlId, order.getId()));

            //fixme 订单明细未播种，默认可发货

            if (!waveSeeds.isEmpty()) {

                ArrayList<WaveSeedLog> waveSeedLogs = new ArrayList<>();

@@ -511,11 +534,15 @@
                if (!waveSeedLogService.saveBatch(waveSeedLogs)) {

                    throw new CoolException("波明历史档保存失败！！");

                }



                List<Long> list = waveSeeds.stream().map(WaveSeed::getId).collect(Collectors.toList());

                //删除播种明细信息

                if (!waveSeedMapper.removeByIds(list)) {

                    throw new CoolException("播种明细删除携程！！");

                }



            }

            //删除播种明细信息

            if (waveSeedMapper.deleteByIds(waveSeeds) < 1) {

                throw new CoolException("播种明细删除携程！！");

            }



        });



        orderList.forEach(one -> {