Implement modify(), untested as of now

src/api/users/users.rs

@@ -1,13 +1,15 @@
 use reqwest::Client;
+use serde_json::{from_str, to_string};
 
 use crate::{
     api::{
         limits::Limits,
         types::{User, UserObject},
-        UserSettings,
+        UserModifySchema, UserSettings,
     },
     errors::InstanceServerError,
     instance::Instance,
+    limit::LimitedRequester,
 };
 
 impl<'a> User<'a> {
@@ -77,21 +79,48 @@ impl<'a> User<'a> {
         }
     }
 
+    /// Modify the current user's `UserObject`.
+    ///
+    /// # Arguments
+    ///
+    /// * `modify_schema` - A `UserModifySchema` object containing the fields to modify.
+    ///
+    /// # Errors
+    ///
+    /// Returns an `InstanceServerError` if the request fails or if a password is required but not provided.
     pub async fn modify(
-        self,
+        &mut self,
-        username: Option<&str>,
+        modify_schema: UserModifySchema,
-        avatar: Option<&str>,
+    ) -> Result<UserObject, InstanceServerError> {
-        bio: Option<&str>,
+        if modify_schema.new_password.is_some()
-        accent_color: Option<u64>,
+            || modify_schema.email.is_some()
-        banner: Option<&str>,
+            || modify_schema.code.is_some()
-        current_password: Option<&str>,
+        {
-        new_password: Option<&str>,
+            return Err(InstanceServerError::PasswordRequiredError);
-        code: Option<&str>,
+        }
-        email: Option<&str>,
+        let request = Client::new()
-        discriminator: Option<i16>,
+            .patch(format!("{}/users/@me/", self.belongs_to.urls.get_api()))
-    ) {
+            .body(to_string(&modify_schema).unwrap())
-        let mut limits = self.limits;
+            .bearer_auth(self.token());
-        let request = Client::new().patch(format!("{}/users/@me/", self.belongs_to.urls.get_api()));
+        let result = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Global,
+                &mut self.belongs_to.limits,
+                &mut self.limits,
+            )
+            .await
+        {
+            Ok(response) => response,
+            Err(e) => return Err(e),
+        };
+        let user_updated: UserObject = from_str(&result.text().await.unwrap()).unwrap();
+        let _ = std::mem::replace(
+            &mut self.object.as_mut().unwrap(),
+            &mut user_updated.clone(),
+        );
+        Ok(user_updated)
     }
 }