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

#[cfg(feature = "multi")]
use parking_lot::lock_api::Mutex;
use std::time::Duration;

use crate::constants::MY_USER_AGENT;
use crate::wrapper::request_data::WebRegWrapperData;
use reqwest::Client;

use crate::wrapper::WebRegWrapper;

/// A builder for the `WebRegWrapper`. This should be used to construct a new wrapper.
///
/// # Example
/// ```rust,no_run
/// use webweg::wrapper::WebRegWrapper;
/// use std::time::Duration;
///
/// # fn main() {
///  let wrapper = WebRegWrapper::builder()
///     .with_cookies("abc")
///     .with_default_timeout(Duration::from_secs(10))
///     .try_build_wrapper();
///
///  assert!(wrapper.is_some());
/// # }
/// ```
pub struct WebRegWrapperBuilder {
    cookies: Option<String>,
    client: Client,
    user_agent: String,
    default_timeout: Duration,
    close_after_request: bool,
}

impl WebRegWrapperBuilder {
    /// Constructs a `WebRegWrapperBuilder` with the default client, user agent, and default timeout.
    /// You are responsible for providing the cookies and term.
    ///
    /// # Returns
    /// A `WebRegWrapperBuilder`.
    pub fn new() -> Self {
        Self {
            cookies: None,
            client: Client::new(),
            user_agent: MY_USER_AGENT.to_owned(),
            default_timeout: Duration::from_secs(30),
            close_after_request: false,
        }
    }

    /// Sets the cookies to the specified cookies.
    ///
    /// # Parameters
    /// - `cookie`: The WebReg cookies.
    ///
    /// # Returns
    /// The builder.
    pub fn with_cookies(mut self, cookie: impl Into<String>) -> Self {
        self.cookies = Some(cookie.into());
        self
    }

    /// Sets the client to the specified client.
    ///
    /// # Parameters
    /// - `client`: The client to use.
    ///
    /// # Returns
    /// The builder.
    pub fn with_client(mut self, client: Client) -> Self {
        self.client = client;
        self
    }

    /// Sets the user agent to the specified user agent.
    ///
    /// # Parameters
    /// - `user_agent`: The user agent to use.
    ///
    /// # Returns
    /// The builder.
    pub fn with_user_agent(mut self, user_agent: impl Into<String>) -> Self {
        self.user_agent = user_agent.into();
        self
    }

    /// Sets the timeout to the specified timeout.
    ///
    /// # Parameters
    /// - `timeout`: The timeout to use.
    ///
    /// # Returns
    /// The builder.
    pub fn with_default_timeout(mut self, timeout: Duration) -> Self {
        self.default_timeout = timeout;
        self
    }

    /// Whether the client should close the connection after completing the request.
    ///
    /// If you plan on overriding the session cookies when making a request under this wrapper,
    /// consider setting this to `true`. Otherwise, you might get stale login errors when overriding
    /// cookies for a particular request. That being said, setting this to `true` may incur
    /// performance penalties; in particular, requests may be up to 3-4 times slower if this is `true`.
    ///
    /// It is recommended that this field's value is set to `false` if you do not need to switch
    /// cookies for this wrapper.
    ///
    /// # Parameters
    /// - `close`: Whether to close the connection after completing the request.
    ///
    /// # Returns
    /// The builder.
    pub fn should_close_after_request(mut self, close: bool) -> Self {
        self.close_after_request = close;
        self
    }

    /// Attempts to build the wrapper. To successfully build the wrapper, the cookies and term
    /// must be provided.
    ///
    /// # Returns
    /// The `WebRegWrapper` if both the `cookies` and `term` are specified. If any of those
    /// are not specified, `None` will be returned.
    pub fn try_build_wrapper(self) -> Option<WebRegWrapper> {
        if let Some(cookies) = self.cookies {
            Some(WebRegWrapper {
                data: WebRegWrapperData {
                    #[cfg(feature = "multi")]
                    cookies: Mutex::new(cookies),
                    #[cfg(not(feature = "multi"))]
                    cookies,
                    client: self.client,
                    user_agent: self.user_agent,
                    timeout: self.default_timeout,
                    close_after_request: self.close_after_request,
                },
            })
        } else {
            None
        }
    }
}

impl Default for WebRegWrapperBuilder {
    fn default() -> Self {
        Self::new()
    }
}