medullah-multipart 0.7.1

Library For Handling File Uploads Based on Ntex
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

use crate::file_validator::{ErrorMessage, InputError};
use crate::FileInput;
use std::fmt::{Display, Formatter};
use std::io::Error;

pub type MultipartResult<T> = Result<T, MultipartError>;

#[derive(Debug)]
pub enum MultipartError {
    NoFile,
    IoError(Error),
    NoContentType(String),
    MissingDataField(String),
    InvalidContentDisposition(String),
    NtexError(ntex_multipart::MultipartError),
    ValidationError(InputError),
}

impl From<Error> for MultipartError {
    fn from(value: Error) -> Self {
        MultipartError::IoError(value)
    }
}

impl Display for MultipartError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            MultipartError::IoError(err) => {
                write!(f, "{}", err)
            }
            MultipartError::NoFile => {
                write!(f, "No file was uploaded")
            }
            MultipartError::MissingDataField(ct) => {
                write!(f, "Data field '{}' is required", ct)
            }
            MultipartError::NoContentType(ct) => {
                write!(f, "Invalid content type: {}", ct)
            }
            MultipartError::InvalidContentDisposition(err) => {
                write!(f, "Invalid content disposition: {}", err)
            }
            MultipartError::NtexError(err) => {
                write!(f, "{}", err)
            }
            MultipartError::ValidationError(err) => {
                let field_name = err.name.clone().replace("_", " ");
                match err.error.clone() {
                    ErrorMessage::NoFiles => {
                        write!(f, "No files were uploaded for field: '{field_name}'")
                    }
                    ErrorMessage::FileTooSmall(size) => {
                        write!(
                            f,
                            "File size is too small for field '{field_name}'. Minimum size is {}",
                            FileInput::format_size(size)
                        )
                    }
                    ErrorMessage::FileTooLarge(size) => {
                        write!(
                            f,
                            "File size is too big for field '{field_name}'. Maximum size is {}",
                            FileInput::format_size(size)
                        )
                    }
                    ErrorMessage::TooFewFiles(count) => {
                        write!(
                            f,
                            "Too few files uploaded for field '{field_name}'. Minimum is {}",
                            count
                        )
                    }
                    ErrorMessage::TooManyFiles(count) => {
                        write!(
                            f,
                            "Too many files uploaded for field '{field_name}'. Maximum is {}",
                            count
                        )
                    }
                    ErrorMessage::InvalidFileExtension(ext) => {
                        write!(
                            f,
                            "Invalid file extension for field '{field_name}': .{}",
                            ext.clone().unwrap_or_default()
                        )
                    }
                    ErrorMessage::InvalidContentType(mime) => {
                        write!(f, "Invalid mime type: {}", mime)
                    }
                    ErrorMessage::MissingFileExtension(mime) => {
                        write!(f, "Invalid file, file extension is required: {}", mime)
                    }
                }
            }
        }
    }
}