animeschedule 0.1.5

A complete async/sync typed AnimeSchedule 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use std::sync::Arc;

use http::HeaderMap;
use reqwest::{Client, IntoUrl, RequestBuilder};
use serde::de::DeserializeOwned;
use tracing::debug;

use crate::{errors::ApiError, rate_limit::RateLimit, utils::IsJson, Auth};

#[derive(Copy, Clone, Debug)]
pub(crate) enum RequestMethod {
    Get,
    Put,
    Delete,
}

pub(crate) struct ApiRequest {
    // these fields are synced between all clients
    auth: Arc<Auth>,
    http: reqwest::Client,
    // these are not
    #[allow(clippy::complexity)]
    response_cb: Option<Box<dyn FnOnce(&HeaderMap) + 'static>>,
    request_cb: Option<Box<dyn FnOnce(RequestBuilder) -> RequestBuilder + 'static>>,
}

impl Clone for ApiRequest {
    fn clone(&self) -> Self {
        let ApiRequest { auth, http, .. } = self;

        ApiRequest {
            auth: auth.clone(),
            http: http.clone(),
            // we don't need to clone this. it's set individually per call, and runs only once
            response_cb: None,
            request_cb: None,
        }
    }
}

impl ApiRequest {
    pub fn new(auth: Arc<Auth>, http: Client) -> Self {
        Self {
            auth,
            http,
            response_cb: None,
            request_cb: None,
        }
    }

    pub fn response_cb(&mut self, response_cb: impl FnOnce(&HeaderMap) + 'static) {
        self.response_cb = Some(Box::new(response_cb));
    }

    pub fn request_cb(
        &mut self,
        request_cb: impl FnOnce(RequestBuilder) -> RequestBuilder + 'static,
    ) {
        self.request_cb = Some(Box::new(request_cb));
    }

    pub async fn get<D>(
        &mut self,
        url: impl IntoUrl,
        is_auth: bool,
    ) -> Result<(RateLimit, D), ApiError>
    where
        D: DeserializeOwned,
    {
        self.api_request(url.into_url()?, RequestMethod::Get, is_auth)
            .await
    }

    pub async fn delete<D>(
        &mut self,
        url: impl IntoUrl,
        is_auth: bool,
    ) -> Result<(RateLimit, D), ApiError>
    where
        D: DeserializeOwned,
    {
        self.api_request(url.into_url()?, RequestMethod::Delete, is_auth)
            .await
    }

    pub async fn put<D>(
        &mut self,
        url: impl IntoUrl,
        is_auth: bool,
    ) -> Result<(RateLimit, D), ApiError>
    where
        D: DeserializeOwned,
    {
        self.api_request(url.into_url()?, RequestMethod::Put, is_auth)
            .await
    }

    /// is_auth : Use user authentication in request; otherwise use ClientID header
    async fn api_request<D>(
        &mut self,
        url: impl IntoUrl,
        method: RequestMethod,
        // whether to use oauth2 access token or client id header
        is_auth: bool,
    ) -> Result<(RateLimit, D), ApiError>
    where
        D: DeserializeOwned,
    {
        let request = match method {
            RequestMethod::Get => self.http.get(url.into_url()?),
            RequestMethod::Delete => self.http.delete(url.into_url()?),
            RequestMethod::Put => self.http.put(url.into_url()?),
        };

        let request = if is_auth {
            request.bearer_auth(
                self.auth
                    .access_token()
                    .ok_or(ApiError::AccessTokenError)?
                    .secret(),
            )
        } else {
            request.bearer_auth(self.auth.app_token())
        };

        let request = if let Some(cb) = self.request_cb.take() {
            cb(request)
        } else {
            request
        };

        let response = request.send().await?;

        let headers = response.headers();
        let limit = RateLimit::new(headers);

        if let Some(cb) = self.response_cb.take() {
            cb(headers);
        }

        let status = response.status();
        let text = response.text().await?;

        debug!(status = status.as_u16(), response = text);

        if !text.is_json() {
            return Err(ApiError::ApiError {
                status,
                error: text,
            });
        }

        let data = serde_json::from_str(&text)?;

        Ok((limit.unwrap(), data))
    }
}