discloud-rs 0.3.0-alpha

A rust wrapper for Discloud's API
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

use std::fmt::Debug;

use reqwest::{Client, Method};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use tracing::{debug, trace};

use crate::{config::Config, Error};

#[derive(Debug, Clone, Deserialize, Default)]
pub struct DiscloudDefaultResponse {
    pub status: String,
    pub message: String,
}

pub fn default_url(path: &str) -> String {
    format!("https://api.discloud.app/v2/{path}")
}

pub async fn make_request<T: DeserializeOwned + Debug>(
    config: &Config,
    method: Method,
    path: &str,
) -> Result<T, Error> {
    let url = default_url(path);

    debug!("Creating request client");
    let client = Client::builder().user_agent(&config.user_agent).build()?;

    debug!(url = url, "Making request");
    let response = client
        .request(method, url)
        .header("api-token", &config.token)
        .send()
        .await?;

    let response_status = response.status();

    if !response_status.is_success() {
        let response_body = response.text().await?;
        debug!(
            status = response_status.as_u16(),
            response_body = response_body,
            "Request failed"
        );
        if response_status.is_server_error() {
            return Err(Error::ServerError);
        }

        let response: DiscloudDefaultResponse =
            serde_json::from_str(&response_body).unwrap_or_default();

        return Err(match response_status.as_u16() {
            403 => Error::Forbidden,
            401 => Error::InvalidToken,
            429 => Error::Ratelimited,
            404 => Error::NotFound(response.message.leak()),
            409 => Error::Conflict(response.message.leak()),
            _ => Error::Unknown,
        });
    }

    let body = response.json::<T>().await?;
    debug!(response_body = format!("{body:?}"), "Request succeed");
    Ok(body)
}

pub async fn make_request_with_body<T: DeserializeOwned + Debug, B: Serialize + Debug>(
    config: &Config,
    method: Method,
    path: &str,
    body: B,
) -> Result<T, Error> {
    let url = default_url(path);

    debug!("Creating request client");
    let client = Client::builder().user_agent(&config.user_agent).build()?;

    debug!(url = url, "Making request");
    let response = client
        .request(method, url)
        .json(&body)
        .header("api-token", &config.token)
        .send()
        .await?;

    let response_status = response.status();

    if !response_status.is_success() {
        let response_body = response.text().await?;
        trace!(?body);
        debug!(
            status = response_status.as_u16(),
            response_body, "Request failed"
        );
        if response_status.is_server_error() {
            return Err(Error::ServerError);
        }
        let response: DiscloudDefaultResponse =
            serde_json::from_str(&response_body).unwrap_or_default();

        return Err(match response_status.as_u16() {
            401 => Error::InvalidToken,
            403 => Error::Forbidden,
            429 => Error::Ratelimited,
            404 => Error::NotFound(response.message.leak()),
            409 => Error::Conflict(response.message.leak()),
            _ => Error::Unknown,
        });
    }

    let body = response.json::<T>().await?;
    debug!(response_body = format!("{body:?}"), "Request succeed");
    Ok(body)
}