CUT库条码T开头，截取后10位

pjb

2025-03-08 83b51a5a0774ea8ecb9a06304af3b956a21307c8

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

@@ -1,54 +1,585 @@
package com.zy.asrs.wms.asrs.service.impl;



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

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

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

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

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.asrs.entity.*;

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.*;

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

import com.zy.asrs.wms.asrs.entity.param.BatchMergeOrdersParam;

import com.zy.asrs.wms.asrs.entity.param.GeneratePakInParam;

import com.zy.asrs.wms.asrs.service.MobileService;

import com.zy.asrs.wms.asrs.service.WaitPakinService;

import com.zy.asrs.wms.asrs.service.WorkService;

import com.zy.asrs.wms.asrs.entity.param.PakinOnShelvesParams;

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

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

import com.zy.asrs.wms.system.entity.Host;

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

import io.netty.util.internal.StringUtil;

import org.springframework.beans.BeanUtils;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;



import java.util.ArrayList;

import java.math.BigDecimal;

import java.util.*;

import java.util.stream.Collectors;



@Service

public class MobileServiceImpl implements MobileService {



    @Autowired

    private WaitPakinService waitPakinService;



    @Autowired

    private WaitPakinLogService waitPakinLogService;

    @Autowired

    private WorkService workService;

    @Autowired

    private HostService hostService;

    @Autowired

    private OrderService orderService;

    @Autowired

    private OrderDetlService orderDetlService;

    @Autowired

    private OrderLogService orderLogService;

    @Autowired

    private LocService locService;

    @Autowired

    private LocDetlService locDetlService;

    @Autowired

    private LocAreaService locAreaService;

    @Autowired

    private LocAreaTypeService locAreaTypeService;

    @Autowired

    private PickSheetService pickSheetService;

    @Autowired

    private PickSheetDetlService pickSheetDetlService;

    @Autowired

    private MatService matService;

    @Autowired

    private WaveService waveService;

    @Autowired

    private WaveLogService waveLogService;

    @Autowired

    private CacheSiteService cacheSiteService;

    @Autowired

    WaveDetlLogService waveDetlLogService;

    @Autowired

    private WaveDetlService waveDetlService;

    @Autowired

    private CacheSiteMapper cacheSiteMapper;



    @Autowired

    private SeedSitesMapper seedSitesMapper;

    @Autowired

    private OrderDetlMapper orderDetlMapper;

    @Autowired

    private WaveSeedMapper waveSeedMapper;

    @Autowired

    private WaveSeedLogService waveSeedLogService;

    @Autowired

    private OrderDetlLogService orderDetlLogService;



    @Autowired

    private PlatformDetlService platformDetlService;

    @Autowired

    private PlatformDetlLogService platformDetlLogService;







    @Override

    @Transactional

    @Transactional(rollbackFor = Exception.class)

    public boolean batchMergeOrders(BatchMergeOrdersParam ordersParam) {

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

        if (Objects.isNull(order)) {

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

        }



        ArrayList<WaitPakin> waitPakins = new ArrayList<>();

        ordersParam.getOrderDetls().forEach(orderdetl -> {

            WaitPakin waitPakin = new WaitPakin();

            waitPakin.setBatch(orderdetl.getBatch()).setAnfme(orderdetl.getMergeNum()).setBarcode(ordersParam.getMergeNo()).setMatnr(orderdetl.getMatnr()).setDetlId(orderdetl.getDetlId()).setIoStatus(0).setOrderNo(orderdetl.getOrderNo()).setOrderId(orderdetl.getOrderId()).setStatus(1);

            waitPakin.setBatch(orderdetl.getBatch())

                    .setAnfme(orderdetl.getMergeNum())

                    .setBarcode(ordersParam.getMergeNo())

                    .setMatnr(orderdetl.getMatnr())

                    .setDetlId(orderdetl.getDetlId())

                    .setIoStatus(0)

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

            waitPakins.add(waitPakin);

        });



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

        //组拖通知档

        waitPakins.forEach(pakin -> {

            waitPakinService.comb(pakin);

        });



        //生成任务档

        GeneratePakInParam generatePakInParam = new GeneratePakInParam();

        //当前没有起始站点，默认101， 高低位默认传低库位

        generatePakInParam.setBarcode(ordersParam.getMergeNo())

                .setOriginSite("101")

                .setTaskType(TaskStsType.GENERATE_IN.id).setLocTypeHeight(LocTypeHeightType.LOW.id);

        if (workService.generatePakIn(generatePakInParam)) {

            return true;

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

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

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

            //生成任务档

            GeneratePakInParam generatePakInParam = new GeneratePakInParam();

            //当前没有起始站点，默认101， 高低位默认传低库位

            generatePakInParam.setBarcode(ordersParam.getMergeNo())

                    .setOriginSite("101")

                    .setTaskType(TaskStsType.GENERATE_IN.id).setLocTypeHeight(LocTypeHeightType.LOW.id);

            if (workService.generatePakIn(generatePakInParam)) {

                return true;

            }

        }

        return false;

    }



