no message

skyouc

6 天以前 e046dba174365eb8934ee1e4206f09821145e876

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

@@ -1,10 +1,17 @@
package com.zy.asrs.wms.asrs.service.impl;



import com.alibaba.fastjson.JSONObject;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;

import com.baomidou.mybatisplus.extension.service.IService;

import com.zy.asrs.framework.common.R;

import com.zy.asrs.framework.exception.CoolException;

import com.zy.asrs.wms.apis.wcs.entity.request.SlapLightControlParam;

import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;

import com.zy.asrs.wms.apis.wcs.utils.HttpEssUtils;

import com.zy.asrs.wms.asrs.entity.*;

import com.zy.asrs.wms.asrs.entity.dto.MatnrDetlDto;

import com.zy.asrs.wms.asrs.entity.dto.PickSheetDetlDto;

import com.zy.asrs.wms.asrs.entity.dto.ShippingOrderDetlDto;

import com.zy.asrs.wms.asrs.entity.enums.*;

@@ -17,7 +24,7 @@
import com.zy.asrs.wms.system.entity.Host;

import com.zy.asrs.wms.system.service.HostService;

import io.netty.util.internal.StringUtil;

import org.aspectj.weaver.ast.Or;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

@@ -28,6 +35,7 @@
import java.util.stream.Collectors;



@Service

@Slf4j

public class MobileServiceImpl implements MobileService {



    @Autowired

@@ -76,16 +84,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("订单不存在！！");

@@ -100,17 +119,20 @@
                    .setMatnr(orderdetl.getMatnr())

                    .setDetlId(orderdetl.getDetlId())

                    .setIoStatus(0)

                    .setOrderNo(orderdetl.getOrderNo()).setOrderId(orderdetl.getOrderId()).setStatus(1);

                    .setOrderNo(orderdetl.getOrderNo())

                    .setOrderId(orderdetl.getOrderId())

                    .setStatus(1);

            waitPakins.add(waitPakin);

        });



        //组拖通知档

        waitPakins.forEach(pakin -> {

            waitPakinService.comb(pakin);

            waitPakinService.comb(pakin, ordersParam.getInType());

        });





        // UTC入库单据(非平库入库单据)

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

        if (!ordersParam.getInType().equals(OrderType.PK_IN_ORDER.id)) {

            /*** 项目下发流程 * 1. PDA组拖通知档* 2. 生成任务档* 3. 通过定时任务下发至ESS** */

            //生成任务档

            GeneratePakInParam generatePakInParam = new GeneratePakInParam();

@@ -161,7 +183,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("当前拖盘没有组拖档!!");

@@ -189,6 +210,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("单据明细修改失败！！");

            }

        });



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

@@ -196,56 +227,69 @@
            WaitPakinLog pakinLog = new WaitPakinLog();

            BeanUtils.copyProperties(waitPakin, pakinLog);

            pakinLog.setIoStatus(1);

            pakinLog.setId(null);

            if (!waitPakinLogService.saveOrUpdate(pakinLog)) {

                throw new CoolException("组拖历史档更新失败");

            }

        });



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

            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 ) * 1000) / 1000.0;

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

            if (sum.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);

            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;

    }



