Merge remote-tracking branch 'origin/devlop-phyz' into devlop-phyz

chen.lin

昨天 a488088a18a9b8808bc57124681cee8c4ada7299

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java

@@ -11,6 +11,7 @@
import com.vincent.rsf.server.common.constant.Constants;
import com.vincent.rsf.server.manager.controller.dto.ExistDto;
import com.vincent.rsf.server.manager.controller.dto.OrderOutItemDto;
import com.vincent.rsf.server.manager.controller.dto.OrderOutItemPdaDto;
import com.vincent.rsf.server.manager.controller.params.*;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.server.manager.entity.*;
@@ -275,6 +276,107 @@
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R generateWavesOrderAuto(GenWaveParams params,String stationId,String locCode) {
        if (Objects.isNull(params.getIds()) || params.getIds().isEmpty()) {
            throw new CoolException("参数不能为空！！");
        }
        List<WkOrder> orders = this.list(new LambdaQueryWrapper<WkOrder>()
                .eq(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val)
                .in(WkOrder::getId, params.getIds()));
        if (orders.isEmpty()) {
            throw new CoolException("当前单据状态不能执行波次生成操作！！");
        }
        Double sum = orders.stream().mapToDouble(WkOrder::getAnfme).sum();
        Double workQty = orders.stream().mapToDouble(WkOrder::getWorkQty).sum();
        Double anfme = Math.round((sum - workQty) * 10000) / 10000.0;
        Wave wave = new Wave();
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_WAVE_TYPE, null);
        if (StringUtils.isBlank(ruleCode)) {
            throw new CoolException("编码规则错误：请要查看「SYS_WAVE_TYPE」是否设置成功！！");
        }
        wave.setOrderNum(params.getIds().size())
                .setType(Short.parseShort("1"))
                .setCode(ruleCode)
                .setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_INIT.val)
                .setAnfme(anfme);
        if (!waveService.save(wave)) {
            throw new CoolException("波次保存失败！！");
        }

        List<Long> list = orders.stream().map(WkOrder::getId).collect(Collectors.toList());
        List<WkOrderItem> orderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getOrderId, list).apply("anfme > work_qty"));
        if (orderItems.isEmpty()) {
            throw new CoolException("单据不存在！！");
        }

        //合并物料，生成波次明细
        List<WaveItem> waveItems = mergeWave(orderItems, wave);

        if (!waveItemService.saveBatch(waveItems)) {
            throw new CoolException("波次明细保存失败！！");
        }
        double sum1 = waveItems.stream().mapToDouble(WaveItem::getAnfme).sum();
        wave.setAnfme(sum1).setGroupQty(waveItems.size());
        wave.setStationId(stationId);
        wave.setLocCode(locCode);
        if (!waveService.saveOrUpdate(wave)) {
            throw new CoolException("主单修改失败！！");
        }
        for (int i = 0; i < orderItems.size(); i++) {
            orderItems.get(i).setWorkQty(orderItems.get(i).getAnfme());
        }

        /**
         *订单信息存储至逻辑关联表
         */
        for (WaveItem item : waveItems) {
            List<WkOrderItem> items = orderItems.stream()
                    .filter(orderItem -> item.getMatnrId()
                            .equals(orderItem.getMatnrId()))
                    .collect(Collectors.toList());

            items.forEach(orderItem -> {
                WaveOrderRela orderRela = new WaveOrderRela();
                orderRela.setId(null)
                        .setOrderId(orderItem.getOrderId())
                        .setOrderItemId(orderItem.getId())
                        .setWaveId(wave.getId())
                        .setWaveItemId(item.getId());
                if (!waveOrderRelaService.saveOrUpdate(orderRela)) {
                    throw new CoolException("<UNK>");
                }
            });
        }


        if (!asnOrderItemService.saveOrUpdateBatch(orderItems)) {
            throw new CoolException("出库单执行数量修改失败！！");
        }
        for (WkOrder order : orders) {
            Double wkQty = Math.round((order.getWorkQty() + order.getAnfme()) * 10000) / 10000.0;
            if (!this.update(new LambdaUpdateWrapper<WkOrder>()
                    .set(WkOrder::getWaveId, wave.getId())
                    .set(WkOrder::getWorkQty, wkQty)
                    .set(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_WAVE.val)
                    .eq(WkOrder::getId, order.getId()))) {
                throw new CoolException("执行状态修改修改失败！！");
            }
        }

        return R.ok("操作完成！！");
    }

    /**
     * @param
     * @return
     * @author Ryan
     * @description 生成波次
     * @time 2025/4/24 15:04
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R generateWaves(GenWaveParams params) {
        if (Objects.isNull(params.getIds()) || params.getIds().isEmpty()) {
            throw new CoolException("参数不能为空！！");
@@ -480,7 +582,15 @@
        List<Long> itemIds = new ArrayList<>();
        itemIds.add(orderItemId);
        locItems = getOutOrderList(param.getOrderId(), waveRule,itemIds);
        return R.ok(locItems);
        List<OrderOutItemPdaDto> locItemList = new ArrayList<>();
        for (OrderOutItemDto locItem : locItems) {
            for (LocItem locItem1 : locItem.getLocItemList()) {
                OrderOutItemPdaDto orderOutItemPdaDto = new OrderOutItemPdaDto();
                orderOutItemPdaDto.setLocItem(locItem1);
                locItemList.add(orderOutItemPdaDto);
            }
        }
        return R.ok(locItemList);
    }

    @Override