src/routes/users/block_user.rs

+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+
+use futures::try_join;
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+
+#[put("/<target>/block")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let col = get_collection("users");
+
+    let target = target.fetch_user().await?;
+
+    match get_relationship(&user, &target.id) {
+        RelationshipStatus::User | RelationshipStatus::Blocked => Err(Error::NoEffect),
+        RelationshipStatus::BlockedOther => {
+            col.update_one(
+                doc! {
+                    "_id": &user.id,
+                    "relations._id": &target.id
+                },
+                doc! {
+                    "$set": {
+                        "relations.$.status": "Blocked"
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "user",
+            })?;
+
+            ClientboundNotification::UserRelationship {
+                id: user.id.clone(),
+                user: target,
+                status: RelationshipStatus::Blocked,
+            }
+            .publish(user.id.clone());
+
+            Ok(json!({ "status": "Blocked" }))
+        }
+        RelationshipStatus::None => {
+            match try_join!(
+                col.update_one(
+                    doc! {
+                        "_id": &user.id
+                    },
+                    doc! {
+                        "$push": {
+                            "relations": {
+                                "_id": &target.id,
+                                "status": "Blocked"
+                            }
+                        }
+                    },
+                    None
+                ),
+                col.update_one(
+                    doc! {
+                        "_id": &target.id
+                    },
+                    doc! {
+                        "$push": {
+                            "relations": {
+                                "_id": &user.id,
+                                "status": "BlockedOther"
+                            }
+                        }
+                    },
+                    None
+                )
+            ) {
+                Ok(_) => {
+                    let target = target
+                        .from_override(&user, RelationshipStatus::Blocked)
+                        .await?;
+                    let user = user
+                        .from_override(&target, RelationshipStatus::BlockedOther)
+                        .await?;
+                    let target_id = target.id.clone();
+
+                    ClientboundNotification::UserRelationship {
+                        id: user.id.clone(),
+                        user: target,
+                        status: RelationshipStatus::Blocked,
+                    }
+                    .publish(user.id.clone());
+
+                    ClientboundNotification::UserRelationship {
+                        id: target_id.clone(),
+                        user,
+                        status: RelationshipStatus::BlockedOther,
+                    }
+                    .publish(target_id);
+
+                    Ok(json!({ "status": "Blocked" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+        RelationshipStatus::Friend
+        | RelationshipStatus::Incoming
+        | RelationshipStatus::Outgoing => {
+            match try_join!(
+                col.update_one(
+                    doc! {
+                        "_id": &user.id,
+                        "relations._id": &target.id
+                    },
+                    doc! {
+                        "$set": {
+                            "relations.$.status": "Blocked"
+                        }
+                    },
+                    None
+                ),
+                col.update_one(
+                    doc! {
+                        "_id": &target.id,
+                        "relations._id": &user.id
+                    },
+                    doc! {
+                        "$set": {
+                            "relations.$.status": "BlockedOther"
+                        }
+                    },
+                    None
+                )
+            ) {
+                Ok(_) => {
+                    let target = target
+                        .from_override(&user, RelationshipStatus::Blocked)
+                        .await?;
+                    let user = user
+                        .from_override(&target, RelationshipStatus::BlockedOther)
+                        .await?;
+                    let target_id = target.id.clone();
+
+                    ClientboundNotification::UserRelationship {
+                        id: user.id.clone(),
+                        user: target,
+                        status: RelationshipStatus::Blocked,
+                    }
+                    .publish(user.id.clone());
+
+                    ClientboundNotification::UserRelationship {
+                        id: target_id.clone(),
+                        user,
+                        status: RelationshipStatus::BlockedOther,
+                    }
+                    .publish(target_id);
+
+                    Ok(json!({ "status": "Blocked" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+    }
+}

src/routes/users/change_username.rs

+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use rauth::auth::{Auth, Session};
+use regex::Regex;
+use rocket::State;
+use rocket_contrib::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+// ! FIXME: should be global somewhere; maybe use config(?)
+lazy_static! {
+    static ref RE_USERNAME: Regex = Regex::new(r"^[a-zA-Z0-9_.]+$").unwrap();
+}
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate(length(min = 2, max = 32), regex = "RE_USERNAME")]
+    username: Option<String>,
+    #[validate(length(min = 8, max = 72))]
+    password: String,
+}
+
+#[patch("/<_ignore_id>/username", data = "<data>")]
+pub async fn req(
+    auth: State<'_, Auth>,
+    session: Session,
+    user: User,
+    data: Json<Data>,
+    _ignore_id: String,
+) -> Result<()> {
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    auth.verify_password(&session, data.password.clone())
+        .await
+        .map_err(|_| Error::InvalidCredentials)?;
+
+    let mut set = doc! {};
+    if let Some(username) = &data.username {
+        if User::is_username_taken(&username).await? {
+            return Err(Error::UsernameTaken);
+        }
+
+        set.insert("username", username.clone());
+    }
+
+    get_collection("users")
+        .update_one(doc! { "_id": &user.id }, doc! { "$set": set }, None)
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "update_one",
+            with: "user",
+        })?;
+
+    ClientboundNotification::UserUpdate {
+        id: user.id.clone(),
+        data: json!({
+            "username": data.username
+        }),
+        clear: None,
+    }
+    .publish_as_user(user.id.clone());
+
+    Ok(())
+}

src/routes/users/edit_user.rs

+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+use crate::{database::*, notifications::events::RemoveUserField};
+
+use mongodb::bson::{doc, to_document};
+use rocket_contrib::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize, Debug)]
+pub struct UserProfileData {
+    #[validate(length(min = 0, max = 2000))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    content: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[validate(length(min = 1, max = 128))]
+    background: Option<String>,
+}
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate]
+    status: Option<UserStatus>,
+    #[validate]
+    profile: Option<UserProfileData>,
+    #[validate(length(min = 1, max = 128))]
+    avatar: Option<String>,
+    remove: Option<RemoveUserField>,
+}
+
+#[patch("/<_ignore_id>", data = "<data>")]
+pub async fn req(user: User, data: Json<Data>, _ignore_id: String) -> Result<()> {
+    let mut data = data.into_inner();
+
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    if data.status.is_none()
+        && data.profile.is_none()
+        && data.avatar.is_none()
+        && data.remove.is_none()
+    {
+        return Ok(());
+    }
+
+    let mut unset = doc! {};
+    let mut set = doc! {};
+
+    let mut remove_background = false;
+    let mut remove_avatar = false;
+
+    if let Some(remove) = &data.remove {
+        match remove {
+            RemoveUserField::ProfileContent => {
+                unset.insert("profile.content", 1);
+            }
+            RemoveUserField::ProfileBackground => {
+                unset.insert("profile.background", 1);
+                remove_background = true;
+            }
+            RemoveUserField::StatusText => {
+                unset.insert("status.text", 1);
+            }
+            RemoveUserField::Avatar => {
+                unset.insert("avatar", 1);
+                remove_avatar = true;
+            }
+        }
+    }
+
+    if let Some(status) = &data.status {
+        set.insert(
+            "status",
+            to_document(&status).map_err(|_| Error::DatabaseError {
+                operation: "to_document",
+                with: "status",
+            })?,
+        );
+    }
+
+    if let Some(profile) = data.profile {
+        if let Some(content) = profile.content {
+            set.insert("profile.content", content);
+        }
+
+        if let Some(attachment_id) = profile.background {
+            let attachment =
+                File::find_and_use(&attachment_id, "backgrounds", "user", &user.id).await?;
+            set.insert(
+                "profile.background",
+                to_document(&attachment).map_err(|_| Error::DatabaseError {
+                    operation: "to_document",
+                    with: "attachment",
+                })?,
+            );
+
+            remove_background = true;
+        }
+    }
+
+    let avatar = std::mem::replace(&mut data.avatar, None);
+    if let Some(attachment_id) = avatar {
+        let attachment = File::find_and_use(&attachment_id, "avatars", "user", &user.id).await?;
+        set.insert(
+            "avatar",
+            to_document(&attachment).map_err(|_| Error::DatabaseError {
+                operation: "to_document",
+                with: "attachment",
+            })?,
+        );
+
+        remove_avatar = true;
+    }
+
+    let mut operations = doc! {};
+    if set.len() > 0 {
+        operations.insert("$set", &set);
+    }
+
+    if unset.len() > 0 {
+        operations.insert("$unset", unset);
+    }
+
+    if operations.len() > 0 {
+        get_collection("users")
+            .update_one(doc! { "_id": &user.id }, operations, None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "user",
+            })?;
+    }
+
+    ClientboundNotification::UserUpdate {
+        id: user.id.clone(),
+        data: json!(set),
+        clear: data.remove,
+    }
+    .publish_as_user(user.id.clone());
+
+    if remove_avatar {
+        if let Some(old_avatar) = user.avatar {
+            old_avatar.delete().await?;
+        }
+    }
+
+    if remove_background {
+        if let Some(profile) = user.profile {
+            if let Some(old_background) = profile.background {
+                old_background.delete().await?;
+            }
+        }
+    }
+
+    Ok(())
+}

src/routes/users/fetch_dms.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use futures::StreamExt;
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+
+#[get("/dms")]
+pub async fn req(user: User) -> Result<JsonValue> {
+    let mut cursor = get_collection("channels")
+        .find(
+            doc! {
+                "$or": [
+                    {
+                        "channel_type": "DirectMessage",
+                        "active": true
+                    },
+                    {
+                        "channel_type": "Group"
+                    }
+                ],
+                "recipients": user.id
+            },
+            None,
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find",
+            with: "channels",
+        })?;
+
+    let mut channels = vec![];
+    while let Some(result) = cursor.next().await {
+        if let Ok(doc) = result {
+            channels.push(doc);
+        }
+    }
+
+    Ok(json!(channels))
+}

src/routes/users/fetch_profile.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>/profile")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let target = target.fetch_user().await?;
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_user(&target)
+        .for_user_given()
+        .await?;
+
+    if !perm.get_view_profile() {
+        Err(Error::MissingPermission)?
+    }
+
+    if target.profile.is_some() {
+        Ok(json!(target.profile))
+    } else {
+        Ok(json!({}))
+    }
+}

src/routes/users/fetch_relationship.rs

+use crate::database::*;
+use crate::util::result::Result;
+
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>/relationship")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    Ok(json!({ "status": get_relationship(&user, &target.id) }))
+}

