feat: move everything into a single file and compact it down

src/endpoints/get_cns.rs

@@ -1,52 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// This is what Wolves returns to us
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResult {
-    success: i8,
-    result: Vec<WolvesResultCNS>,
-}
-
-// this is teh actual data we care about
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResultCNS {
-    id: String,
-    name: String,
-    // Link to their page such as https://ulwolves.ie/society/computer
-    link: String,
-    // array of Committee members member_id's
-    committee: Vec<String>,
-}
-
-async fn get_committees(wolves_url_base: &str, api_key: &str) -> Vec<WolvesResultCNS> {
-    if wolves_url_base.is_empty() {
-        return vec![];
-    }
-
-    // TODO: Change teh stored env value to teh base domain
-    // TODO: this address may change
-    let url = format!("{}/get_cns", wolves_url_base);
-
-    // get wolves data
-    match reqwest::Client::new()
-        .post(&url)
-        .header("X-AM-Identity", api_key)
-        .send()
-        .await
-    {
-        Ok(x) => {
-            if let Ok(WolvesResult {success, result }) = x.json::<WolvesResult>().await {
-                if success != 1 {
-                    return vec![];
-                }
-
-                return result;
-            }
-        }
-        Err(e) => {
-            dbg!(e);
-        }
-    }
-
-    vec![]
-}

src/endpoints/get_id_from_email.rs

