启动扫描报错修复

chen.lin

1 天以前 4c1ac97d065cd4f179fbe2a63970d447c0c54c62

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

@@ -428,7 +428,7 @@
                for (SyncLocsDto dto : dtos) {
                    Loc loc = new Loc();
                    String string = new Random().nextInt(10000000) + "";
                    Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, string));
                    Loc one = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, dto.getLocNo()));
                    if (!Objects.isNull(one)) {
                        string = new Random().nextInt(10000000) + "";
                    }
@@ -437,11 +437,11 @@
                            .setRow(dto.getRow())
                            .setLev(dto.getLev())
                            .setId(null)
                            .setAreaId(41L)
                            .setWarehouseId(27L)
                            .setAreaId(42L)
                            .setWarehouseId(29L)
                            .setBarcode(string)
                            .setCol(dto.getBay())
                            .setType(dto.getLocType())
                            .setType(dto.getLocType().equals("16") ? "17" : "15")
                            .setStatus(dto.getStatusBool())
                            .setUseStatus(LocStsType.getLocSts(dto.getLocSts()));
                    if (!locService.save(loc)) {
@@ -463,13 +463,31 @@
    @Override
    public R receiveExMsg(ExMsgParams params) {
        if (Objects.isNull(params)) {
            log.error("RCS回调为空！");
            return R.error("参数不能为空！！");
        }
        log.info("========== 接收RCS回调 ==========");
        log.info("任务编号：{}，事件类型：{}", params.getSeqNum(), params.getEventType());
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, params.getSeqNum()));
        if (Objects.isNull(task)) {
            throw new CoolException("任务不存在可已结束！！");
            log.error("任务不存在或已结束！任务编号：{}", params.getSeqNum());
            throw new CoolException("任务不存在或已结束！！");
        }
        /**取箱完成*/
        log.info("查询到任务 - 任务编码：{}，任务类型：{}，当前状态：{}", 
                task.getTaskCode(), task.getTaskType(), task.getTaskStatus());

        /**料箱搬运中， 修改站点状态*/
//        if (params.getEventType().equals(CallBackEvent.CALL_BACK_EVENT_OBIT.event)) {
//            if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)
//                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)
//                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)
//                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type)
//                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_IN.type)
//                    || task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
//
//            }
//            /**取箱完成， 修改任务状态*/
//        } else
        if (params.getEventType().equals(CallBackEvent.CALL_BACK_EVENT_END.event)) {
            if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)