src/routes/users/fetch_relationships.rs

+use crate::database::*;
+use crate::util::result::Result;
+
+use rocket_contrib::json::JsonValue;
+
+#[get("/relationships")]
+pub async fn req(user: User) -> Result<JsonValue> {
+    Ok(if let Some(vec) = user.relations {
+        json!(vec)
+    } else {
+        json!([])
+    })
+}

src/routes/users/fetch_user.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let target = target.fetch_user().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_user(&target)
+        .for_user_given()
+        .await?;
+
+    if !perm.get_access() {
+        Err(Error::MissingPermission)?
+    }
+
+    Ok(json!(target.from(&user).with(perm)))
+}

src/routes/users/find_mutual.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use futures::StreamExt;
+use mongodb::bson::{doc, Document};
+use mongodb::options::FindOptions;
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>/mutual")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let users = get_collection("users")
+        .find(
+            doc! {
+                "$and": [
+                    { "relations": { "$elemMatch": { "_id": &user.id, "status": "Friend" } } },
+                    { "relations": { "$elemMatch": { "_id": &target.id, "status": "Friend" } } }
+                ]
+            },
+            FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find",
+            with: "users",
+        })?
+        .filter_map(async move |s| s.ok())
+        .collect::<Vec<Document>>()
+        .await
+        .into_iter()
+        .filter_map(|x| x.get_str("_id").ok().map(|x| x.to_string()))
+        .collect::<Vec<String>>();
+
+    Ok(json!({ "users": users }))
+}

