Run cargo fmt.

src/database/entities/channel.rs

@@ -1,7 +1,7 @@
 use crate::database::*;
+use crate::util::result::{Error, Result};
 use mongodb::bson::to_document;
 use serde::{Deserialize, Serialize};
-use crate::util::result::{Error, Result};
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(tag = "type")]

src/database/entities/message.rs

@@ -1,5 +1,9 @@
-use crate::{database::*, notifications::events::ClientboundNotification, util::result::{Error, Result}};
-use mongodb::bson::{DateTime, to_bson};
+use crate::{
+    database::*,
+    notifications::events::ClientboundNotification,
+    util::result::{Error, Result},
+};
+use mongodb::bson::{to_bson, DateTime};
 use serde::{Deserialize, Serialize};
 
 /*#[derive(Serialize, Deserialize, Debug)]
@@ -39,13 +43,13 @@ pub struct Message {
 impl Message {
     pub async fn send(self) -> Result<()> {
         get_collection("messages")
-            .insert_one(
-                to_bson(&self).unwrap().as_document().unwrap().clone(),
-                None
-            )
+            .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
             .await
-            .map_err(|_| Error::DatabaseError { operation: "insert_one", with: "messages" })?;
-        
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "messages",
+            })?;
+
         let channel = self.channel.clone();
         ClientboundNotification::Message(self)
             .publish(channel)

src/database/guards/reference.rs

@@ -1,11 +1,11 @@
 use crate::database::*;
 use crate::util::result::{Error, Result};
 
-use validator::Validate;
+use mongodb::bson::{doc, from_bson, from_document, Bson};
 use rocket::http::RawStr;
 use rocket::request::FromParam;
-use mongodb::bson::{Bson, doc, from_bson, from_document};
-use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use validator::Validate;
 
 #[derive(Validate, Serialize, Deserialize)]
 pub struct Ref {
@@ -33,12 +33,10 @@ impl Ref {
             })?
             .ok_or_else(|| Error::UnknownUser)?;
 
-        Ok(
-            from_document::<T>(doc).map_err(|_| Error::DatabaseError {
-                operation: "from_document",
-                with: &collection,
-            })?,
-        )
+        Ok(from_document::<T>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: &collection,
+        })?)
     }
 
     pub async fn fetch_user(&self) -> Result<User> {

src/database/guards/user.rs

@@ -1,6 +1,6 @@
 use crate::database::*;
 
-use mongodb::bson::{Bson, doc, from_bson, from_document};
+use mongodb::bson::{doc, from_bson, from_document, Bson};
 use rauth::auth::Session;
 use rocket::http::Status;
 use rocket::request::{self, FromRequest, Outcome, Request};

src/database/migrations/scripts.rs

@@ -2,7 +2,7 @@ use super::super::{get_collection, get_db};
 
 use crate::rocket::futures::StreamExt;
 use log::info;
-use mongodb::bson::{Bson, doc, from_bson, from_document};
+use mongodb::bson::{doc, from_bson, from_document, Bson};
 use mongodb::options::FindOptions;
 use serde::{Deserialize, Serialize};
 

src/database/permissions/channel.rs

@@ -23,28 +23,28 @@ pub async fn calculate(user: &User, target: &Channel) -> ChannelPermissions<[u32
     match target {
         Channel::SavedMessages { user: owner, .. } => {
             if &user.id == owner {
-                ChannelPermissions([ ChannelPermission::View + ChannelPermission::SendMessage ])
+                ChannelPermissions([ChannelPermission::View + ChannelPermission::SendMessage])
             } else {
-                ChannelPermissions([ 0 ])
+                ChannelPermissions([0])
             }
         }
         Channel::DirectMessage { recipients, .. } => {
             if recipients.iter().find(|x| *x == &user.id).is_some() {
-                if let Some(recipient) = recipients
-                    .iter()
-                    .find(|x| *x != &user.id) {
+                if let Some(recipient) = recipients.iter().find(|x| *x != &user.id) {
                     let perms = super::user::calculate(&user, recipient).await;
 
                     if perms.get_send_message() {
-                        return ChannelPermissions([ ChannelPermission::View + ChannelPermission::SendMessage ]);
+                        return ChannelPermissions([
+                            ChannelPermission::View + ChannelPermission::SendMessage
+                        ]);
                     }
-                    
-                    return ChannelPermissions([ ChannelPermission::View as u32 ]);
+
+                    return ChannelPermissions([ChannelPermission::View as u32]);
                 }
             }
 
-            ChannelPermissions([ 0 ])
+            ChannelPermissions([0])
         }
-        _ => unreachable!()
+        _ => unreachable!(),
     }
 }

src/database/permissions/mod.rs

@@ -1,4 +1,4 @@
-pub mod user;
 pub mod channel;
+pub mod user;
 
 pub use user::get_relationship;

src/database/permissions/user.rs

@@ -31,20 +31,20 @@ pub async fn calculate(user: &User, target: &str) -> UserPermissions<[u32; 1]> {
     let mut permissions: u32 = 0;
     match get_relationship(&user, &target) {
         RelationshipStatus::Friend => {
-            return UserPermissions([ UserPermission::Access + UserPermission::SendMessage + UserPermission::Invite ])
+            return UserPermissions([UserPermission::Access
+                + UserPermission::SendMessage
+                + UserPermission::Invite])
         }
-        RelationshipStatus::Blocked |
-        RelationshipStatus::BlockedOther => {
-            return UserPermissions([ UserPermission::Access as u32 ])
+        RelationshipStatus::Blocked | RelationshipStatus::BlockedOther => {
+            return UserPermissions([UserPermission::Access as u32])
         }
-        RelationshipStatus::Incoming |
-        RelationshipStatus::Outgoing => {
+        RelationshipStatus::Incoming | RelationshipStatus::Outgoing => {
             permissions = UserPermission::Access as u32;
         }
         _ => {}
     }
 
-    UserPermissions([ permissions ])
+    UserPermissions([permissions])
 }
 
 pub fn get_relationship(a: &User, b: &str) -> RelationshipStatus {