Add indexUid filtering on the /tasks route

meilisearch-http/src/lib.rs

@@ -2,7 +2,7 @@
 #[macro_use]
 pub mod error;
 pub mod analytics;
-mod task;
+pub mod task;
 #[macro_use]
 pub mod extractors;
 pub mod helpers;

meilisearch-http/src/routes/tasks.rs

@@ -2,21 +2,33 @@ use actix_web::{web, HttpRequest, HttpResponse};
 use meilisearch_error::ResponseError;
 use meilisearch_lib::tasks::task::TaskId;
 use meilisearch_lib::tasks::TaskFilter;
-use meilisearch_lib::MeiliSearch;
+use meilisearch_lib::{IndexUid, MeiliSearch};
+use serde::Deserialize;
+use serde_cs::vec::CS;
 use serde_json::json;
 
 use crate::analytics::Analytics;
 use crate::extractors::authentication::{policies::*, GuardedData};
 use crate::extractors::sequential_extractor::SeqHandler;
-use crate::task::{TaskListView, TaskView};
+use crate::task::{TaskListView, TaskStatus, TaskType, TaskView};
 
 pub fn configure(cfg: &mut web::ServiceConfig) {
     cfg.service(web::resource("").route(web::get().to(SeqHandler(get_tasks))))
         .service(web::resource("/{task_id}").route(web::get().to(SeqHandler(get_task))));
 }
 
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct TasksFilter {
+    #[serde(rename = "type")]
+    type_: Option<CS<TaskType>>,
+    status: Option<CS<TaskStatus>>,
+    index_uid: Option<CS<IndexUid>>,
+}
+
 async fn get_tasks(
     meilisearch: GuardedData<ActionPolicy<{ actions::TASKS_GET }>, MeiliSearch>,
+    params: web::Query<TasksFilter>,
     req: HttpRequest,
     analytics: web::Data<dyn Analytics>,
 ) -> Result<HttpResponse, ResponseError> {
@@ -26,15 +38,34 @@ async fn get_tasks(
         Some(&req),
     );
 
+    let TasksFilter {
+        type_,
+        status,
+        index_uid,
+    } = params.into_inner();
+
     let search_rules = &meilisearch.filters().search_rules;
-    let filters = if search_rules.is_index_authorized("*") {
-        None
-    } else {
-        let mut filters = TaskFilter::default();
-        for (index, _policy) in search_rules.clone() {
-            filters.filter_index(index);
+    let filters = match index_uid {
+        Some(indexes) => {
+            let mut filters = TaskFilter::default();
+            for name in indexes.into_inner() {
+                if search_rules.is_index_authorized(&name) {
+                    filters.filter_index(name.to_string());
+                }
+            }
+            Some(filters)
+        }
+        None => {
+            if search_rules.is_index_authorized("*") {
+                None
+            } else {
+                let mut filters = TaskFilter::default();
+                for (index, _policy) in search_rules.clone() {
+                    filters.filter_index(index);
+                }
+                Some(filters)
+            }
         }
-        Some(filters)
     };
 
     let tasks: TaskListView = meilisearch

meilisearch-http/src/task.rs

@@ -1,4 +1,5 @@
 use std::fmt::Write;
+use std::str::FromStr;
 use std::write;
 
 use meilisearch_error::ResponseError;
@@ -8,14 +9,14 @@ use meilisearch_lib::tasks::batch::BatchId;
 use meilisearch_lib::tasks::task::{
     DocumentDeletion, Task, TaskContent, TaskEvent, TaskId, TaskResult,
 };
-use serde::{Serialize, Serializer};
+use serde::{Deserialize, Serialize, Serializer};
 use time::{Duration, OffsetDateTime};
 
 use crate::AUTOBATCHING_ENABLED;
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-enum TaskType {
+pub enum TaskType {
     IndexCreation,
     IndexUpdate,
     IndexDeletion,
@@ -50,15 +51,47 @@ impl From<TaskContent> for TaskType {
     }
 }
 
-#[derive(Debug, Serialize)]
+impl FromStr for TaskType {
+    type Err = &'static str;
+
+    fn from_str(status: &str) -> Result<Self, &'static str> {
+        match status {
+            "indexCreation" => Ok(TaskType::IndexCreation),
+            "indexUpdate" => Ok(TaskType::IndexUpdate),
+            "indexDeletion" => Ok(TaskType::IndexDeletion),
+            "documentAddition" => Ok(TaskType::DocumentAddition),
+            "documentPartial" => Ok(TaskType::DocumentPartial),
+            "documentDeletion" => Ok(TaskType::DocumentDeletion),
+            "settingsUpdate" => Ok(TaskType::SettingsUpdate),
+            "clearAll" => Ok(TaskType::ClearAll),
+            _ => Err("invalid task type value"),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-enum TaskStatus {
+pub enum TaskStatus {
     Enqueued,
     Processing,
     Succeeded,
     Failed,
 }
 
+impl FromStr for TaskStatus {
+    type Err = &'static str;
+
+    fn from_str(status: &str) -> Result<Self, &'static str> {
+        match status {
+            "enqueued" => Ok(TaskStatus::Enqueued),
+            "processing" => Ok(TaskStatus::Processing),
+            "succeeded" => Ok(TaskStatus::Succeeded),
+            "failed" => Ok(TaskStatus::Failed),
+            _ => Err("invalid task status value"),
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 #[allow(clippy::large_enum_variant)]