src/routes/users/get_default_avatar.rs

+use rocket::{Request, Response};
+use rocket::response::{self, NamedFile, Responder};
+use std::path::Path;
+
+use crate::database::Ref;
+
+pub struct CachedFile(NamedFile);
+
+pub static CACHE_CONTROL: &'static str = "public, max-age=31536000, immutable";
+
+impl<'r> Responder<'r, 'static> for CachedFile {
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
+        Response::build_from(self.0.respond_to(req)?)
+            .raw_header("Cache-control", CACHE_CONTROL)
+            .ok()
+    }
+}
+
+#[get("/<target>/default_avatar")]
+pub async fn req(target: Ref) -> Option<CachedFile> {
+    match target.id.chars().nth(25).unwrap() {
+        '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' => {
+            NamedFile::open(Path::new("assets/user_red.png")).await.ok().map(|n| CachedFile(n))
+        }
+        '8' | '9' | 'A' | 'C' | 'B' | 'D' | 'E' | 'F' => {
+            NamedFile::open(Path::new("assets/user_green.png"))
+                .await
+                .ok().map(|n| CachedFile(n))
+        }
+        'G' | 'H' | 'J' | 'K' | 'M' | 'N' | 'P' | 'Q' => {
+            NamedFile::open(Path::new("assets/user_blue.png"))
+                .await
+                .ok().map(|n| CachedFile(n))
+        }
+        'R' | 'S' | 'T' | 'V' | 'W' | 'X' | 'Y' | 'Z' => {
+            NamedFile::open(Path::new("assets/user_yellow.png"))
+                .await
+                .ok().map(|n| CachedFile(n))
+        }
+        _ => unreachable!(),
+    }
+}

