webweg 0.9.2

An asynchronous API wrapper for UCSD's WebReg course enrollment system.
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171

#[cfg(feature = "multi")]
use parking_lot::Mutex;
use reqwest::header::{CONNECTION, COOKIE, USER_AGENT};
use reqwest::{Client, IntoUrl, RequestBuilder};
use std::time::Duration;

pub(crate) enum ReqType<U: IntoUrl> {
    Post(U),
    Get(U),
}

/// A structure that represents data held by the wrapper or a request.
pub struct WebRegWrapperData {
    /// The cookies.
    #[cfg(feature = "multi")]
    pub(crate) cookies: Mutex<String>,
    #[cfg(not(feature = "multi"))]
    pub(crate) cookies: String,
    /// The client used to make the request.
    pub(crate) client: Client,
    /// The user agent.
    pub(crate) user_agent: String,
    /// The timeout for this request.
    pub(crate) timeout: Duration,
    /// Whether to close the connection after the request has been completed.
    ///
    /// Setting this field to `true` means that your requests can be made with different cookies
    /// with the same wrapper. However, this also means that you'll incur a performance hit when
    /// making a request.
    ///
    /// It is recommended that this field's value is set to `false` if you do not need to switch
    /// cookies for this wrapper.
    pub(crate) close_after_request: bool,
}

impl<'a> ReqwestWebRegClientData<'a> for WebRegWrapperData {
    #[cfg(feature = "multi")]
    fn get_cookies(&'a self) -> String {
        self.cookies.lock().to_owned()
    }
    #[cfg(not(feature = "multi"))]
    fn get_cookies(&'a self) -> &'a str {
        self.cookies.as_str()
    }

    fn get_client(&'a self) -> &'a Client {
        &self.client
    }

    fn get_user_agent(&'a self) -> &'a str {
        self.user_agent.as_str()
    }

    fn get_timeout(&'a self) -> Duration {
        self.timeout
    }

    fn close_after_request(&'a self) -> bool {
        self.close_after_request
    }
}

/// A structure that represents data held by the wrapper or a request.
pub(crate) struct WebRegWrapperDataRef<'a> {
    #[cfg(feature = "multi")]
    pub cookies: String,
    /// The cookies.
    #[cfg(not(feature = "multi"))]
    pub cookies: &'a str,
    /// The client used to make the request.
    pub client: &'a Client,
    /// The user agent.
    pub user_agent: &'a str,
    /// The timeout for this request.
    pub timeout: Duration,
    /// Whether to close the connection after the request has been completed.
    ///
    /// Setting this field to `true` means that your requests can be made with different cookies
    /// with the same wrapper. However, this also means that you'll incur a performance hit when
    /// making a request.
    pub close_after_request: bool,
}

impl<'a> ReqwestWebRegClientData<'a> for WebRegWrapperDataRef<'a> {
    #[cfg(feature = "multi")]
    fn get_cookies(&'a self) -> String {
        self.cookies.to_owned()
    }
    #[cfg(not(feature = "multi"))]
    fn get_cookies(&'a self) -> &'a str {
        self.cookies
    }

    fn get_client(&'a self) -> &'a Client {
        self.client
    }

    fn get_user_agent(&'a self) -> &'a str {
        self.user_agent
    }

    fn get_timeout(&'a self) -> Duration {
        self.timeout
    }

    fn close_after_request(&'a self) -> bool {
        self.close_after_request
    }
}

pub(crate) trait ReqwestWebRegClientData<'a> {
    /// The cookies for this request.
    ///
    /// # Returns
    /// The cookies.
    #[cfg(not(feature = "multi"))]
    fn get_cookies(&'a self) -> &'a str;
    #[cfg(feature = "multi")]
    fn get_cookies(&'a self) -> String;

    /// The client to be used for this request.
    ///
    /// # Returns
    /// The client.
    fn get_client(&'a self) -> &'a Client;

    /// The user agent to be used for this request.
    ///
    /// # Returns
    /// The user agent.
    fn get_user_agent(&'a self) -> &'a str;

    /// The timeout to be used for this request.
    ///
    /// # Returns
    /// The timeout.
    fn get_timeout(&'a self) -> Duration;

    /// Whether the connection should be closed after the request is completed.
    ///
    /// # Returns
    /// Whether the connection should be closed after the request is completed.
    fn close_after_request(&'a self) -> bool;

    /// Makes a request with the desired request type using the headers provided by the user.
    ///
    /// # Parameters
    /// - `req_type`: The request type.
    ///
    /// # Returns
    /// A request builder that can further be built on top of, if needed.
    fn req<U>(&'a self, req_type: ReqType<U>) -> RequestBuilder
    where
        U: IntoUrl,
    {
        let client = self.get_client();
        let mut req = match req_type {
            ReqType::Post(u) => client.post(u),
            ReqType::Get(u) => client.get(u),
        }
        .header(COOKIE, self.get_cookies())
        .header(USER_AGENT, self.get_user_agent())
        .timeout(self.get_timeout());

        if self.close_after_request() {
            req = req.header(CONNECTION, "close");
        }

        req
    }
}