style: cargo fmt

src/api/v1/auth/logout.rs

@@ -38,7 +38,9 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
     refresh_token_cookie.make_removal();
 
     if deleted == 0 {
-        return Ok(HttpResponse::NotFound().cookie(refresh_token_cookie).finish())
+        return Ok(HttpResponse::NotFound()
+            .cookie(refresh_token_cookie)
+            .finish());
     }
 
     Ok(HttpResponse::Ok().cookie(refresh_token_cookie).finish())

src/api/v1/channels/uuid/socket.rs

@@ -83,7 +83,9 @@ pub async fn ws(
 
                     let message_body: MessageBody = serde_json::from_str(&text)?;
 
-                    let message = channel.new_message(&data, uuid, message_body.message, message_body.reply_to).await?;
+                    let message = channel
+                        .new_message(&data, uuid, message_body.message, message_body.reply_to)
+                        .await?;
 
                     redis::cmd("PUBLISH")
                         .arg(&[channel_uuid.to_string(), serde_json::to_string(&message)?])

src/api/v1/guilds/uuid/members.rs

@@ -1,5 +1,9 @@
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Me, Member}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Me, Member},
+    utils::{get_auth_header, global_checks},
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, web};

src/api/v1/me/friends/mod.rs

@@ -1,6 +1,6 @@
+use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
-use ::uuid::Uuid;
 
 pub mod uuid;
 
