leetup 1.2.6

Leetcode cli
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

use crate::{service::Session, Config, LeetUpError, Result};
use anyhow::anyhow;
use log::debug;
use reqwest::{header, header::HeaderMap, header::HeaderValue, Client, Response};

pub struct RemoteClient<'a> {
    config: &'a Config,
    session: Option<&'a Session>,
}

impl<'a> RemoteClient<'_> {
    pub fn new(config: &'a Config, session: Option<&'a Session>) -> RemoteClient<'a> {
        RemoteClient { config, session }
    }

    /// Make a GET request
    pub async fn get(
        &self,
        url: &str,
        headers_opt: Option<HeaderMap>,
        session: Option<&Session>,
    ) -> Result<Response> {
        let headers = self.headers_with_session(headers_opt, session);
        let client = Client::builder().default_headers(headers).build()?;
        client.get(url).send().await.map_err(LeetUpError::Reqwest)
    }

    /// Make a POST request
    pub async fn post<T: serde::Serialize + ?Sized, F>(
        &self,
        url: &str,
        body: &T,
        with_headers: F,
    ) -> Result<serde_json::value::Value>
    where
        F: FnOnce() -> Option<HeaderMap>,
    {
        let headers = self.headers_with_session(with_headers(), self.session);
        debug!("Headers: {:#?}", headers);
        let client = Client::builder().default_headers(headers).build()?;

        let client = client
            .post(url)
            .header(
                header::ORIGIN,
                HeaderValue::from_str(&self.config.urls.base).unwrap(),
            )
            .json(body);

        let res = client.send().await?;

        if res.status() == 200 {
            res.json::<serde_json::value::Value>()
                .await
                .map_err(|e| e.into())
        } else {
            Err(LeetUpError::Any(anyhow!("Status: {}", res.status())))
        }
    }

    fn headers_with_session(
        &self,
        headers_opt: Option<HeaderMap>,
        session: Option<&Session>,
    ) -> HeaderMap {
        let mut headers = headers_opt.unwrap_or_default();

        if let Some(session) = session {
            let cookie: String = session.into();
            headers.insert("Cookie", HeaderValue::from_str(&cookie).unwrap());
            headers.insert("X-CSRFToken", HeaderValue::from_str(&session.csrf).unwrap());
            headers.insert(
                "X-Requested-With",
                HeaderValue::from_static("XMLHttpRequest"),
            );
        }

        headers
    }
}