组托优化

chen.lin

1 天以前 f99e3966686d3891b814ff28d200b001fcdc8e1e

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

@@ -744,11 +744,14 @@
            }
            BeanUtils.copyProperties(locWorking, locItem);
            locItem.setWorkQty(0.0).setQty(0.0).setLocCode(loc.getCode()).setLocId(loc.getId()).setId(null).setUpdateBy(loginUserId).setUpdateTime(new Date());
            items.add(locItem);
            //数量为零的不入库
            if (locItem.getAnfme().compareTo(0.0) > 0) {
                items.add(locItem);
            }
        }

        if (!locItemService.saveBatch(items)) {
            throw new CoolException("作业库存回写失败！！");
//            throw new CoolException("作业库存回写失败！！");
        }

        TaskItem taskItem = taskItems.stream().findFirst().get();
@@ -774,16 +777,132 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R removeTask(Long[] ids, Long loginUserId) {
        List<Integer> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
        // 先查询所有任务（不限制状态），用于检查RCS任务
        List<Integer> list = Arrays.asList(TaskType.TASK_TYPE_IN.type, TaskType.TASK_TYPE_OUT.type, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type,
                TaskType.TASK_TYPE_CHECK_OUT.type, TaskType.TASK_TYPE_EMPITY_IN.type, TaskType.TASK_TYPE_LOC_MOVE.type,
                TaskType.TASK_TYPE_EMPITY_OUT.type, TaskType.TASK_TYPE_MERGE_OUT.type);
        List<Task> allTasks = this.list(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskType, list)
                .in(Task::getId, (Object[]) ids));
        
        if (allTasks.isEmpty()) {
            throw new CoolException("任务不存在！！");
        }
        
        // 收集需要取消的RCS任务编号和批次编号（不限制状态，只要已下发到RCS就需要取消）
        List<String> rcsTaskCodes = new ArrayList<>();
        String batchNo = null;
        for (Task task : allTasks) {
            // 判断任务是否已下发到RCS
            // 入库任务：状态 >= WCS_EXECUTE_IN(2) 表示已下发
            // 出库任务：状态 >= WCS_EXECUTE_OUT(102) 表示已下发
            boolean isRcsTask = false;
            if (task.getTaskType() < 100) {
                // 入库任务
                if (task.getTaskStatus() >= TaskStsType.WCS_EXECUTE_IN.id) {
                    isRcsTask = true;
                }
            } else {
                // 出库任务
                if (task.getTaskStatus() >= TaskStsType.WCS_EXECUTE_OUT.id) {
                    isRcsTask = true;
                }
            }
            
            if (isRcsTask && StringUtils.isNotBlank(task.getTaskCode())) {
                rcsTaskCodes.add(task.getTaskCode());
                // 获取批次编号，优先使用任务的barcode，如果没有则使用任务编号
                if (StringUtils.isBlank(batchNo)) {
                    if (StringUtils.isNotBlank(task.getBarcode())) {
                        batchNo = task.getBarcode();
                    } else if (StringUtils.isNotBlank(task.getTaskCode())) {
                        // 如果任务没有barcode，使用任务编号作为批次编号
                        batchNo = task.getTaskCode();
                    }
                }
                log.info("任务已下发到RCS，需要取消RCS任务 - 任务ID：{}，任务编号：{}，任务状态：{}，托盘码：{}", 
                        task.getId(), task.getTaskCode(), task.getTaskStatus(), task.getBarcode());
            }
        }
        
        // 如果有任务已下发到RCS，先调用RCS取消接口
        boolean rcsCancelSuccess = false;
        if (!rcsTaskCodes.isEmpty()) {
            try {
                log.info("========== 开始取消RCS任务 ==========");
                log.info("需要取消的RCS任务编号：{}", rcsTaskCodes);
                String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.cancelTask;
                log.info("RCS取消任务请求地址：{}", rcsUrl);
                
                // 如果没有批次编号，使用第一个任务编号作为批次编号
                if (StringUtils.isBlank(batchNo) && !rcsTaskCodes.isEmpty()) {
                    batchNo = rcsTaskCodes.get(0);
                }
                
                Map<String, Object> cancelParams = new HashMap<>();
                cancelParams.put("tasks", rcsTaskCodes);
                if (StringUtils.isNotBlank(batchNo)) {
                    cancelParams.put("batchNo", batchNo);
                }
                
                log.info("RCS取消任务请求参数：{}", JSONObject.toJSONString(cancelParams));
                
                HttpHeaders headers = new HttpHeaders();
                headers.add("Content-Type", "application/json");
                headers.add("api-version", "v2.0");
                HttpEntity<Map<String, Object>> httpEntity = new HttpEntity<>(cancelParams, headers);
                
                long startTime = System.currentTimeMillis();
                ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
                long endTime = System.currentTimeMillis();
                
                log.info("RCS取消任务响应耗时：{}ms", (endTime - startTime));
                log.info("RCS取消任务响应状态码：{}", exchange.getStatusCode());
                log.info("RCS取消任务响应体：{}", exchange.getBody());
                
                if (Objects.isNull(exchange.getBody())) {
                    log.error("RCS取消任务失败：响应体为空");
                    throw new CoolException("RCS取消任务失败：响应体为空");
                }
                
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.coercionConfigDefaults()
                        .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                
                if (result.getCode() == 200) {
                    log.info("========== RCS任务取消成功 ==========");
                    log.info("成功取消的RCS任务编号：{}", rcsTaskCodes);
                    rcsCancelSuccess = true;
                } else {
                    log.error("RCS取消任务失败：{}", result.getMsg());
                    throw new CoolException("RCS取消任务失败：" + result.getMsg());
                }
            } catch (JsonProcessingException e) {
                log.error("RCS取消任务响应解析失败：{}", e.getMessage(), e);
                throw new CoolException("RCS取消任务响应解析失败：" + e.getMessage());
            } catch (Exception e) {
                log.error("RCS取消任务异常：{}", e.getMessage(), e);
                throw new CoolException("RCS取消任务异常：" + e.getMessage());
            }
        }
        
        // 查询符合取消条件的任务（状态为1、101、199）
        List<Integer> allowedStatuses = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id, TaskStsType.WAVE_SEED.id);
        List<Task> tasks = this.list(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskType, list)
                .in(Task::getId, ids)
                .in(Task::getTaskStatus, longs));
        if (tasks.isEmpty()) {
                .in(Task::getId, (Object[]) ids)
                .in(Task::getTaskStatus, allowedStatuses));
        
        // 如果符合取消条件的任务为空，但RCS取消成功，允许继续（可能是任务状态已变更）
        if (tasks.isEmpty() && !rcsCancelSuccess) {
            throw new CoolException("任务已处执行状态不可取消！！");
        }
        
        // 如果符合取消条件的任务为空，但RCS取消成功，记录日志并返回
        if (tasks.isEmpty() && rcsCancelSuccess) {
            log.warn("WMS内部任务状态不符合取消条件，但RCS任务已成功取消 - 任务ID：{}", Arrays.toString(ids));
            return R.ok("RCS任务已取消，WMS内部任务状态已变更");
        }
        for (Task task : tasks) {
            //取消移库任务
@@ -1017,17 +1136,18 @@
                .setBarcode(task.getBarcode())
                .setTaskStatus(TaskStsType.GENERATE_IN.id);

        TaskInParam param = new TaskInParam();
        param.setSourceStaNo(task.getTargSite())
                .setIoType(type)
                .setLocType1(Integer.parseInt(loc.getType()));
//        TaskInParam param = new TaskInParam();
//        param.setSourceStaNo(task.getTargSite())
//                .setIoType(type)
//                .setLocType1(Integer.parseInt(loc.getType()));
        //获取新库位
        InTaskMsgDto locInfo = wcsService.getLocNo(param);
//        InTaskMsgDto locInfo = wcsService.getLocNo(param);

        if (Objects.isNull(locInfo)) {
            throw new CoolException("获取库位失败！！");
        }
        task.setTargLoc(locInfo.getLocNo())
//        if (Objects.isNull(locInfo)) {
//            throw new CoolException("获取库位失败！！");
//        }
        //希日上报物有情况，不需要获取新库位
        task.setTargLoc(task.getOrgLoc())
                .setOrgSite(task.getTargSite());

        if (!this.updateById(task)) {
@@ -1096,26 +1216,25 @@
        List<LocItemWorking> workings = new ArrayList<>();
        List<TaskItem> items = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        items.forEach(taskItem -> {
            if (taskItem.getAnfme() > 0) {
                LocItemWorking itemWorking = new LocItemWorking();
                BeanUtils.copyProperties(taskItem, itemWorking);
                itemWorking.setTaskId(task.getId())
                        .setQty(0.0)
                        .setLocId(loc1.getId())
                        .setLocCode(loc1.getCode());
                workings.add(itemWorking);
            }
            LocItemWorking itemWorking = new LocItemWorking();
            BeanUtils.copyProperties(taskItem, itemWorking);
            itemWorking.setTaskId(task.getId())
                    .setQty(0.0)
                    .setLocId(loc1.getId())
                    .setLocCode(loc1.getCode());
            workings.add(itemWorking);
        });

        if (!locItemWorkingService.saveBatch(workings)) {
            throw new CoolException("临时库存更新失败！！");
        if (!workings.isEmpty()) {
            if (!locItemWorkingService.saveBatch(workings)) {
                throw new CoolException("临时库存更新失败！！");
            }
        }

        loc1.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);

        if (!locService.updateById(loc1)) {
            throw new CoolException("库位预约入库失败！！");
        }
        locService.updateById(loc1);
//        if (!locService.updateById(loc1)) {
//            throw new CoolException("库位预约入库失败！！");
//        }
        return task;
    }

@@ -1127,7 +1246,7 @@
     */
    @Synchronized
    @Transactional(rollbackFor = Exception.class)
    public void complateOutStock(Task task, Long loginUserId) throws Exception {
    public void complateOutStock(Task task, Long loginUserId) {
        if (Objects.isNull(task)) {
            throw new CoolException("参数不能为空！！");
        }
@@ -1224,15 +1343,26 @@
                throw new CoolException(e.getMessage());
            }
        }

        /**修改为库位状态为O.空库*/
        if (!locService.update(new LambdaUpdateWrapper<Loc>()
                .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                .set(Loc::getBarcode, null)
                .set(Loc::getUpdateBy, loginUserId)
                .set(Loc::getUpdateTime, new Date())
                .eq(Loc::getId, loc.getId()))) {
            throw new CoolException("库位状态修改失败！！");
        if (task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type) || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
            /**修改为库位状态为S.预约入库，保留原有库位*/
            if (!locService.update(new LambdaUpdateWrapper<Loc>()
                    .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_S.type)
                    .set(Loc::getBarcode, null)
                    .set(Loc::getUpdateBy, loginUserId)
                    .set(Loc::getUpdateTime, new Date())
                    .eq(Loc::getId, loc.getId()))) {
                throw new CoolException("库位状态修改失败！！");
            }
        } else {
            /**修改为库位状态为O.空库*/
            if (!locService.update(new LambdaUpdateWrapper<Loc>()
                    .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                    .set(Loc::getBarcode, null)
                    .set(Loc::getUpdateBy, loginUserId)
                    .set(Loc::getUpdateTime, new Date())
                    .eq(Loc::getId, loc.getId()))) {
                throw new CoolException("库位状态修改失败！！");
            }
        }

        if (!this.update(new LambdaUpdateWrapper<Task>()
@@ -1388,13 +1518,28 @@
    public void pubTaskToWcs(List<Task> tasks) {
        WcsTaskParams taskParams = new WcsTaskParams();
        List<TaskItemParam> items = new ArrayList<>();
        
        // 设置批次编号（使用第一个任务的barcode，如果为null则使用任务编码）
        String batchNo = null;
        if (!tasks.isEmpty()) {
            Task firstTask = tasks.get(0);
            batchNo = StringUtils.isNotBlank(firstTask.getBarcode()) 
                    ? firstTask.getBarcode() 
                    : firstTask.getTaskCode();
        }
        if (StringUtils.isBlank(batchNo)) {
            // 如果批次编号仍为空，生成一个默认值
            batchNo = "BATCH_" + System.currentTimeMillis();
        }

        taskParams.setBatchNo(batchNo);
        log.info("设置批次编号：{}", batchNo);
        
        tasks.forEach(task -> {
            TaskItemParam itemParam = new TaskItemParam();
            //任务类型，任务编码
            itemParam.setTaskType(RcsTaskType.getTypeDesc(task.getTaskType()))
                    .setSeqNum(task.getTaskCode());
            //主参数
            taskParams.setBatch(task.getBarcode());
            //任务编码（对应seqNum）
            itemParam.setTaskNo(task.getTaskCode());
            itemParam.setPriority(1);
            BasStation station = null;
            if (!task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                station = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getTargSite()));
@@ -1460,28 +1605,50 @@
            }
            items.add(itemParam);
        });
        taskParams.setTaskList(items);
        taskParams.setTasks(items);
        /**任务下发接口*/
        String pubTakUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.pubTask;
        /**RCS基础配置链接*/
        log.info("任务下发，请求地址： {}， 请求参数： {}", pubTakUrl, JSONObject.toJSONString(taskParams));
        log.info("========== 开始下发任务到RCS ==========");
        log.info("RCS请求地址：{}", pubTakUrl);
        log.info("批次编号：{}", batchNo);
        log.info("任务数量：{}", tasks.size());
        log.info("任务列表详情：");
        tasks.forEach(task -> {
            log.info("  - 任务编码：{}，任务类型：{}，源库位：{}，目标库位：{}，源站点：{}，目标站点：{}", 
                    task.getTaskCode(), task.getTaskType(), task.getOrgLoc(), 
                    task.getTargLoc(), task.getOrgSite(), task.getTargSite());
        });
        log.info("请求参数：{}", JSONObject.toJSONString(taskParams));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        headers.add("api-version", "v2.0");
        HttpEntity httpEntity = new HttpEntity(taskParams, headers);
        long startTime = System.currentTimeMillis();
        ResponseEntity<String> exchange = restTemplate.exchange(pubTakUrl, HttpMethod.POST, httpEntity, String.class);
        log.info("任务下发后，响应结果： {}", exchange);
        long endTime = System.currentTimeMillis();
        log.info("RCS响应耗时：{}ms", (endTime - startTime));
        log.info("RCS响应状态码：{}", exchange.getStatusCode());
        log.info("RCS响应头：{}", exchange.getHeaders());
        log.info("RCS响应体：{}", exchange.getBody());
        if (Objects.isNull(exchange.getBody())) {
            throw new CoolException("任务下发失败！！");
            log.error("========== RCS任务下发失败 ==========");
            log.error("RCS响应体为空，无法解析响应结果");
            log.error("请求地址：{}", pubTakUrl);
            log.error("请求参数：{}", JSONObject.toJSONString(taskParams));
            throw new CoolException("任务下发失败，RCS响应体为空！！");
        } else {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.coercionConfigDefaults()
                        .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                log.info("RCS响应解析结果 - code：{}，msg：{}，data：{}", 
                        result.getCode(), result.getMsg(), result.getData());
                if (result.getCode() == 200) {
                    log.info("RCS任务下发成功，开始更新任务状态");
                    tasks.forEach(task -> {

                        log.info("更新任务状态 - 任务编码：{}，任务类型：{}", task.getTaskCode(), task.getTaskType());
                        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)
@@ -1494,10 +1661,12 @@
                                throw new CoolException("站点不存在！！");
                            }

                            log.info("更新入库任务状态 - 任务编码：{}，新状态：{}", task.getTaskCode(), TaskStsType.WCS_EXECUTE_IN.id);
                            if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                                    .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_IN.id))) {
                                throw new CoolException("任务状态修改失败！！");
                            }
                            log.info("入库任务状态更新成功 - 任务编码：{}", task.getTaskCode());
                            /**排除移库功能*/
                            if (!task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                                /**如果是普通站点，修改站点状态为出库预约*/
@@ -1518,10 +1687,12 @@
                                throw new CoolException("站点不存在！！");
                            }

                            log.info("更新出库任务状态 - 任务编码：{}，新状态：{}", task.getTaskCode(), TaskStsType.WCS_EXECUTE_OUT.id);
                            if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                                    .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_OUT.id))) {
                                throw new CoolException("任务状态修改失败！！");
                            }
                            log.info("出库任务状态更新成功 - 任务编码：{}", task.getTaskCode());
                            /**如果是普通站点，修改站点状态为入库预约*/
                            if (curSta.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                                curSta.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);
@@ -1531,15 +1702,27 @@
                            }
                        }
                    });
                    log.info("========== RCS任务下发完成，共{}个任务状态已更新 ==========", tasks.size());
                } else {
                    log.error(JSONObject.toJSONString(result));
                    log.error("========== RCS任务下发失败 ==========");
                    log.error("RCS返回错误 - code：{}，msg：{}，data：{}", 
                            result.getCode(), result.getMsg(), result.getData());
                    log.error("失败的任务列表：");
                    tasks.forEach(task -> {
                        log.error("  - 任务编码：{}，任务类型：{}", task.getTaskCode(), task.getTaskType());
                    });
//                    throw new CoolException("任务下发失败！！");
                }
            } catch (JsonProcessingException e) {
                throw new CoolException(e.getMessage());
                log.error("========== RCS任务下发异常 ==========");
                log.error("解析RCS响应失败，响应体：{}", exchange.getBody(), e);
                throw new CoolException("解析RCS响应失败：" + e.getMessage());
            } catch (Exception e) {
                log.error("========== RCS任务下发异常 ==========");
                log.error("任务下发过程中发生异常", e);
                throw e;
            }
        }

    }/**