src/routes/users/mod.rs

+use rocket::Route;
+
+mod add_friend;
+mod block_user;
+mod change_username;
+mod edit_user;
+mod fetch_dms;
+mod fetch_profile;
+mod fetch_relationship;
+mod fetch_relationships;
+mod fetch_user;
+mod find_mutual;
+mod get_default_avatar;
+mod open_dm;
+mod remove_friend;
+mod unblock_user;
+
+pub fn routes() -> Vec<Route> {
+    routes![
+        // User Information
+        fetch_user::req,
+        edit_user::req,
+        change_username::req,
+        get_default_avatar::req,
+        fetch_profile::req,
+        // Direct Messaging
+        fetch_dms::req,
+        open_dm::req,
+        // Relationships
+        find_mutual::req,
+        fetch_relationships::req,
+        fetch_relationship::req,
+        add_friend::req,
+        remove_friend::req,
+        block_user::req,
+        unblock_user::req,
+    ]
+}

src/routes/users/open_dm.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+use ulid::Ulid;
+
+#[get("/<target>/dm")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let query = if user.id == target.id {
+        doc! {
+            "channel_type": "SavedMessages",
+            "user": &user.id
+        }
+    } else {
+        doc! {
+            "channel_type": "DirectMessage",
+            "recipients": {
+                "$all": [ &user.id, &target.id ]
+            }
+        }
+    };
+
+    let existing_channel = get_collection("channels")
+        .find_one(query, None)
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find_one",
+            with: "channel",
+        })?;
+
+    if let Some(doc) = existing_channel {
+        Ok(json!(doc))
+    } else {
+        let id = Ulid::new().to_string();
+        let channel = if user.id == target.id {
+            Channel::SavedMessages { id, user: user.id }
+        } else {
+            Channel::DirectMessage {
+                id,
+                active: false,
+                recipients: vec![user.id, target.id],
+                last_message: None,
+            }
+        };
+
+        channel.clone().publish().await?;
+        Ok(json!(channel))
+    }
+}

src/routes/users/remove_friend.rs

