订单状态更新

guyue

1 天以前 00c46e6daca9f068a86ef0d3571a2a206628c328

订单状态更新

 src/main/java/com/linghu/controller/CollectController.java

@@ -69,6 +69,8 @@
    private TypeService typeService;
    @Autowired
    private UserService userService;
    @Autowired
    private OrderService orderService;


 /*   @PostMapping("/search")
@@ -231,11 +233,6 @@
                           searchTaskRequest.getConfig().getMax_concurrent_users() : 3;
                   List<List<UserDto>> userBatches = splitUsersIntoBatches(searchTaskRequest.getUsers(), maxConcurrentUsers,keywordId);

                   // 获取 keywordId

                   //分割

     
                   return Flux.fromIterable(userBatches)
                           .flatMap(batch -> {
                               SearchTaskRequest batchRequest = new SearchTaskRequest();
@@ -282,7 +279,9 @@
        return Mono.fromRunnable(() -> {
                    boolean success = keywordTaskService.saveOrUpdateBatch(keywordTasks);
                    if (!success) {
                        throw new RuntimeException("保存关键词任务关联失败");
//                        throw new RuntimeException("保存关键词任务关联失败");
                        // 添加异常处理
                        Mono.error( new RuntimeException("保存关键词任务关联失败"));
                    }
                })
                .doFinally(signalType -> log.info("成功保存 {} 个关键词任务关联", keywordTasks.size()))
@@ -291,12 +290,12 @@

    private List<List<UserDto>> splitUsersIntoBatches(List<UserDto> users, int batchSize,Integer keywordId) {

        Keyword keyword = keywordService.getById(keywordId);
  /*      Keyword keyword = keywordService.getById(keywordId);
        if (null==keyword.getNum()){
            keyword.setNum(0);
        }
        keyword.setNum(keyword.getNum()+1);
        keywordService.updateById(keyword);
        keywordService.updateById(keyword);*/

        List<List<UserDto>> batches = new ArrayList<>();
        for (int i = 0; i < users.size(); i += batchSize) {
@@ -324,6 +323,21 @@
                                    updateWrapper.set(Keyword::getStatus, "submitted");
                                    updateWrapper.set(Keyword::getTask_id, taskResponse.getTask_id());
                                    keywordService.update(updateWrapper);
                                    //设置轮数
                                    Keyword keyword = keywordService.getById(batchRequest.getKeyword_id());
                                    if (null==keyword.getNum()){
                                        keyword.setNum(0);
                                    }
                                    keyword.setNum(keyword.getNum()+1);
                                    keywordService.updateById(keyword);
                                    //设置订单进入采集状态
                                    LambdaUpdateWrapper<Orders> updateOrderWrapper = new LambdaUpdateWrapper<>();
                                    updateOrderWrapper.eq(Orders::getOrder_id, keyword.getOrder_id()) // 确保字段名正确
                                            .set(Orders::getStatus, 2); // 直接设置状态值

                                    boolean success = orderService.update(updateOrderWrapper);
                                    log.info("订单状态更新结果: {}", success ? "成功" : "失败");

                                }).subscribeOn(Schedulers.boundedElastic()) // 在弹性线程池执行
                                .thenReturn(taskResponse);
                    }
@@ -559,12 +573,43 @@
                        // 不跳出循环，继续检查是否存在 canceled
                    }
                }

// 更新关键词状态
                if (!finalStatus.equals(keyword.getStatus())) {
                    keyword.setStatus(finalStatus);
                    keywordService.updateById(keyword);
                    String orderId = keyword.getOrder_id();
                    if (orderId == null || orderId.isEmpty()) {
                        System.out.println("关键词[" + keyword.getKeyword_id() + "]未关联订单，跳过订单状态更新");
                        return;
                    }

                    // 2. 查询该订单下的所有关键词
                    LambdaQueryWrapper<Keyword> orderKeywordsWrapper = new LambdaQueryWrapper<>();
                    orderKeywordsWrapper.eq(Keyword::getOrder_id, orderId);
                    List<Keyword> orderKeywords = keywordService.list(orderKeywordsWrapper);

                    if (orderKeywords.isEmpty()) {
                        System.out.println("订单[" + orderId + "]下无关键词，跳过状态更新");
                        return;
                    }

                    // 3. 检查所有关键词的状态是否均为 completed 或 false
                    boolean allValid = orderKeywords.stream()
                            .allMatch(k -> "completed".equals(k.getStatus()) || "false".equals(k.getStatus()));

                    // 4. 若所有关键词状态均有效，更新订单状态为3
                    if (allValid) {
                        Orders orders = orderService.getById(orderId);
                        if (orders != null) {
                            orders.setStatus(3); // 假设Orders有Integer类型的status字段
                            orderService.updateById(orders);
                            System.out.println("订单[" + orderId + "]所有关键词状态符合条件，已更新状态为3");
                        } else {
                            System.out.println("未找到订单[" + orderId + "]，无法更新状态");
                        }
                    }
                }
                Orders orders = orderService.getById(keyword.getOrder_id());

                // 2. 批量查询所有问题
                LambdaQueryWrapper<Question> queryWrapper = new LambdaQueryWrapper<>();

 src/main/java/com/linghu/model/entity/Keyword.java

@@ -41,7 +41,7 @@
    private String task_id;

    /**
     * 任务状态（notSubmitted：待处理；submitted：已提交 ；  ）           
     * 任务状态（notSubmitted：待处理；submitted：已提交 ； completed: 已完成 ，false：异常  ）
     */
    private String status;