pastemd 0.1.5

Pluggable pastebin backend
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};

use serde::{Deserialize, Serialize};
use dorsal::DefaultReturn;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Paste {
    pub id: String,
    pub url: String,
    pub content: String,
    pub password: String,
    pub date_published: u128,
    pub date_edited: u128,
    pub metadata: PasteMetadata,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
/// All of these fields are
pub struct PasteMetadata {
    /// Can be disabled
    pub owner: String,
    /// Paste page title
    pub title: String,
    /// Paste view password (can be disabled)
    pub view_password: String,
}

impl Default for PasteMetadata {
    fn default() -> Self {
        Self {
            owner: String::new(),
            title: String::new(),
            view_password: String::from("off"),
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PasteCreate {
    #[serde(default)]
    pub url: String,
    pub content: String,
    #[serde(default)]
    pub password: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PasteDelete {
    pub password: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PasteEdit {
    pub password: String,
    pub new_content: String,
    #[serde(default)]
    pub new_password: String,
    #[serde(default)]
    pub new_url: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PasteEditMetadata {
    pub password: String,
    pub metadata: PasteMetadata,
}

/// General API errors
pub enum PasteError {
    PasswordIncorrect,
    AlreadyExists,
    ValueError,
    NotFound,
    Other,
}

impl PasteError {
    pub fn to_string(&self) -> String {
        use crate::model::PasteError::*;
        match self {
            PasswordIncorrect => String::from("The given password is invalid."),
            AlreadyExists => String::from("A paste with this URL already exists."),
            ValueError => String::from("One of the field values given is invalid."),
            NotFound => String::from("No paste with this URL has been found."),
            _ => String::from("An unspecified error has occured"),
        }
    }
}

impl IntoResponse for PasteError {
    fn into_response(self) -> Response {
        use crate::model::PasteError::*;
        match self {
            PasswordIncorrect => (
                StatusCode::UNAUTHORIZED,
                Json(DefaultReturn::<u16> {
                    success: false,
                    message: self.to_string(),
                    payload: 401,
                }),
            )
                .into_response(),
            AlreadyExists => (
                StatusCode::BAD_REQUEST,
                Json(DefaultReturn::<u16> {
                    success: false,
                    message: self.to_string(),
                    payload: 400,
                }),
            )
                .into_response(),
            NotFound => (
                StatusCode::NOT_FOUND,
                Json(DefaultReturn::<u16> {
                    success: false,
                    message: self.to_string(),
                    payload: 404,
                }),
            )
                .into_response(),
            _ => (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(DefaultReturn::<u16> {
                    success: false,
                    message: self.to_string(),
                    payload: 500,
                }),
            )
                .into_response(),
        }
    }
}