@@ -477,48 +495,94 @@
                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                        .set(Task::getTaskStatus, TaskStsType.COMPLETE_IN.id))) {
                    throw new CoolException("任务状态修改失败！！");
                }

                if (!task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                    BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getOrgSite()));
                    if (Objects.isNull(station)) {
                        log.error("入库站点不存在 - 站点名称：{}，任务编码：{}", task.getOrgSite(), task.getTaskCode());
                        throw new CoolException("数据错误，站点不存在！！");
                    }
                    log.info("查询到入库站点 - 站点名称：{}，站点类型：{}，当前状态：{}", 
                            station.getStationName(), station.getType(), station.getUseStatus());
                    if (station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                        log.info("更新入库站点状态 - 站点名称：{}，新状态：{}", station.getStationName(), LocStsType.LOC_STS_TYPE_O.type);
                        station.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
                        if (!basStationService.updateById(station)) {
                            log.error("入库站点状态修改失败 - 站点名称：{}", station.getStationName());
                            throw new CoolException("站点状态修改失败！！");
                        }
                        log.info("入库站点状态更新成功 - 站点名称：{}", station.getStationName());
                    }
                }

                log.info("准备更新入库任务状态 - 任务编码：{}，当前状态：{}，目标状态：{}", 
                        task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_IN.id);
                
                // 如果任务状态已经大于等于目标状态，跳过更新
                if (task.getTaskStatus() >= TaskStsType.COMPLETE_IN.id) {
                    log.warn("入库任务状态已大于等于目标状态，跳过更新 - 任务编码：{}，当前状态：{}，目标状态：{}", 
                            task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_IN.id);
                } else {
                    boolean updated = taskService.update(new LambdaUpdateWrapper<Task>()
                            .lt(Task::getTaskStatus, TaskStsType.COMPLETE_IN.id)
                            .eq(Task::getTaskCode, task.getTaskCode())
                            .set(Task::getTaskStatus, TaskStsType.COMPLETE_IN.id));
                    if (!updated) {
                        log.error("入库任务状态修改失败 - 任务编码：{}，当前状态：{}，目标状态：{}，可能任务状态已大于等于目标状态", 
                                task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_IN.id);
                        throw new CoolException("任务状态修改失败！！当前任务状态：" + task.getTaskStatus() + "，目标状态：" + TaskStsType.COMPLETE_IN.id);
                    }
                    log.info("入库任务状态更新成功 - 任务编码：{}", task.getTaskCode());
                }
            } else if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)) {
                if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                        .set(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id))) {
                    throw new CoolException("任务状态修改失败！！");
                }

                /**修改出库站点状态*/
                BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                        .eq(BasStation::getStationName, task.getTargSite()));
                if (Objects.isNull(station)) {
                    log.error("出库站点不存在 - 站点名称：{}，任务编码：{}", task.getTargSite(), task.getTaskCode());
                    throw new CoolException("数据错误，站点不存在！！");
                }
                log.info("查询到出库站点 - 站点名称：{}，站点类型：{}，当前状态：{}", 
                        station.getStationName(), station.getType(), station.getUseStatus());
                if (station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                    log.info("更新出库站点状态 - 站点名称：{}，新状态：{}", station.getStationName(), LocStsType.LOC_STS_TYPE_F.type);
                    station.setUseStatus(LocStsType.LOC_STS_TYPE_F.type);
                    if (!basStationService.updateById(station)) {
                        log.error("出库站点状态修改失败 - 站点名称：{}", station.getStationName());
                        throw new CoolException("站点状态修改失败！！");
                    }
                    log.info("出库站点状态更新成功 - 站点名称：{}", station.getStationName());
                }
                log.info("准备更新出库任务状态 - 任务编码：{}，当前状态：{}，目标状态：{}", 
                        task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_OUT.id);
                
                // 如果任务状态已经大于等于目标状态，跳过更新
                if (task.getTaskStatus() >= TaskStsType.COMPLETE_OUT.id) {
                    log.warn("出库任务状态已大于等于目标状态，跳过更新 - 任务编码：{}，当前状态：{}，目标状态：{}", 
                            task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_OUT.id);
                } else {
                    boolean updated = taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                            .lt(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id)
                            .set(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id));
                    if (!updated) {
                        log.error("出库任务状态修改失败 - 任务编码：{}，当前状态：{}，目标状态：{}，可能任务状态已大于等于目标状态", 
                                task.getTaskCode(), task.getTaskStatus(), TaskStsType.COMPLETE_OUT.id);
                        throw new CoolException("任务状态修改失败！！当前任务状态：" + task.getTaskStatus() + "，目标状态：" + TaskStsType.COMPLETE_OUT.id);
                    }
                    log.info("出库任务状态更新成功 - 任务编码：{}", task.getTaskCode());
                }
            }
        } else {
            log.warn("未处理的事件类型 - 事件类型：{}，任务编码：{}，任务类型：{}", 
                    params.getEventType(), task.getTaskCode(), task.getTaskType());
        }

        log.info(JSONObject.toJSONString(params));
        log.info("========== RCS回调处理完成 ==========");
        log.info("处理结果：{}", JSONObject.toJSONString(params));
        return R.ok(JSONObject.toJSONString(params));
    }

@@ -531,7 +595,7 @@
    @Override
    public R pubWcsTask(WcsTaskParams params) {
        String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.pubTask;
        log.info("任务下发，请求地址： {}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
        log.info("任务下发，请求地址3： {}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        headers.add("api-version", "v2.0");