dialtone_axum 0.1.0

Dialtone Axum Back-end
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

use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::Json;
use dialtone_common::ap::id::IdError;
use dialtone_common::rest::simple_exchanges::SimpleResponse;
use dialtone_common::utils::parse_acct::ParseUserAcctError;

#[derive(Debug)]
pub enum ResponseError {
    WrongCredentials(Option<String>),
    MissingCredentials(Option<String>),
    TokenDecodingError(Option<String>),
    TokenCreation(Option<String>),
    BadTokenInHeader(Option<String>),
    UnableToAuthenticate(Option<String>),
    NoAuthorizationsAvailable(Option<String>),
    UnableToAuthorize(Option<String>),
    BadRequest(Option<String>),
    NotFound(Option<String>),
    InternalServerError(Option<String>),
}

impl ResponseError {
    pub fn not_found() -> ResponseError {
        ResponseError::NotFound(None)
    }
}

impl IntoResponse for ResponseError {
    fn into_response(self) -> Response {
        let (status, error_message, log_msg) = match self {
            ResponseError::WrongCredentials(ref log_msg) => {
                (StatusCode::FORBIDDEN, "Wrong credentials", log_msg)
            }
            ResponseError::MissingCredentials(ref log_msg) => {
                (StatusCode::UNAUTHORIZED, "Missing credentials", log_msg)
            }
            ResponseError::TokenDecodingError(ref log_msg) => {
                (StatusCode::BAD_REQUEST, "Token decoding error", log_msg)
            }
            ResponseError::TokenCreation(ref log_msg) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "Token creation error",
                log_msg,
            ),
            ResponseError::BadTokenInHeader(ref log_msg) => {
                (StatusCode::BAD_REQUEST, "Bad token in header", log_msg)
            }
            ResponseError::UnableToAuthenticate(ref log_msg) => {
                (StatusCode::UNAUTHORIZED, "Wrong credentials", log_msg)
            }
            ResponseError::NoAuthorizationsAvailable(ref log_msg) => (
                StatusCode::FORBIDDEN,
                "No authorizations available",
                log_msg,
            ),
            ResponseError::UnableToAuthorize(ref log_msg) => {
                (StatusCode::FORBIDDEN, "Unable to authorize", log_msg)
            }
            ResponseError::BadRequest(ref log_msg) => {
                (StatusCode::BAD_REQUEST, "Bad request", log_msg)
            }
            ResponseError::NotFound(ref log_msg) => (StatusCode::NOT_FOUND, "Not found", log_msg),
            ResponseError::InternalServerError(ref log_msg) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "Internal server error",
                log_msg,
            ),
        };
        if let Some(log_msg) = log_msg {
            match self {
                ResponseError::InternalServerError(_) => tracing::error!("{}", log_msg),
                _ => tracing::warn!("{}", log_msg),
            }
        }
        let body = Json(SimpleResponse::failure_with_msg(error_message));
        (status, body).into_response()
    }
}

impl From<sqlx::Error> for ResponseError {
    fn from(err: sqlx::Error) -> Self {
        ResponseError::InternalServerError(Some(err.to_string()))
    }
}

impl From<anyhow::Error> for ResponseError {
    fn from(err: anyhow::Error) -> Self {
        ResponseError::InternalServerError(Some(err.to_string()))
    }
}

impl From<IdError> for ResponseError {
    fn from(err: IdError) -> Self {
        ResponseError::BadRequest(Some(err.to_string()))
    }
}

impl From<ParseUserAcctError> for ResponseError {
    fn from(_err: ParseUserAcctError) -> Self {
        ResponseError::BadRequest(None)
    }
}