    @Override

    public List<Host> getHosts() {

        return hostService.list();

    }





    @Override

    @Transactional(rollbackFor = Exception.class)

    public boolean pakinToStock(PakinOnShelvesParams shelvesParams) {

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

        if (Objects.isNull(loc)) {

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

        }

        if (loc.getLocStsId() != LocStsType.O.val()) {

            throw new CoolException("当前库位状态不是空库状态." + LocStsType.O.val());

        }



        //判断当前仓库是否为平库位

        List<LocArea> locAreas = locAreaService.list(new LambdaQueryWrapper<LocArea>().eq(LocArea::getLocId, loc.getId()));

        if (locAreas.isEmpty()) {

            throw new CoolException("库位没有分配所属仓库区域！！");

        }

        locAreas.forEach(locArea -> {

            LocAreaType typeServiceOne = locAreaTypeService.getOne(new LambdaQueryWrapper<LocAreaType>().eq(LocAreaType::getId, locArea.getTypeId()));

            if (typeServiceOne.getParentId() != LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id && typeServiceOne.getId() != LocAreaTypeSts.LOC_AREA_TYPE_FLAT.id) {

                throw new CoolException("请选择平库区库位，再操作！！");

            }

        });



        loc.setBarcode(shelvesParams.getBarcode());

        loc.setUpdateTime(new Date());

        //库存状态修改为在库状态

        loc.setLocStsId(LocStsType.F.val());

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

        }



        waitPakins.forEach(pakin -> {

            LocDetl locDetl = new LocDetl();

            locDetl.setAnfme(pakin.getAnfme());

            locDetl.setBatch(pakin.getBatch());

            locDetl.setMatId(pakin.getMatnrId$());

            locDetl.setCreateTime(new Date());

            locDetl.setOrderNo(pakin.getOrderNo());

            locDetl.setLocNo(loc.getLocNo());

            locDetl.setLocId(loc.getId());

            locDetl.setMatnr(pakin.getMatnr());

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

            if (Objects.isNull(one)) {

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

            }

            locDetl.setMatId(one.getId());

            locDetl.setMemo(pakin.getMemo());

            locDetl.setUpdateTime(new Date());

            if (!locDetlService.saveOrUpdate(locDetl)) {

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

            }

            //修改状态为入库中

            pakin.setIoStatus(1);

        });



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

