docbox-http 0.9.1

Docbox HTTP layer, routes, types, and middleware
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::error::HttpError;
use axum::http::StatusCode;
use docbox_core::{
    database::models::folder::{FolderId, FolderWithExtra, ResolvedFolderWithExtra},
    folders::create_folder::CreateFolderError,
};
use garde::Validate;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use utoipa::ToSchema;
use uuid::Uuid;

/// Request to create a folder
#[derive(Debug, Validate, Deserialize, ToSchema)]
pub struct CreateFolderRequest {
    /// Name for the folder
    #[garde(length(min = 1, max = 255))]
    #[schema(min_length = 1, max_length = 255)]
    pub name: String,

    /// ID of the folder to store folder in
    #[garde(skip)]
    #[schema(value_type = Uuid)]
    pub folder_id: FolderId,
}

/// Response for requesting a document box
#[derive(Debug, Serialize, ToSchema)]
pub struct FolderResponse {
    /// The folder itself
    pub folder: FolderWithExtra,

    /// Resolved contents of the folder
    pub children: ResolvedFolderWithExtra,
}

/// Request to rename and or move a folder
#[derive(Debug, Validate, Deserialize, ToSchema)]
pub struct UpdateFolderRequest {
    /// Name for the folder
    #[garde(inner(length(min = 1, max = 255)))]
    #[schema(min_length = 1, max_length = 255)]
    pub name: Option<String>,

    /// ID of the new parent folder for the folder
    #[garde(skip)]
    #[schema(value_type = Option<Uuid>)]
    pub folder_id: Option<FolderId>,

    /// Whether to pin the folder
    #[garde(skip)]
    #[schema(value_type = Option<bool>)]
    pub pinned: Option<bool>,
}

/// Request to create a zip file of folder contents
#[derive(Debug, Validate, Deserialize, ToSchema)]
pub struct ZipFolderRequest {
    /// Optionally only include the specified items (files and folders)
    ///
    /// Inclusion is only applied to the direct descendants
    /// of the folder use exclude to exclude specific content
    /// from nested folders
    #[garde(skip)]
    #[serde(alias = "include_files")]
    pub include: Option<Vec<Uuid>>,

    /// Optionally exclude the specified items (files and folders)
    /// including any items that don't match the provided list of IDs
    ///
    /// Exclusion is applied deeply to nested files and folders
    #[garde(skip)]
    #[serde(alias = "exclude_files")]
    pub exclude: Option<Vec<Uuid>>,
}

#[derive(Debug, Error)]
pub enum HttpFolderError {
    #[error("unknown folder")]
    UnknownFolder,

    /// Failed to create the folder
    #[error(transparent)]
    CreateError(CreateFolderError),

    #[error("unknown target folder")]
    UnknownTargetFolder,

    #[error("cannot delete root folder")]
    CannotDeleteRoot,

    #[error("cannot modify root folder")]
    CannotModifyRoot,

    #[error("cannot move a folder into itself")]
    CannotMoveIntoSelf,

    #[error("failed to create zip file")]
    CreateZipFile,
}

impl HttpError for HttpFolderError {
    fn status(&self) -> axum::http::StatusCode {
        match self {
            HttpFolderError::UnknownFolder | HttpFolderError::UnknownTargetFolder => {
                StatusCode::NOT_FOUND
            }
            HttpFolderError::CannotModifyRoot
            | HttpFolderError::CannotDeleteRoot
            | HttpFolderError::CannotMoveIntoSelf => StatusCode::BAD_REQUEST,
            HttpFolderError::CreateError(_) | HttpFolderError::CreateZipFile => {
                StatusCode::INTERNAL_SERVER_ERROR
            }
        }
    }
}