Implements the get all batches route with filters working

crates/meilisearch/src/routes/batches.rs

@@ -2,25 +2,24 @@ use actix_web::{
     web::{self, Data},
     HttpResponse,
 };
+use deserr::actix_web::AwebQueryParameter;
 use index_scheduler::{IndexScheduler, Query};
 use meilisearch_types::{
-    batches::BatchId, error::ResponseError, keys::actions, task_view::TaskView,
+    batch_view::BatchView, batches::BatchId, deserr::DeserrQueryParamError, error::ResponseError,
+    keys::actions,
 };
+use serde::Serialize;
 
 use crate::extractors::{authentication::GuardedData, sequential_extractor::SeqHandler};
 
-use super::ActionPolicy;
+use super::{tasks::TasksFilterQuery, ActionPolicy};
 
 pub fn configure(cfg: &mut web::ServiceConfig) {
-    cfg
-        // .service(
-        //     web::resource("")
-        //         .route(web::get().to(SeqHandler(get_tasks)))
-        // )
+    cfg.service(web::resource("").route(web::get().to(SeqHandler(get_batches))))
         .service(web::resource("/{batch_id}").route(web::get().to(SeqHandler(get_batch))));
 }
 
-async fn get_task(
+async fn get_batch(
     index_scheduler: GuardedData<ActionPolicy<{ actions::TASKS_GET }>, Data<IndexScheduler>>,
     batch_uid: web::Path<String>,
 ) -> Result<HttpResponse, ResponseError> {
@@ -37,12 +36,45 @@ async fn get_task(
 
     let query = index_scheduler::Query { uids: Some(vec![batch_uid]), ..Query::default() };
     let filters = index_scheduler.filters();
-    let (tasks, _) = index_scheduler.get_tasks_from_authorized_indexes(query, filters)?;
+    let (batches, _) = index_scheduler.get_batches_from_authorized_indexes(query, filters)?;
 
-    if let Some(task) = tasks.first() {
-        let task_view = TaskView::from_task(task);
+    if let Some(batch) = batches.first() {
+        let task_view = BatchView::from_batch(batch);
         Ok(HttpResponse::Ok().json(task_view))
     } else {
         Err(index_scheduler::Error::TaskNotFound(batch_uid).into())
     }
 }
+
+#[derive(Debug, Serialize)]
+pub struct AllBatches {
+    results: Vec<BatchView>,
+    total: u64,
+    limit: u32,
+    from: Option<u32>,
+    next: Option<u32>,
+}
+
+async fn get_batches(
+    index_scheduler: GuardedData<ActionPolicy<{ actions::TASKS_GET }>, Data<IndexScheduler>>,
+    params: AwebQueryParameter<TasksFilterQuery, DeserrQueryParamError>,
+) -> Result<HttpResponse, ResponseError> {
+    let mut params = params.into_inner();
+    // We +1 just to know if there is more after this "page" or not.
+    params.limit.0 = params.limit.0.saturating_add(1);
+    let limit = params.limit.0;
+    let query = params.into_query();
+
+    let filters = index_scheduler.filters();
+    let (tasks, total) = index_scheduler.get_batches_from_authorized_indexes(query, filters)?;
+    let mut results: Vec<_> = tasks.iter().map(BatchView::from_batch).collect();
+
+    // If we were able to fetch the number +1 tasks we asked
+    // it means that there is more to come.
+    let next = if results.len() == limit as usize { results.pop().map(|t| t.uid) } else { None };
+
+    let from = results.first().map(|t| t.uid);
+    let tasks = AllBatches { results, limit: limit.saturating_sub(1), total, from, next };
+
+    Ok(HttpResponse::Ok().json(tasks))
+}

crates/meilisearch/src/routes/mod.rs

@@ -33,6 +33,7 @@ pub mod tasks;
 
 pub fn configure(cfg: &mut web::ServiceConfig) {
     cfg.service(web::scope("/tasks").configure(tasks::configure))
+        .service(web::scope("/batches").configure(batches::configure))
         .service(web::resource("/health").route(web::get().to(get_health)))
         .service(web::scope("/logs").configure(logs::configure))
         .service(web::scope("/keys").configure(api_key::configure))

crates/meilisearch/src/routes/tasks.rs

@@ -70,7 +70,7 @@ pub struct TasksFilterQuery {
 }
 
 impl TasksFilterQuery {
-    fn into_query(self) -> Query {
+    pub(crate) fn into_query(self) -> Query {
         Query {
             limit: Some(self.limit.0),
             from: self.from.as_deref().copied(),