nils/papercrate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

document types

Browse Source
This commit is contained in:
nils
2025-10-31 00:13:16 +01:00
parent 3941ec61d3
commit 813ce24aeb
19 changed files with 1714 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/routes/document_types.rs
+142
View File
@@ -0,0 +1,142 @@
use axum::{
extract::{Json, Path},
http::StatusCode,
};
use diesel::prelude::*;
use serde::Deserialize;
use utoipa::ToSchema;
use uuid::Uuid;
use crate::{
auth::TenantScopedConn,
error::{AppError, AppResult},
models::{DocumentType, NewDocumentType},
schema::document_types,
};
use super::documents::DocumentTypeResponse;
#[derive(Deserialize, ToSchema)]
pub struct CreateDocumentTypeRequest {
pub name: String,
}
#[derive(Deserialize, ToSchema)]
pub struct UpdateDocumentTypeRequest {
pub name: Option<String>,
}
pub async fn list_document_types(
TenantScopedConn {
mut conn,
tenant_id,
..
}: TenantScopedConn,
) -> AppResult<Json<Vec<DocumentTypeResponse>>> {
let types: Vec<DocumentType> = document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.order(document_types::name.asc())
.load(&mut conn)?;
Ok(Json(
types.into_iter().map(DocumentTypeResponse::from).collect(),
))
}
pub async fn create_document_type(
TenantScopedConn {
mut conn,
tenant_id,
..
}: TenantScopedConn,
Json(payload): Json<CreateDocumentTypeRequest>,
) -> AppResult<(StatusCode, Json<DocumentTypeResponse>)> {
let name = payload.name.trim();
if name.is_empty() {
return Err(AppError::bad_request("name must not be empty"));
}
let new_type = NewDocumentType {
id: Uuid::new_v4(),
tenant_id,
name: name.to_string(),
};
match diesel::insert_into(document_types::table)
.values(&new_type)
.get_result::<DocumentType>(&mut conn)
{
Ok(created) => Ok((
StatusCode::CREATED,
Json(DocumentTypeResponse::from(created)),
)),
Err(diesel::result::Error::DatabaseError(
diesel::result::DatabaseErrorKind::UniqueViolation,
_,
)) => Err(
AppError::conflict("a document type with that name already exists")
.with_code("duplicate_document_type"),
),
Err(err) => Err(AppError::from(err)),
}
}
pub async fn update_document_type(
Path(document_type_id): Path<Uuid>,
TenantScopedConn {
mut conn,
tenant_id,
..
}: TenantScopedConn,
Json(payload): Json<UpdateDocumentTypeRequest>,
) -> AppResult<Json<DocumentTypeResponse>> {
let name = payload
.name
.as_ref()
.map(|value| value.trim())
.filter(|value| !value.is_empty())
.ok_or_else(|| AppError::bad_request("name must be provided and not empty"))?;
let target = document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.find(document_type_id);
let update_result = diesel::update(target.clone())
.set(document_types::name.eq(name))
.get_result::<DocumentType>(&mut conn);
match update_result {
Ok(updated) => Ok(Json(DocumentTypeResponse::from(updated))),
Err(diesel::result::Error::NotFound) => Err(AppError::not_found()),
Err(diesel::result::Error::DatabaseError(
diesel::result::DatabaseErrorKind::UniqueViolation,
_,
)) => Err(
AppError::conflict("a document type with that name already exists")
.with_code("duplicate_document_type"),
),
Err(err) => Err(AppError::from(err)),
}
}
pub async fn delete_document_type(
Path(document_type_id): Path<Uuid>,
TenantScopedConn {
mut conn,
tenant_id,
..
}: TenantScopedConn,
) -> AppResult<StatusCode> {
let affected = diesel::delete(
document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.find(document_type_id),
)
.execute(&mut conn)?;
if affected == 0 {
return Err(AppError::not_found());
}
Ok(StatusCode::NO_CONTENT)
}
backend/src/routes/documents.rs
+140 -4
View File
@@ -8,7 +8,7 @@ use axum::http::StatusCode;
use axum::response::IntoResponse;
use chrono::{DateTime, NaiveDateTime, Utc};
use diesel::dsl::exists;
use diesel::{prelude::*, result::DatabaseErrorKind, select};
use diesel::{prelude::*, result::DatabaseErrorKind, select, OptionalExtension};
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use sha2::{Digest, Sha256};
@@ -37,12 +37,13 @@ use crate::documents::{
use crate::error::{AppError, AppResult};
use crate::jobs::{enqueue_job, JOB_ANALYZE_DOCUMENT, JOB_INDEX_DOCUMENT_TEXT};
use crate::models::{
Document, DocumentAsset, DocumentAssetObject, DocumentVersion, NewDocument, NewDocumentTag,
NewDocumentVersion, Tag,
Document, DocumentAsset, DocumentAssetObject, DocumentType, DocumentVersion, NewDocument,
NewDocumentTag, NewDocumentVersion, Tag,
};
use crate::schema::{
document_asset_objects, document_assets, document_correspondents, document_tags,
document_versions, documents, folders, refresh_tokens::dsl as refresh_dsl, tags,
document_types, document_versions, documents, folders, refresh_tokens::dsl as refresh_dsl,
tags,
};
use crate::state::AppState;
use crate::utils::{
@@ -65,6 +66,7 @@ pub struct DocumentListQuery {
pub query: Option<String>,
pub tags: Option<String>,
pub correspondents: Option<String>,
pub document_types: Option<String>,
#[serde(default = "default_document_status_filter")]
pub status: DocumentStatusFilter,
}
@@ -128,6 +130,21 @@ impl From<Tag> for TagResponse {
}
}
#[derive(Clone, Serialize, Deserialize, ToSchema)]
pub struct DocumentTypeResponse {
pub id: Uuid,
pub name: String,
}
impl From<DocumentType> for DocumentTypeResponse {
fn from(value: DocumentType) -> Self {
Self {
id: value.id,
name: value.name,
}
}
}
#[derive(Serialize, ToSchema)]
pub struct DocumentResponse {
pub id: Uuid,
@@ -141,6 +158,10 @@ pub struct DocumentResponse {
pub deleted_at: Option<String>,
pub issued_at: Option<String>,
pub metadata: Value,
#[serde(skip_serializing_if = "Option::is_none")]
pub document_type_id: Option<Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub document_type: Option<DocumentTypeResponse>,
pub tags: Vec<TagResponse>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub correspondents: Vec<DocumentCorrespondentResponse>,
@@ -181,6 +202,9 @@ pub struct UpdateDocumentRequest {
#[serde(default)]
#[schema(nullable)]
pub metadata: Option<DocumentMetadataUpdate>,
#[serde(default)]
#[schema(nullable, value_type = Option<Uuid>)]
pub document_type_id: Option<Uuid>,
}
#[derive(Serialize, ToSchema)]
@@ -234,6 +258,7 @@ struct DocumentUpdateChangeset {
issued_at: Option<Option<NaiveDateTime>>,
metadata: Option<Value>,
updated_at: Option<NaiveDateTime>,
document_type_id: Option<Option<Uuid>>,
}
#[derive(Deserialize, Copy, Clone, PartialEq, Eq, ToSchema)]
@@ -346,6 +371,7 @@ pub async fn list_documents(
query,
tags,
correspondents,
document_types,
status,
} = params;
@@ -378,6 +404,11 @@ pub async fn list_documents(
.map(|s| s.trim())
.filter(|s| !s.is_empty())
.map(|s| s.to_owned());
let document_types_param = document_types
.as_ref()
.map(|s| s.trim())
.filter(|s| !s.is_empty())
.map(|s| s.to_owned());
let include_descendants = include_descendants.unwrap_or(true);
@@ -517,6 +548,20 @@ pub async fn list_documents(
}
}
if let Some(document_types_param) = document_types_param.as_ref() {
let type_ids: Result<Vec<Uuid>, _> = document_types_param
.split(',')
.map(|s| Uuid::parse_str(s.trim()))
.collect();
if let Ok(ids) = type_ids {
if !ids.is_empty() {
let filter_values: Vec<Option<Uuid>> = ids.into_iter().map(Some).collect();
docs_query = docs_query.filter(documents::document_type_id.eq_any(filter_values));
}
}
}
if let Some(ref set) = filter_ids {
if set.is_empty() {
return Ok(Json(vec![]));
@@ -565,6 +610,20 @@ pub async fn list_documents(
.load(&mut conn)?
};
let type_ids: HashSet<Uuid> = docs.iter().filter_map(|doc| doc.document_type_id).collect();
let doc_type_map: HashMap<Uuid, DocumentType> = if type_ids.is_empty() {
HashMap::new()
} else {
let ids: Vec<Uuid> = type_ids.iter().copied().collect();
document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.filter(document_types::id.eq_any(&ids))
.load::<DocumentType>(&mut conn)?
.into_iter()
.map(|typ| (typ.id, typ))
.collect()
};
let doc_ids: Vec<Uuid> = docs.iter().map(|doc| doc.id).collect();
let tags_map = load_tags_for_documents(&mut conn, &doc_ids)?;
let mut correspondents_map = load_correspondents_for_documents(&mut conn, &doc_ids)?;
@@ -576,6 +635,9 @@ pub async fn list_documents(
let tags = tags_map.get(&doc.id).cloned();
let correspondents = correspondents_map.remove(&doc.id).unwrap_or_default();
let current_version = primary_versions.get(&doc.id).cloned();
let doc_type = doc
.document_type_id
.and_then(|id| doc_type_map.get(&id).cloned());
response.push(to_document_response(
&state,
user_id,
@@ -583,6 +645,7 @@ pub async fn list_documents(
tags,
correspondents,
current_version,
doc_type,
)?);
}
@@ -664,6 +727,8 @@ pub async fn get_document(
.find(doc.current_version_id)
.first(&mut conn)?;
let doc_type = load_document_type(&mut conn, tenant_id, doc.document_type_id)?;
let tags_map = load_tags_for_documents(&mut conn, &[document_id])?;
let mut correspondents_map = load_correspondents_for_documents(&mut conn, &[document_id])?;
let version_id = current_version.id;
@@ -680,6 +745,7 @@ pub async fn get_document(
tags_map.get(&document_id).cloned(),
correspondents_map.remove(&document_id).unwrap_or_default(),
Some((version_response, assets)),
doc_type,
)?,
}))
}
@@ -1314,6 +1380,46 @@ pub async fn update_document(
}
}
let doc_type_update =
classify_nullable(payload_obj.get("document_type_id")).map_err(AppError::bad_request)?;
match doc_type_update {
NullableValue::Omitted => {}
NullableValue::Null => {
if document.document_type_id.is_some() {
changes.document_type_id = Some(None);
has_changes = true;
}
}
NullableValue::String(raw) => {
let trimmed = raw.trim();
if trimmed.is_empty() {
return Err(AppError::bad_request(
"document_type_id must not be empty when provided",
));
}
let parsed = Uuid::parse_str(trimmed)
.map_err(|_| AppError::bad_request("document_type_id must be a valid UUID"))?;
if document.document_type_id != Some(parsed) {
let exists = document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.find(parsed)
.first::<DocumentType>(&mut conn)
.optional()?;
if exists.is_none() {
return Err(AppError::bad_request(
"document_type_id does not exist for this tenant",
));
}
changes.document_type_id = Some(Some(parsed));
has_changes = true;
}
}
}
if !has_changes {
return Err(AppError::bad_request("no changes provided"));
}
@@ -1347,6 +1453,8 @@ pub async fn update_document(
.find(document.current_version_id)
.first(&mut conn)?;
let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
if title_changed {
if let Err(err) = enqueue_job(
&mut conn,
@@ -1383,6 +1491,7 @@ pub async fn update_document(
tags_map.get(&document_id).cloned(),
correspondents_map.remove(&document_id).unwrap_or_default(),
Some((version_response, assets)),
doc_type,
)?,
}))
}
@@ -2005,6 +2114,7 @@ async fn process_upload(
document.updated_at = now;
}
let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
let tags_map = load_tags_for_documents(&mut conn, &[document.id])?;
let mut correspondents_map =
load_correspondents_for_documents(&mut conn, &[document.id])?;
@@ -2028,6 +2138,7 @@ async fn process_upload(
tags,
correspondents,
Some((version_response, assets)),
doc_type,
)?,
}));
}
@@ -2067,6 +2178,7 @@ async fn process_upload(
title: derived_title.clone(),
metadata: metadata_value.clone(),
tenant_id,
document_type_id: None,
};
diesel::insert_into(documents::table)
.values(&new_document)
@@ -2125,6 +2237,7 @@ async fn process_upload(
)?;
}
let doc_type = load_document_type(&mut conn, tenant_id, document.document_type_id)?;
let tags_map = load_tags_for_documents(&mut conn, &[doc_id])?;
let mut correspondents_map = load_correspondents_for_documents(&mut conn, &[doc_id])?;
let tags = tags_map.get(&doc_id).cloned();
@@ -2139,6 +2252,7 @@ async fn process_upload(
tags,
correspondents,
Some((to_version_response(version.clone()), Vec::new())),
doc_type,
)?,
}
};
@@ -2171,6 +2285,7 @@ pub(crate) fn to_document_response(
tags: Option<Vec<Tag>>,
correspondents: Vec<DocumentCorrespondentResponse>,
current_version: Option<(DocumentVersionResponse, Vec<DocumentAssetResponse>)>,
doc_type: Option<DocumentType>,
) -> AppResult<DocumentResponse> {
let current_version = if let Some((version, assets)) = current_version {
let download_path = build_download_path(state, &doc, user_id)?;
@@ -2195,6 +2310,11 @@ pub(crate) fn to_document_response(
deleted_at: doc.deleted_at.map(to_iso),
issued_at: doc.issued_at.map(to_iso),
metadata: doc.metadata,
document_type_id: doc.document_type_id,
document_type: doc_type.map(|typ| DocumentTypeResponse {
id: typ.id,
name: typ.name,
}),
tags: tags
.unwrap_or_default()
.into_iter()
@@ -2204,3 +2324,19 @@ pub(crate) fn to_document_response(
current_version,
})
}
fn load_document_type(
conn: &mut PgConnection,
tenant_id: Uuid,
type_id: Option<Uuid>,
) -> diesel::QueryResult<Option<DocumentType>> {
if let Some(id) = type_id {
document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.find(id)
.first::<DocumentType>(conn)
.optional()
} else {
Ok(None)
}
}
backend/src/routes/folders.rs
+22 -2
View File
@@ -1,3 +1,5 @@
use std::collections::{HashMap, HashSet};
use axum::{
extract::{Json, Path, Query, State},
http::StatusCode,
@@ -7,8 +9,8 @@ use serde::{Deserialize, Serialize};
use serde_json::Value;
use uuid::Uuid;
use crate::models::{Document, Folder, NewFolder};
use crate::schema::{documents, folders};
use crate::models::{Document, DocumentType, Folder, NewFolder};
use crate::schema::{document_types, documents, folders};
use crate::state::AppState;
use crate::{
auth::TenantScopedConn,
@@ -320,6 +322,20 @@ pub async fn list_folder_contents(
.load(&mut conn)?
};
let type_ids: HashSet<Uuid> = docs.iter().filter_map(|doc| doc.document_type_id).collect();
let doc_type_map: HashMap<Uuid, DocumentType> = if type_ids.is_empty() {
HashMap::new()
} else {
let ids: Vec<Uuid> = type_ids.iter().copied().collect();
document_types::table
.filter(document_types::tenant_id.eq(tenant_id))
.filter(document_types::id.eq_any(&ids))
.load::<DocumentType>(&mut conn)?
.into_iter()
.map(|typ| (typ.id, typ))
.collect()
};
let doc_ids: Vec<Uuid> = docs.iter().map(|doc| doc.id).collect();
let tags_map = load_tags_for_documents(&mut conn, &doc_ids)?;
let mut correspondents_map = load_correspondents_for_documents(&mut conn, &doc_ids)?;
@@ -332,6 +348,9 @@ pub async fn list_folder_contents(
let tags = tags_map.get(&doc.id).cloned();
let correspondents = correspondents_map.remove(&doc.id).unwrap_or_default();
let current_version = primary_versions.get(&doc.id).cloned();
let doc_type = doc
.document_type_id
.and_then(|id| doc_type_map.get(&id).cloned());
documents.push(to_document_response(
&state,
user_id,
@@ -339,6 +358,7 @@ pub async fn list_folder_contents(
tags,
correspondents,
current_version,
doc_type,
)?);
}
backend/src/routes/mod.rs
+13
View File
@@ -17,6 +17,7 @@ use crate::{auth::AuthenticatedUser, openapi::ApiDoc, state::AppState};
pub mod auth;
pub mod correspondents;
pub mod document_types;
pub mod documents;
pub mod folders;
pub mod health;
@@ -132,6 +133,17 @@ pub fn create_router(state: AppState) -> Router<()> {
.route("/", get(tags::list_tags).post(tags::create_tag))
.route("/:id", patch(tags::update_tag).delete(tags::delete_tag));
let document_types_routes = Router::new()
.route(
"/",
get(document_types::list_document_types).post(document_types::create_document_type),
)
.route(
"/:id",
patch(document_types::update_document_type)
.delete(document_types::delete_document_type),
);
let correspondents_routes = Router::new()
.route(
"/",
@@ -159,6 +171,7 @@ pub fn create_router(state: AppState) -> Router<()> {
.nest("/api/documents", documents_routes)
.nest("/api/folders", folders_routes)
.nest("/api/tags", tags_routes)
.nest("/api/document-types", document_types_routes)
.nest("/api/correspondents", correspondents_routes)
.nest("/api/profile", profile_routes)
.nest("/api/assets", assets_routes)