Simplify requests, completed "getting-category-problems" api

Author: clearloop

CHANGELOG.md

@@ -1,5 +1,6 @@
+### 1.Write down all leetcode api.
 
-### Decrypt cookie from google chrome
+### 0.Decrypt cookie from google chrome
 
 #### First few words are strange.
 1. check if the res can pass

Cargo.lock

@@ -1,9 +1,7 @@
 # leetcode-cli
 
-ref to [leetcode-cli](https://github.com/skygragon/leetcode-cli), rust version.
+ref to [leetcode-cli](https://github.com/skygragon/leetcode-cli), rust version, [spec](/spec.md)
 
 ## Note
 
-Please make sure you have logined in leetcode.com with chrome.
-
-
+Please make sure you have logined in `leetcode.com` with `chrome`.

README.md

@@ -0,0 +1,12 @@
+### 1.Write down all leetcode api.
+
+### 0.Decrypt cookie from google chrome
+
+#### First few words are strange.
+1. check if the res can pass
+2. check bytes with other platform(node version)
+3. replace aes-128-cbc to try
+4. follow crypto guide to implement decrypt
+5. check line by line
+6. find the iv bug
+7. remove aes tmp blocks

examples/sqlite/main.rs

@@ -4,7 +4,6 @@ fn main() {
     env_logger::init();
 
     let lc = leetcode::LeetCode::new();
-    if let Some(mut res) = lc.get_user_info() {
-        println!("{:#?}", res.text());
-    }
+    let mut res = lc.get_category_problems("database");
+    println!("{:#?}", res.text());
 }

spec.md

@@ -70,16 +70,21 @@ pub fn cookies() -> Ident {
     let res = cookies
         .filter(host_key.like("%leetcode.com"))
         .load::<Cookies>(&conn)
-        .expect("Error loading cookies");
+        .expect("Loading cookies from google chrome failed.");
 
+    // Get system password
+    let ring = Keyring::new("Chrome Safe Storage", "Chrome");
+    let pass = ring.get_password().expect("Get Password failed");
+
+    // Decode cookies
     let mut m: HashMap<String, String> = HashMap::new();
     for c in res.to_owned() {
         if (
             c.name == "csrftoken".to_string()
         ) || (
             c.name == "LEETCODE_SESSION".to_string()
         ) {
-            m.insert(c.name, decode_cookies(c.encrypted_value));
+            m.insert(c.name, decode_cookies(&pass, c.encrypted_value));
         }
     }
 
@@ -91,13 +96,10 @@ pub fn cookies() -> Ident {
 
 
 /// Decode cookies from chrome
-fn decode_cookies(v: Vec<u8>) -> String {
-    let ring = Keyring::new("Chrome Safe Storage", "Chrome");
-    let pass = ring.get_password().expect("Get Password failed");
-
+fn decode_cookies(pass: &str, v: Vec<u8>) -> String {
     let mut key = [0_u8; 16];
     pkcs5::pbkdf2_hmac(
-        &pass.as_bytes(),
+        pass.as_bytes(),
         b"saltysalt",
         1003,
         hash::MessageDigest::sha1(),

spec/README.md

@@ -1,3 +1,9 @@
+use self::req::{Json, Mode, Req};
+use crate::{
+    conf::{self, Config},
+    plugins::chrome,
+};
+
 use std::{
     collections::HashMap,
     str::FromStr,
@@ -15,14 +21,6 @@ use reqwest::{
     }
 };
 
-use crate::{
-    plugins::chrome,
-    conf::{self, Config},
-};
-
-/// Standardize leetcode api response
-pub type LeetCodeResp = Option<Response>;
-
 /// Leet API set
 pub struct LeetCode {
     conf: Config,
@@ -31,7 +29,8 @@ pub struct LeetCode {
 }
 
 impl LeetCode {
-    fn headers(mut headers: HeaderMap, ts: Vec<(&str, &str)>) -> HeaderMap {
+    /// Parse reqwest headers
+    pub fn headers(mut headers: HeaderMap, ts: Vec<(&str, &str)>) -> HeaderMap {
         for (k, v) in ts.into_iter() {
             headers.insert(
                 HeaderName::from_str(k).unwrap(),
@@ -41,10 +40,10 @@ impl LeetCode {
 
         headers
     }
-    
+
+    /// New LeetCode client
     pub fn new() -> LeetCode {
-        debug!("building reqwest client...");
-        
+        debug!("Building reqwest client...");
         let conf = conf::locate();
         let cookies = chrome::cookies();
         let default_headers = LeetCode::headers(
@@ -71,40 +70,40 @@ impl LeetCode {
         }
     }
 
-    pub fn get_favorites(self) -> LeetCodeResp {
-        debug!("running leetcode.get_category_problems...");
+    /// Get user favorite problems
+    pub fn get_favorites(self) -> Response {
         let url = &self.conf.sys.urls["favorites"];
-        let headers = LeetCode::headers(
-            self.default_headers,
-            vec![("Referer", url)],
-        );
 
-        let req = self.client
-            .get(url)
-            .headers(headers);
+        Req {
+            default_headers: self.default_headers,
+            info: false,
+            json: None,
+            mode: Mode::Get,
+            name: "get_favorites",
+            url: url.to_string(),
+        }.send(&self.client)
+    }
 
-        println!("{:#?}", &req);
-        let res = req
-            .send();
+    /// Get category problems
+    pub fn get_category_problems(self, category: &'static str) -> Response {
+        let pre_url = &self.conf.sys.urls["problems"];
+        let url = &pre_url.replace("$category", category);
 
-        match res.is_err() {
-            true => {
-                error!("get_favorites request failed.");
-                None
-            }
-            _ => Some(res.unwrap())
-        }
+        Req {
+            default_headers: self.default_headers,
+            info: false,
+            json: None,
+            mode: Mode::Get,
+            name: "get_category_problems",
+            url: url.to_string(),
+        }.send(&self.client)
     }
-    
-    pub fn get_user_info(self) -> Option<Response> {
-        debug!("running leetcode.get_user_info...");
-        let headers = LeetCode::headers(
-            self.default_headers,
-            vec![("Referer", &self.conf.sys.urls["graphql"])],
-        );
-        
-        let mut m: HashMap<&str, &str> = HashMap::new();
-        m.insert(
+
+    /// Get user info
+    pub fn get_user_info(self) -> Response {
+        let url = &self.conf.sys.urls["graphql"];
+        let mut json: Json = HashMap::new();
+        json.insert(
             "query",
             r#"{
               user {
@@ -113,19 +112,81 @@ impl LeetCode {
               },
             }"#,
         );
+        
+        Req {
+            default_headers: self.default_headers,
+            info: false,
+            json: Some(json),
+            mode: Mode::Post,
+            name: "get_user_info",
+            url: url.to_string(),
+        }.send(&self.client)
+    }
+}
 
-        let res = self.client
-            .post(&self.conf.sys.urls["graphql"])
-            .headers(headers)
-            .json(&m)
-            .send();
 
-        match res.is_err() {
-            true => {
-                error!("get_user_info request failed.");
-                None
+/// Sub-module for leetcode, simplify requests
+mod req {
+    use super::LeetCode;
+    use std::collections::HashMap;
+    use reqwest::{
+        Client,
+        header::HeaderMap,
+        RequestBuilder,
+        Response,
+    };
+
+    /// Standardize json format
+    pub type Json = HashMap<&'static str, &'static str>;
+
+    /// Standardize request mode
+    pub enum Mode {
+        Get,
+        Post
+    }
+
+    /// LeetCode request prototype
+    pub struct Req {
+        pub default_headers: HeaderMap,
+        pub json: Option<Json>,
+        pub info: bool,
+        pub mode: Mode,
+        pub name: &'static str,
+        pub url: String,
+    }
+
+    impl Req {
+        pub fn send<'req>(self, client: &'req Client) -> Response {
+            debug!("Running leetcode::{}...", &self.name);
+            if self.info {
+                info!("Downloading {} deps...", &self.name);
+            }
+            
+            let headers = LeetCode::headers(
+                self.default_headers,
+                vec![("Referer", &self.url)],
+            );
+
+            let req: RequestBuilder;
+            match self.mode {
+                Mode::Get => {
+                    req = client.get(&self.url);
+                },
+                Mode::Post => {
+                    req = client.post(&self.url).json(&self.json);
+                }
+            }
+            
+            let res = req
+                .headers(headers)
+                .send();
+
+            if res.is_err() {
+                error!("leetcode::{} went error.", &self.name);
+                panic!("leetcode::{} failed.", &self.name);
             }
-            _ => Some(res.unwrap())
+
+            res.unwrap()
         }
     }
 }