Merge branch 'master' into 'master'

Code cleanup/formatting

See merge request !2

src/database/entities/user.rs

-use crate::{database::get_collection, notifications::events::ClientboundNotification, util::result::{Error, Result}};
 use crate::database::guards::reference::Ref;
-use mongodb::{bson::{doc, from_bson, Bson}, options::FindOptions};
+use crate::{
+    database::get_collection,
+    notifications::events::ClientboundNotification,
+    util::result::{Error, Result},
+};
+use futures::StreamExt;
+use mongodb::{
+    bson::{doc, from_bson, Bson},
+    options::FindOptions,
+};
 use rauth::auth::Session;
 use rocket::http::Status;
 use rocket::request::{self, FromRequest, Outcome, Request};
 use serde::{Deserialize, Serialize};
-use futures::StreamExt;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum RelationshipStatus {
@@ -35,7 +42,7 @@ pub struct User {
 
     // ? This should never be pushed to the collection.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub relationship: Option<RelationshipStatus>
+    pub relationship: Option<RelationshipStatus>,
 }
 
 #[rocket::async_trait]
@@ -77,13 +84,13 @@ impl User {
 
     pub async fn generate_ready_payload(self) -> Result<ClientboundNotification> {
         let mut users = vec![];
-        
+
         if let Some(relationships) = &self.relations {
             let user_ids: Vec<String> = relationships
                 .iter()
                 .map(|relationship| relationship.id.clone())
                 .collect();
-            
+
             let mut cursor = get_collection("users")
                 .find(
                     doc! {
@@ -93,23 +100,29 @@ impl User {
                     },
                     FindOptions::builder()
                         .projection(doc! { "_id": 1, "username": 1 })
-                        .build()
+                        .build(),
                 )
                 .await
-                .map_err(|_| Error::DatabaseError { operation: "find", with: "users" })?;
-            
+                .map_err(|_| Error::DatabaseError {
+                    operation: "find",
+                    with: "users",
+                })?;
+
             while let Some(result) = cursor.next().await {
                 if let Ok(doc) = result {
-                    let mut user: User = from_bson(Bson::Document(doc))
-                        .map_err(|_| Error::DatabaseError { operation: "from_bson", with: "user" })?;
-                    
+                    let mut user: User =
+                        from_bson(Bson::Document(doc)).map_err(|_| Error::DatabaseError {
+                            operation: "from_bson",
+                            with: "user",
+                        })?;
+
                     user.relationship = Some(
                         relationships
                             .iter()
                             .find(|x| user.id == x.id)
                             .ok_or_else(|| Error::InternalError)?
                             .status
-                            .clone()
+                            .clone(),
                     );
 
                     users.push(user);

src/notifications/events.rs

@@ -33,7 +33,7 @@ pub enum ClientboundNotification {
     Error(WebSocketError),
     Authenticated,
     Ready {
-        users: Vec<User>
+        users: Vec<User>,
     },
 
     /*MessageCreate {

src/notifications/websocket.rs

@@ -97,11 +97,10 @@ async fn accept(stream: TcpStream) {
                                             ) {
                                                 send(ClientboundNotification::Authenticated);
 
-                                                match task::block_on(
-                                                    user.generate_ready_payload()
-                                                ) {
+                                                match task::block_on(user.generate_ready_payload())
+                                                {
                                                     Ok(payload) => {
-                                                    send(payload);
+                                                        send(payload);
                                                     }
                                                     Err(_) => {
                                                         send(ClientboundNotification::Error(

src/routes/root.rs

-use crate::util::variables::{DISABLE_REGISTRATION, HCAPTCHA_SITEKEY, USE_EMAIL, USE_HCAPTCHA, EXTERNAL_WS_URL};
+use crate::util::variables::{
+    DISABLE_REGISTRATION, EXTERNAL_WS_URL, HCAPTCHA_SITEKEY, USE_EMAIL, USE_HCAPTCHA,
+};
 
 use mongodb::bson::doc;
 use rocket_contrib::json::JsonValue;

src/routes/users/add_friend.rs

@@ -13,29 +13,39 @@ use crate::{
 };
 use futures::try_join;
 use mongodb::bson::doc;
-use mongodb::options::{FindOneOptions, Collation};
+use mongodb::options::{Collation, FindOneOptions};
 use rocket_contrib::json::JsonValue;
 
 #[put("/<username>/friend")]
 pub async fn req(user: User, username: String) -> Result<JsonValue> {
     let col = get_collection("users");
-    let doc = col.find_one(
-        doc! {
-            "username": username
-        },
-        FindOneOptions::builder()
-            .collation(Collation::builder().locale("en").strength(2).build())
-            .build(),
-    )
-    .await
-    .map_err(|_| Error::DatabaseError { operation: "find_one", with: "user" })?
-    .ok_or_else(|| Error::UnknownUser)?;
+    let doc = col
+        .find_one(
+            doc! {
+                "username": username
+            },
+            FindOneOptions::builder()
+                .collation(Collation::builder().locale("en").strength(2).build())
+                .build(),
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find_one",
+            with: "user",
+        })?
+        .ok_or_else(|| Error::UnknownUser)?;
 
-    let target_id = doc
-        .get_str("_id")
-        .map_err(|_| Error::DatabaseError { operation: "get_str(_id)", with: "user" })?;
+    let target_id = doc.get_str("_id").map_err(|_| Error::DatabaseError {
+        operation: "get_str(_id)",
+        with: "user",
+    })?;
 
-    match get_relationship(&user, &Ref { id: target_id.to_string() }) {
+    match get_relationship(
+        &user,
+        &Ref {
+            id: target_id.to_string(),
+        },
+    ) {
         RelationshipStatus::User => return Err(Error::NoEffect),
         RelationshipStatus::Friend => return Err(Error::AlreadyFriends),
         RelationshipStatus::Outgoing => return Err(Error::AlreadySentRequest),

src/routes/users/mod.rs

 use rocket::Route;
 
 mod add_friend;
-mod get_avatar;
 mod block_user;
 mod fetch_dms;
 mod fetch_relationship;
 mod fetch_relationships;
 mod fetch_user;
+mod get_avatar;
 mod open_dm;
 mod remove_friend;
 mod unblock_user;
@@ -16,11 +16,9 @@ pub fn routes() -> Vec<Route> {
         // User Information
         fetch_user::req,
         get_avatar::req,
-
         // Direct Messaging
         fetch_dms::req,
         open_dm::req,
-
         // Relationships
         fetch_relationships::req,
         fetch_relationship::req,

src/routes/users/remove_friend.rs

@@ -16,10 +16,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
     let col = get_collection("users");
 
     match get_relationship(&user, &target) {
-        RelationshipStatus::Blocked
-        | RelationshipStatus::BlockedOther
-        | RelationshipStatus::User
-        | RelationshipStatus::None => Err(Error::NoEffect),
         RelationshipStatus::Friend
         | RelationshipStatus::Outgoing
         | RelationshipStatus::Incoming => {
@@ -80,5 +76,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
                 }),
             }
         }
+        _ => Err(Error::NoEffect),
     }
 }

src/routes/users/unblock_user.rs

@@ -16,12 +16,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
     let col = get_collection("users");
 
     match get_relationship(&user, &target) {
-        RelationshipStatus::None
-        | RelationshipStatus::User
-        | RelationshipStatus::BlockedOther
-        | RelationshipStatus::Incoming
-        | RelationshipStatus::Outgoing
-        | RelationshipStatus::Friend => Err(Error::NoEffect),
         RelationshipStatus::Blocked => {
             match get_relationship(&target.fetch_user().await?, &user.as_ref()) {
                 RelationshipStatus::Blocked => {
@@ -115,5 +109,6 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
                 _ => Err(Error::InternalError),
             }
         }
+        _ => Err(Error::NoEffect),
     }
 }

src/util/variables.rs

@@ -42,12 +42,8 @@ lazy_static! {
 pub fn preflight_checks() {
     if *USE_EMAIL == false {
         #[cfg(not(debug_assertions))]
-        {
-            if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
-                panic!(
-                    "Not letting you run this in production, set REVOLT_UNSAFE_NO_EMAIL=1 to run."
-                );
-            }
+        if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
+            panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
         }
 
         #[cfg(debug_assertions)]
@@ -56,10 +52,8 @@ pub fn preflight_checks() {
 
     if *USE_HCAPTCHA == false {
         #[cfg(not(debug_assertions))]
-        {
-            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
-                panic!("Not letting you run this in production, set REVOLT_UNSAFE_NO_CAPTCHA=1 to run.");
-            }
+        if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
+            panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
         }
 
         #[cfg(debug_assertions)]