style: cargo clippy & cargo fmt

src/objects/channel.rs

@@ -183,12 +183,11 @@ impl Channel {
             .await?;
 
         if data
-            .get_cache_key(format!("{}_channels", guild_uuid))
+            .get_cache_key(format!("{guild_uuid}_channels"))
             .await
             .is_ok()
         {
-            data.del_cache_key(format!("{}_channels", guild_uuid))
-                .await?;
+            data.del_cache_key(format!("{guild_uuid}_channels")).await?;
         }
 
         Ok(channel)

src/objects/email_token.rs

@@ -16,7 +16,11 @@ pub struct EmailToken {
 
 impl EmailToken {
     pub async fn get(data: &Data, user_uuid: Uuid) -> Result<EmailToken, Error> {
-        let email_token = serde_json::from_str(&data.get_cache_key(format!("{}_email_verify", user_uuid)).await?)?;
+        let email_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_email_verify"))
+                .await?,
+        )?;
 
         Ok(email_token)
     }
@@ -29,14 +33,15 @@ impl EmailToken {
             user_uuid: me.uuid,
             token: token.clone(),
             // TODO: Check if this can be replaced with something built into valkey
-            created_at: Utc::now()
+            created_at: Utc::now(),
         };
 
-        data.set_cache_key(format!("{}_email_verify", me.uuid), email_token,  86400).await?;
+        data.set_cache_key(format!("{}_email_verify", me.uuid), email_token, 86400)
+            .await?;
 
         let mut verify_endpoint = data.config.web.frontend_url.join("verify-email")?;
 
-        verify_endpoint.set_query(Some(&format!("token={}", token)));
+        verify_endpoint.set_query(Some(&format!("token={token}")));
 
         let email = data
             .mail_client
@@ -54,7 +59,8 @@ impl EmailToken {
     }
 
     pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_email_verify", self.user_uuid)).await?;
+        data.del_cache_key(format!("{}_email_verify", self.user_uuid))
+            .await?;
 
         Ok(())
     }

src/objects/member.rs

@@ -5,7 +5,12 @@ use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{error::Error, objects::{Permissions, Role}, schema::guild_members, Conn, Data};
+use crate::{
+    Conn, Data,
+    error::Error,
+    objects::{Permissions, Role},
+    schema::guild_members,
+};
 
 use super::{User, load_or_empty};
 
@@ -34,12 +39,16 @@ impl MemberBuilder {
         })
     }
 