        waitPakins.forEach(waitPakin -> {

            WaitPakinLog pakinLog = new WaitPakinLog();

            BeanUtils.copyProperties(waitPakin, pakinLog);

            pakinLog.setIoStatus(1);

            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("历史单据更新失败！！");

            }

        });



        //删除订单数据

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

            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;

    }



    @Override

    public PickSheetDetlDto outFlatSheet(String code) {

        PickSheetDetlDto pickDetlDto = new PickSheetDetlDto();

        PickSheet pickSheet = pickSheetService.getOne(new LambdaQueryWrapper<PickSheet>()

                .eq(PickSheet::getPickNo, code)

                .eq(PickSheet::getDeleted, 0)

                .eq(PickSheet::getStatus, 1)

        );

        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)

                .eq(PickSheetDetl::getDeleted, 0));

        pickDetlDto.setPickSheetDetlList(sheetDetls);

        return pickDetlDto;

    }





    @Override

    @Transactional(rollbackFor = Exception.class)

    public boolean confirmFlatSheet(String code) {

        PickSheet pickSheet = pickSheetService.getOne(new LambdaQueryWrapper<PickSheet>().eq(PickSheet::getPickNo, code));

        if (Objects.isNull(pickSheet)) {

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

        }

        if (pickSheet.getStatus() == 1) {

            //状态修改为： 已转历史档

            pickSheet.setStatus(3);

            if (!pickSheetService.updateById(pickSheet)) {

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

            } else{

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

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

                }

            }

        } else {

            throw new CoolException("请勿操作历史档数据！！");

        }

        List<PickSheetDetl> sheetDetls = pickSheetDetlService.list(new LambdaQueryWrapper<PickSheetDetl>().eq(PickSheetDetl::getPickId, pickSheet.getId()));

        Map<Long, List<PickSheetDetl>> listMap = sheetDetls.stream().collect(Collectors.groupingBy(PickSheetDetl::getLocId));

        listMap.keySet().forEach(key -> {

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

            listMap.get(key).forEach(pickDetl -> {

                LocDetl detl = locDetlService.getOne(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getId, pickDetl.getLocDetlId()));

                if (Objects.isNull(detl)) {

                    throw new CoolException("数据错误！！");

                }

                //更新锁定库存

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

                if (qty.compareTo(new BigDecimal("0.00")) <= 0) {

                    detl.setDeleted(1);

                    if (!locDetlService.removeById(detl)) {

                        throw new CoolException("库存明细删除失败！！");

                    }

                } else { //结果大于零，更新库存明细

                    if (!locDetlService.updateById(detl)) {

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

                    }

                }

            });

            /**明细更新完成后，判断是否为空，为空更新主单状态为空库，拖盘码清空，不为空不做更新**/

            List<LocDetl> list = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocId, loc.getId()).eq(LocDetl::getDeleted, 0));

            if (list.isEmpty()) {

                boolean update = locService.update(new LambdaUpdateWrapper<Loc>()

                        .eq(Loc::getId, loc.getId())

                        .set(Loc::getBarcode, null)

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

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

                if (!update) {

                    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("波次明细列表删除失败！！");

        }



        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;

    }



    /**

     * 获取播种墙站点

     * @return

     */

    @Override

    public List<CacheSite> getSeedLocs() {

        return cacheSiteMapper.selectList(new LambdaQueryWrapper<>());

    }



    /**

     * 订单绑定播种墙站点+

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

        if (Objects.isNull(siteNo)) {

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

        }

        if (param.get("type").equals("bind")) {

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

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

            }

            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("订单播种位绑定失败！！" );

            }



            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("播种站点更新失败！！");

            }

        } else {

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

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

            }

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

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

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

            }

        }

        return true;

    }



    @Override

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

        //判断订单是否为空

        if (StringUtil.isNullOrEmpty((String) params.get("orderNo"))) {

            throw new CoolException("订单编码号不能为空！！");

        }

        String orderNo = params.get("orderNo").toString();

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

        if (Objects.isNull(order)) {

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

        }

        if (!order.getOrderType().equals(OrderType.UTC_OUT_ORDER.id)) {

            throw new CoolException("订单为入库单据，不能发货！！");

        }



        List<ShippingOrderDetlDto> waveSeeds = waveSeedMapper.selectShippingOrderDtel(orderNo);



        return R.ok(waveSeeds);

    }



    /**

     * 发货单明细确认

     * 1. 出库修改订单完成状态，判断订单是否完成，完成加入历史档，未完成修改订单已完成数量

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

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

     * @param params

     * @return

     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public R confirmShippingDetl(List<ShippingOrderDetlDto> params) {

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

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

            }

            OrderDetlLog orderDetlLog = new OrderDetlLog();

            BeanUtils.copyProperties(byId, orderDetlLog);

            orderDetlLog.setQty(order.getWorkQty());

            orderDetlLog.setWorkQty(0.0);

            if (!orderDetlLogService.save(orderDetlLog)) {

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

            }



            //完全拣货，订单完成删除原始订单明细

            //new BigDecimal(order.getAnfme()).compareTo(new BigDecimal(order.getWorkQty())) == 0

            if (new BigDecimal(order.getAnfme()).compareTo(new BigDecimal(order.getWorkQty())) == 0) {

                if (!orderDetlService.removeById(byId)) {

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

                }

            } else { //部分拣货

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

                byId.setWorkQty(0.0);

                if (!orderDetlService.updateById(byId)) {

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

                }

            }



            List<WaveSeed> waveSeeds = waveSeedMapper.selectList(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);

                    waveSeedLogs.add(waveSeedLog);

               });

                if (!waveSeedLogService.saveBatch(waveSeedLogs)) {

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

                }

            }

            //删除播种明细信息

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

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

            }

        });



        orderList.forEach(one -> {

            OrderLog orderLog = new OrderLog();

            BeanUtils.copyProperties(one, orderLog);

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



            if (!orderLogService.save(orderLog)) {

                throw new CoolException("原始订单转历史档失败！！");

            }

            //查询当前订单下否还有明细存在

            List<OrderDetl> orders = orderDetlService.list(new LambdaQueryWrapper<OrderDetl>().in(OrderDetl::getOrderNo, one.getOrderNo()));

            //订单明细为空，则删除主单

            if (orders.isEmpty()) {

                if (!orderService.remove(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, one.getOrderNo()))) {

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

                }

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

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

                if (orderService.updateById(one));

            }

        });



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

        if (waveIds.isEmpty()) {

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

        }

        List<Wave> waves = waveService.list(new LambdaQueryWrapper<Wave>().in(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("波次删除失败");

            }

        }



        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("订单信息未进集货区！！");

        }

        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("发货完成！！");

    }



}