波次出库修改

skyouc

1 天以前 450320f28d8db37264d7fc448c01fb32f64610b2

波次出库修改

 rsf-server/src/main/java/com/vincent/rsf/server/api/controller/pda/PdaOutStockController.java

@@ -3,6 +3,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
import com.vincent.rsf.server.api.entity.params.WavePickItemsParams;
import com.vincent.rsf.server.api.service.PdaOutStockService;
import com.vincent.rsf.server.system.controller.BaseController;
import io.swagger.annotations.Api;
@@ -54,10 +55,28 @@
    }

    @PreAuthorize("hasAuthority('manager:task:list')")
    @PostMapping("/wave/order/items")
    @ApiOperation("获取波次拣货明细")
    public R getWaveOrderItem(@RequestBody Map<String, Object> params) {
        return pdaOutStockService.getWaveOrderItems(params);
    }

    @PreAuthorize("hasAuthority('manager:task:list')")
    @ApiOperation("波次明细拣货")
    @PostMapping("/wave/pick/item")
    public R wavePickItems(@RequestBody WavePickItemsParams items) {
        return pdaOutStockService.wavePickItems(items);
    }


    @PreAuthorize("hasAuthority('manager:task:list')")
    @PostMapping("/saveWavePick")
    @ApiOperation("根据容器码查询波次及出库单")
    public R saveWavePick(@RequestBody ContainerWaveParam containerWaveParam) {

        return pdaOutStockService.saveWavePick(containerWaveParam,getLoginUserId());
    }



}

 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/params/ContainerWaveParam.java

@@ -1,6 +1,8 @@
package com.vincent.rsf.server.api.entity.params;

import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
import com.vincent.rsf.server.manager.entity.TaskItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.experimental.Accessors;
@@ -14,5 +16,7 @@

    private String container;

    private List<WkOrderItem> orderItems;

    private List<ContainerWaveDto> containerWaveDtos;
}

 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/params/WavePickItemsParams.java

New file
@@ -0,0 +1,24 @@
package com.vincent.rsf.server.api.entity.params;

import com.vincent.rsf.server.manager.entity.TaskItem;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;

@Data
@Accessors(chain = true)
@ApiModel(value = "WavePickItemsParams", description = "波次拣货明细")
public class WavePickItemsParams {

    @ApiModelProperty("托盘码")
    private String barcode;

    @ApiModelProperty("订单ID")
    private Long orderId;

    @ApiModelProperty("任务明细")
    private List<TaskItem> taskItems;
}

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/PdaOutStockService.java

@@ -3,6 +3,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
import com.vincent.rsf.server.api.entity.params.WavePickItemsParams;

import java.util.List;
import java.util.Map;
@@ -17,4 +18,20 @@
    R saveWavePick(ContainerWaveParam containerWaveParam,Long loginUserId);

    R saveOutTaskSts(String barcode);

    /**
     * @author Ryan
     * @date 2025/11/13
     * @description: 获取波次订单明细
     * @version 1.0
     */
    R getWaveOrderItems(Map<String, Object> params);

    /**
     * @author Ryan
     * @date 2025/11/13
     * @description: 波次明细拣货
     * @version 1.0
     */
    R wavePickItems(WavePickItemsParams items);
}

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java

@@ -6,19 +6,24 @@
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.entity.dto.ContainerWaveDto;
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
import com.vincent.rsf.server.api.entity.params.WavePickItemsParams;
import com.vincent.rsf.server.api.service.PdaOutStockService;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.TaskStsType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.system.entity.Fields;
import com.vincent.rsf.server.system.entity.FieldsItem;
import com.vincent.rsf.server.system.service.FieldsItemService;
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.service.impl.FieldsItemServiceImpl;
import com.vincent.rsf.server.system.service.impl.FieldsServiceImpl;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;

