folder tree

backend/src/routes/documents.rs

@@ -4,7 +4,7 @@ use axum::extract::{Json, Multipart, Path, Query, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use chrono::{DateTime, NaiveDateTime, Utc};
-use diesel::dsl::{exists, sql};
+use diesel::dsl::{exists, not, sql};
 use diesel::{prelude::*, result::DatabaseErrorKind, select, sql_types::Text, OptionalExtension};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -467,44 +467,70 @@ pub async fn list_documents(
     }
 
     if let Some(tags_param) = tags_param.as_ref() {
-        let tag_ids: Result<Vec<Uuid>, _> = tags_param
-            .split(',')
-            .map(|s| Uuid::parse_str(s.trim()))
-            .collect();
+        if tags_param.trim().eq_ignore_ascii_case("none") {
+            let docs_without_tags: Vec<Uuid> = documents::table
+                .filter(documents::tenant_id.eq(tenant_id))
+                .filter(documents::deleted_at.is_null())
+                .filter(not(exists(
+                    document_tags::table.filter(document_tags::document_id.eq(documents::id)),
+                )))
+                .select(documents::id)
+                .load(&mut conn)?;
 
-        if let Ok(ids) = tag_ids {
-            if !ids.is_empty() {
-                let mut doc_id_set: Option<HashSet<Uuid>> = None;
-                for tag_id in &ids {
-                    let docs_for_tag: Vec<Uuid> = document_tags::table
-                        .filter(document_tags::tag_id.eq(*tag_id))
-                        .select(document_tags::document_id)
-                        .load(&mut conn)?;
-                    let docs_set: HashSet<Uuid> = docs_for_tag.into_iter().collect();
-                    doc_id_set = Some(match doc_id_set {
-                        Some(existing) => existing.intersection(&docs_set).cloned().collect(),
-                        None => docs_set,
-                    });
+            let docs_set: HashSet<Uuid> = docs_without_tags.into_iter().collect();
 
-                    if let Some(ref set) = doc_id_set {
-                        if set.is_empty() {
-                            break;
+            if docs_set.is_empty() {
+                return Ok(Json(vec![]));
+            }
+
+            let new_filter = match &filter_ids {
+                Some(existing) => existing.intersection(&docs_set).copied().collect(),
+                None => docs_set,
+            };
+
+            filter_ids = Some(new_filter);
+        } else {
+            let tag_ids: Result<Vec<Uuid>, _> = tags_param
+                .split(',')
+                .map(|s| Uuid::parse_str(s.trim()))
+                .collect();
+
+            if let Ok(ids) = tag_ids {
+                if !ids.is_empty() {
+                    let mut doc_id_set: Option<HashSet<Uuid>> = None;
+                    for tag_id in &ids {
+                        let docs_for_tag: Vec<Uuid> = document_tags::table
+                            .filter(document_tags::tag_id.eq(*tag_id))
+                            .select(document_tags::document_id)
+                            .load(&mut conn)?;
+                        let docs_set: HashSet<Uuid> = docs_for_tag.into_iter().collect();
+                        doc_id_set = Some(match doc_id_set {
+                            Some(existing) => existing.intersection(&docs_set).cloned().collect(),
+                            None => docs_set,
+                        });
+
+                        if let Some(ref set) = doc_id_set {
+                            if set.is_empty() {
+                                break;
+                            }
                         }
                     }
+
+                    let matching_doc_ids: HashSet<Uuid> = doc_id_set.unwrap_or_default();
+
+                    if matching_doc_ids.is_empty() {
+                        return Ok(Json(vec![]));
+                    }
+
+                    let new_filter = match &filter_ids {
+                        Some(existing) => {
+                            existing.intersection(&matching_doc_ids).copied().collect()
+                        }
+                        None => matching_doc_ids.clone(),
+                    };
+
+                    filter_ids = Some(new_filter);
                 }
-
-                let matching_doc_ids: HashSet<Uuid> = doc_id_set.unwrap_or_default();
-
-                if matching_doc_ids.is_empty() {
-                    return Ok(Json(vec![]));
-                }
-
-                let new_filter = match &filter_ids {
-                    Some(existing) => existing.intersection(&matching_doc_ids).copied().collect(),
-                    None => matching_doc_ids.clone(),
-                };
-
-                filter_ids = Some(new_filter);
             }
         }
     }