@@ -257,10 +301,11 @@
                .eq(PickSheet::getDeleted, 0)

                .eq(PickSheet::getStatus, 1)

        );

        BeanUtils.copyProperties(pickSheet, pickDetlDto);

        if (Objects.isNull(pickDetlDto)) {

            throw new CoolException("对象复制失败！！");

        if (Objects.isNull(pickSheet)) {

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

        }

        BeanUtils.copyProperties(pickSheet, pickDetlDto);



        List<PickSheetDetl> sheetDetls = pickSheetDetlService.list(new LambdaQueryWrapper<PickSheetDetl>()

                .eq(PickSheetDetl::getPickId, pickSheet.getId())

                .eq(PickSheetDetl::getStatus, 1)

@@ -282,7 +327,7 @@
            pickSheet.setStatus(3);

            if (!pickSheetService.updateById(pickSheet)) {

                throw new CoolException("转历史档失败！！");

            } else{

            } else {

                if (!pickSheetDetlService.update(new LambdaUpdateWrapper<PickSheetDetl>().eq(PickSheetDetl::getPickId, pickSheet.getId()).set(PickSheetDetl::getStatus, 3))) {

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

                }

@@ -300,8 +345,8 @@
                    throw new CoolException("数据错误！！");

                }

                //更新锁定库存

                BigDecimal workQty = BigDecimal.valueOf(detl.getAnfme()).subtract(pickDetl.getAnfme());

                detl.setWorkQty(workQty.doubleValue());

//                BigDecimal workQty = BigDecimal.valueOf(detl.getAnfme()).subtract(pickDetl.getAnfme());

                detl.setWorkQty(0.0);

                //计算结果小于等于零，移出库存明细

                BigDecimal qty = BigDecimal.valueOf(detl.getAnfme()).subtract(pickDetl.getAnfme());

                detl.setAnfme(qty.doubleValue());

@@ -324,32 +369,35 @@
                        .set(Loc::getBarcode, null)

                        .set(Loc::getUpdateTime, new Date())

                        .set(Loc::getLocStsId, LocStsType.O.val()));

                if (update) {

                if (!update) {

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

                }

            }

        });

        
        //判断是否为波次单据

        if (pickSheet.getType().equals(1)) {

            //删除波次及对应明细信息

            if (!waveService.remove(new LambdaQueryWrapper<Wave>().eq(Wave::getId, pickSheet.getWaveId()))) {

                throw new CoolException("波次列表单据删除失败！！");

            }



        //删除波次及对应明细信息

        if (!waveService.remove(new LambdaQueryWrapper<Wave>().eq(Wave::getId, pickSheet.getWaveId()))) {

            throw new CoolException("波次列表单据删除失败！！");

        }

            if (!waveDetlService.remove(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, pickSheet.getWaveId()))) {

                throw new CoolException("波次明细列表删除失败！！");

            }



        if (!waveDetlService.remove(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, pickSheet.getWaveId()))) {

            throw new CoolException("波次明细列表删除失败！！");

        }



        List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().eq(Order::getWaveId, pickSheet.getWaveId()));

        if (orders.isEmpty()) {

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

        }

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

        boolean remove = orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));

        if (!remove) {

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

        }

        if (!orderService.remove(new LambdaQueryWrapper<Order>().in(Order::getId, list))) {

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

            List<Order> orders = orderService.list(new LambdaQueryWrapper<Order>().eq(Order::getWaveId, pickSheet.getWaveId()));

            if (orders.isEmpty()) {

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

            }

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

            boolean remove = orderDetlService.remove(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderId, list));

            if (!remove) {

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

            }

            if (!orderService.remove(new LambdaQueryWrapper<Order>().in(Order::getId, list))) {

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

            }

        }



        return true;

@@ -357,6 +405,7 @@


    /**

     * 获取播种墙站点

     *

     * @return

     */

    @Override