import javax.annotation.Resource;
import java.math.BigDecimal;
@@ -42,6 +47,8 @@
    private WaveOrderRelaService waveOrderRelaService;
    @Autowired
    private FieldsItemService fieldsItemService;
    @Autowired
    private FieldsService fieldsService;

    @Override
    public R getOutStockTaskItem(String barcode) {
@@ -98,7 +105,6 @@
    @Override
    public R getContainerWaveList(Map<String, String> map) {
        String barcode = map.get("barcode");

        if (Cools.isEmpty(barcode)) {
            throw new CoolException("参数有误");
        }
@@ -109,37 +115,183 @@
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }
        ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        for (TaskItem taskItem : taskItems) {
            ContainerWaveDto containerWaveDto = new ContainerWaveDto();
            containerWaveDto.setTaskItem(taskItem);
            Wave wave = waveService.getById(taskItem.getSourceId());
            if (null == wave) {
                throw new CoolException("未找到容器号对应波次");
            }
        Set<Long> longSet = taskItems.stream().map(TaskItem::getSourceId).collect(Collectors.toSet());
            List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
                    .eq(WaveOrderRela::getWaveId, wave.getId()));
                .in(WaveOrderRela::getWaveId, longSet));
            if (Cools.isEmpty(waveOrderRelas)) {
                throw new CoolException("波次对应关联单未找到");
            }
            Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
            ArrayList<WkOrderItem> list = new ArrayList<>();
            List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
            for (WkOrder wkOrder : wkOrderList) {
                List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getOrderId, wkOrder.getId())
                        .eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode, taskItem.getMatnrCode())
                        .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch, taskItem.getBatch()));
                if (null != orderItem) {
                    list.addAll(orderItem);
        Set<Long> orderIds = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
        List<WkOrder> wkOrders = asnOrderService.listByIds(orderIds);
        if (wkOrders.isEmpty()) {
            throw new CoolException("单据不存在！！");
                }
            }
            containerWaveDto.setWkOrderItems(list);
            containerWaveDtos.add(containerWaveDto);
        Set<String> codes = taskItems.stream().map(TaskItem::getMatnrCode).collect(Collectors.toSet());
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .in(WkOrderItem::getMatnrCode, codes)
                .in(WkOrderItem::getOrderId, orderIds));

        return R.ok("查询成功").add(orderItems);

