#新增 1. 单据上报功能优化

skyouc

18 小时以前 ed4d6474cd902bab8fa99cd00361b42bbfe55ebd

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

@@ -5,20 +5,38 @@
import com.vincent.rsf.framework.common.R;
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.manager.service.impl.StockItemServiceImpl;
import com.vincent.rsf.server.manager.service.impl.StockServiceImpl;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
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 com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;
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;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class PdaOutStockServiceImpl implements PdaOutStockService {
@@ -33,17 +51,27 @@
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;
    @Autowired
    private WaveOrderRelaService waveOrderRelaService;
    @Autowired
    private FieldsItemService fieldsItemService;
    @Autowired
    private FieldsService fieldsService;
    @Autowired
    private StockService stockService;
    @Autowired
    private StockItemServiceImpl stockItemService;

    @Override
    public R getOutStockTaskItem(String barcode) {
        LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Task::getBarcode, barcode);
        Task task = taskService.getOne(lambdaQueryWrapper);
        if (null == task){
        if (null == task) {
            return R.error("未查询到相关任务");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (null == taskItems || taskItems.size() <= 0){
        if (null == taskItems || taskItems.size() <= 0) {
            return R.error("任务出错，未查询到相关任务明细");
        }

@@ -52,9 +80,36 @@
    }

    @Override
    public R saveOutTaskSts(String barcode) {
        LambdaQueryWrapper<Task> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Task::getBarcode, barcode);
        Task task = taskService.getOne(lambdaQueryWrapper);
        if (null == task) {
            throw new CoolException("未找到容器号对应任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
        maps.keySet().forEach(key -> {
            WkOrderItem orderItem = asnOrderItemService.getById(key);
            if (Objects.isNull(orderItem)) {
                throw new CoolException("单据明细不存在！！");
            }
        });
        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
        if (!taskService.updateById(task)) {
            return R.error("更新任务状态失败");
        }

        return R.ok("确认成功");
    }

    @Override
    public R getWaveListItem(String barcode) {
        LambdaQueryWrapper<Wave> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(!Cools.isEmpty(barcode),Wave::getCode,barcode);
        lambdaQueryWrapper.eq(!Cools.isEmpty(barcode), Wave::getCode, barcode);
        List<Wave> waveList = waveService.list(lambdaQueryWrapper);
        return R.ok(waveList);
    }
@@ -62,83 +117,353 @@
    @Override
    public R getContainerWaveList(Map<String, String> map) {
        String barcode = map.get("barcode");

        if (Cools.isEmpty(barcode) ){
        if (Cools.isEmpty(barcode)) {
            throw new CoolException("参数有误");
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, barcode));
        if (null == task){
        if (null == task) {
            throw new CoolException("未找到容器号对应任务");
        }
        if (task.getTaskStatus().equals(TaskStsType.COMPLETE_OUT.id)){
            throw new CoolException("当前状态为不可拣货状态");
        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("未找到容器号对应波次");
            }
            ArrayList<AsnOrderItem> list = new ArrayList<>();
            List<AsnOrder> asnOrderList = asnOrderService.list(new LambdaQueryWrapper<AsnOrder>().eq(AsnOrder::getWaveId, wave.getId()));
            for (AsnOrder asnOrder : asnOrderList) {
                AsnOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>()
                        .eq(AsnOrderItem::getAsnId, asnOrder.getId())
                        .eq(AsnOrderItem::getMatnrCode, taskItem.getMatnrCode())
                        .eq(AsnOrderItem::getSplrBatch, taskItem.getBatch())
                );
                if (null != orderItem){
                    list.add(orderItem);
                }


            }
            containerWaveDto.setAsnOrderItems(list);
            containerWaveDtos.add(containerWaveDto);
        Set<Long> longSet = taskItems.stream().map(TaskItem::getSourceId).collect(Collectors.toSet());
        List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
                .in(WaveOrderRela::getWaveId, longSet));
        if (Cools.isEmpty(waveOrderRelas)) {
            throw new CoolException("波次对应关联单未找到");
        }
        Set<Long> orderIds = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
        List<WkOrder> wkOrders = asnOrderService.listByIds(orderIds);
        if (wkOrders.isEmpty()) {
            throw new CoolException("单据不存在！！");
        }
        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(containerWaveDtos);
        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);
    }

    /**
     * @author Ryan
     * @date 2025/11/13
     * @description: 获取波次拣货明细
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R saveWavePick(List<ContainerWaveDto> containerWaveDtos) {
        if (null == containerWaveDtos || containerWaveDtos.size() <= 0){
            return R.error("参数错误");
    public R getWaveOrderItems(Map<String, Object> param) {
        if (Objects.isNull(param)) {
            return R.error("参数不能为空！！");
        }
        Task task = taskService.getById(containerWaveDtos.get(0).getTaskItem().getTaskId());
        if (null == task){
        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("未找到托盘对应的任务");
        }

        for (ContainerWaveDto containerWaveDto : containerWaveDtos) {
            //做一次校验，判断前端所有出库数量是否超过本托出库数量
            double sum = containerWaveDto.getAsnOrderItems().stream().mapToDouble(AsnOrderItem::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 (AsnOrderItem orderItem : containerWaveDto.getAsnOrderItems()) {
                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
                BigDecimal orderDemandQty = new BigDecimal(orderItem.getDemandQty().toString());
                if (num.compareTo(orderDemandQty) < 0){
                    throw new CoolException("播种数量大于单据出库数量，请检查");
                }
                orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
                if (!asnOrderItemService.updateById(orderItem)){
                    throw new CoolException("单据明细更新失败");
                }
            }
        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);

        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
        if (!taskService.updateById(task)){
            throw new CoolException("任务状态更新失败");
            if (!asnOrderItemService.updateById(orderItem)) {
                throw new CoolException("出库单明细更新失败！！");
            }

            Stock stock = new Stock();
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
            if (StringUtils.isBlank(ruleCode)) {
                throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
            }
            Double sum = taskItems.stream().mapToDouble(TaskItem::getAnfme).sum();
            stock.setCode(ruleCode)
                    .setUpdateBy(SystemAuthUtils.getLoginUserId())
                    .setBarcode(task.getBarcode())
                    .setLocCode(task.getOrgLoc())
                    .setType(order.getType())
                    .setWkType(Short.parseShort(order.getWkType()))
                    .setSourceId(orderItem.getOrderId())
                    .setSourceCode(orderItem.getOrderCode())
                    .setUpdateTime(new Date())
                    .setAnfme(sum);

            if (!stockService.save(stock)) {
                throw new CoolException("出入库历史保存失败！！");
            }

           List<StockItem> stockItems = new ArrayList<>();
            items.forEach(taskItem -> {
                taskItem.setQty(taskItem.getAnfme()).setOrderId(order.getId()).setOrderItemId(orderItem.getId());
                if (!taskItemService.updateById(taskItem)) {
                    throw new CoolException("状态完成失败！！");
                }
                StockItem stockItem = new StockItem();
                BeanUtils.copyProperties(taskItem, stockItem);
                stockItem.setStockId(stock.getId()).setStockCode(stock.getCode()).setSourceItemId(orderItem.getId());
                stockItems.add(stockItem);
            });
            if (!stockItemService.saveBatch(stockItems)) {
                throw new CoolException("出入库历史明细保存失败！！");
            }
        });

        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, params.getOrderId()));
        double total = orderItems.stream().mapToDouble(WkOrderItem::getQty).sum();
        double wkQty = orderItems.stream().mapToDouble(WkOrderItem::getWorkQty).sum();
        order.setQty(total).setWorkQty(order.getWorkQty() - wkQty);
        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();
    }


    private void saveOrderToStock(Order order) {


    }

    /**
     * @author Ryan
     * @date 2025/11/5
     * @description: 波次拣货
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    @Synchronized
    public R saveWavePick(ContainerWaveParam containerWaveParam, Long loginUserId) {
        if (null == containerWaveParam ) {
            return R.error("参数错误");
        }
        List<WkOrderItem> orderItems = containerWaveParam.getContainerWaveDtos();
        if (Objects.isNull(orderItems) || orderItems.isEmpty()) {
            return R.error("数据错误！！");
        }

        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, containerWaveParam.getContainer()));
        if (null == task) {
            return R.error("未找到托盘对应的任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        }

        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        taskItems.forEach(taskItem -> {
           if (!(taskItem.getQty().compareTo(taskItem.getAnfme()) == 0)) {
               throw new CoolException("有单据物料未拣，请拣完后再确认！！");
           }
        });

//        orderItems.forEach(orderItem -> {
//            try {
//                taskService.saveOutStockItem(taskItems, orderItem, null, null, SystemAuthUtils.getLoginUserId());
//            } catch (Exception e) {
//                throw new RuntimeException(e);
//            }
//        });

//        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("播种数量不等于容器出库数量，请检查");
//            }
//            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();
    }


    private Boolean checkWaveComplete(TaskItem taskItem) {
        Wave wave = waveService.getById(taskItem.getSourceId());
        List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getWaveId, wave.getId()));
        return wkOrderList.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }

    private Boolean checkOrderComplete(WkOrderItem orderItem) {
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderCode, orderItem.getOrderCode()));
        return wkOrderItems.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }
}