From 8b09d16542285db0bf52ecf9e1e3d35840dd71e9 Mon Sep 17 00:00:00 2001
From: bitfl0wer <florian@pro-weber.com>
Date: Tue, 9 May 2023 17:19:41 +0200
Subject: [PATCH] Make register and login return UserObject

---
 src/api/auth/register.rs | 56 ++++++++--------------------------------
 src/api/users/users.rs   | 11 +++++---
 2 files changed, 19 insertions(+), 48 deletions(-)

diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs
index 2d78742..be4b56b 100644
--- a/src/api/auth/register.rs
+++ b/src/api/auth/register.rs
@@ -1,9 +1,9 @@
 pub mod register {
     use reqwest::Client;
-    use serde_json::json;
+    use serde_json::{from_str, json};
 
     use crate::{
-        api::{limits::LimitType, schemas::RegisterSchema, types::ErrorResponse},
+        api::{limits::LimitType, schemas::RegisterSchema, types::ErrorResponse, Token},
         errors::InstanceServerError,
         instance::Instance,
     };
@@ -43,9 +43,12 @@ pub mod register {
 
             let response_unwrap = response.unwrap();
             let status = response_unwrap.status();
-            let response_text_string = response_unwrap.text().await.unwrap();
+            let response_unwrap_text = response_unwrap.text().await.unwrap();
+            println!("{}", response_unwrap_text);
+            let token = from_str::<Token>(&response_unwrap_text).unwrap();
+            let token = token.token;
             if status.is_client_error() {
-                let json: ErrorResponse = serde_json::from_str(&response_text_string).unwrap();
+                let json: ErrorResponse = serde_json::from_str(&token).unwrap();
                 let error_type = json.errors.errors.iter().next().unwrap().0.to_owned();
                 let mut error = "".to_string();
                 for (_, value) in json.errors.errors.iter() {
@@ -55,12 +58,9 @@ pub mod register {
                 }
                 return Err(InstanceServerError::InvalidFormBodyError { error_type, error });
             }
-            let user_object = self
-                .get_user(response_text_string.clone(), None)
-                .await
-                .unwrap();
+            let user_object = self.get_user(token.clone(), None).await.unwrap();
             let settings = crate::api::types::User::get_settings(
-                &response_text_string,
+                &token,
                 &self.urls.get_api().to_string(),
                 &mut self.limits,
             )
@@ -68,7 +68,7 @@ pub mod register {
             .unwrap();
             let user: crate::api::types::User = crate::api::types::User::new(
                 self,
-                response_text_string.clone(),
+                token.clone(),
                 cloned_limits,
                 settings,
                 Some(user_object),
@@ -81,42 +81,9 @@ pub mod register {
 #[cfg(test)]
 mod test {
     use crate::api::schemas::{AuthEmail, AuthPassword, AuthUsername, RegisterSchema};
-    use crate::errors::InstanceServerError;
     use crate::instance::Instance;
     use crate::limit::LimitedRequester;
     use crate::URLBundle;
-    #[tokio::test]
-    async fn test_incomplete_registration() {
-        let urls = URLBundle::new(
-            "http://localhost:3001/api".to_string(),
-            "http://localhost:3001".to_string(),
-            "http://localhost:3001".to_string(),
-        );
-        let limited_requester = LimitedRequester::new().await;
-        let mut test_instance = Instance::new(urls.clone(), limited_requester)
-            .await
-            .unwrap();
-        let reg = RegisterSchema::new(
-            AuthUsername::new("hiiii".to_string()).unwrap(),
-            None,
-            true,
-            Some(AuthEmail::new("me@mail.xy".to_string()).unwrap()),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-        assert_eq!(
-            InstanceServerError::InvalidFormBodyError {
-                error_type: "date_of_birth".to_string(),
-                error: "This field is required (BASE_TYPE_REQUIRED)".to_string()
-            },
-            test_instance.register_account(&reg).await.err().unwrap()
-        );
-    }
 
     #[tokio::test]
     async fn test_registration() {
@@ -133,7 +100,7 @@ mod test {
             AuthUsername::new("Hiiii".to_string()).unwrap(),
             Some(AuthPassword::new("mysupersecurepass123!".to_string()).unwrap()),
             true,
-            Some(AuthEmail::new("three12@aaaa.xyz".to_string()).unwrap()),
+            Some(AuthEmail::new("four5@aaaa.xyz".to_string()).unwrap()),
             None,
             None,
             Some("2000-01-01".to_string()),
@@ -143,6 +110,5 @@ mod test {
         )
         .unwrap();
         let token = test_instance.register_account(&reg).await.unwrap().token;
-        println!("{}", token);
     }
 }
diff --git a/src/api/users/users.rs b/src/api/users/users.rs
index 8b53b6c..88a68ca 100644
--- a/src/api/users/users.rs
+++ b/src/api/users/users.rs
@@ -35,16 +35,20 @@ impl<'a> User<'a> {
         }
         let request = reqwest::Client::new().get(url).bearer_auth(token);
         let mut requester = crate::limit::LimitedRequester::new().await;
+        let mut cloned_limits = instance_limits.clone();
         match requester
             .send_request(
                 request,
                 crate::api::limits::LimitType::Ip,
                 instance_limits,
-                &mut Limits::default(),
+                &mut cloned_limits,
             )
             .await
         {
-            Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()),
+            Ok(result) => {
+                let result_text = result.text().await.unwrap();
+                Ok(serde_json::from_str::<UserObject>(&result_text).unwrap())
+            }
             Err(e) => Err(e),
         }
     }
@@ -57,13 +61,14 @@ impl<'a> User<'a> {
         let request: reqwest::RequestBuilder = Client::new()
             .get(format!("{}/users/@me/settings/", url_api))
             .bearer_auth(token);
+        let mut cloned_limits = instance_limits.clone();
         let mut requester = crate::limit::LimitedRequester::new().await;
         match requester
             .send_request(
                 request,
                 crate::api::limits::LimitType::Ip,
                 instance_limits,
-                &mut Limits::default(),
+                &mut cloned_limits,
             )
             .await
         {