Merge branch 'dev'

Author: hayd1n

.gitignore

@@ -15,6 +15,8 @@ Cargo.lock
 
 
 # Added by cargo
-
 /target
 /Cargo.lock
+
+# macOS
+.DS_Store

Cargo.toml

@@ -1,18 +1,21 @@
 [package]
 name = "q"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
-authors = ["CRT-HAO"]
+authors = ["hayd1n", "Hayden Chang <m831718@gmail.com>"]
 repository = "https://github.com/NTUST-Hack/q"
 
-
 [dependencies]
-reqwest = { version = "0.11", features = ["json", "blocking"] }
+reqwest = { version = "0.12.5", features = ["json"] }
 serde = "1.0.196"
 serde-aux = "4.4.0"
 serde_derive = "1.0.196"
 serde_json = "1.0.1"
+serde_with = "3.8.1"
 tokio = { version = "1", features = ["full"] }
+url = "2.5.2"
 
 [dev-dependencies]
+anyhow = "1.0.86"
+futures = "0.3.30"
 tokio-task-pool = "0.1.5"

README.md

@@ -12,16 +12,17 @@ NTUST Query Course Library
 use q::Q;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() -> anyhow::Result<()> {
     let c = Q::new();
 
     let details = c
-        .query("1122", "AT2005701", "en")
+        .query("1131", "TCG046301", q::Language::Zh)
         .await
         .expect("failed to query course description");
 
     println!("{:#?}", details);
 
     Ok(())
 }