@@ -366,13 +415,15 @@


    /**

     * 订单绑定播种墙站点+

     *

     * @param param

     * @return

     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public boolean bindOrderBySite(Map<String, Object> param) {

        CacheSite siteNo = cacheSiteMapper.selectOne(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getSiteNo, param.get("siteNo")), false);

        CacheSite siteNo = cacheSiteMapper.selectOne(new LambdaQueryWrapper<CacheSite>()

                .eq(CacheSite::getSiteNo, param.get("siteNo")), false);

        if (Objects.isNull(siteNo)) {

            throw new CoolException("站点异常！！");

        }

@@ -380,33 +431,77 @@
            if (!StringUtil.isNullOrEmpty(siteNo.getOrderNo())) {

                throw new CoolException("当前播种站点已绑定订单！！");

            }

            Order order = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, param.get("orderNo").toString()));

            Order order = orderService.getOne(new LambdaQueryWrapper<Order>()

                    .eq(Order::getOrderNo, param.get("orderNo").toString()));

            if (Objects.isNull(order)) {

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

            }

            siteNo.setOrderNo(order.getOrderNo()).setOrderId(order.getId()).setSiteStatus(CacheSiteStatusType.R.id).setBarcode(param.get("barcode").toString());

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

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

            siteNo.setOrderNo(order.getOrderNo())

                    .setOrderId(order.getId())

                    .setSiteStatus(CacheSiteStatusType.R.id)

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

            if (!cacheSiteService.saveOrUpdate(siteNo)) {

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

            }



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

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

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

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

            if (update < 1) {

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

            }

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

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

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

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

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

//            }

            //绑定成功，播种墙亮灯

            sowLightMange(siteNo.getSiteNo(), order, "LIGHT");

        } else {

            if (StringUtil.isNullOrEmpty(siteNo.getOrderNo())) {

                throw new CoolException("当前播种站点未绑定订单！！");

            }

           siteNo.setOrderId(null).setOrderNo(null).setSiteNo("0");

            siteNo.setOrderId(null).setOrderNo(null).setBarcode(null).setSiteNo("0");

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

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

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

            }

        }

        return true;

    }



    /**

     * @author Ryan

     * @date 2025/7/11

     * @description: 绑定播种墙亮灯

     * @version 1.0

     */

    public void sowLightMange(String siteNo, Order order, String light) {

        // 到达拣选位，控制播种墙亮灯

        CacheSite cacheSite = cacheSiteService.getOne(new LambdaQueryWrapper<CacheSite>()

                .eq(CacheSite::getSiteNo, siteNo));

        if (Objects.isNull(cacheSite)) {

            log.error("条码：{}，未找到播种墙亮灯", siteNo);

            throw new CoolException("未找到播种墙");

        }

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

        if (Objects.isNull(detls)) {

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

        }

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

        SlapLightControlParam slapLightControlParam = new SlapLightControlParam();

        slapLightControlParam

                .setControllerCode(cacheSite.getMemo())

                .setTagCode(cacheSite.getSiteNo())

                .setColor("GREEN")

                .setIndex(cacheSite.getIndex())

//                .setMode("LIGHT")

                .setMode(light)

                .setDisplay(anfme + "");

        // 发起亮灯请求

        log.info("播种墙亮灯下发", JSONObject.toJSONString(slapLightControlParam));

        CommonReponse response = HttpEssUtils.post("到达拣选位，播种墙亮灯", HttpEssUtils.PLT_SEND_COMMAND, slapLightControlParam);

        if (response.getCode().equals(0)) {

            log.info("播种墙{}亮灯成功", cacheSite.getSiteNo());

        } else {

            log.info("播种墙{}亮灯失败", cacheSite.getSiteNo());

        }

    }





    @Override

    public R selectShippingDetl(Map<String, Object> params) {

@@ -433,6 +528,7 @@
     * 1. 出库修改订单完成状态，判断订单是否完成，完成加入历史档，未完成修改订单已完成数量

     * 2. 删除订单已完成播种明细信息

     * 3. 清除集货区绑定数据

     *

     * @param params

     * @return

     */

@@ -442,6 +538,18 @@
        if (params.isEmpty()) {

            throw new CoolException("发货单据明细为空，不可执行发货操作！！");

        }



        //获取当前上传所有订单号

        Set<String> orderNoSet = params.stream().map(ShippingOrderDetlDto::getOrderNo).collect(Collectors.toSet());

        if (orderNoSet.isEmpty()) {

            throw new CoolException("主单信息不存在，请核对出库订单！！");

        }



        List<Order> orderList = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getOrderNo, orderNoSet));

        if (orderList.isEmpty()) {

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

        }



        params.forEach(order -> {

            OrderDetl byId = orderDetlService.getById(order.getId());

            if (Objects.isNull(byId)) {

@@ -449,6 +557,7 @@
            }

            OrderDetlLog orderDetlLog = new OrderDetlLog();

            BeanUtils.copyProperties(byId, orderDetlLog);

            orderDetlLog.setId(null);

            orderDetlLog.setQty(order.getWorkQty());

            orderDetlLog.setWorkQty(0.0);

            if (!orderDetlLogService.save(orderDetlLog)) {

@@ -462,46 +571,41 @@
                    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<>();

                waveSeeds.forEach(seed -> {

                   WaveSeedLog waveSeedLog = new WaveSeedLog();

                   BeanUtils.copyProperties(seed, waveSeedLog);

                   waveSeedLog.setId(null);

                    WaveSeedLog waveSeedLog = new WaveSeedLog();

                    BeanUtils.copyProperties(seed, waveSeedLog);

                    waveSeedLog.setId(null);

                    waveSeedLogs.add(waveSeedLog);

               });

                });

                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("播种明细删除携程！！");

            }



        });



        //获取当前上传所有订单号

        Set<String> orderNoSet = params.stream().map(ShippingOrderDetlDto::getOrderNo).collect(Collectors.toSet());

        if (orderNoSet.isEmpty()) {

            throw new CoolException("主单信息不存在，请核对出库订单！！");

        }



        List<Order> orderList = orderService.list(new LambdaQueryWrapper<Order>().in(Order::getOrderNo, orderNoSet));

        if (orderList.isEmpty()) {

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

        }

        orderList.forEach(one -> {

            OrderLog orderLog = new OrderLog();

            BeanUtils.copyProperties(one, orderLog);

            orderLog.setId(null);

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



            if (!orderLogService.save(orderLog)) {

@@ -516,44 +620,150 @@
                }

            } else { //不为空，修改订单状态，可重新组拖

                one.setOrderSettle(OrderSettleType.INIT.val());

                if (orderService.updateById(one));

                if (orderService.updateById(one)) ;

            }

        });



        Set<Long> waveIds = orderList.stream().map(Order::getWaveId).collect(Collectors.toSet());

        if (waveIds.isEmpty()) {

            throw new CoolException("波次信息为空！！");

        Set<Long> ordersSet = orderList.stream().map(Order::getId).collect(Collectors.toSet());

        List<PlatformDetl> platDetls = platformDetlService.list(new LambdaQueryWrapper<PlatformDetl>().in(PlatformDetl::getOrderId, ordersSet));

        if (platDetls.isEmpty()) {

            throw new CoolException("订单信息未进集货区！！");

        }

        List<Wave> waves = waveService.list(new LambdaQueryWrapper<Wave>().eq(Wave::getId, waveIds));

        for (Wave wave : waves) {

            WaveLog waveLog = new WaveLog();

            waveLog.sync(wave);

            waveLog.setId(null);

            if (!waveLogService.save(waveLog)) {

                throw new CoolException("波次转历史失败");

            }



            List<WaveDetl> waveDetls = waveDetlService.list(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, wave.getId()));

            for (WaveDetl waveDetl : waveDetls) {

                WaveDetlLog waveDetlLog = new WaveDetlLog();

                waveDetlLog.sync(waveDetl);

                waveDetlLog.setId(null);

                waveDetlLog.setWaveId(waveLog.getId());

                if (!waveDetlLogService.save(waveDetlLog)) {

                    throw new CoolException("波次明细转历史失败");

                }



                if (!waveDetlService.removeById(waveDetl.getId())) {

                    throw new CoolException("波次明细删除失败");

                }

            }



            if (!waveService.removeById(wave.getId())) {

                throw new CoolException("波次删除失败");

            }

        ArrayList<PlatformDetlLog> platformDetls = new ArrayList<>();

        platDetls.forEach(plat -> {

            PlatformDetlLog detl = new PlatformDetlLog();

            BeanUtils.copyProperties(plat, detl);

            detl.setId(null);

            platformDetls.add(detl);

        });

        //集货区转历史档

        if (!platformDetlLogService.saveBatch(platformDetls)) {

            throw new CoolException("集货区订单转历史档失败！！");

        }



        return R.ok("发货完成！！");

    }



    /**

     * @author Ryan

     * @date 2025/6/28

     * @description: 获取平库推荐库位

     * @version 1.0

     */

    @Override

    public R getRecommendLocs() {

        return locService.getRecommengLocs();

    }



    /**

     * @author Ryan

     * @date 2025/6/28

     * @description: 查询物料信息

     * @version 1.0

     */

    @Override

    public R getMatsByCode(String matnr) {

        QueryWrapper<LocDetl> wrapper = new QueryWrapper<>();

        wrapper.eq("matnr", matnr).select("matnr, SUM(anfme) anfme");

        LocDetl detl = locDetlService.getOne(wrapper);



        Mat one = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getMatnr, detl.getMatnr()), false);

        if (Objects.isNull(one)) {

            throw new CoolException("物料不存在！！");

        }

        one.setAnfme(detl.getAnfme());

        return R.ok().add(Arrays.asList(one));

    }



    /**

     * @author Ryan

     * @date 2025/7/10

     * @description: 获取库位明细

     * @version 1.0

     */

    @Override

    public List<LocDetl> getDetlsByCode(String barcode) {

        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, barcode));

        if (Objects.isNull(loc)) {

            throw new CoolException("库位不存在！！");

        }

        LocArea locArea = locAreaService.getOne(new LambdaQueryWrapper<LocArea>()

                .eq(LocArea::getLocId, loc.getId())

                .eq(LocArea::getTypeId, LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id));

        if (Objects.isNull(locArea)) {

            throw new CoolException("非平库库位不可执行此操作！！");

        }

        List<LocDetl> detls = locDetlService.list(new LambdaQueryWrapper<LocDetl>()

                .eq(LocDetl::getLocNo, barcode));

        for (int i = 0; i < detls.size(); i++) {

            Mat mat = matService.getOne(new LambdaQueryWrapper<Mat>().eq(Mat::getId, detls.get(i).getMatId()));

            MatnrDetlDto detlDto = new MatnrDetlDto();

            detlDto.setTspec(mat.getSpecs())

                    .setType(mat.getModel())

                    .setMatnrName(mat.getMaktx())

                    .setMatnrNo(mat.getMatnr());

            detls.get(i).setMats(detlDto);

        }

        return detls;

    }



    /**

     * @author Ryan

     * @date 2025/7/11

     * @description: 平库库位转移

     * @version 1.0

     */

    @Override

    public R transferLocs(Map<String, String> param) {

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

                .eq(Loc::getLocStsId, LocStsType.F.val())

                .eq(Loc::getLocNo, param.get("barcode")));

        if (Objects.isNull(barcode)) {

            throw new CoolException(param.get("barcode") +  "库位状态不可执行此操作！！");

        }

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

                .eq(Loc::getLocStsId, LocStsType.O.val())

                .eq(Loc::getLocNo, param.get("tarCode")));

        if (Objects.isNull(tarCode)) {

            throw new CoolException("请检查目标为唯位是否存在或是否为空库！！");

        }



        List<Long> ids = Arrays.asList(barcode.getId(), tarCode.getId());



        List<LocArea> locAreas = locAreaService.list(new LambdaQueryWrapper<LocArea>()

                .in(LocArea::getLocId, ids)

                .eq(LocArea::getTypeId, LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id));

        if (!locAreas.isEmpty() && locAreas.size() != ids.size()) {

            throw new CoolException("非平库不可执行此操作！！");

        }



        List<LocDetl> locDetls = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocNo, barcode.getLocNo()));

        if (locDetls.isEmpty()) {

            return R.error("库位明细不存在！！");

        }



        if (!locService.update(new LambdaUpdateWrapper<Loc>()

                .eq(Loc::getLocNo, barcode.getLocNo())

                .set(Loc::getBarcode, null)

                .set(Loc::getLocStsId, LocStsType.O.val()))) {

            throw new CoolException("源库位状态修改失败！！");

        }



        if (!locService.update(new LambdaUpdateWrapper<Loc>().eq(Loc::getLocNo, tarCode.getLocNo())

                .set(Loc::getBarcode, barcode.getBarcode())

                .set(Loc::getLocStsId, LocStsType.F.val()))) {

            throw new CoolException("目标库位修改失败！！");

        }



        if (!locDetlService.update(new LambdaUpdateWrapper<LocDetl>()

                .eq(LocDetl::getLocId, barcode.getId())

                .set(LocDetl::getLocId, tarCode.getId())

                .set(LocDetl::getLocNo, tarCode.getLocNo()))) {

            throw new CoolException("库位明细修改失败！！");

        }



        return R.ok();

    }





}