pda确认流程优化

chen.lin

昨天 ed170766d35e68256f60ab48e3fd7071326455a9

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

@@ -29,6 +29,7 @@
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.LocServiceImpl;
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.manager.enums.LocStsType;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
@@ -44,6 +45,9 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.Random;
@@ -77,6 +81,8 @@
    private WaitPakinItemService waitPakinItemService;
    @Autowired
    private BasStationService basStationService;
    @Autowired
    private LocItemWorkingService locItemWorkingService;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
@@ -118,8 +124,235 @@
        // 验证设备站点
        DeviceSite deviceSite = validateDeviceSite(param);

        // 验证组拖状态
        WaitPakin waitPakin = validateWaitPakin(param.getBarcode());
        // 提前定义waitPakin，避免作用域问题
        WaitPakin waitPakin = null;

        // 先验证组拖状态，获取组托明细信息（用于批号匹配和单号检查）
        waitPakin = validateWaitPakin(param.getBarcode());
        List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(
                new LambdaQueryWrapper<WaitPakinItem>()
                        .eq(WaitPakinItem::getPakinId, waitPakin.getId()));

        // 先检查是否有拣料入库任务（需要同时匹配箱号和批号）
        Task pickInTask = null;
        // 检查是否有盘点入库任务（需要同时匹配箱号和批号）
        Task checkInTask = null;
        
        if (!waitPakinItems.isEmpty()) {
            // 获取组托明细中的批号列表（去重）
            List<String> batchList = waitPakinItems.stream()
                    .map(WaitPakinItem::getBatch)
                    .filter(Objects::nonNull)
                    .filter(batch -> !batch.trim().isEmpty())
                    .distinct()
                    .collect(Collectors.toList());
            
            if (!batchList.isEmpty()) {
                log.info("检查组托明细批号 - 批号列表：{}", batchList);
                
                // 查询拣料入库任务：箱号匹配且状态为1、2或199（RCS申请入库时，状态199需要变成2）
                List<Task> pickInTasks = taskService.list(new LambdaQueryWrapper<Task>()
                        .eq(Task::getBarcode, param.getBarcode())
                        .eq(Task::getTaskType, TaskType.TASK_TYPE_PICK_IN.type)
                        .in(Task::getTaskStatus, TaskStsType.GENERATE_IN.id, TaskStsType.WAVE_SEED.id)
                        .orderByDesc(Task::getCreateTime));
                
                // 通过TaskItem的batch字段匹配批号
                for (Task task : pickInTasks) {
                    List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>()
                            .eq(TaskItem::getTaskId, task.getId())
                            .in(TaskItem::getBatch, batchList));
                    
                    if (!taskItems.isEmpty()) {
                        pickInTask = task;
                        log.info("找到匹配的拣料入库任务（箱号和批号都匹配） - 任务编码：{}，批号：{}", 
                                task.getTaskCode(), batchList);
                        break;
                    }
                }
                
                // 查询盘点入库任务：箱号匹配且状态为1、2或199（RCS申请入库时，状态199需要变成2）
                List<Task> checkInTasks = taskService.list(new LambdaQueryWrapper<Task>()
                        .eq(Task::getBarcode, param.getBarcode())
                        .eq(Task::getTaskType, TaskType.TASK_TYPE_CHECK_IN.type)
                        .in(Task::getTaskStatus, TaskStsType.GENERATE_IN.id, TaskStsType.WCS_EXECUTE_IN.id, TaskStsType.WAVE_SEED.id)
                        .orderByDesc(Task::getCreateTime));
                
                // 通过TaskItem的batch字段匹配批号
                for (Task task : checkInTasks) {
                    List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>()
                            .eq(TaskItem::getTaskId, task.getId())
                            .in(TaskItem::getBatch, batchList));
                    
                    if (!taskItems.isEmpty()) {
                        checkInTask = task;
                        log.info("找到匹配的盘点入库任务（箱号和批号都匹配） - 任务编码：{}，批号：{}", 
                                task.getTaskCode(), batchList);
                        break;
                    }
                }
            }
        }
        
        // 如果是拣料入库任务，直接返回，不校验组托
        if (Objects.nonNull(pickInTask)) {
            log.info("拣料入库任务，直接返回，不校验组托 - 任务编码：{}，当前状态：{}", 
                    pickInTask.getTaskCode(), pickInTask.getTaskStatus());
            
            // 如果状态是199，RCS申请入库时应该变成状态2（RCS任务已下发）
            if (pickInTask.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
                log.info("拣料入库任务状态为199，RCS申请入库时更新为状态2 - 任务编码：{}", pickInTask.getTaskCode());
                Long loginUserId = SystemAuthUtils.getLoginUserId();
                if (loginUserId == null) {
                    log.warn("无法获取系统用户ID，使用默认值1");
                    loginUserId = 1L;
                }
                
                // 更新状态为2（RCS任务已下发）
                boolean statusUpdated = taskService.update(new LambdaUpdateWrapper<Task>()
                        .eq(Task::getId, pickInTask.getId())
                        .eq(Task::getTaskStatus, TaskStsType.WAVE_SEED.id)
                        .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_IN.id)
                        .set(Task::getUpdateBy, loginUserId)
                        .set(Task::getUpdateTime, new Date()));
                
                if (statusUpdated) {
                    log.info("拣料入库任务状态已更新为2（RCS任务已下发） - 任务编码：{}", pickInTask.getTaskCode());
                    // 重新查询任务以获取最新状态
                    pickInTask = taskService.getById(pickInTask.getId());
                } else {
                    log.warn("拣料入库任务状态更新为2失败，可能状态已变更 - 任务编码：{}，当前状态：{}", 
                            pickInTask.getTaskCode(), pickInTask.getTaskStatus());
                }
            }
            
            // 更新入库站点信息（如果与当前申请的站点不同）
            if (StringUtils.isNotBlank(param.getSourceStaNo()) && 
                !param.getSourceStaNo().equals(pickInTask.getOrgSite())) {
                log.info("更新拣料入库任务的入库站点 - 任务编码：{}，原站点：{}，新站点：{}", 
                        pickInTask.getTaskCode(), pickInTask.getOrgSite(), param.getSourceStaNo());
                pickInTask.setOrgSite(param.getSourceStaNo());
                if (!taskService.updateById(pickInTask)) {
                    log.warn("更新拣料入库任务的入库站点失败 - 任务编码：{}", pickInTask.getTaskCode());
                }
            }
            
            // 返回拣料入库任务的信息
            InTaskMsgDto msgDto = new InTaskMsgDto();
            msgDto.setWorkNo(pickInTask.getTaskCode());
            msgDto.setTaskId(pickInTask.getId());
            msgDto.setLocNo(pickInTask.getTargLoc());
            msgDto.setSourceStaNo(pickInTask.getOrgSite());
            msgDto.setStaNo(pickInTask.getTargSite());
            return msgDto;
        }
        
        // 如果是盘点入库任务，直接返回，不校验组托
        if (Objects.nonNull(checkInTask)) {
            log.info("盘点入库任务，直接返回，不校验组托 - 任务编码：{}，当前状态：{}", 
                    checkInTask.getTaskCode(), checkInTask.getTaskStatus());
            
            // 如果状态是199，RCS申请入库时应该变成状态2（RCS任务已下发）
            if (checkInTask.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
                log.info("盘点入库任务状态为199，RCS申请入库时更新为状态2 - 任务编码：{}", checkInTask.getTaskCode());
                Long loginUserId = SystemAuthUtils.getLoginUserId();
                if (loginUserId == null) {
                    log.warn("无法获取系统用户ID，使用默认值1");
                    loginUserId = 1L;
                }
                
                // 更新状态为2（RCS任务已下发）
                boolean statusUpdated = taskService.update(new LambdaUpdateWrapper<Task>()
                        .eq(Task::getId, checkInTask.getId())
                        .eq(Task::getTaskStatus, TaskStsType.WAVE_SEED.id)
                        .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_IN.id)
                        .set(Task::getUpdateBy, loginUserId)
                        .set(Task::getUpdateTime, new Date()));
                
                if (statusUpdated) {
                    log.info("盘点入库任务状态已更新为2（RCS任务已下发） - 任务编码：{}", checkInTask.getTaskCode());
                    // 重新查询任务以获取最新状态
                    checkInTask = taskService.getById(checkInTask.getId());
                } else {
                    log.warn("盘点入库任务状态更新为2失败，可能状态已变更 - 任务编码：{}，当前状态：{}", 
                            checkInTask.getTaskCode(), checkInTask.getTaskStatus());
                }
            }
            
            // 更新入库站点信息（如果与当前申请的站点不同）
            if (StringUtils.isNotBlank(param.getSourceStaNo()) && 
                !param.getSourceStaNo().equals(checkInTask.getOrgSite())) {
                log.info("更新盘点入库任务的入库站点 - 任务编码：{}，原站点：{}，新站点：{}", 
                        checkInTask.getTaskCode(), checkInTask.getOrgSite(), param.getSourceStaNo());
                checkInTask.setOrgSite(param.getSourceStaNo());
                if (!taskService.updateById(checkInTask)) {
                    log.warn("更新盘点入库任务的入库站点失败 - 任务编码：{}", checkInTask.getTaskCode());
                }
            }
            
            // 返回盘点入库任务的信息
            InTaskMsgDto msgDto = new InTaskMsgDto();
            msgDto.setWorkNo(checkInTask.getTaskCode());
            msgDto.setTaskId(checkInTask.getId());
            msgDto.setLocNo(checkInTask.getTargLoc());
            msgDto.setSourceStaNo(checkInTask.getOrgSite());
            msgDto.setStaNo(checkInTask.getTargSite());
            return msgDto;
        }
        
        // 检查其他入库任务类型（用箱号查询，状态为1或2）
        // 注意：盘点入库已单独处理，不再包含在此列表中
        List<Integer> otherInboundTaskTypes = Arrays.asList(
                TaskType.TASK_TYPE_IN.type,
                TaskType.TASK_TYPE_MERGE_IN.type,
                TaskType.TASK_TYPE_EMPITY_IN.type
        );
        
        Task existingInTask = taskService.getOne(new LambdaQueryWrapper<Task>()
                .eq(Task::getBarcode, param.getBarcode())
                .in(Task::getTaskType, otherInboundTaskTypes)
                .in(Task::getTaskStatus, TaskStsType.GENERATE_IN.id, TaskStsType.WCS_EXECUTE_IN.id)
                .orderByDesc(Task::getCreateTime)
                .last("LIMIT 1"));
        
        if (Objects.nonNull(existingInTask)) {
            log.info("找到匹配的其他入库任务 - 任务编码：{}，任务类型：{}，箱号：{}", 
                    existingInTask.getTaskCode(), existingInTask.getTaskType(), param.getBarcode());
            
            // 检查组托明细是否有订单编码（任务编号）
            List<WaitPakinItem> itemsWithAsnCode = waitPakinItems.stream()
                    .filter(item -> StringUtils.isNotBlank(item.getAsnCode()))
                    .collect(Collectors.toList());
            
            if (!itemsWithAsnCode.isEmpty()) {
                log.info("组托档有任务编号，使用现有入库任务单号 - 任务编码：{}，箱号：{}，任务编号数量：{}", 
                        existingInTask.getTaskCode(), param.getBarcode(), itemsWithAsnCode.size());
                
                // 更新入库站点信息（如果与当前申请的站点不同）
                if (StringUtils.isNotBlank(param.getSourceStaNo()) && 
                    !param.getSourceStaNo().equals(existingInTask.getOrgSite())) {
                    log.info("更新入库任务的入库站点 - 任务编码：{}，原站点：{}，新站点：{}", 
                            existingInTask.getTaskCode(), existingInTask.getOrgSite(), param.getSourceStaNo());
                    existingInTask.setOrgSite(param.getSourceStaNo());
                    if (!taskService.updateById(existingInTask)) {
                        log.warn("更新入库任务的入库站点失败 - 任务编码：{}", existingInTask.getTaskCode());
                    }
                }
                
                // 返回现有入库任务的信息
                InTaskMsgDto msgDto = new InTaskMsgDto();
                msgDto.setWorkNo(existingInTask.getTaskCode());
                msgDto.setTaskId(existingInTask.getId());
                msgDto.setLocNo(existingInTask.getTargLoc());
                msgDto.setSourceStaNo(existingInTask.getOrgSite());
                msgDto.setStaNo(existingInTask.getTargSite());
                return msgDto;
            } else {
                log.info("组托档没有任务编号，继续创建新任务 - 箱号：{}", param.getBarcode());
            }
        } else {
            log.info("未找到匹配的其他入库任务，继续创建新任务 - 箱号：{}", param.getBarcode());
        }

        // 生成任务编码
        String ruleCode = generateTaskCode();
