agv增加一个新单号防重复 ，增加一个手动呼叫agv

chen.llin

5 天以前 74951023b54f1789d1244fe923219d467487d771

 src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java

@@ -12,6 +12,7 @@
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.task.handler.AgvHandler;
import com.zy.asrs.utils.MatUtils;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.NodeUtils;
@@ -22,6 +23,7 @@

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

@@ -58,35 +60,34 @@
    @Resource
    private TaskService taskService;

    @Resource
    private AgvHandler agvHandler;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R agvCallback(AgvCallbackDto param) {
        log.debug("agvCallback param:{}", param);
        log.debug("agv回调 param:{}", param);
        // 优先使用taskId，如果没有则使用id（向后兼容）
        String taskId = Cools.isEmpty(param.getTaskId()) ? param.getId() : param.getTaskId();
        if (Cools.isEmpty(taskId)) {
            return R.error("任务id不能为空");
        }
        
        log.info("收到AGV任务回调请求，taskId：{}，fromBin：{}，toBin：{}，robotGroup：{}，kind：{}", 
            taskId, param.getFromBin(), param.getToBin(), 
            Cools.isEmpty(param.getRobotGroup()) ? param.getRobotName() : param.getRobotGroup(), 
        log.info("收到AGV任务回调请求，taskId：{}，fromBin：{}，toBin：{}，robotGroup：{}，kind：{}",
            taskId, param.getFromBin(), param.getToBin(),
            Cools.isEmpty(param.getRobotGroup()) ? param.getRobotName() : param.getRobotGroup(),
            param.getKind());
        
        // 根据taskId查询任务
        Task task = null;
        try {
            // 尝试将taskId解析为Long类型的id
            Long taskIdLong = Long.parseLong(taskId);
            task = taskService.selectById(taskIdLong);
        } catch (NumberFormatException e) {
            // 如果不是数字，尝试通过其他字段查询（如sheetNo等）
            log.debug("taskId不是数字格式，尝试通过其他字段查询，taskId：{}", taskId);
            task = taskService.selectOne(
                new EntityWrapper<Task>().eq("sheet_no", taskId)
            );
        // 优先通过agvWrkNo字段查询（新格式：T+wrk_no+年月日时分秒）
        task = taskService.selectOne(
            new EntityWrapper<Task>().eq("agv_wrk_no", taskId).eq("is_deleted", 0)
        );
        if (task != null) {
            log.debug("通过agvWrkNo（agv_wrk_no={}）找到任务，taskId：{}", taskId, task.getId());
        }
        

        if (task == null) {
            log.warn("未找到对应的任务，taskId：{}", taskId);
            return R.error("任务不存在，taskId：" + taskId);
@@ -108,16 +109,46 @@
        
        task.setModiTime(new Date());
        
        // 标记任务是否已经被转移到历史表
        boolean taskMovedToHistory = false;
        
        // 如果有status字段，按原有逻辑处理（向后兼容）
        if (!Cools.isEmpty(param.getStatus())) {
            switch (param.getStatus()) {
                case "Assigned":
                    // AGV已派车，确认接收命令，记录确认时间
                    if (task.getPlcStrTime() == null) {
                        task.setPlcStrTime(new Date());
//                        log.info("AGV已确认接收命令，记录确认时间，taskId：{}", taskId);
                    }
                    if (Cools.isEmpty(robotGroup)) {
                        task.setInvWh(param.getRobotName());
                    }
                    break;
                case "Done":
                    task.setWrkSts(9L);
                    // status="Done" 才算搬运完成，结束掉AGV任务（适用于所有任务类型：入库、出库、转移）
                    if (task.getWrkSts() != null && task.getWrkSts() == 8L) {
                        task.setWrkSts(9L);
                        task.setModiTime(new Date());
                        String taskTypeName = "";
                        if (!Cools.isEmpty(param.getKind())) {
                            taskTypeName = param.getKind();
                        }
                        log.info("AGV回调搬运完成（status=Done），完结AGV呼叫单，taskId：{}，任务类型：{}", taskId, taskTypeName);
                        // 保存任务更新后，转移到历史表
                        if (taskService.updateById(task)) {
                            try {
                                agvHandler.moveTaskToHistory(Collections.singletonList(task));
                                taskMovedToHistory = true;
                                log.info("AGV回调搬运完成，已将任务转移到历史表，taskId：{}", taskId);
                            } catch (Exception e) {
                                log.error("AGV回调搬运完成，转移任务到历史表失败，taskId：{}", taskId, e);
                            }
                        }
                    } else {
                        log.debug("AGV回调status=Done，但任务状态不是8（当前状态：{}），不结束任务，taskId：{}", 
                            task.getWrkSts(), taskId);
                    }
                    break;
                case "Failed":
                case "Cancelled":
@@ -126,18 +157,26 @@
            }
        }
        
        // 根据任务类型进行相应处理
        // 根据任务类型进行相应处理（记录日志，但不在此处结束任务，任务结束统一由status="Done"处理）
        if (!Cools.isEmpty(param.getKind())) {
            String kind = param.getKind();
            if ("货物转运".equals(kind)) {
                log.info("处理货物转运任务，taskId：{}", taskId);
            } else if ("实托入库".equals(kind)) {
                log.info("处理实托入库任务，taskId：{}", taskId);
                log.info("处理货物转运任务，taskId：{}，status：{}", taskId, param.getStatus());
            } else if ("实托入库".equals(kind) || "空托入库".equals(kind)) {
                log.info("处理入库任务，taskId：{}，status：{}", taskId, param.getStatus());
                // 注意：任务结束统一由 status="Done" 处理，此处不再重复处理
            } else if ("实托出库".equals(kind)) {
                log.info("处理实托出库任务，taskId：{}", taskId);
                log.info("处理实托出库任务，taskId：{}，status：{}", taskId, param.getStatus());
                // 注意：任务结束统一由 status="Done" 处理，此处不再重复处理
            }
        }
        
        // 如果任务已经被转移到历史表，直接返回成功
        if (taskMovedToHistory) {
            log.info("AGV任务回调处理成功，任务已转移到历史表，taskId：{}", taskId);
            return R.ok();
        }
        
        // 保存任务更新
        if (!taskService.updateById(task)) {
            log.error("更新任务失败，taskId：{}", taskId);