@@ -57,7 +57,11 @@ struct UserReq {
 /// 400 Bad Request (usually means users are already friends)
 ///
 #[post("/friends")]
-pub async fn post(req: HttpRequest, json: web::Json<UserReq>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
+pub async fn post(
+    req: HttpRequest,
+    json: web::Json<UserReq>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers)?;

src/api/v1/me/friends/uuid.rs

@@ -10,7 +10,11 @@ use crate::{
 };
 
 #[delete("/friends/{uuid}")]
-pub async fn delete(req: HttpRequest, path: web::Path<(Uuid,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
+pub async fn delete(
+    req: HttpRequest,
+    path: web::Path<(Uuid,)>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
     let auth_header = get_auth_header(headers)?;

src/api/v1/me/mod.rs

@@ -10,8 +10,8 @@ use crate::{
     utils::{get_auth_header, global_checks},
 };
 
-mod guilds;
 mod friends;
+mod guilds;
 
 pub fn web() -> Scope {
     web::scope("/me")

src/api/v1/users/uuid.rs

@@ -4,7 +4,11 @@ use actix_web::{HttpRequest, HttpResponse, get, web};
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Me, User}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    objects::{Me, User},
+    utils::{get_auth_header, global_checks},
 };
 
 /// `GET /api/v1/users/{uuid}` Returns user with the given UUID

src/objects/friends.rs

@@ -9,7 +9,7 @@ use crate::schema::{friend_requests, friends};
 #[diesel(table_name = friends)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Friend {
-    pub uuid1:  Uuid,
+    pub uuid1: Uuid,
     pub uuid2: Uuid,
     pub accepted_at: DateTime<Utc>,
 }

src/objects/me.rs

@@ -1,5 +1,8 @@
 use actix_web::web::BytesMut;
-use diesel::{delete, insert_into, update, ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
+use diesel::{
+    ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper, delete, insert_into,
+    update,
+};
 use diesel_async::RunQueryDsl;
 use serde::Serialize;
 use tokio::task;
@@ -7,7 +10,11 @@ use url::Url;
 use uuid::Uuid;
 
 use crate::{
-    error::Error, objects::{FriendRequest, Friend, User}, schema::{friend_requests, friends, guild_members, guilds, users}, utils::{image_check, EMAIL_REGEX, USERNAME_REGEX}, Conn, Data
+    Conn, Data,
+    error::Error,
+    objects::{Friend, FriendRequest, User},
+    schema::{friend_requests, friends, guild_members, guilds, users},
+    utils::{EMAIL_REGEX, USERNAME_REGEX, image_check},
 };
 
 use super::{Guild, guild::GuildBuilder, load_or_empty, member::MemberBuilder};
@@ -121,7 +128,10 @@ impl Me {
     }
 
     pub async fn set_username(&mut self, data: &Data, new_username: String) -> Result<(), Error> {
-        if !USERNAME_REGEX.is_match(&new_username) || new_username.len() < 3 || new_username.len() > 32 {
+        if !USERNAME_REGEX.is_match(&new_username)
+            || new_username.len() < 3
+            || new_username.len() > 32
+        {
             return Err(Error::BadRequest("Invalid username".to_string()));
         }
 
@@ -232,7 +242,11 @@ impl Me {
         Ok(())
     }
 
-    pub async fn friends_with(&self, conn: &mut Conn, user_uuid: Uuid) -> Result<Option<Friend>, Error> {
+    pub async fn friends_with(
+        &self,
+        conn: &mut Conn,
+        user_uuid: Uuid,
+    ) -> Result<Option<Friend>, Error> {
         use friends::dsl;
 
         let friends: Vec<Friend> = if self.uuid < user_uuid {
@@ -241,7 +255,7 @@ impl Me {
                     .filter(dsl::uuid1.eq(self.uuid))
                     .filter(dsl::uuid2.eq(user_uuid))
                     .load(conn)
-                    .await
+                    .await,
             )?
         } else {
             load_or_empty(
@@ -249,12 +263,12 @@ impl Me {
                     .filter(dsl::uuid1.eq(user_uuid))
                     .filter(dsl::uuid2.eq(self.uuid))
                     .load(conn)
-                    .await
+                    .await,
             )?
         };
 
         if friends.is_empty() {
-            return Ok(None)
+            return Ok(None);
         }
 
         Ok(Some(friends[0].clone()))
@@ -263,7 +277,7 @@ impl Me {
     pub async fn add_friend(&self, conn: &mut Conn, user_uuid: Uuid) -> Result<(), Error> {
         if self.friends_with(conn, user_uuid).await?.is_some() {
             // TODO: Check if another error should be used
-            return Err(Error::BadRequest("Already friends with user".to_string()))
+            return Err(Error::BadRequest("Already friends with user".to_string()));
         }
 
         use friend_requests::dsl;
@@ -273,7 +287,7 @@ impl Me {
                 .filter(dsl::sender.eq(user_uuid))
                 .filter(dsl::receiver.eq(self.uuid))
                 .load(conn)
-                .await
+                .await,
         )?;
 
         #[allow(clippy::get_first)]
@@ -316,7 +330,7 @@ impl Me {
     pub async fn remove_friend(&self, conn: &mut Conn, user_uuid: Uuid) -> Result<(), Error> {
         if self.friends_with(conn, user_uuid).await?.is_none() {
             // TODO: Check if another error should be used
-            return Err(Error::BadRequest("Not friends with user".to_string()))
+            return Err(Error::BadRequest("Not friends with user".to_string()));
         }
 
         use friends::dsl;
@@ -348,7 +362,7 @@ impl Me {
                 .filter(dsl::uuid1.eq(self.uuid))
                 .select(Friend::as_select())
                 .load(&mut conn)
-                .await
+                .await,
         )?;
 
         let friends2 = load_or_empty(
@@ -356,7 +370,7 @@ impl Me {
                 .filter(dsl::uuid2.eq(self.uuid))
                 .select(Friend::as_select())
                 .load(&mut conn)
-                .await
+                .await,
         )?;
 
         let friend_futures = friends1.iter().map(async move |friend| {

src/objects/member.rs

@@ -6,7 +6,10 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
-    error::Error, objects::{Me, Permissions, Role}, schema::guild_members, Conn, Data
+    Conn, Data,
+    error::Error,
+    objects::{Me, Permissions, Role},
+    schema::guild_members,
 };
 
 use super::{User, load_or_empty};
@@ -97,7 +100,12 @@ impl Member {
         Ok(member_builder)
     }
 
-    pub async fn fetch_one(data: &Data, me: &Me, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
+    pub async fn fetch_one(
+        data: &Data,
+        me: &Me,
+        user_uuid: Uuid,
+        guild_uuid: Uuid,
+    ) -> Result<Self, Error> {
         let mut conn = data.pool.get().await?;
 
         use guild_members::dsl;

src/objects/mod.rs

@@ -9,6 +9,7 @@ use uuid::Uuid;
 
 mod channel;
 mod email_token;
+mod friends;
 mod guild;
 mod invite;
 mod me;
@@ -17,10 +18,11 @@ mod message;
 mod password_reset_token;
 mod role;
 mod user;
-mod friends;
 
 pub use channel::Channel;
 pub use email_token::EmailToken;
+pub use friends::Friend;
+pub use friends::FriendRequest;
 pub use guild::Guild;
 pub use invite::Invite;
 pub use me::Me;
@@ -30,8 +32,6 @@ pub use password_reset_token::PasswordResetToken;
 pub use role::Permissions;
 pub use role::Role;
 pub use user::User;
-pub use friends::Friend;
-pub use friends::FriendRequest;
 
 use crate::error::Error;
 

src/objects/user.rs

@@ -4,7 +4,7 @@ use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{error::Error, objects::Me, schema::users, Conn, Data};
+use crate::{Conn, Data, error::Error, objects::Me, schema::users};
 
 use super::load_or_empty;
 
@@ -68,7 +68,11 @@ impl User {
         Ok(user)
     }
 
-    pub async fn fetch_one_with_friendship(data: &Data, me: &Me, user_uuid: Uuid) -> Result<Self, Error> {
+    pub async fn fetch_one_with_friendship(
+        data: &Data,
+        me: &Me,
+        user_uuid: Uuid,
+    ) -> Result<Self, Error> {
         let mut conn = data.pool.get().await?;
 
         let mut user = Self::fetch_one(data, user_uuid).await?;