#合并订单出库，统一转波次出库前最新代码

Junjie

2024-09-13 a1a7c03eae40f4b0344fce652e1a240cf5283624

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/manage/OutManage.java

@@ -4,8 +4,9 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.asrs.entity.dto.*;
import com.zy.asrs.wms.asrs.entity.dto.OrderOutMergeDto;
import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;
import com.zy.asrs.wms.asrs.entity.enums.LocStsType;
import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType;
import com.zy.asrs.wms.asrs.entity.param.*;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.service.*;
@@ -52,7 +53,16 @@
    private OperationPortService operationPortService;
    @Autowired
    private OrderUtils orderUtils;

    @Autowired
    private OrderNoRuleService orderNoRuleService;
    @Autowired
    private WaveService waveService;
    @Autowired
    private WaveDetlService waveDetlService;
    @Autowired
    private CacheSiteService cacheSiteService;
    @Autowired
    private WaveSeedService waveSeedService;

    /**
     * 出库
@@ -530,10 +540,12 @@
    }

    @Transactional
    public void orderOutMerge(List<OrderOutMergeParam> params) {
        if(params == null){
    public void orderOutMerge(OrderOutMergeParamDto dto) {
        if(dto == null){
            throw new CoolException("参数不能为空");
        }

        List<OrderOutMergeParam> params = dto.getList();

        if (params.isEmpty()) {
            throw new CoolException("参数不能为空");
@@ -640,6 +652,7 @@
            map.put(orderOutMergeDto.getLocId(), list);
        }

        List<TaskDetl> taskDetls = new ArrayList<>();
        for (Map.Entry<Long, List<OrderOutMergeDto>> entry : map.entrySet()) {
            Long locId = entry.getKey();
            List<OrderOutMergeDto> list = entry.getValue();
@@ -711,6 +724,8 @@
                        throw new CoolException("明细扩展生成失败");
                    }
                }

                taskDetls.add(taskDetl);
            }

            //库位F => R
@@ -723,6 +738,144 @@

        }

        if (dto.getWaveId() != null) {
            HashMap<Long, List<TaskDetl>> orderMap = new HashMap<>();
            for (TaskDetl taskDetl : taskDetls) {
                Long orderId = taskDetl.getOrderId();

                List<TaskDetl> list = orderMap.get(orderId);
                if (list == null) {
                    list = new ArrayList<>();
                }

                list.add(taskDetl);
                orderMap.put(orderId, list);
            }

            for (Map.Entry<Long, List<TaskDetl>> entry : orderMap.entrySet()) {
                List<TaskDetl> list = entry.getValue();

                List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getSiteStatus, CacheSiteStatusType.O.id));
                if (cacheSites.isEmpty()) {
                    throw new CoolException("缓存站空间不足，请稍后再试");
                }
                CacheSite cacheSite = cacheSites.get(0);

                Long orderId = null;
                String orderNo = null;
                for (TaskDetl taskDetl : list) {
                    orderId = taskDetl.getOrderId();
                    orderNo = taskDetl.getOrderNo();
                    Long orderDetlId = taskDetl.getDetlId();

                    WaveSeed waveSeed = new WaveSeed();
                    waveSeed.setSiteId(cacheSite.getId());
                    waveSeed.setSiteNo(cacheSite.getSiteNo());
                    waveSeed.setOrderDetlId(orderDetlId);
                    waveSeed.setTaskDetlId(taskDetl.getId());
                    waveSeed.setAnfme(taskDetl.getAnfme());
                    waveSeed.setWorkQty(0D);
                    if (!waveSeedService.save(waveSeed)) {
                        throw new CoolException("波次播种创建失败");
                    }
                }

                if(orderId == null){
                    continue;
                }

                cacheSite.setOrderId(orderId);
                cacheSite.setOrderNo(orderNo);
                cacheSite.setSiteStatus(CacheSiteStatusType.R.id);
                cacheSite.setUpdateTime(new Date());
                if (!cacheSiteService.updateById(cacheSite)) {
                    throw new CoolException("缓存站更新失败");
                }

            }
        }

    }

    @Transactional
    public void generateWave(List<Long> orderIds) {
        if (orderIds == null) {
            throw new CoolException("参数不能为空");
        }

        if (orderIds.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        List<Order> orderList = orderService.listByIds(orderIds);
        if (orderList.isEmpty()) {
            throw new CoolException("订单不存在");
        }

        for (Order order : orderList) {
            if (order.getWaveId() != null) {
                throw new CoolException("当前订单中已经生成波次");
            }
        }

        String waveNo = orderNoRuleService.getOrderNo(3);
        Wave wave = new Wave();
        wave.setWaveNo(waveNo);
        wave.setWaveType(0);
        if (!waveService.save(wave)) {
            throw new CoolException("波次生成失败");
        }

        for (Order order : orderList) {
            WaveDetl waveDetl = new WaveDetl();
            waveDetl.setWaveNo(waveNo);
            waveDetl.setWaveId(wave.getId());
            waveDetl.setOrderId(order.getId());
            waveDetl.setOrderNo(order.getOrderNo());
            if (!waveDetlService.save(waveDetl)) {
                throw new CoolException("波次明细生成失败");
            }

            order.setWaveId(wave.getId());
            order.setWaveNo(waveNo);
            order.setUpdateTime(new Date());
            if (!orderService.updateById(order)) {
                throw new CoolException("订单反写波次失败");
            }
        }

    }

    @Transactional
    public void cancelWave(List<Long> waveIds) {
        if (waveIds == null) {
            throw new CoolException("参数不能为空");
        }

        if (waveIds.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        List<Wave> waves = waveService.listByIds(waveIds);
        if (waves.isEmpty()) {
            throw new CoolException("波次不存在");
        }

        for (Wave wave : waves) {
            List<WaveDetl> waveDetls = waveDetlService.list(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, wave.getId()));
            for (WaveDetl waveDetl : waveDetls) {
                Order order = orderService.getById(waveDetl.getOrderId());
                order.setWaveId(null);
                order.setWaveNo(null);
                if (!orderService.updateById(order)) {
                    throw new CoolException("订单反写失败");
                }

                waveDetlService.removeById(waveDetl.getId());
            }

            waveService.removeById(wave.getId());
        }

    }