+
 ```

examples/blocking_query.rs

@@ -0,0 +1,13 @@
+use q::blocking::Q;
+
+fn main() -> anyhow::Result<()> {
+    let c = Q::new();
+
+    let details = c
+        .query("1122", "AT2005701", q::Language::En)
+        .expect("failed to query course description");
+
+    println!("{:#?}", details);
+
+    Ok(())
+}

examples/custom_reqwest.rs

@@ -0,0 +1,30 @@
+use std::time::Duration;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Use a custom reqwest client builder
+    let mut reqwest_client_builder = q::default_reqwest_builder();
+
+    // Set a timeout of 10 seconds
+    reqwest_client_builder = reqwest_client_builder.timeout(Duration::from_secs(10));
+
+    // Build the reqwest client
+    let reqwest_client = reqwest_client_builder
+        .build()
+        .expect("failed to build reqwest client");
+
+    // Create a new client with the custom reqwest client
+    let c = q::ClientBuilder::new()
+        .reqwest_client(reqwest_client)
+        .build();
+
+    // Query course details
+    let details = c
+        .query("1131", "TCG046301", q::Language::Zh)
+        .await
+        .expect("failed to query course description");
+
+    println!("{:#?}", details);
+
+    Ok(())
+}

examples/query.rs

@@ -1,11 +1,11 @@
 use q::Q;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() -> anyhow::Result<()> {
     let c = Q::new();
 
     let details = c
-        .query("1122", "AT2005701", "en")
+        .query("1131", "TCG046301", q::Language::Zh)
         .await
         .expect("failed to query course description");
 

examples/search.rs

@@ -0,0 +1,19 @@
+use q::Q;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let c = Q::new();
+
+    let mut options = q::SearchOptions::new("1131", q::Language::Zh);
+
+    options.course_no = "cs".to_string();
+
+    let details = c
+        .search(&options, true)
+        .await
+        .expect("failed to search courses");
+
+    println!("{:#?}", details);
+
+    Ok(())
+}

examples/worker_pool.rs

@@ -6,21 +6,24 @@ use std::{
     time::Duration,
 };
 
+use q::QueryError;
 use tokio_task_pool::Pool;
 
 const SEMESTER: &'static str = "1122";
-const LANGUAGE: &'static str = "zh";
+const LANGUAGE: q::Language = q::Language::Zh;
 
-async fn worker(client: &q::Q, course_no: &str) {
-    let details = client.query(SEMESTER, course_no, LANGUAGE).await.unwrap();
+async fn worker(client: &q::Q, course_no: &str) -> Result<(), QueryError> {
+    let details = client.query(SEMESTER, course_no, LANGUAGE).await?;
     println!(
         "{: <10} | {:　<10} | {}/{}",
         details.course_no, details.course_name, details.choose_student, details.restrict2
     );
+
+    Ok(())
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
     const THREADS: usize = 64;
 
     let duration = Duration::from_secs(10);
@@ -66,7 +69,7 @@ async fn main() {
                     let c = clients_clone.get(i % THREADS).unwrap();
                     let no = courses_clone.get(i % courses_length).unwrap();
 
-                    worker(c, no).await;
+                    worker(c, no).await.unwrap();
 
                     times_clone.fetch_add(1, Ordering::Relaxed);
                 })
@@ -87,4 +90,6 @@ async fn main() {
         times.load(Ordering::Relaxed),
         duration
     );
+
+    Ok(())
 }

src/async_impl/mod.rs

@@ -0,0 +1,182 @@
+use std::collections::HashMap;
+
+use url::Url;
+
+use crate::{
+    default_reqwest_builder, CourseDetails, CourseInfo, Language, QueryError, SearchOptions,
+    DEFAULT_API_URL,
+};
+
+#[derive(Debug)]
+pub struct ClientBuilder {
+    reqwest_client: reqwest::Client,
+    base_url: Url,
+}
+
+impl ClientBuilder {
+    pub fn new() -> Self {
+        ClientBuilder {
+            reqwest_client: default_reqwest_builder().build().unwrap(),
+            base_url: Url::parse(&DEFAULT_API_URL).unwrap(),
+        }
+    }
+
+    pub fn reqwest_client(mut self, client: reqwest::Client) -> Self {
+        self.reqwest_client = client;
+        self
+    }
+
+    pub fn api_url(mut self, url: Url) -> Self {
+        self.base_url = url;
+        self
+    }
+
+    pub fn build(self) -> Q {
+        Q {
+            http_client: self.reqwest_client,
+            base_url: self.base_url,
+        }
+    }
+}
+
+pub struct Q {
+    http_client: reqwest::Client,
+    base_url: Url,
+}
+
+impl Q {
+    pub fn new() -> Self {
+        ClientBuilder::new().build()
+    }
+
+    pub async fn search(
+        &self,
+        options: &SearchOptions,
+        merge_courses: bool,
+    ) -> Result<Vec<CourseInfo>, QueryError> {
+        let url = self.base_url.join("courses").unwrap();
+
+        let resp = match self.http_client.post(url).json(&options).send().await {
+            Ok(resp) => resp,
+            Err(e) => return Err(QueryError::HttpError(format!("{}", e))),
+        };
+
+        match resp.json::<Vec<CourseInfo>>().await {
+            Ok(json) => Ok(if merge_courses {
+                crate::merge_courses(json)
+            } else {
+                json
+            }),
+            Err(e) => return Err(QueryError::ParseError(format!("{}", e))),
+        }
+    }
+
+    pub async fn query(
+        &self,
+        semester: &str,
+        course_no: &str,
+        language: Language,
+    ) -> Result<CourseDetails, QueryError> {
+        // is "coursedetials" not "coursedetails"
+        // looks like an idiotic typo in the API
+        let url = self.base_url.join("coursedetials").unwrap();
+
+        let mut params = HashMap::new();
+        params.insert("semester", semester);
+        params.insert("course_no", course_no);
+        params.insert("language", language.as_str());
+
+        let resp = match self.http_client.get(url).query(&params).send().await {
+            Ok(resp) => resp,
+            Err(e) => return Err(QueryError::HttpError(format!("{}", e))),
+        };
+
+        let full = match resp.bytes().await {
+            Ok(bytes) => bytes,
+            Err(e) => return Err(QueryError::ParseError(format!("{}", e))),
+        };
+
+        // # debug
+        // let text = match String::from_utf8(full.to_vec()) {
+        //     Ok(bytes) => bytes,
+        //     Err(e) => return Err(QueryError::ParseError(format!("{}", e))),
+        // };
+        // println!("{}", text);
+
+        let json = match serde_json::from_slice::<Vec<CourseDetails>>(&full) {
+            Ok(json) => json,
+            Err(e) => return Err(QueryError::ParseError(format!("{}", e))),
+        };
+
+        if let Some(course_details) = json.get(0) {
+            Ok(course_details.clone())
+        } else {
+            Err(QueryError::ParseError(format!("No course found")))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::future::join_all;
+
+    #[tokio::test]
+    async fn new() {
+        let _client = Q::new();
+    }
+
+    #[tokio::test]
+    async fn search() {
+        let client = Q::new();
+
+        let mut options = SearchOptions::new("1131", Language::Zh);
+
+        options.course_no = "cs".to_string();
+
+        let _details = client
+            .search(&options, true)
+            .await
+            .expect("failed to search courses");
+
+        println!("{:#?}", _details);
+    }
+
+    #[tokio::test]
+    async fn query() {
+        let client = Q::new();
+
+        let _details = client
+            .query("1122", "AT2005701", Language::Zh)
+            .await
+            .expect("Failed to query");
+
+        println!("{:#?}", _details)
+    }
+
+    #[tokio::test]
+    async fn query_all_cs() {
+        let client = Q::new();
+
+        let mut options = SearchOptions::new("1131", Language::Zh);
+
+        options.course_no = "cs".to_string();
+
+        let search_results = client
+            .search(&options, true)
+            .await
+            .expect("failed to search courses");
+
+        let futures = search_results.into_iter().map(|c| async move {
+            let query_client = Q::new();
+            let details = query_client
+                .query(&c.semester, &c.course_no, Language::Zh)
+                .await
+                .expect("Failed to query");
+
+            println!("{:#?}", details);
+        });
+
+        join_all(futures).await;
+    }
+}