twitch_highway 0.0.10

Twitch Api reqest Http
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

use asknothingx2_util::{
    api::{HeaderBuilder, HeaderMap},
    oauth::{AccessToken, ClientId},
};
use url::Url;

pub trait TwitchAPIBase {
    fn access_token(&self) -> &AccessToken;
    fn client_id(&self) -> &ClientId;
    fn build_headers(&self) -> HH {
        HH::base(self.access_token(), self.client_id())
    }
    fn build_url(&self) -> UU {
        UU::new()
    }
}

pub struct TwitchAPI {
    access_token: AccessToken,
    client_id: ClientId,
}

impl TwitchAPI {
    pub fn new(access_token: AccessToken, client_id: ClientId) -> Self {
        Self {
            access_token,
            client_id,
        }
    }
}

impl TwitchAPIBase for TwitchAPI {
    fn access_token(&self) -> &AccessToken {
        &self.access_token
    }

    fn client_id(&self) -> &ClientId {
        &self.client_id
    }
}

pub struct HH(HeaderBuilder);
impl HH {
    pub fn base(access_token: &AccessToken, client_id: &ClientId) -> Self {
        Self(
            HeaderBuilder::new()
                .authorization("Bearer", access_token.secret().as_str())
                .client_id(client_id.as_str()),
        )
    }

    pub fn json(mut self) -> Self {
        self.0 = self.0.content_type_json();
        self
    }

    pub fn build(self) -> HeaderMap {
        self.0.build()
    }
}

pub struct UU(Url);

impl Default for UU {
    fn default() -> Self {
        UU(url::Url::parse(crate::TWITCH_API_BASE).unwrap())
    }
}

impl UU {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn path<T: AsRef<str>, L: IntoIterator<Item = T>>(mut self, path: L) -> Self {
        self.0.path_segments_mut().unwrap().extend(path);
        self
    }

    pub fn query<K: AsRef<str>, V: AsRef<str>, L: IntoIterator<Item = (K, V)>>(
        mut self,
        querys: L,
    ) -> Self {
        self.0.query_pairs_mut().extend_pairs(querys);
        self
    }

    pub fn query_option<T: AsRef<str>>(mut self, key: &str, value: Option<T>) -> Self {
        if let Some(value) = value {
            self.0.query_pairs_mut().append_pair(key, value.as_ref());
        }
        self
    }

    pub fn query_option_extend<K: AsRef<str>, V: AsRef<str>, L: IntoIterator<Item = (K, V)>>(
        mut self,
        querys: Option<L>,
    ) -> Self {
        if let Some(querys) = querys {
            self.0.query_pairs_mut().extend_pairs(querys);
        }
        self
    }

    pub fn build(self) -> Url {
        self.0
    }
}