@@ -140,7 +373,7 @@
        updateLocStatus(task.getTargLoc(), waitPakin.getBarcode());

        // 获取并验证组拖明细
        List<WaitPakinItem> waitPakinItems = getWaitPakinItems(waitPakin.getId());
        waitPakinItems = getWaitPakinItems(waitPakin.getId());

        // 创建并保存任务明细
        saveTaskItems(task.getId(), waitPakinItems, param.getUser());
@@ -676,6 +909,33 @@
                        throw new CoolException("任务状态修改失败！！当前任务状态：" + task.getTaskStatus() + "，目标状态：" + TaskStsType.COMPLETE_OUT.id);
                    }
                    log.info("出库任务状态更新成功 - 任务编码：{}", task.getTaskCode());
                    
                    // 全版出库在RCS回调后处理库存并设置为199，等待PDA快速拣货确认后更新为200
                    if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)) {
                        log.info("全版出库任务，开始处理库存并更新状态为199 - 任务编码：{}", task.getTaskCode());
                        try {
                            // 重新查询任务以获取最新状态（198）
                            task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode()));
                            
                            // 调用completeTask处理库存（会设置为199）
                            List<Task> taskList = new ArrayList<>();
                            taskList.add(task);
                            taskService.completeTask(taskList);
                            
                            // 重新查询任务以获取最新状态（199）
                            task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode()));
                            
                            if (task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
                                log.info("全版出库任务状态已更新为199（等待PDA快速拣货确认后更新为200） - 任务编码：{}", task.getTaskCode());
                            } else {
                                log.warn("全版出库任务状态更新为199失败 - 任务编码：{}，当前状态：{}", 
                                        task.getTaskCode(), task.getTaskStatus());
                            }
                        } catch (Exception e) {
                            log.error("全版出库任务处理失败 - 任务编码：{}，错误：{}", task.getTaskCode(), e.getMessage(), e);
                            // 不抛出异常，避免影响RCS回调的正常返回
                        }
                    }
                }
            }
        } else {
@@ -1096,18 +1356,56 @@
        // 该方法会执行以下流程：
        // 1. 验证设备站点
        // 2. 验证组拖状态
        // 3. 生成任务编码
        // 4. 获取库位号
        // 5. 创建并保存任务
        // 6. 更新库位状态
        // 7. 获取并验证组拖明细
        // 8. 创建并保存任务明细
        // 9. 更新组托状态
        // 3. 检查是否有匹配的入库任务（拣料/盘点入库会匹配状态199并更新为2）
        // 4. 生成任务编码（如果需要创建新任务）
        // 5. 获取库位号
        // 6. 创建并保存任务（如果需要创建新任务）
        // 7. 更新库位状态
        // 8. 获取并验证组拖明细
        // 9. 创建并保存任务明细
        // 10. 更新组托状态
        InTaskMsgDto msgDto = createInTask(param);
        //RCS已经在输送线上，所以不需要下发任务
        taskService.updateById(new Task(){{setId(msgDto.getTaskId());setTaskStatus(2);}});
        
        // 查询任务当前状态
        Task task = taskService.getById(msgDto.getTaskId());
        if (Objects.isNull(task)) {
            throw new CoolException("任务不存在，任务ID：" + msgDto.getTaskId());
        }
        
        // RCS申请入库时，需要将任务状态更新为2（RCS任务已下发）
        // 情况1：如果是拣料/盘点入库任务，状态199已经在createInTask中更新为2了
        // 情况2：如果是新创建的任务（无订单号组托），状态是1，需要更新为2
        // 情况3：如果状态已经是2，不需要更新
        if (task.getTaskStatus().equals(TaskStsType.GENERATE_IN.id)) {
            log.info("新创建的入库任务（无订单号组托），RCS申请入库时更新为状态2 - 任务编码：{}", task.getTaskCode());
            Long loginUserId = SystemAuthUtils.getLoginUserId();
            if (loginUserId == null) {
                log.warn("无法获取系统用户ID，使用默认值1");
                loginUserId = 1L;
            }
            
            boolean statusUpdated = taskService.update(new LambdaUpdateWrapper<Task>()
                    .eq(Task::getId, task.getId())
                    .eq(Task::getTaskStatus, TaskStsType.GENERATE_IN.id)
                    .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_IN.id)
                    .set(Task::getUpdateBy, loginUserId)
                    .set(Task::getUpdateTime, new Date()));
            
            if (statusUpdated) {
                log.info("新创建的入库任务状态已更新为2（RCS任务已下发） - 任务编码：{}", task.getTaskCode());
            } else {
                log.warn("新创建的入库任务状态更新为2失败，可能状态已变更 - 任务编码：{}，当前状态：{}", 
                        task.getTaskCode(), task.getTaskStatus());
            }
        } else if (task.getTaskStatus().equals(TaskStsType.WCS_EXECUTE_IN.id)) {
            log.info("入库任务状态已经是2（RCS任务已下发），无需更新 - 任务编码：{}", task.getTaskCode());
        } else {
            log.info("入库任务当前状态：{}，RCS申请入库时保持当前状态 - 任务编码：{}", 
                    task.getTaskStatus(), task.getTaskCode());
        }
        
        log.info("========== RCS-申请入库任务成功 ==========");
        log.info("RCS-返回 任务编码：{}，库位号：{}", msgDto.getWorkNo(), msgDto.getLocNo());
        log.info("RCS-返回 任务编码：{}，库位号：{}，任务状态：{}", msgDto.getWorkNo(), msgDto.getLocNo(), task.getTaskStatus());

        // 返回结果，只返回库位号（根据接口文档要求）
        JSONObject result = new JSONObject();