@@ -1,42 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(untagged)]
-pub enum WolvesResultUserResult {
-    B(bool),
-    S(String),
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResultUser {
-    success: i64,
-    result: WolvesResultUserResult,
-}
-
-async fn get_user(wolves_url_base: &str, api_key: &str ,email: &str) -> Option<i64> {
-    let url = format!("{}/get_id_from_email", wolves_url_base);
-
-    match reqwest::Client::new()
-        .post(&url)
-        .form(&[("email", email)])
-        .header("X-AM-Identity", api_key)
-        .send()
-        .await
-    {
-        Ok(x) => {
-            if let Ok(y) = x.json::<WolvesResultUser>().await {
-                // this is the only time we will get a positive response, the None at the end catches everything else
-                if let WolvesResultUserResult::S(z) = y.result {
-                    if let Ok(id) = z.parse::<i64>() {
-                        return Some(id);
-                    }
-                }
-            }
-        }
-        Err(e) => {
-            dbg!(e);
-        }
-    }
-
-    None
-}

src/endpoints/get_members.rs

@@ -1,55 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResult {
-    success: i8,
-    result: Vec<WolvesResultUser>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-struct WolvesResultUser {
-    // TODO: Might be worth trying to get this replaced with the club/soc ID?
-    committee: String,
-    member_id: String,
-    first_name: String,
-    last_name: String,
-    contact_email: String,
-    opt_in_email: String,
-    student_id: Option<String>,
-    note: Option<String>,
-    expiry: String,
-    requested: String,
-    approved: String,
-    sitename: String,
-    domain: String,
-}
-
-async fn get_wolves_sub(wolves_url_base: &str, api_key: &str) -> Vec<WolvesResultUser> {
-    if wolves_url_base.is_empty() {
-        return vec![];
-    }
-
-    let url = format!("{}/get_members", wolves_url_base);
-    match reqwest::Client::new()
-        .post(&url)
-        .header("X-AM-Identity", api_key)
-        .send()
-        .await
-    {
-        Ok(x) => {
-            if let Ok(WolvesResult {success,result}) = x.json::<WolvesResult>().await {
-                // this is the only time we will get a positive response, the None at the end catches everything else
-                if success != 1 {
-                    return vec![];
-                }
-                return result;
-            }
-
-        }
-        Err(e) => {
-            dbg!(e);
-        }
-    }
-
-    vec![]
-}

src/endpoints/mod.rs

@@ -1,3 +0,0 @@
-mod get_members;
-mod get_cns;
-mod get_id_from_email;

src/lib.rs

@@ -1,16 +1,171 @@
-mod endpoints;
+use serde::{Deserialize, Serialize};
 
-pub fn add(left: u64, right: u64) -> u64 {
+// This is what Wolves returns to us
-    left + right
+// success will always be 1/
+#[derive(Deserialize, Serialize, Debug)]
+struct WolvesResult<T> {
+    success: i8,
+    result: Vec<T>,
 }
 
-#[cfg(test)]
+#[derive(Deserialize, Serialize, Debug)]
-mod tests {
+struct WolvesResultSingle<T> {
-    use super::*;
+    success: i8,
+    result: T,
+}
 
-    #[test]
+// get_members
-    fn it_works() {
+#[derive(Deserialize, Serialize, Debug)]
-        let result = add(2, 2);
+struct WolvesUser {
-        assert_eq!(result, 4);
+    // TODO: Might be worth trying to get this replaced with the club/soc ID?
+    committee: String,
+    member_id: String,
+    first_name: String,
+    last_name: String,
+    contact_email: String,
+    opt_in_email: String,
+    student_id: Option<String>,
+    note: Option<String>,
+    expiry: String,
+    requested: String,
+    approved: String,
+    sitename: String,
+    domain: String,
+}
+
+
+// get_cns
+#[derive(Deserialize, Serialize, Debug)]
+struct WolvesCNS {
+    id: String,
+    name: String,
+    // Link to their page such as https://ulwolves.ie/society/computer
+    link: String,
+    // array of Committee members member_id's
+    committee: Vec<String>,
+}
+
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(untagged)]
+pub enum WolvesUserExists {
+    B(bool),
+    S(String),
+}
+
+pub struct Client<'a> {
+    base_wolves: &'a str,
+    base_key: Option<&'a str>,
+}
+
+impl Client {
+    pub fn new(base_wolves: &str, base_key: Option<&str>) -> Self {
+        Self{
+            base_wolves,
+            base_key
         }
+    }
+
+    // This should handle any method where wolves returns an array
+    async fn get_bulk<T>(self, wolves_endpoint: &str,  api_key: &str) -> Vec<T> {
+        if self.base_wolves.is_empty() {
+            return vec![];
+        }
+
+        let url = format!("{}/{}", self.base_wolves, wolves_endpoint);
+
+        // get wolves data
+        match reqwest::Client::new()
+            .post(&url)
+            .header("X-AM-Identity", api_key)
+            .send()
+            .await
+        {
+            Ok(x) => {
+                if let Ok(WolvesResult {success, result }) = x.json::<WolvesResult<T>>().await {
+                    if success != 1 {
+                        return vec![];
+                    }
+
+                    return result;
+                }
+            }
+            Err(e) => {
+                dbg!(e);
+            }
+        }
+        vec![]
+    }
+
+    // this is the command that gets a list of all members in a club/soc
+    // uses the api key for each club/soc
+    pub async fn get_members(self, api_key: &str) -> Vec<WolvesUser>{
+        self.get_bulk::<WolvesUser>("get_members", api_key)
+    }
+
+    // command to get club/soc and committee members
+    // uses the instance key if it exists
+    pub async fn get_committees(self) -> Vec<WolvesCNS> {
+        if let Some(api_key) = self.base_key {
+            self.get_bulk::<WolvesCNS>("get_cns", api_key)
+        } else {
+            vec![]
+        }
+    }
+
+
+    // method to get member_id from an email
+    // email can be either the login email or contact email
+    pub async fn get_member(self, email: &str) -> Option<i64> {
+        // if the key isnt set then we cant do anything.
+        let api_key = match self.base_key {
+            None => { return None; }
+            Some(key) => {key}
+        };
+
+        let url = format!("{}/get_id_from_email", self.base_wolves);
+
+        match reqwest::Client::new()
+            .post(&url)
+            .form(&[("email", email)])
+            .header("X-AM-Identity", api_key)
+            .send()
+            .await
+        {
+            Ok(x) => {
+                if let Ok(y) = x.json::<WolvesResultSingle<WolvesUserExists>>().await {
+                    // this is the only time we will get a positive response, the None at the end catches everything else
+                    if let WolvesUserExists::S(z) = y.result {
+                        if let Ok(id) = z.parse::<i64>() {
+                            return Some(id);
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                dbg!(e);
+            }
+        }
+
+        None
+    }
+
 }
+
+
+
+
+// pub fn add(left: u64, right: u64) -> u64 {
+//     left + right
+// }
+//
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//
+//     #[test]
+//     fn it_works() {
+//         let result = add(2, 2);
+//         assert_eq!(result, 4);
+//     }
+// }