animeschedule 0.1.13

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

use const_format::formatcp;
use serde::Serialize;
use serde_with::skip_serializing_none;

use crate::{
    errors::ApiError,
    objects::{Categories, Category},
    rate_limit::RateLimit,
    AnimeScheduleClient, API_URL, RUNTIME,
};

const API_CATEGORITES_TYPE: &str = formatcp!("{API_URL}/categories/{{categoryType}}");
const API_CATEGORITES_TYPE_SLUG: &str = formatcp!("{API_URL}/categories/{{categoryType}}/{{slug}}");

pub struct CategoryApi {
    client: AnimeScheduleClient,
    category_type: String,
}

impl CategoryApi {
    pub(crate) fn new(client: AnimeScheduleClient, category: &str) -> Self {
        Self {
            client,
            category_type: category.to_owned(),
        }
    }

    pub fn get(&self) -> CategoryGet {
        CategoryGet {
            client: self.client.clone(),
            category_type: self.category_type.clone(),
            q: None,
        }
    }
}

#[skip_serializing_none]
#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct CategoryGet {
    #[serde(skip)]
    client: AnimeScheduleClient,
    #[serde(skip)]
    category_type: String,

    /// Filter by text. Maximum length is 200.
    q: Option<String>,
}

impl CategoryGet {
    /// Fetch the data of a specific category
    pub fn slug(&self, slug: &str) -> CategorySlug {
        CategorySlug {
            client: self.client.clone(),
            slug: slug.to_owned(),
            category_type: self.category_type.clone(),
        }
    }

    /// Filter by text. Maximum length is 200.
    pub fn q(mut self, q: &str) -> Self {
        let mut q = q.to_owned();
        q.truncate(200);

        self.q = Some(q);
        self
    }

    /// Fetch the data of multiple categories by query
    pub async fn send(mut self) -> Result<(RateLimit, Categories), ApiError> {
        let url = API_CATEGORITES_TYPE.replace("{categoryType}", &self.category_type);

        let query = serde_qs::to_string(&self).unwrap();

        let url = format!("{url}?{query}");

        self.client.http.get(url, false).await
    }

    pub fn send_blocking(self) -> Result<(RateLimit, Categories), ApiError> {
        RUNTIME.block_on(self.send())
    }
}

/// Fetch the data of a specific category
pub struct CategorySlug {
    client: AnimeScheduleClient,
    slug: String,
    category_type: String,
}

impl CategorySlug {
    /// Fetch the data of a specific category
    pub async fn send(mut self) -> Result<(RateLimit, Category), ApiError> {
        let url = API_CATEGORITES_TYPE_SLUG
            .replace("{categoryType}", &self.category_type)
            .replace("{slug}", &self.slug);

        self.client.http.get(url, false).await
    }

    pub fn send_blocking(self) -> Result<(RateLimit, Category), ApiError> {
        RUNTIME.block_on(self.send())
    }
}