-    pub async fn check_permission(&self, data: &Data, permission: Permissions) -> Result<(), Error> {
+    pub async fn check_permission(
+        &self,
+        data: &Data,
+        permission: Permissions,
+    ) -> Result<(), Error> {
         if !self.is_owner {
-            let roles = Role::fetch_from_member(&data, self.uuid).await?;
+            let roles = Role::fetch_from_member(data, self.uuid).await?;
             let allowed = roles.iter().any(|r| r.permissions & permission as i64 != 0);
             if !allowed {
-                return Err(Error::Forbidden("Not allowed".to_string()))
+                return Err(Error::Forbidden("Not allowed".to_string()));
             }
         }
 

src/objects/mod.rs

@@ -26,8 +26,8 @@ pub use me::Me;
 pub use member::Member;
 pub use message::Message;
 pub use password_reset_token::PasswordResetToken;
-pub use role::Role;
 pub use role::Permissions;
+pub use role::Role;
 pub use user::User;
 
 use crate::error::Error;
@@ -106,7 +106,7 @@ impl MailClient {
 
         let response = mailer.send(email).await?;
 
-        debug!("mail sending response: {:?}", response);
+        debug!("mail sending response: {response:?}");
 
         Ok(())
     }

src/objects/password_reset_token.rs

@@ -3,19 +3,17 @@ use argon2::{
     password_hash::{SaltString, rand_core::OsRng},
 };
 use chrono::Utc;
-use diesel::{
-    ExpressionMethods, QueryDsl, update,
-};
+use diesel::{ExpressionMethods, QueryDsl, update};
 use diesel_async::RunQueryDsl;
 use lettre::message::MultiPart;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
+    Data,
     error::Error,
     schema::users,
-    utils::{generate_token, global_checks, user_uuid_from_identifier, PASSWORD_REGEX},
-    Data
+    utils::{PASSWORD_REGEX, generate_token, global_checks, user_uuid_from_identifier},
 };
 
 #[derive(Serialize, Deserialize)]
@@ -27,8 +25,12 @@ pub struct PasswordResetToken {
 
 impl PasswordResetToken {
     pub async fn get(data: &Data, token: String) -> Result<PasswordResetToken, Error> {
-        let user_uuid: Uuid = serde_json::from_str(&data.get_cache_key(format!("{}", token)).await?)?;
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
+        let user_uuid: Uuid = serde_json::from_str(&data.get_cache_key(token.to_string()).await?)?;
+        let password_reset_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_password_reset"))
+                .await?,
+        )?;
 
         Ok(password_reset_token)
     }
@@ -41,7 +43,11 @@ impl PasswordResetToken {
 
         let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
 
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
+        let password_reset_token = serde_json::from_str(
+            &data
+                .get_cache_key(format!("{user_uuid}_password_reset"))
+                .await?,
+        )?;
 
         Ok(password_reset_token)
     }
@@ -69,12 +75,17 @@ impl PasswordResetToken {
             created_at: Utc::now(),
         };
 
-        data.set_cache_key(format!("{}_password_reset", user_uuid), password_reset_token,  86400).await?;
+        data.set_cache_key(
+            format!("{user_uuid}_password_reset"),
+            password_reset_token,
+            86400,
+        )
+        .await?;
         data.set_cache_key(token.clone(), user_uuid, 86400).await?;
 
         let mut reset_endpoint = data.config.web.frontend_url.join("reset-password")?;
 
-        reset_endpoint.set_query(Some(&format!("token={}", token)));
+        reset_endpoint.set_query(Some(&format!("token={token}")));
 
         let email = data
             .mail_client
@@ -134,12 +145,13 @@ impl PasswordResetToken {
 
         data.mail_client.send_mail(email).await?;
 
-        self.delete(&data).await
+        self.delete(data).await
     }
 
     pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_password_reset", &self.user_uuid)).await?;
-        data.del_cache_key(format!("{}", &self.token)).await?;
+        data.del_cache_key(format!("{}_password_reset", &self.user_uuid))
+            .await?;
+        data.del_cache_key(self.token.to_string()).await?;
 
         Ok(())
     }

src/objects/role.rs

@@ -6,7 +6,12 @@ use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{error::Error, schema::{role_members, roles}, utils::order_by_is_above, Conn, Data};
+use crate::{
+    Conn, Data,
+    error::Error,
+    schema::{role_members, roles},
+    utils::order_by_is_above,
+};
 
 use super::{HasIsAbove, HasUuid, load_or_empty};
 
@@ -70,8 +75,8 @@ impl Role {
     }
 
     pub async fn fetch_from_member(data: &Data, member_uuid: Uuid) -> Result<Vec<Self>, Error> {
-        if let Ok(roles) = data.get_cache_key(format!("{}_roles", member_uuid)).await {
-            return Ok(serde_json::from_str(&roles)?)
+        if let Ok(roles) = data.get_cache_key(format!("{member_uuid}_roles")).await {
+            return Ok(serde_json::from_str(&roles)?);
         }
 
         let mut conn = data.pool.get().await?;
@@ -91,7 +96,8 @@ impl Role {
             roles.push(membership.fetch_role(&mut conn).await?);
         }
 
-        data.set_cache_key(format!("{}_roles", member_uuid), roles.clone(), 300).await?;
+        data.set_cache_key(format!("{member_uuid}_roles"), roles.clone(), 300)
+            .await?;
 
         Ok(roles)
     }
@@ -108,7 +114,7 @@ impl Role {
     }
 
     pub async fn fetch_permissions(&self) -> Vec<Permissions> {
-        Permissions::fetch_permissions(self.permissions.clone())
+        Permissions::fetch_permissions(self.permissions)
     }
 
     pub async fn new(conn: &mut Conn, guild_uuid: Uuid, name: String) -> Result<Self, Error> {