跳过波次任务

chen.lin

50 分钟以前 323a159cfe54156adfc04a4b7e5ed4b552214632

跳过波次任务

 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/TaskSchedules.java

@@ -607,47 +607,67 @@
            } else if ((task.getTaskType() >= TaskType.TASK_TYPE_OUT.type && task.getTaskType() <= TaskType.TASK_TYPE_EMPITY_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)) {
                /**判断单据是否完成**/
                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("单据不存在！！");
                }

                Config allowChang = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));

                wkOrders.forEach(order -> {
                    //判断是否允许超收，不允许超收添加拒收判断
                    if (!Objects.isNull(allowChang)) {
                        if (!Boolean.parseBoolean(allowChang.getVal())) {
                            if (order.getAnfme().compareTo(order.getQty()) == 0) {
                                order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                                if (!asnOrderService.updateById(order)) {
                                    throw new CoolException("出库单更新状态失败");
                                }
                            }
                // 只有波次类型的任务才需要查询波次关联单
                if (task.getResource() != null && task.getResource().equals(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val)) {
                    Set<Long> longSet = taskItems.stream()
                            .map(TaskItem::getSourceId)
                            .filter(Objects::nonNull)
                            .collect(Collectors.toSet());
                    
                    if (longSet.isEmpty()) {
                        logger.warn("任务{}的任务明细中没有有效的sourceId，跳过波次关联单查询。任务编码：{}，任务类型：{}", 
                                task.getId(), task.getTaskCode(), task.getTaskType());
                    } else {
                        List<WaveOrderRela> waveOrderRelas = waveOrderRelaService.list(new LambdaQueryWrapper<WaveOrderRela>()
                                .in(WaveOrderRela::getWaveId, longSet));
                        if (Cools.isEmpty(waveOrderRelas)) {
                            logger.warn("任务{}的波次对应关联单未找到，可能是数据不一致或任务不是通过波次创建的。任务编码：{}，sourceIds：{}", 
                                    task.getId(), task.getTaskCode(), longSet);
                        } else {
                            if (order.getAnfme().compareTo(order.getQty()) <= 0) {
                                order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                                if (!asnOrderService.updateById(order)) {
                                    throw new CoolException("出库单更新状态失败");
                                }
                            Set<Long> orderIds = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toSet());
                            List<WkOrder> wkOrders = asnOrderService.listByIds(orderIds);
                            if (wkOrders.isEmpty()) {
                                logger.warn("任务{}的关联单据不存在。任务编码：{}，orderIds：{}", 
                                        task.getId(), task.getTaskCode(), orderIds);
                            } else {
                                Config allowChang = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));

                                wkOrders.forEach(order -> {
                                    //判断是否允许超收，不允许超收添加拒收判断
                                    if (!Objects.isNull(allowChang)) {
                                        if (!Boolean.parseBoolean(allowChang.getVal())) {
                                            if (order.getAnfme().compareTo(order.getQty()) == 0) {
                                                order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                                                if (!asnOrderService.updateById(order)) {
                                                    logger.error("出库单更新状态失败。订单ID：{}，订单编码：{}", order.getId(), order.getCode());
                                                }
                                            }
                                        } else {
                                            if (order.getAnfme().compareTo(order.getQty()) <= 0) {
                                                order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
                                                if (!asnOrderService.updateById(order)) {
                                                    logger.error("出库单更新状态失败。订单ID：{}，订单编码：{}", order.getId(), order.getCode());
                                                }
                                            }
                                        }
                                    }
                                    //检查单据是否完成

                                });
                            }
                        }
                    }
                    //检查单据是否完成

                });
                } else {
                    logger.debug("任务{}不是波次类型任务（资源类型：{}），跳过波次关联单查询。任务编码：{}", 
                            task.getId(), task.getResource(), task.getTaskCode());
                }
                
                //出库单上报RCS修改库位状态
                try {
                    reportStationStatus(task);
                } catch (Exception e) {
                    throw new CoolException(e.getMessage());
                    logger.error("任务{}上报RCS修改库位状态失败。任务编码：{}", task.getId(), task.getTaskCode(), e);
                    // 不抛出异常，避免中断定时任务
                }
            }


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

@@ -1399,16 +1399,36 @@
        if (Objects.isNull(loc)) {
            throw new CoolException("库位不存在！！");
        }
        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_R.type)) {
            throw new CoolException("库位状态不处理于R.出库预约！！");
        }

        
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (taskItems.isEmpty()) {
            throw new CoolException("任务明细不存在！！");
        }

        List<LocItem> locItems = locItemService.list(new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocId, loc.getId()));
        
        // 如果库位状态不是R，检查是否已经处理过
        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_R.type)) {
            // 如果库位明细为空，说明已经处理过了，直接更新任务状态为199
            if (locItems.isEmpty()) {
                logger.warn("任务{}的库位{}状态为{}，但库位明细为空，可能已经处理过，直接更新任务状态为199", 
                        task.getId(), loc.getCode(), loc.getUseStatus());
                if (!this.update(new LambdaUpdateWrapper<Task>()
                        .eq(Task::getId, task.getId())
                        .set(Task::getUpdateBy, loginUserId)
                        .set(Task::getUpdateTime, new Date())
                        .set(Task::getTaskStatus, TaskStsType.WAVE_SEED.id))) {
                    throw new CoolException("任务状态更新失败！！");
                }
                return; // 跳过后续处理
            } else {
                // 库位明细不为空但状态不是R，记录错误但不抛出异常，让定时任务继续处理其他任务
                logger.error("任务{}的库位{}状态为{}，不是R.出库预约状态，但库位明细不为空，跳过处理。任务编码：{}，库位编码：{}", 
                        task.getId(), loc.getCode(), loc.getUseStatus(), task.getTaskCode(), loc.getCode());
                return; // 跳过处理，避免异常中断定时任务
            }
        }
        
        // 如果库位明细为空，可能是已经被处理过了，允许继续执行
        if (!locItems.isEmpty()) {
            List<LocItemWorking> workings = new ArrayList<>();