+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+
+use futures::try_join;
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+
+#[delete("/<target>/friend")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let col = get_collection("users");
+
+    let target = target.fetch_user().await?;
+
+    match get_relationship(&user, &target.id) {
+        RelationshipStatus::Friend
+        | RelationshipStatus::Outgoing
+        | RelationshipStatus::Incoming => {
+            match try_join!(
+                col.update_one(
+                    doc! {
+                        "_id": &user.id
+                    },
+                    doc! {
+                        "$pull": {
+                            "relations": {
+                                "_id": &target.id
+                            }
+                        }
+                    },
+                    None
+                ),
+                col.update_one(
+                    doc! {
+                        "_id": &target.id
+                    },
+                    doc! {
+                        "$pull": {
+                            "relations": {
+                                "_id": &user.id
+                            }
+                        }
+                    },
+                    None
+                )
+            ) {
+                Ok(_) => {
+                    let target = target
+                        .from_override(&user, RelationshipStatus::None)
+                        .await?;
+                    let user = user
+                        .from_override(&target, RelationshipStatus::None)
+                        .await?;
+                    let target_id = target.id.clone();
+
+                    ClientboundNotification::UserRelationship {
+                        id: user.id.clone(),
+                        user: target,
+                        status: RelationshipStatus::None,
+                    }
+                    .publish(user.id.clone());
+
+                    ClientboundNotification::UserRelationship {
+                        id: target_id.clone(),
+                        user,
+                        status: RelationshipStatus::None,
+                    }
+                    .publish(target_id);
+
+                    Ok(json!({ "status": "None" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+        _ => Err(Error::NoEffect),
+    }
+}

src/routes/users/unblock_user.rs

+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+
+use futures::try_join;
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
+
+#[delete("/<target>/block")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let col = get_collection("users");
+    let target = target.fetch_user().await?;
+
+    match get_relationship(&user, &target.id) {
+        RelationshipStatus::Blocked => match get_relationship(&target, &user.id) {
+            RelationshipStatus::Blocked => {
+                col.update_one(
+                    doc! {
+                        "_id": &user.id,
+                        "relations._id": &target.id
+                    },
+                    doc! {
+                        "$set": {
+                            "relations.$.status": "BlockedOther"
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                })?;
+
+                let target = target
+                    .from_override(&user, RelationshipStatus::BlockedOther)
+                    .await?;
+                ClientboundNotification::UserRelationship {
+                    id: user.id.clone(),
+                    user: target,
+                    status: RelationshipStatus::BlockedOther,
+                }
+                .publish(user.id.clone());
+
+                Ok(json!({ "status": "BlockedOther" }))
+            }
+            RelationshipStatus::BlockedOther => {
+                match try_join!(
+                    col.update_one(
+                        doc! {
+                            "_id": &user.id
+                        },
+                        doc! {
+                            "$pull": {
+                                "relations": {
+                                    "_id": &target.id
+                                }
+                            }
+                        },
+                        None
+                    ),
+                    col.update_one(
+                        doc! {
+                            "_id": &target.id
+                        },
+                        doc! {
+                            "$pull": {
+                                "relations": {
+                                    "_id": &user.id
+                                }
+                            }
+                        },
+                        None
+                    )
+                ) {
+                    Ok(_) => {
+                        let target = target
+                            .from_override(&user, RelationshipStatus::None)
+                            .await?;
+                        let user = user
+                            .from_override(&target, RelationshipStatus::None)
+                            .await?;
+                        let target_id = target.id.clone();
+
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target,
+                            status: RelationshipStatus::None,
+                        }
+                        .publish(user.id.clone());
+
+                        ClientboundNotification::UserRelationship {
+                            id: target_id.clone(),
+                            user: user,
+                            status: RelationshipStatus::None,
+                        }
+                        .publish(target_id);
+
+                        Ok(json!({ "status": "None" }))
+                    }
+                    Err(_) => Err(Error::DatabaseError {
+                        operation: "update_one",
+                        with: "user",
+                    }),
+                }
+            }
+            _ => Err(Error::InternalError),
+        },
+        _ => Err(Error::NoEffect),
+    }
+}

src/util/mod.rs

+pub mod result;
+pub mod variables;

src/util/result.rs

+use json;
+use rocket::http::{ContentType, Status};
+use rocket::request::Request;
+use rocket::response::{self, Responder, Response};
+use serde::Serialize;
+use std::io::Cursor;
+use validator::ValidationErrors;
+
+#[derive(Serialize, Debug)]
+#[serde(tag = "type")]
+pub enum Error {
+    LabelMe,
+
+    // ? Onboarding related errors.
+    AlreadyOnboarded,
+
+    // ? User related errors.
+    UsernameTaken,
+    UnknownUser,
+    AlreadyFriends,
+    AlreadySentRequest,
+    Blocked,
+    BlockedByOther,
+    NotFriends,
+
+    // ? Channel related errors.
+    UnknownChannel,
+    UnknownAttachment,
+    UnknownMessage,
+    CannotEditMessage,
+    CannotJoinCall,
+    TooManyAttachments,
+    TooManyReplies,
+    EmptyMessage,
+    CannotRemoveYourself,
+    GroupTooLarge {
+        max: usize,
+    },
+    AlreadyInGroup,
+    NotInGroup,
+
+    // ? Server related errors.
+    UnknownServer,
+    InvalidRole,
+    Banned,
+
+    // ? General errors.
+    TooManyIds,
+    FailedValidation {
+        error: ValidationErrors,
+    },
+    DatabaseError {
+        operation: &'static str,
+        with: &'static str,
+    },
+    InternalError,
+    MissingPermission,
+    InvalidOperation,
+    InvalidCredentials,
+    DuplicateNonce,
+    VosoUnavailable,
+    NotFound,
+    NoEffect,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// HTTP response builder for Error enum
+impl<'r> Responder<'r, 'static> for Error {
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
+        let status = match self {
+            Error::LabelMe => Status::InternalServerError,
+
+            Error::AlreadyOnboarded => Status::Forbidden,
+
+            Error::UnknownUser => Status::NotFound,
+            Error::UsernameTaken => Status::Conflict,
+            Error::AlreadyFriends => Status::Conflict,
+            Error::AlreadySentRequest => Status::Conflict,
+            Error::Blocked => Status::Conflict,
+            Error::BlockedByOther => Status::Forbidden,
+            Error::NotFriends => Status::Forbidden,
+
+            Error::UnknownChannel => Status::NotFound,
+            Error::UnknownMessage => Status::NotFound,
+            Error::UnknownAttachment => Status::BadRequest,
+            Error::CannotEditMessage => Status::Forbidden,
+            Error::CannotJoinCall => Status::BadRequest,
+            Error::TooManyAttachments => Status::BadRequest,
+            Error::TooManyReplies => Status::BadRequest,
+            Error::EmptyMessage => Status::UnprocessableEntity,
+            Error::CannotRemoveYourself => Status::BadRequest,
+            Error::GroupTooLarge { .. } => Status::Forbidden,
+            Error::AlreadyInGroup => Status::Conflict,
+            Error::NotInGroup => Status::NotFound,
+
+            Error::UnknownServer => Status::NotFound,
+            Error::InvalidRole => Status::NotFound,
+            Error::Banned => Status::Forbidden,
+
+            Error::FailedValidation { .. } => Status::UnprocessableEntity,
+            Error::DatabaseError { .. } => Status::InternalServerError,
+            Error::InternalError => Status::InternalServerError,
+            Error::MissingPermission => Status::Forbidden,
+            Error::InvalidOperation => Status::BadRequest,
+            Error::TooManyIds => Status::BadRequest,
+            Error::InvalidCredentials => Status::Forbidden,
+            Error::DuplicateNonce => Status::Conflict,
+            Error::VosoUnavailable => Status::BadRequest,
+            Error::NotFound => Status::NotFound,
+            Error::NoEffect => Status::Ok,
+        };
+
+        // Serialize the error data structure into JSON.
+        let string = json!(self).to_string();
+
+        // Build and send the request.
+        Response::build()
+            .sized_body(string.len(), Cursor::new(string))
+            .header(ContentType::new("application", "json"))
+            .status(status)
+            .ok()
+    }
+}

src/util/variables.rs

+use std::env;
+
+#[cfg(debug_assertions)]
+use log::warn;
+
+lazy_static! {
+    // Application Settings
+    pub static ref MONGO_URI: String =
+        env::var("REVOLT_MONGO_URI").expect("Missing REVOLT_MONGO_URI environment variable.");
+    pub static ref WS_HOST: String =
+        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9000".to_string());
+    pub static ref PUBLIC_URL: String =
+        env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.");
+    pub static ref APP_URL: String =
+        env::var("REVOLT_APP_URL").expect("Missing REVOLT_APP_URL environment variable.");
+    pub static ref EXTERNAL_WS_URL: String =
+        env::var("REVOLT_EXTERNAL_WS_URL").expect("Missing REVOLT_EXTERNAL_WS_URL environment variable.");
+
+    pub static ref AUTUMN_URL: String =
+        env::var("AUTUMN_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref JANUARY_URL: String =
+        env::var("JANUARY_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref VOSO_URL: String =
+        env::var("VOSO_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref VOSO_WS_HOST: String =
+        env::var("VOSO_WS_HOST").unwrap_or_else(|_| "wss://example.com".to_string());
+    pub static ref VOSO_MANAGE_TOKEN: String =
+        env::var("VOSO_MANAGE_TOKEN").unwrap_or_else(|_| "0".to_string());
+
+    pub static ref HCAPTCHA_KEY: String =
+        env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "0x0000000000000000000000000000000000000000".to_string());
+    pub static ref HCAPTCHA_SITEKEY: String =
+        env::var("REVOLT_HCAPTCHA_SITEKEY").unwrap_or_else(|_| "10000000-ffff-ffff-ffff-000000000001".to_string());
+    pub static ref VAPID_PRIVATE_KEY: String =
+        env::var("REVOLT_VAPID_PRIVATE_KEY").expect("Missing REVOLT_VAPID_PRIVATE_KEY environment variable.");
+    pub static ref VAPID_PUBLIC_KEY: String =
+        env::var("REVOLT_VAPID_PUBLIC_KEY").expect("Missing REVOLT_VAPID_PUBLIC_KEY environment variable.");
+
+    // Application Flags
+    pub static ref INVITE_ONLY: bool = env::var("REVOLT_INVITE_ONLY").map_or(false, |v| v == "1");
+    pub static ref USE_EMAIL: bool = env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
+        env::var("REVOLT_SMTP_HOST").is_ok()
+            && env::var("REVOLT_SMTP_USERNAME").is_ok()
+            && env::var("REVOLT_SMTP_PASSWORD").is_ok()
+            && env::var("REVOLT_SMTP_FROM").is_ok(),
+        |v| v == *"1"
+    );
+    pub static ref USE_HCAPTCHA: bool = env::var("REVOLT_HCAPTCHA_KEY").is_ok();
+    pub static ref USE_PROMETHEUS: bool = env::var("REVOLT_ENABLE_PROMETHEUS").map_or(false, |v| v == "1");
+    pub static ref USE_AUTUMN: bool = env::var("AUTUMN_PUBLIC_URL").is_ok();
+    pub static ref USE_JANUARY: bool = env::var("JANUARY_PUBLIC_URL").is_ok();
+    pub static ref USE_VOSO: bool = env::var("VOSO_PUBLIC_URL").is_ok() && env::var("VOSO_MANAGE_TOKEN").is_ok();
+
+    // SMTP Settings
+    pub static ref SMTP_HOST: String =
+        env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_USERNAME: String =
+        env::var("REVOLT_SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_PASSWORD: String =
+        env::var("REVOLT_SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_FROM: String = env::var("REVOLT_SMTP_FROM").unwrap_or_else(|_| "".to_string());
+
+    // Application Logic Settings
+    pub static ref MAX_GROUP_SIZE: usize =
+        env::var("REVOLT_MAX_GROUP_SIZE").unwrap_or_else(|_| "50".to_string()).parse().unwrap();
+    pub static ref EARLY_ADOPTER_BADGE: i64 =
+        env::var("REVOLT_EARLY_ADOPTER_BADGE").unwrap_or_else(|_| "0".to_string()).parse().unwrap();
+}
+
+pub fn preflight_checks() {
+    format!("{}", *APP_URL);
+    format!("{}", *MONGO_URI);
+    format!("{}", *PUBLIC_URL);
+    format!("{}", *EXTERNAL_WS_URL);
+
+    format!("{}", *VAPID_PRIVATE_KEY);
+    format!("{}", *VAPID_PUBLIC_KEY);
+
+    if *USE_EMAIL == false {
+        #[cfg(not(debug_assertions))]
+        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)]
+        warn!("No SMTP settings specified! Remember to configure email.");
+    }
+
+    if *USE_HCAPTCHA == false {
+        #[cfg(not(debug_assertions))]
+        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)]
+        warn!("No Captcha key specified! Remember to add hCaptcha key.");
+    }
+}

src/version.rs

+pub const VERSION: &str = "0.5.1-alpha.21";

src/websocket/mod.rs

-extern crate ws;
-
-use crate::database;
-
-use ulid::Ulid;
-use std::sync::RwLock;
-use hashbrown::HashMap;
-
-use bson::{ bson, doc };
-use serde_json::{ Value, from_str, json };
-
-use ws::{ listen, Handler, Sender, Result, Message, Handshake, CloseCode, Error };
-
-struct Cell {
-	id: String,
-	out: Sender,
-}
-
-use once_cell::sync::OnceCell;
-static mut CLIENTS: OnceCell<RwLock<HashMap<String, Vec<Cell>>>> = OnceCell::new();
-
-struct Server {
-	out: Sender,
-	id: Option<String>,
-	internal: String,
-}
-
-impl Handler for Server {
-    fn on_open(&mut self, _: Handshake) -> Result<()> {
-		Ok(())
-    }
-
-    fn on_message(&mut self, msg: Message) -> Result<()> {
-		if let Message::Text(text) = msg {
-			let data: Value = from_str(&text).unwrap();
-
-			if let Value::String(packet_type) = &data["type"] {
-				match packet_type.as_str() {
-					"authenticate" => {
-						if let Some(_) = self.id {
-							self.out.send(
-								json!({
-									"type": "authenticate",
-									"success": false,
-									"error": "Already authenticated!"
-								})
-								.to_string()
-							)
-						} else if let Value::String(token) = &data["token"] {
-							let col = database::get_collection("users");
-							
-							match col.find_one(
-								doc! { "access_token": token },
-								None
-							).unwrap() {
-								Some(u) => {
-									let id = u.get_str("_id").expect("Missing id.");
-
-									unsafe {
-										let mut map = CLIENTS.get_mut().unwrap().write().unwrap();
-										let cell = Cell { id: self.internal.clone(), out: self.out.clone() };
-										if map.contains_key(&id.to_string()) {
-											map.get_mut(&id.to_string())
-												.unwrap()
-												.push(cell);
-										} else {
-											map.insert(id.to_string(), vec![cell]);
-										}
-									}
-
-									println!("Websocket client connected. [ID: {} // {}]", id.to_string(), self.internal);
-
-									self.id = Some(id.to_string());
-									self.out.send(
-										json!({
-											"type": "authenticate",
-											"success": true
-										})
-										.to_string()
-									)
-								},
-								None =>
-									self.out.send(
-										json!({
-											"type": "authenticate",
-											"success": false,
-											"error": "Invalid authentication token."
-										})
-										.to_string()
-									)
-							}
-						} else {
-							self.out.send(
-								json!({
-									"type": "authenticate",
-									"success": false,
-									"error": "Missing authentication token."
-								})
-								.to_string()
-							)
-						}
-					},
-					_ => Ok(())
-				}
-			} else {
-				Ok(())
-			}
-		} else {
-			Ok(())
-		}
-    }
-
-    fn on_close(&mut self, code: CloseCode, reason: &str) {
-        match code {
-            CloseCode::Normal => println!("The client is done with the connection."),
-            CloseCode::Away   => println!("The client is leaving the site."),
-            CloseCode::Abnormal => println!(
-                "Closing handshake failed! Unable to obtain closing status from client."),
-            _ => println!("The client encountered an error: {}", reason),
-        }
-
-		if let Some(id) = &self.id {
-			println!("Websocket client disconnected. [ID: {} // {}]", id, self.internal);
-			unsafe {
-				let mut map = CLIENTS.get_mut().unwrap().write().unwrap();
-				let arr = map.get_mut(&id.clone()).unwrap();
-
-				if arr.len() == 1 {
-					map.remove(&id.clone());
-				} else {
-					let index = arr.iter().position(|x| x.id == self.internal).unwrap();
-					arr.remove(index);
-					println!("User [{}] is still connected {} times", self.id.as_ref().unwrap(), arr.len());
-				}
-			}
-		}
-    }
-
-    fn on_error(&mut self, err: Error) {
-        println!("The server encountered an error: {:?}", err);
-    }
-}
-
-pub fn launch_server() {
-	unsafe {
-		if let Err(_) = CLIENTS.set(RwLock::new(HashMap::new())) {
-			panic!("Failed to set CLIENTS map!");
-		}
-	}
-
-	listen("192.168.0.10:9999", |out| { Server { out: out, id: None, internal: Ulid::new().to_string() } }).unwrap()
-}
-
-pub fn send_message(id: String, message: String) -> std::result::Result<(), ()> {
-	unsafe {
-		let map = CLIENTS.get().unwrap().read().unwrap();
-		if map.contains_key(&id) {
-			let arr = map.get(&id).unwrap();
-
-			for item in arr {
-				if let Err(_) = item.out.send(message.clone()) {
-					return Err(());
-				}
-			}
-		}
-
-		Ok(())
-	}
-}
-
-// ! TODO: WRITE THREADED QUEUE SYSTEM
-// ! FETCH RECIPIENTS HERE INSTEAD OF IN METHOD
-
-pub fn queue_message(ids: Vec<String>, message: String) {
-	for id in ids {
-		send_message(id, message.clone()).expect("uhhhhhhhhhh can i get uhhhhhhhhhhhhhhhhhh mcdonald cheese burger with fries");
-	}
-}