//        ArrayList<ContainerWaveDto> containerWaveDtos = new ArrayList<>();
////        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
//        for (TaskItem taskItem : taskItems) {
//            ContainerWaveDto containerWaveDto = new ContainerWaveDto();
//            containerWaveDto.setTaskItem(taskItem);
//            Wave wave = waveService.getById(taskItem.getSourceId());
//            if (null == wave) {
//                throw new CoolException("未找到容器号对应波次");
//            }
//            List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
//                    .eq(WaveOrderRela::getWaveId, wave.getId()));
//            if (Cools.isEmpty(waveOrderRelas)) {
//                throw new CoolException("波次对应关联单未找到");
//            }
//            Set<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
//            ArrayList<WkOrderItem> list = new ArrayList<>();
//            List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
//            for (WkOrder wkOrder : wkOrderList) {
//                List<WkOrderItem> orderItem = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
//                        .eq(WkOrderItem::getOrderId, wkOrder.getId())
//                        .eq(StringUtils.isNotEmpty(taskItem.getMatnrCode()), WkOrderItem::getMatnrCode, taskItem.getMatnrCode())
//                        .eq(StringUtils.isNotEmpty(taskItem.getBatch()), WkOrderItem::getSplrBatch, taskItem.getBatch()));
//                if (null != orderItem) {
//                    list.addAll(orderItem);
//                }
//            }
//            containerWaveDto.setWkOrderItems(list);
//            containerWaveDtos.add(containerWaveDto);
//        }
//        return R.ok("查询成功").add(wkOrders);
        }

        return R.ok(containerWaveDtos);
    /**
     * @author Ryan
     * @date 2025/11/13
     * @description: 获取波次拣货明细
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R getWaveOrderItems(Map<String, Object> param) {
        if (Objects.isNull(param)) {
            return R.error("参数不能为空！！");
        }
        if (Objects.isNull(param.get("fieldsIndex"))) {
            return R.error("票号不能为空！！");
        }
        if (Objects.isNull(param.get("barcode"))) {
            return R.error("容器号不能为空！！");
        }
        if (Objects.isNull(param.get("orderId"))) {
            return R.error("订单ID不能为空！！");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, param.get("barcode").toString()));
        if (Objects.isNull(task)) {
            throw new CoolException("数据错误，任务档已不存在！！");
        }
        FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
                .eq(FieldsItem::getValue, param.get("fieldsIndex").toString())
                .last("limit 1"));
        if (Objects.isNull(fieldsItem)) {
            return R.error("数据错误，票号不存在！！");
        }
        TaskItem taskItem = taskItemService.getOne(new LambdaQueryWrapper<TaskItem>()
                        .eq(TaskItem::getFieldsIndex, fieldsItem.getUuid())
                .eq(TaskItem::getTaskId, task.getId()));
        if (Objects.isNull(taskItem)) {
            return R.error("数据错误，任务档明细不存在！！");
        }
//        Long orderId = Long.valueOf(param.get("orderId").toString());
//        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orderId));
//        if (orderItems.isEmpty()) {
//            return R.error("数据错误，订单数据不存在！！");
//        }
        //根据索引获取动态字段Value值
        Map<String, String> fields = new HashMap<>();
        Fields fields1 = fieldsService.getById(fieldsItem.getFieldsId());
        fields.put(fields1.getFields(), fieldsItem.getValue());
        taskItem.setExtendFields(fields);

        return R.ok().add(taskItem);
    }

    /**
     * @author Ryan
     * @date 2025/11/13
     * @description: 波次明细拣货
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R wavePickItems(WavePickItemsParams params) {
        if (Objects.isNull(params.getBarcode())) {
            return R.error("托盘码不能为空！！");
        }
        if (Objects.isNull(params.getOrderId())) {
            return R.error("订单ID不能为空！！");
        }
        if (Objects.isNull(params.getTaskItems()) || params.getTaskItems().isEmpty()) {
            return R.error("拣货明细不能为空！");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, params.getBarcode()));
        if (null == task) {
            return R.error("未找到托盘对应的任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }
        WkOrder order = asnOrderService.getById(params.getOrderId());
        if (Objects.isNull(order)) {
            return R.error("单据信息不存在！！");
        }
        List<TaskItem> taskItems = params.getTaskItems();
        Map<String, List<TaskItem>> listMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getMatnrCode));
        listMap.keySet().forEach(code -> {
            List<TaskItem> items = listMap.get(code);
            //一张出库单，相同的品种不会出现两次
            WkOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                    .eq(WkOrderItem::getMatnrCode, code)
                    .eq(WkOrderItem::getOrderId, order.getId()));
            if (Objects.isNull(orderItem)) {
                throw new CoolException("数据错误，拣料不在单据需求中！！");
            }
            Double summed = items.stream().mapToDouble(TaskItem::getAnfme).sum();
            //加上历史拣料数量
            Double pickQty = Math.round((orderItem.getQty() + summed) * 10000) / 10000.0;
            if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
                throw new CoolException("播种数量不能超出订单需求数量");
            }
            orderItem.setQty(pickQty);

            if (!asnOrderItemService.updateById(orderItem)) {
                throw new CoolException("出库单明细更新失败！！");
            }

            items.forEach(taskItem -> {
                taskItem.setQty(taskItem.getAnfme());
                if (!taskItemService.updateById(taskItem)) {
                    throw new CoolException("状态完成失败！！");
                }
            });
        });

        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, params.getOrderId()));
        double total = orderItems.stream().mapToDouble(WkOrderItem::getQty).sum();
        order.setQty(total);
        if (!asnOrderService.updateById(order)) {
            throw new CoolException("订单数量更新失败！！");
        }
//        //检查单据是否完成
//        if (order.getAnfme().compareTo(order.getQty()) == 0) {
//            order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
//            if (!asnOrderService.updateById(order)) {
//                throw new CoolException("出库单更新状态失败");
//            }
//        }

        return R.ok();
    }

    /**
@@ -163,73 +315,75 @@
            return R.error("任务状态不是等待确认");
        }

        for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
            //做一次校验，判断前端所有出库数量是否超过本托出库数量
            double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
            BigDecimal total = new BigDecimal(String.valueOf(sum));
            BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
            if (!anfme.equals(total)) {
                throw new CoolException("播种数量不等于容器出库数量，请检查");
            }
            for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
                if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
                    continue;
                }
                WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
                BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
                if (num.compareTo(orderDemandQty) < 0) {
                    throw new CoolException("播种数量大于单据出库数量，请检查");
                }
                WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
                if (Cools.isEmpty(wkOrder)) {
                    throw new CoolException("出库单主单未找到");
                }
                wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
                if (!asnOrderService.updateById(wkOrder)) {
                    throw new CoolException("出库单更新状态失败");
                }

                if (Objects.isNull(oldOrderItem.getFieldsIndex())) {
                    throw new CoolException("票号不能为空！！");
                }
                //Fix 这里只针对希日项目的票号功能，票号和uuid为一对一的情况，不会出现重复的情况
                FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, oldOrderItem.getFieldsIndex()).last("limit 1"));
                if (!Objects.isNull(fieldsItem)) {
                    orderItem.setFieldsIndex(fieldsItem.getUuid());
                }
                orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
                if (!asnOrderItemService.updateById(orderItem)) {
                    throw new CoolException("单据明细更新失败");
                }
                //检查单据是否完成
                Boolean orderChecked = checkOrderComplete(orderItem);
                if (orderChecked) {
                    wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                    if (!asnOrderService.updateById(wkOrder)) {
                        throw new CoolException("出库单更新状态失败");
                    }
                }
            }
        //检查波次是否完成
//            Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
//            if (waveChecked){
//                Wave wave = waveService.getById(containerWaveDto.getTaskItem().getSourceId());
//                if (null == wave){
//                    throw new CoolException("未找到容器号对应波次");
//        containerWaveParam.getOrderItems().forEach(orderItem -> {
//
//        });
//        for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
//            //做一次校验，判断前端所有出库数量是否超过本托出库数量
//            double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
//            BigDecimal total = new BigDecimal(String.valueOf(sum));
//            BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
//            if (!anfme.equals(total)) {
//                throw new CoolException("播种数量不等于容器出库数量，请检查");
//                }
//                wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
//                if (!waveService.updateById(wave)){
//                    throw new CoolException("波次单更新状态失败");
//            for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
//                if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
//                    continue;
//                }
//                WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
//                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
//                BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
//                if (num.compareTo(orderDemandQty) < 0) {
//                    throw new CoolException("播种数量大于单据出库数量，请检查");
//                }
//                WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
//                if (Cools.isEmpty(wkOrder)) {
//                    throw new CoolException("出库单主单未找到");
//                }
//                wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
//                if (!asnOrderService.updateById(wkOrder)) {
//                    throw new CoolException("出库单更新状态失败");
//                }
//
//                if (Objects.isNull(oldOrderItem.getFieldsIndex())) {
//                    throw new CoolException("票号不能为空！！");
//                }
//                //Fix 这里只针对希日项目的票号功能，票号和uuid为一对一的情况，不会出现重复的情况
//                FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, oldOrderItem.getFieldsIndex()).last("limit 1"));
//                if (!Objects.isNull(fieldsItem)) {
//                    orderItem.setFieldsIndex(fieldsItem.getUuid());
//                }
//                orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
//                if (!asnOrderItemService.updateById(orderItem)) {
//                    throw new CoolException("单据明细更新失败");
//                }
//                //检查单据是否完成
//                Boolean orderChecked = checkOrderComplete(orderItem);
//                if (orderChecked) {
//                    wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
//                    if (!asnOrderService.updateById(wkOrder)) {
//                        throw new CoolException("出库单更新状态失败");
//                }
//            }
        }
//            }
//        //检查波次是否完成
////            Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
////            if (waveChecked){
////                Wave wave = waveService.getById(containerWaveDto.getTaskItem().getSourceId());
////                if (null == wave){
////                    throw new CoolException("未找到容器号对应波次");
////                }
////                wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
////                if (!waveService.updateById(wave)){
////                    throw new CoolException("波次单更新状态失败");
////                }
////            }
//        }

        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
        if (!taskService.updateById(task)) {
            throw new CoolException("任务状态更新失败");
        }


        return R.ok();
    }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/dto/ExistDto.java

@@ -9,4 +9,5 @@
    private String locNo;
    private String matnr;
    private String batch;
    private String lastSite;
}

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

@@ -723,7 +723,7 @@
                        p1.getUpdateBy(),
                        p1.getMemo()
                ),
                WaveItem::getSplrBatch, WaveItem::getMatnrCode, WaveItem::getFieldsIndex
                 WaveItem::getMatnrCode
        );

        return waveItems;

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

@@ -279,21 +279,48 @@
    @Synchronized
    @Transactional(rollbackFor = Exception.class)
    public void generateOutTask(List<OrderOutItemDto> itemParams, Long loginUserId, Wave wave) throws Exception {
        for (OrderOutItemDto itemDto : itemParams) {
        Map<Long, List<OrderOutItemDto>> listMap = itemParams.stream().collect(Collectors.groupingBy(OrderOutItemDto::getLocId));
        listMap.keySet().forEach(id -> {
            double sum = listMap.get(id).stream().mapToDouble(OrderOutItemDto::getAnfme).sum();
            List<LocItem> items = new ArrayList<>();
            //生成明细
            listMap.get(id).forEach(orderOutItemDto -> {
                items.add(orderOutItemDto.getLocItem());
            });
            //获取不为空站点
            List<OrderOutItemDto> itemDtos = listMap.get(id).stream().filter(orderOutItemDto -> !Objects.isNull(orderOutItemDto.getSitesNo())).collect(Collectors.toList());
            OrderOutItemDto itemDto = itemDtos.stream().findFirst().get();
            itemDto.setAnfme(sum);
            LocToTaskParams taskParams = new LocToTaskParams();
            Loc loc = locService.getById(itemDto.getLocId());
            if (Objects.isNull(loc)) {
                continue;
            }
            taskParams.setItems(Arrays.asList(itemDto.getLocItem()))
            taskParams.setItems(items)
                    .setSiteNo(itemDto.getSitesNo())
                    .setType(Constants.TASK_TYPE_WAVE_OUT_STOCK)
                    .setSourceId(wave.getId())
                    .setTarLoc(loc.getCode());

            //TODO 生成出库任务，获取波次单据信息
            try {
            locItemService.generateTask(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val, taskParams, loginUserId);
            } catch (Exception e) {
                throw new CoolException("出库任务生成失败！");
        }
        });

//        for (OrderOutItemDto itemDto : itemParams) {
//            LocToTaskParams taskParams = new LocToTaskParams();
//            Loc loc = locService.getById(itemDto.getLocId());
//            if (Objects.isNull(loc)) {
//                continue;
//            }
//            taskParams.setItems(Arrays.asList(itemDto.getLocItem()))
//                    .setSiteNo(itemDto.getSitesNo())
//                    .setType(Constants.TASK_TYPE_WAVE_OUT_STOCK)
//                    .setSourceId(wave.getId())
//                    .setTarLoc(loc.getCode());
//
//            //TODO 生成出库任务，获取波次单据信息
//            locItemService.generateTask(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val, taskParams, loginUserId);
//        }
    }

    /**

 rsf-server/src/main/java/com/vincent/rsf/server/manager/utils/LocManageUtil.java

@@ -13,7 +13,7 @@
import com.vincent.rsf.server.manager.enums.WaveRuleType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.enums.LocStsType;
import io.swagger.models.auth.In;

import org.apache.commons.lang3.StringUtils;

import javax.swing.*;
@@ -158,7 +158,8 @@
        List<OrderOutItemDto> list = new ArrayList<>();
        //不让站点重复使用问题
        List<BasStation> stations = new ArrayList<>();
        Set<ExistDto> existDtos = new HashSet<>();
        List<ExistDto> existDtos = new ArrayList<>();
        Set<Loc> locs = new HashSet<>();
        for (WaveToLocParams item : params) {
            BigDecimal issued = new BigDecimal(item.getAnfme().toString())
                    .subtract(new BigDecimal(item.getWorkQty().toString()));
@@ -189,12 +190,14 @@
                                .setSource(item.getItemId());//波次明细ID
                        OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                        orderOutItemDto.setLocItem(locItem);

                        orderOutItemDto.setSource(item.getItemId())
                                .setSourceId(item.getWaveId());
                        List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
                                .eq(!Objects.isNull(loc.getChannel()), DeviceSite::getChannel, loc.getChannel())
                                .eq(DeviceSite::getType, issued.doubleValue() >= locItem.getAnfme() && itemList.size() == 1 ? TaskType.TASK_TYPE_OUT.type : TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                        );

                        if (locs.add(loc)) {
                        if (!deviceSites.isEmpty()) {
                            List<OrderOutItemDto.staListDto> maps = new ArrayList<>();
                            for (DeviceSite sta : deviceSites) {
@@ -221,9 +224,8 @@
                            }
                            orderOutItemDto.setSitesNo(basStation.getStationName());
                        }
                        }

                        orderOutItemDto.setSource(item.getItemId())
                                .setSourceId(item.getWaveId());

                        list.add(orderOutItemDto);