Add Gravatar support.

Code cleanup/formatting

See merge request revolt/delta!2

.dockerignore

@@ -0,0 +1,2 @@
+target
+.env

.gitignore

@@ -1,3 +1,6 @@
+Rocket.toml
 /target
 **/*.rs.bk
+.mongo
 .env
+avatar.png

.gitlab-ci.yml

@@ -0,0 +1,20 @@
+stages:
+  - build
+
+# Rocket does not currently compile on stable Rust.
+# Once it does, we can uncomment this, and instead
+# put `allow-failure: true` on the nightly build.
+#
+# rust-latest:
+#   stage: build
+#   image: rust:latest
+#   script:
+#     - cargo build --verbose
+#     - cargo test --verbose
+
+rust-nightly:
+  stage: build
+  image: rustlang/rust:nightly
+  script:
+    - cargo build --verbose
+    - cargo test --verbose

Cargo.toml

@@ -1,29 +1,47 @@
 [package]
 name = "revolt"
-version = "0.1.0"
+version = "0.3.3-alpha.0"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-mongodb = "0.9.2"
-bson = "0.14.1"
-rocket = { version = "0.4.4", default-features = false }
-once_cell = "1.3.1"
+futures = "0.3.8"
+impl_ops = "0.1.1"
+many-to-many = "0.1.2"
+ctrlc = { version = "3.0", features = ["termination"] }
+async-std = { version = "1.8.0", features = ["tokio02", "attributes"] }
+async-tungstenite = { version = "0.10.0", features = ["async-std-runtime"] }
+rauth = { git = "https://gitlab.insrt.uk/insert/rauth", rev = "d48b0087cc546d2c9ef53f27d0693c8378172dfe" }
+
+hive_pubsub = { version = "0.4.3", features = ["mongo"] }
+rocket_cors = { git = "https://github.com/insertish/rocket_cors", branch = "master" }
+rocket_prometheus = { git = "https://github.com/insertish/rocket_prometheus", rev = "3d825aedb42793246c306a81fe67c5b187948983" }
+rocket_contrib = { git = "https://github.com/SergioBenitez/Rocket", rev = "031948c1daaa146128d8a435be116476f2adde00" }
+rocket = { git = "https://github.com/SergioBenitez/Rocket", rev = "031948c1daaa146128d8a435be116476f2adde00", default-features = false }
+mongodb = { version = "1.1.1", features = ["tokio-runtime"], default-features = false }
+
+once_cell = "1.4.1"
 dotenv = "0.15.0"
-ulid = "0.3.1"
-serde = { version = "1.0", features = ["derive"] }
-rocket_contrib = "0.4.4"
-validator = "0.10.0"
-bcrypt = "0.7.0"
-chrono = "0.4.11"
-rand = "0.7.3"
-time = "0.2.9"
-reqwest = { version = "0.10.4", features = ["blocking", "json"] }
-num_enum = "0.4.3"
-ws = "0.9.1"
-hashbrown = "0.7.1"
-serde_json = "1.0.51"
-rocket_cors = "0.5.2"
+ulid = "0.4.1"
+
+serde = { version = "1.0.115", features = ["derive"] }
+validator = { version = "0.11", features = ["derive"] }
+snafu = { version = "0.6.9" }
+serde_json = "1.0.57"
 bitfield = "0.13.2"
+
+reqwest = { version = "0.10.8", features = ["json"] }
+urlencoding = "1.1.1"
+lazy_static = "1.4.0"
+num_enum = "0.5.1"
+chrono = "0.4.15"
+time = "0.2.16"
+rand = "0.7.3"
+md5 = "0.7.0"
+regex = "1"
+
+lettre = "0.10.0-alpha.1"
+env_logger = "0.7.1"
+log = "0.4.11"

Dockerfile

@@ -0,0 +1,20 @@
+# Build Stage
+FROM ekidd/rust-musl-builder:nightly-2021-01-01 AS builder
+WORKDIR /home/rust/src
+
+RUN USER=root cargo new --bin revolt
+WORKDIR /home/rust/src/revolt
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+RUN cargo build --release
+
+# Bundle Stage
+FROM alpine:latest
+RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk/*
+COPY --from=builder /home/rust/src/revolt/target/x86_64-unknown-linux-musl/release/revolt ./
+COPY assets ./assets
+EXPOSE 8000
+EXPOSE 9000
+ENV ROCKET_ADDRESS 0.0.0.0
+ENV ROCKET_PORT 8000
+CMD ["./revolt"]

README.md

@@ -0,0 +1,20 @@
+![](assets/banner.png)
+
+Delta is a **blazing fast API server** built with Rust for the REVOLT platform.
+
+Features:
+- Robust and efficient API routes for running a chat platform.
+- Distributed notification system, allowing any node to be seamlessly connected.
+- Simple deployment, based mostly on pure Rust code and libraries.
+- Hooks up to a MongoDB deployment, provide URI and no extra work needed.
+
+## Docker Helper Scripts
+
+If you have Docker installed, you can use the helper scripts to deploy Revolt in your development environment.
+
+```bash
+./build.sh   # build Docker image
+./run.sh     # run Docker container
+./monitor.sh # view container logs
+./remove.sh  # kill and remove container
+```

Rocket.toml

@@ -1,7 +0,0 @@
-[development]
-address = "192.168.0.10"
-port = 5500
-
-[production]
-address = "192.168.0.10"
-port = 5500

docker-compose.yml

@@ -0,0 +1,18 @@
+version: '2'
+
+services:
+  database:
+    image: mongo
+    restart: always
+  web:
+    build: .
+    environment:
+      - REVOLT_MONGO_URI=mongodb://localhost
+      - REVOLT_PUBLIC_URL=https://local.revolt.chat
+      - REVOLT_USE_EMAIL_VERIFICATION=0
+      - REVOLT_UNSAFE_NO_EMAIL=1
+      - REVOLT_UNSAFE_NO_CAPTCHA=1
+    ports:
+      - "8000:8000"
+      - "9000:9000"
+    restart: unless-stopped

src/database/channel.rs

@@ -1,33 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct LastMessage {
-    id: String,
-    user_id: String,
-    short_content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Channel {
-    #[serde(rename = "_id")]
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: u8,
-
-    // for Direct Messages
-    pub active: Option<bool>,
-
-    // for DMs / GDMs
-    pub last_message: Option<LastMessage>,
-    pub recipients: Option<Vec<String>>,
-
-    // for GDMs
-    pub owner: Option<String>,
-
-    // for Guilds
-    pub guild: Option<String>,
-
-    // for Guilds and Group DMs
-    pub name: Option<String>,
-    pub description: Option<String>,
-}

src/database/entities/channel.rs

@@ -0,0 +1,143 @@
+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+use mongodb::bson::{doc, from_document, to_document};
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct LastMessage {
+    #[serde(rename = "_id")]
+    id: String,
+    author: String,
+    short: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "channel_type")]
+pub enum Channel {
+    SavedMessages {
+        #[serde(rename = "_id")]
+        id: String,
+        user: String,
+    },
+    DirectMessage {
+        #[serde(rename = "_id")]
+        id: String,
+        active: bool,
+        recipients: Vec<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        last_message: Option<LastMessage>,
+    },
+    Group {
+        #[serde(rename = "_id")]
+        id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        nonce: Option<String>,
+        name: String,
+        owner: String,
+        description: String,
+        recipients: Vec<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        last_message: Option<LastMessage>,
+    },
+}
+
+impl Channel {
+    pub fn id(&self) -> &str {
+        match self {
+            Channel::SavedMessages { id, .. } => id,
+            Channel::DirectMessage { id, .. } => id,
+            Channel::Group { id, .. } => id,
+        }
+    }
+
+    pub async fn get(id: &str) -> Result<Channel> {
+        let doc = get_collection("channels")
+            .find_one(doc! { "_id": id }, None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "channel",
+            })?
+            .ok_or_else(|| Error::UnknownChannel)?;
+
+        from_document::<Channel>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: "channel",
+        })
+    }
+
+    pub async fn publish(self) -> Result<()> {
+        get_collection("channels")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "channel",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "channel",
+            })?;
+
+        let channel_id = self.id().to_string();
+        ClientboundNotification::ChannelCreate(self)
+            .publish(channel_id)
+            .await
+            .ok();
+
+        Ok(())
+    }
+
+    pub async fn publish_update(&self, data: JsonValue) -> Result<()> {
+        let id = self.id().to_string();
+        ClientboundNotification::ChannelUpdate {
+            id: id.clone(),
+            data,
+        }
+        .publish(id)
+        .await
+        .ok();
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        let id = self.id();
+        get_collection("messages")
+            .delete_many(
+                doc! {
+                    "channel": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "messages",
+            })?;
+
+        get_collection("channels")
+            .delete_one(
+                doc! {
+                    "_id": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "channel",
+            })?;
+
+        ClientboundNotification::ChannelDelete { id: id.to_string() }
+            .publish(id.to_string())
+            .await
+            .ok();
+
+        Ok(())
+    }
+}

src/database/entities/guild.rs

@@ -1,20 +1,19 @@
-use bson::doc;
-use serde::{Deserialize, Serialize};
+// use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct MemberRef {
+/*#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberCompositeKey {
     pub guild: String,
     pub user: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Member {
     #[serde(rename = "_id")]
-    pub id: MemberRef,
+    pub id: MemberCompositeKey,
     pub nickname: Option<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Invite {
     pub code: String,
     pub creator: String,
@@ -27,7 +26,7 @@ pub struct Ban {
     pub reason: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Guild {
     #[serde(rename = "_id")]
     pub id: String,
@@ -36,8 +35,9 @@ pub struct Guild {
     pub description: String,
     pub owner: String,
 
+    pub channels: Vec<String>,
     pub invites: Vec<Invite>,
     pub bans: Vec<Ban>,
 
     pub default_permissions: u32,
-}
+}*/

src/database/entities/message.rs

@@ -0,0 +1,141 @@
+use crate::{
+    database::*,
+    notifications::events::ClientboundNotification,
+    util::result::{Error, Result},
+};
+use mongodb::bson::{doc, to_bson, DateTime};
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+use ulid::Ulid;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Message {
+    #[serde(rename = "_id")]
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<String>,
+    pub channel: String,
+    pub author: String,
+
+    pub content: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edited: Option<DateTime>,
+}
+
+impl Message {
+    pub fn create(author: String, channel: String, content: String) -> Message {
+        Message {
+            id: Ulid::new().to_string(),
+            nonce: None,
+            channel,
+            author,
+
+            content,
+            edited: None,
+        }
+    }
+
+    pub async fn publish(self, channel: &Channel) -> Result<()> {
+        get_collection("messages")
+            .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "message",
+            })?;
+
+        // ! FIXME: temp code
+        let channels = get_collection("channels");
+        match channel {
+            Channel::DirectMessage { id, .. } => {
+                channels
+                    .update_one(
+                        doc! { "_id": id },
+                        doc! {
+                            "$set": {
+                                "active": true,
+                                "last_message": {
+                                    "_id": self.id.clone(),
+                                    "author": self.author.clone(),
+                                    "short": self.content.chars().take(24).collect::<String>()
+                                }
+                            }
+                        },
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "update_one",
+                        with: "channel",
+                    })?;
+            }
+            Channel::Group { id, .. } => {
+                channels
+                    .update_one(
+                        doc! { "_id": id },
+                        doc! {
+                            "$set": {
+                                "last_message": {
+                                    "_id": self.id.clone(),
+                                    "author": self.author.clone(),
+                                    "short": self.content.chars().take(24).collect::<String>()
+                                }
+                            }
+                        },
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "update_one",
+                        with: "channel",
+                    })?;
+            }
+            _ => {}
+        }
+
+        ClientboundNotification::Message(self)
+            .publish(channel.id().to_string())
+            .await
+            .ok();
+
+        Ok(())
+    }
+
+    pub async fn publish_update(&self, data: JsonValue) -> Result<()> {
+        let channel = self.channel.clone();
+        ClientboundNotification::MessageUpdate {
+            id: self.id.clone(),
+            data,
+        }
+        .publish(channel)
+        .await
+        .ok();
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        get_collection("messages")
+            .delete_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "message",
+            })?;
+
+        let channel = self.channel.clone();
+        ClientboundNotification::MessageDelete {
+            id: self.id.clone(),
+        }
+        .publish(channel)
+        .await
+        .ok();
+
+        Ok(())
+    }
+}

src/database/entities/mod.rs

@@ -0,0 +1,9 @@
+mod channel;
+mod guild;
+mod message;
+mod user;
+
+pub use channel::*;
+pub use guild::*;
+pub use message::*;
+pub use user::*;

src/database/entities/user.rs

@@ -0,0 +1,68 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{database::permissions::user::UserPermissions, notifications::websocket::is_online};
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub enum RelationshipStatus {
+    None,
+    User,
+    Friend,
+    Outgoing,
+    Incoming,
+    Blocked,
+    BlockedOther,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Relationship {
+    #[serde(rename = "_id")]
+    pub id: String,
+    pub status: RelationshipStatus,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct User {
+    #[serde(rename = "_id")]
+    pub id: String,
+    pub username: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relations: Option<Vec<Relationship>>,
+
+    // ? This should never be pushed to the collection.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relationship: Option<RelationshipStatus>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub online: Option<bool>,
+}
+
+impl User {
+    /// Mutate the user object to include relationship as seen by user.
+    pub fn from(mut self, user: &User) -> User {
+        if self.id == user.id {
+            self.relationship = Some(RelationshipStatus::User);
+            return self;
+        }
+
+        if let Some(relations) = &user.relations {
+            if let Some(relationship) = relations.iter().find(|x| self.id == x.id) {
+                self.relationship = Some(relationship.status.clone());
+                return self;
+            }
+        }
+
+        self
+    }
+
+    /// Mutate the user object to appear as seen by user.
+    pub fn with(mut self, permissions: UserPermissions<[u32; 1]>) -> User {
+        if !permissions.get_view_all() {
+            self.relations = None;
+        }
+
+        if permissions.get_view_profile() {
+            self.online = Some(is_online(&self.id));
+        }
+
+        self
+    }
+}

src/database/guards/mod.rs

@@ -0,0 +1,4 @@
+pub mod reference;
+pub mod user;
+
+pub use reference::Ref;

src/database/guards/reference.rs

@@ -0,0 +1,80 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::{doc, from_document};
+use rocket::http::RawStr;
+use rocket::request::FromParam;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Ref {
+    #[validate(length(min = 26, max = 26))]
+    pub id: String,
+}
+
+impl Ref {
+    pub fn from(id: String) -> Result<Ref> {
+        Ok(Ref { id })
+    }
+
+    pub async fn fetch<T: DeserializeOwned>(&self, collection: &'static str) -> Result<T> {
+        let doc = get_collection(&collection)
+            .find_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: &collection,
+            })?
+            .ok_or_else(|| Error::UnknownUser)?;
+
+        Ok(from_document::<T>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: &collection,
+        })?)
+    }
+
+    pub async fn fetch_user(&self) -> Result<User> {
+        self.fetch("users").await
+    }
+
+    pub async fn fetch_channel(&self) -> Result<Channel> {
+        self.fetch("channels").await
+    }
+
+    pub async fn fetch_message(&self, channel: &Channel) -> Result<Message> {
+        let message: Message = self.fetch("messages").await?;
+        if &message.channel != channel.id() {
+            Err(Error::InvalidOperation)
+        } else {
+            Ok(message)
+        }
+    }
+}
+
+impl User {
+    pub fn as_ref(&self) -> Ref {
+        Ref {
+            id: self.id.to_string(),
+        }
+    }
+}
+
+impl<'r> FromParam<'r> for Ref {
+    type Error = &'r RawStr;
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        if let Ok(result) = Ref::from(param.to_string()) {
+            if result.validate().is_ok() {
+                return Ok(result);
+            }
+        }
+
+        Err(param)
+    }
+}

src/database/guards/user.rs

@@ -0,0 +1,39 @@
+use crate::database::*;
+
+use mongodb::bson::{doc, from_document};
+use rauth::auth::Session;
+use rocket::http::Status;
+use rocket::request::{self, FromRequest, Outcome, Request};
+
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for User {
+    type Error = rauth::util::Error;
+
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let session: Session = try_outcome!(request.guard::<Session>().await);
+
+        if let Ok(result) = get_collection("users")
+            .find_one(
+                doc! {
+                    "_id": &session.user_id
+                },
+                None,
+            )
+            .await
+        {
+            if let Some(doc) = result {
+                Outcome::Success(from_document(doc).unwrap())
+            } else {
+                Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
+            }
+        } else {
+            Outcome::Failure((
+                Status::InternalServerError,
+                rauth::util::Error::DatabaseError {
+                    operation: "find_one",
+                    with: "user",
+                },
+            ))
+        }
+    }
+}

src/database/message.rs

@@ -1,26 +0,0 @@
-use bson::UtcDateTime;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PreviousEntry {
-    pub content: String,
-    pub time: UtcDateTime,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Message {
-    #[serde(rename = "_id")]
-    pub id: String,
-    // pub nonce: String, used internally
-    pub channel: String,
-    pub author: String,
-
-    pub content: String,
-    pub edited: Option<UtcDateTime>,
-
-    pub previous_content: Option<Vec<PreviousEntry>>,
-}
-
-// ? TODO: write global send message
-// ? pub fn send_message();
-// ? handle websockets?

src/database/migrations/init.rs

@@ -0,0 +1,109 @@
+use super::super::get_db;
+use super::scripts::LATEST_REVISION;
+
+use log::info;
+use mongodb::bson::doc;
+use mongodb::options::CreateCollectionOptions;
+
+pub async fn create_database() {
+    info!("Creating database.");
+    let db = get_db();
+
+    db.create_collection("accounts", None)
+        .await
+        .expect("Failed to create accounts collection.");
+
+    db.create_collection("users", None)
+        .await
+        .expect("Failed to create users collection.");
+
+    db.create_collection("channels", None)
+        .await
+        .expect("Failed to create channels collection.");
+
+    db.create_collection("messages", None)
+        .await
+        .expect("Failed to create messages collection.");
+
+    db.create_collection("migrations", None)
+        .await
+        .expect("Failed to create migrations collection.");
+
+    db.create_collection(
+        "pubsub",
+        CreateCollectionOptions::builder()
+            .capped(true)
+            .size(1_000_000)
+            .build(),
+    )
+    .await
+    .expect("Failed to create pubsub collection.");
+
+    db.run_command(
+        doc! {
+            "createIndexes": "accounts",
+            "indexes": [
+                {
+                    "key": {
+                        "email": 1
+                    },
+                    "name": "email",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                },
+                {
+                    "key": {
+                        "email_normalised": 1
+                    },
+                    "name": "email_normalised",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create account index.");
+
+    db.run_command(
+        doc! {
+            "createIndexes": "users",
+            "indexes": [
+                {
+                    "key": {
+                        "username": 1
+                    },
+                    "name": "username",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                }
+            ]
+        },
+        None,
+    )
+    .await
+    .expect("Failed to create username index.");
+
+    db.collection("migrations")
+        .insert_one(
+            doc! {
+                "_id": 0,
+                "revision": LATEST_REVISION
+            },
+            None,
+        )
+        .await
+        .expect("Failed to save migration info.");
+
+    info!("Created database.");
+}

src/database/migrations/mod.rs

@@ -0,0 +1,19 @@
+use super::get_connection;
+
+pub mod init;
+pub mod scripts;
+
+pub async fn run_migrations() {
+    let client = get_connection();
+
+    let list = client
+        .list_database_names(None, None)
+        .await
+        .expect("Failed to fetch database names.");
+
+    if list.iter().position(|x| x == "revolt").is_none() {
+        init::create_database().await;
+    } else {
+        scripts::migrate_database().await;
+    }
+}

src/database/migrations/scripts.rs

@@ -0,0 +1,58 @@
+use crate::database::get_collection;
+
+use log::info;
+use mongodb::bson::{doc, from_document};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct MigrationInfo {
+    _id: i32,
+    revision: i32,
+}
+
+pub const LATEST_REVISION: i32 = 0;
+
+pub async fn migrate_database() {
+    let migrations = get_collection("migrations");
+    let data = migrations
+        .find_one(None, None)
+        .await
+        .expect("Failed to fetch migration data.");
+
+    if let Some(doc) = data {
+        let info: MigrationInfo =
+            from_document(doc).expect("Failed to read migration information.");
+
+        let revision = run_migrations(info.revision).await;
+
+        migrations
+            .update_one(
+                doc! {
+                    "_id": info._id
+                },
+                doc! {
+                    "$set": {
+                        "revision": revision
+                    }
+                },
+                None,
+            )
+            .await
+            .expect("Failed to commit migration information.");
+
+        info!("Migration complete. Currently at revision {}.", revision);
+    } else {
+        panic!("Database was configured incorrectly, possibly because initalization failed.")
+    }
+}
+
+pub async fn run_migrations(revision: i32) -> i32 {
+    info!("Starting database migration.");
+
+    if revision <= 0 {
+        info!("Running migration [revision 0]: Test migration system.");
+    }
+
+    // Reminder to update LATEST_REVISION when adding new migrations.
+    LATEST_REVISION
+}

src/database/mod.rs

@@ -1,15 +1,17 @@
-use mongodb::{Client, Collection, Database};
-use std::env;
+use crate::util::variables::MONGO_URI;
 
+use mongodb::{Client, Collection, Database};
 use once_cell::sync::OnceCell;
+
 static DBCONN: OnceCell<Client> = OnceCell::new();
 
-pub fn connect() {
-    let client =
-        Client::with_uri_str(&env::var("DB_URI").expect("DB_URI not in environment variables!"))
-            .expect("Failed to init db connection.");
+pub async fn connect() {
+    let client = Client::with_uri_str(&MONGO_URI)
+        .await
+        .expect("Failed to init db connection.");
 
     DBCONN.set(client).unwrap();
+    migrations::run_migrations().await;
 }
 
 pub fn get_connection() -> &'static Client {
@@ -24,11 +26,11 @@ pub fn get_collection(collection: &str) -> Collection {
     get_db().collection(collection)
 }
 
-pub mod channel;
-pub mod guild;
-pub mod message;
-pub mod mutual;
+pub mod entities;
+pub mod guards;
+pub mod migrations;
 pub mod permissions;
-pub mod user;
 
+pub use entities::*;
+pub use guards::*;
 pub use permissions::*;

src/database/mutual.rs

@@ -1,131 +0,0 @@
-use super::{get_collection, MemberPermissions};
-
-use bson::doc;
-use mongodb::options::FindOptions;
-
-pub fn find_mutual_guilds(user_id: &str, target_id: &str) -> Vec<String> {
-    let col = get_collection("members");
-    if let Ok(result) = col.find(
-        doc! {
-            "$and": [
-                { "id": user_id   },
-                { "id": target_id },
-            ]
-        },
-        FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-    ) {
-        let mut results = vec![];
-
-        for doc in result {
-            if let Ok(guild) = doc {
-                results.push(guild.get_str("_id").unwrap().to_string());
-            }
-        }
-
-        results
-    } else {
-        vec![]
-    }
-}
-
-pub fn find_mutual_friends(user_id: &str, target_id: &str) -> Vec<String> {
-    let col = get_collection("users");
-    if let Ok(result) = col.find(
-        doc! {
-            "$and": [
-                { "relations": { "$elemMatch": { "id": user_id,   "status": 0 } } },
-                { "relations": { "$elemMatch": { "id": target_id, "status": 0 } } },
-            ]
-        },
-        FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-    ) {
-        let mut results = vec![];
-
-        for doc in result {
-            if let Ok(user) = doc {
-                results.push(user.get_str("_id").unwrap().to_string());
-            }
-        }
-
-        results
-    } else {
-        vec![]
-    }
-}
-
-pub fn find_mutual_groups(user_id: &str, target_id: &str) -> Vec<String> {
-    let col = get_collection("channels");
-    if let Ok(result) = col.find(
-        doc! {
-            "type": 1,
-            "$and": [
-                { "recipients": user_id },
-                { "recipients": target_id },
-            ]
-        },
-        FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-    ) {
-        let mut results = vec![];
-
-        for doc in result {
-            if let Ok(group) = doc {
-                results.push(group.get_str("_id").unwrap().to_string());
-            }
-        }
-
-        results
-    } else {
-        vec![]
-    }
-}
-
-pub fn has_mutual_connection(user_id: &str, target_id: &str, with_permission: bool) -> bool {
-    let mut doc = doc! { "_id": 1 };
-
-    if with_permission {
-        doc.insert("default_permissions", 1);
-    }
-
-    let opt = FindOptions::builder().projection(doc);
-
-    if let Ok(result) = get_collection("guilds").find(
-        doc! {
-            "$and": [
-                { "members": { "$elemMatch": { "id": user_id   } } },
-                { "members": { "$elemMatch": { "id": target_id } } },
-            ]
-        },
-        if with_permission {
-            opt.build()
-        } else {
-            opt.limit(1).build()
-        },
-    ) {
-        if with_permission {
-            for item in result {
-                // ? logic should match permissions.rs#calculate
-                if let Ok(guild) = item {
-                    if guild.get_str("owner").unwrap() == user_id {
-                        return true;
-                    }
-
-                    let permissions = guild.get_i32("default_permissions").unwrap() as u32;
-
-                    if MemberPermissions([ permissions ]).get_send_direct_messages() {
-                        return true;
-                    }
-                }
-            }
-
-            false
-        } else {
-            if result.count() > 0 {
-                true
-            } else {
-                false
-            }
-        }
-    } else {
-        false
-    }
-}

src/database/permissions.rs

@@ -1,217 +0,0 @@
-use super::mutual::has_mutual_connection;
-use crate::database::guild::Member;
-use crate::database::user::UserRelationship;
-use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::guards::guild::{get_member, GuildRef};
-
-use num_enum::TryFromPrimitive;
-
-#[derive(Debug, PartialEq, Eq, TryFromPrimitive)]
-#[repr(u8)]
-pub enum Relationship {
-    Friend = 0,
-    Outgoing = 1,
-    Incoming = 2,
-    Blocked = 3,
-    BlockedOther = 4,
-    NONE = 5,
-    SELF = 6,
-}
-
-#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
-#[repr(u32)]
-pub enum Permission {
-    Access = 1,
-    CreateInvite = 2,
-    KickMembers = 4,
-    BanMembers = 8,
-    ReadMessages = 16,
-    SendMessages = 32,
-    ManageMessages = 64,
-    ManageChannels = 128,
-    ManageServer = 256,
-    ManageRoles = 512,
-    SendDirectMessages = 1024,
-}
-
-bitfield! {
-    pub struct MemberPermissions(MSB0 [u32]);
-    u32;
-    pub get_access, set_access: 31;
-    pub get_create_invite, set_create_invite: 30;
-    pub get_kick_members, set_kick_members: 29;
-    pub get_ban_members, set_ban_members: 28;
-    pub get_read_messages, set_read_messages: 27;
-    pub get_send_messages, set_send_messages: 26;
-    pub get_manage_messages, set_manage_messages: 25;
-    pub get_manage_channels, set_manage_channels: 24;
-    pub get_manage_server, set_manage_server: 23;
-    pub get_manage_roles, set_manage_roles: 22;
-    pub get_send_direct_messages, set_send_direct_messages: 21;
-}
-
-pub fn get_relationship_internal(
-    user_id: &str,
-    target_id: &str,
-    relationships: &Option<Vec<UserRelationship>>,
-) -> Relationship {
-    if user_id == target_id {
-        return Relationship::SELF;
-    }
-
-    if let Some(arr) = &relationships {
-        for entry in arr {
-            if entry.id == target_id {
-                match entry.status {
-                    0 => return Relationship::Friend,
-                    1 => return Relationship::Outgoing,
-                    2 => return Relationship::Incoming,
-                    3 => return Relationship::Blocked,
-                    4 => return Relationship::BlockedOther,
-                    _ => return Relationship::NONE,
-                }
-            }
-        }
-    }
-
-    Relationship::NONE
-}
-
-pub fn get_relationship(a: &UserRef, b: &UserRef) -> Relationship {
-    if a.id == b.id {
-        return Relationship::SELF;
-    }
-
-    get_relationship_internal(&a.id, &b.id, &a.fetch_relationships())
-}
-
-pub struct PermissionCalculator {
-    pub user: UserRef,
-    pub channel: Option<ChannelRef>,
-    pub guild: Option<GuildRef>,
-    pub member: Option<Member>,
-}
-
-impl PermissionCalculator {
-    pub fn new(user: UserRef) -> PermissionCalculator {
-        PermissionCalculator {
-            user,
-            channel: None,
-            guild: None,
-            member: None,
-        }
-    }
-
-    pub fn channel(self, channel: ChannelRef) -> PermissionCalculator {
-        PermissionCalculator {
-            channel: Some(channel),
-            ..self
-        }
-    }
-
-    pub fn guild(self, guild: GuildRef) -> PermissionCalculator {
-        PermissionCalculator {
-            guild: Some(guild),
-            ..self
-        }
-    }
-
-    pub fn fetch_data(mut self) -> PermissionCalculator {
-        let guild = if let Some(value) = self.guild {
-            Some(value)
-        } else if let Some(channel) = &self.channel {
-            match channel.channel_type {
-                0..=1 => None,
-                2 => {
-                    if let Some(id) = &channel.guild {
-                        GuildRef::from(id.clone())
-                    } else {
-                        None
-                    }
-                }
-                _ => None,
-            }
-        } else {
-            None
-        };
-
-        if let Some(guild) = &guild {
-            self.member = get_member(&guild.id, &self.user.id);
-        }
-
-        self.guild = guild;
-        self
-    }
-
-    pub fn calculate(&self) -> u32 {
-        let mut permissions: u32 = 0;
-        if let Some(guild) = &self.guild {
-            if let Some(_member) = &self.member {
-                // ? logic should match mutual.rs#has_mutual_connection
-                if guild.owner == self.user.id {
-                    return u32::MAX;
-                }
-
-                permissions = guild.default_permissions as u32;
-            }
-        }
-
-        if let Some(channel) = &self.channel {
-            match channel.channel_type {
-                0 => {
-                    if let Some(arr) = &channel.recipients {
-                        let mut other_user = "";
-                        for item in arr {
-                            if item != &self.user.id {
-                                other_user = item;
-                            }
-                        }
-
-                        let relationships = self.user.fetch_relationships();
-                        let relationship =
-                            get_relationship_internal(&self.user.id, &other_user, &relationships);
-
-                        if relationship == Relationship::Friend {
-                            permissions = 177;
-                        } else if relationship == Relationship::Blocked
-                            || relationship == Relationship::BlockedOther
-                        {
-                            permissions = 1;
-                        } else if has_mutual_connection(&self.user.id, other_user, true) {
-                            permissions = 177;
-                        } else {
-                            permissions = 1;
-                        }
-                    }
-                }
-                1 => {
-                    if let Some(id) = &channel.owner {
-                        if &self.user.id == id {
-                            return u32::MAX;
-                        }
-                    }
-
-                    if let Some(arr) = &channel.recipients {
-                        for item in arr {
-                            if item == &self.user.id {
-                                permissions = 177;
-                                break;
-                            }
-                        }
-                    }
-                }
-                2 => {
-                    // nothing implemented yet
-                }
-                _ => {}
-            }
-        }
-
-        permissions
-    }
-
-    pub fn as_permission(&self) -> MemberPermissions<[u32; 1]> {
-        MemberPermissions([self.calculate()])
-    }
-}

src/database/permissions/channel.rs

@@ -0,0 +1,123 @@
+use crate::database::*;
+use crate::util::result::Result;
+
+use super::PermissionCalculator;
+
+use num_enum::TryFromPrimitive;
+use std::ops;
+
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
+#[repr(u32)]
+pub enum ChannelPermission {
+    View = 1,
+    SendMessage = 2,
+    ManageMessages = 4,
+}
+
+bitfield! {
+    pub struct ChannelPermissions(MSB0 [u32]);
+    u32;
+    pub get_view, _: 31;
+    pub get_send_message, _: 30;
+    pub get_manage_messages, _: 29;
+}
+
+impl_op_ex!(+ |a: &ChannelPermission, b: &ChannelPermission| -> u32 { *a as u32 | *b as u32 });
+impl_op_ex_commutative!(+ |a: &u32, b: &ChannelPermission| -> u32 { *a | *b as u32 });
+
+/*pub async fn calculate(user: &User, target: &Channel) -> Result<u32> {
+    match target {
+        Channel::SavedMessages { user: owner, .. } => {
+            if &user.id == owner {
+                Ok(ChannelPermission::View
+                    + ChannelPermission::SendMessage
+                    + ChannelPermission::ManageMessages)
+            } else {
+                Ok(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) {
+                    let perms = super::user::get(&user, recipient).await?;
+
+                    if perms.get_send_message() {
+                        return Ok(ChannelPermission::View + ChannelPermission::SendMessage);
+                    }
+
+                    return Ok(ChannelPermission::View as u32);
+                }
+            }
+
+            Ok(0)
+        }
+        Channel::Group { recipients, .. } => {
+            if recipients.iter().find(|x| *x == &user.id).is_some() {
+                Ok(ChannelPermission::View + ChannelPermission::SendMessage)
+            } else {
+                Ok(0)
+            }
+        }
+    }
+}
+
+pub async fn get(user: &User, target: &Channel) -> Result<ChannelPermissions<[u32; 1]>> {
+    Ok(ChannelPermissions([calculate(&user, &target).await?]))
+}*/
+
+impl<'a> PermissionCalculator<'a> {
+    pub async fn calculate_channel(self) -> Result<u32> {
+        let channel = if let Some(channel) = self.channel {
+            channel
+        } else {
+            unreachable!()
+        };
+
+        match channel {
+            Channel::SavedMessages { user: owner, .. } => {
+                if &self.perspective.id == owner {
+                    Ok(ChannelPermission::View
+                        + ChannelPermission::SendMessage
+                        + ChannelPermission::ManageMessages)
+                } else {
+                    Ok(0)
+                }
+            }
+            Channel::DirectMessage { recipients, .. } => {
+                if recipients
+                    .iter()
+                    .find(|x| *x == &self.perspective.id)
+                    .is_some()
+                {
+                    if let Some(recipient) = recipients.iter().find(|x| *x != &self.perspective.id)
+                    {
+                        let perms = self.for_user(recipient).await?;
+
+                        if perms.get_send_message() {
+                            return Ok(ChannelPermission::View + ChannelPermission::SendMessage);
+                        }
+
+                        return Ok(ChannelPermission::View as u32);
+                    }
+                }
+
+                Ok(0)
+            }
+            Channel::Group { recipients, .. } => {
+                if recipients
+                    .iter()
+                    .find(|x| *x == &self.perspective.id)
+                    .is_some()
+                {
+                    Ok(ChannelPermission::View + ChannelPermission::SendMessage)
+                } else {
+                    Ok(0)
+                }
+            }
+        }
+    }
+
+    pub async fn for_channel(self) -> Result<ChannelPermissions<[u32; 1]>> {
+        Ok(ChannelPermissions([self.calculate_channel().await?]))
+    }
+}

src/database/permissions/mod.rs

@@ -0,0 +1,49 @@
+pub use crate::database::*;
+
+pub mod channel;
+pub mod user;
+
+pub use user::get_relationship;
+
+pub struct PermissionCalculator<'a> {
+    perspective: &'a User,
+
+    user: Option<&'a User>,
+    channel: Option<&'a Channel>,
+
+    has_mutual_conncetion: bool,
+}
+
+impl<'a> PermissionCalculator<'a> {
+    pub fn new(perspective: &'a User) -> PermissionCalculator {
+        PermissionCalculator {
+            perspective,
+
+            user: None,
+            channel: None,
+
+            has_mutual_conncetion: false,
+        }
+    }
+
+    pub fn with_user(self, user: &'a User) -> PermissionCalculator {
+        PermissionCalculator {
+            user: Some(&user),
+            ..self
+        }
+    }
+
+    pub fn with_channel(self, channel: &'a Channel) -> PermissionCalculator {
+        PermissionCalculator {
+            channel: Some(&channel),
+            ..self
+        }
+    }
+
+    pub fn with_mutual_connection(self) -> PermissionCalculator<'a> {
+        PermissionCalculator {
+            has_mutual_conncetion: true,
+            ..self
+        }
+    }
+}

src/database/permissions/user.rs

@@ -0,0 +1,106 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use super::PermissionCalculator;
+
+use mongodb::bson::doc;
+use num_enum::TryFromPrimitive;
+use std::ops;
+
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
+#[repr(u32)]
+pub enum UserPermission {
+    Access = 1,
+    ViewProfile = 2,
+    SendMessage = 4,
+    Invite = 8,
+
+    ViewAll = 2147483648,
+}
+
+bitfield! {
+    pub struct UserPermissions(MSB0 [u32]);
+    u32;
+    pub get_access, _: 31;
+    pub get_view_profile, _: 30;
+    pub get_send_message, _: 29;
+    pub get_invite, _: 28;
+
+    pub get_view_all, _: 0;
+}
+
+impl_op_ex!(+ |a: &UserPermission, b: &UserPermission| -> u32 { *a as u32 | *b as u32 });
+impl_op_ex!(-|a: &UserPermission, b: &UserPermission| -> u32 { *a as u32 & !(*b as u32) });
+impl_op_ex!(-|a: &u32, b: &UserPermission| -> u32 { *a & !(*b as u32) });
+impl_op_ex_commutative!(+ |a: &u32, b: &UserPermission| -> u32 { *a | *b as u32 });
+
+pub fn get_relationship(a: &User, b: &str) -> RelationshipStatus {
+    if a.id == b {
+        return RelationshipStatus::Friend;
+    }
+
+    if let Some(relations) = &a.relations {
+        if let Some(relationship) = relations.iter().find(|x| x.id == b) {
+            return relationship.status.clone();
+        }
+    }
+
+    RelationshipStatus::None
+}
+
+impl<'a> PermissionCalculator<'a> {
+    pub async fn calculate_user(self, target: &str) -> Result<u32> {
+        if &self.perspective.id == target {
+            return Ok(u32::MAX);
+        }
+
+        let mut permissions: u32 = 0;
+        match get_relationship(&self.perspective, &target) {
+            RelationshipStatus::Friend => return Ok(u32::MAX - UserPermission::ViewAll),
+            RelationshipStatus::Blocked | RelationshipStatus::BlockedOther => {
+                return Ok(UserPermission::Access as u32)
+            }
+            RelationshipStatus::Incoming | RelationshipStatus::Outgoing => {
+                permissions = UserPermission::Access as u32;
+                // ! INFO: if we add boolean switch for permission to
+                // ! message people who have mutual, we need to get
+                // ! rid of this return statement.
+                return Ok(permissions);
+            }
+            _ => {}
+        }
+
+        if self.has_mutual_conncetion
+            || get_collection("channels")
+                .find_one(
+                    doc! {
+                        "type": "Group",
+                        "$and": {
+                            "recipients": &self.perspective.id,
+                            "recipients": target
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "find",
+                    with: "channels",
+                })?
+                .is_some()
+        {
+            return Ok(UserPermission::Access as u32);
+        }
+
+        Ok(permissions)
+    }
+
+    pub async fn for_user(self, target: &str) -> Result<UserPermissions<[u32; 1]>> {
+        Ok(UserPermissions([self.calculate_user(&target).await?]))
+    }
+
+    pub async fn for_user_given(self) -> Result<UserPermissions<[u32; 1]>> {
+        let id = &self.user.unwrap().id;
+        Ok(UserPermissions([self.calculate_user(&id).await?]))
+    }
+}

src/database/user.rs

@@ -1,29 +0,0 @@
-use bson::UtcDateTime;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserEmailVerification {
-    pub verified: bool,
-    pub target: Option<String>,
-    pub expiry: Option<UtcDateTime>,
-    pub rate_limit: Option<UtcDateTime>,
-    pub code: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserRelationship {
-    pub id: String,
-    pub status: u8,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct User {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub email: String,
-    pub username: String,
-    pub password: String,
-    pub access_token: Option<String>,
-    pub email_verification: UserEmailVerification,
-    pub relations: Option<Vec<UserRelationship>>,
-}

src/email.rs

@@ -1,50 +0,0 @@
-use reqwest::blocking::Client;
-use std::collections::HashMap;
-use std::env;
-
-pub fn send_email(target: String, subject: String, body: String, html: String) -> Result<(), ()> {
-    let mut map = HashMap::new();
-    map.insert("target", target.clone());
-    map.insert("subject", subject);
-    map.insert("body", body);
-    map.insert("html", html);
-
-    let client = Client::new();
-    match client
-        .post("http://192.168.0.26:3838/send")
-        .json(&map)
-        .send()
-    {
-        Ok(_) => Ok(()),
-        Err(_) => Err(()),
-    }
-}
-
-fn public_uri() -> String {
-    env::var("PUBLIC_URI").expect("PUBLIC_URI not in environment variables!")
-}
-
-pub fn send_verification_email(email: String, code: String) -> bool {
-    let url = format!("{}/api/account/verify/{}", public_uri(), code);
-    send_email(
-        email,
-        "Verify your email!".to_string(),
-        format!("Verify your email here: {}", url),
-        format!("<a href=\"{}\">Click to verify your email!</a>", url),
-    )
-    .is_ok()
-}
-
-pub fn send_welcome_email(email: String, username: String) -> bool {
-    send_email(
-        email,
-        "Welcome to REVOLT!".to_string(),
-        format!("Welcome, {}! You can now use REVOLT.", username.clone()),
-        format!(
-            "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
-            username.clone(),
-            public_uri()
-        ),
-    )
-    .is_ok()
-}

src/guards/auth.rs

@@ -1,162 +0,0 @@
-use bson::{doc, from_bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::{RawStr, Status};
-use rocket::request::{self, FromParam, FromRequest, Request};
-use rocket::Outcome;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use database::user::{User, UserRelationship};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserRef {
-    pub id: String,
-    pub username: String,
-    pub email_verified: bool,
-}
-
-impl UserRef {
-    pub fn from(id: String) -> Option<UserRef> {
-        match database::get_collection("users").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "username": 1,
-                    "email_verification.verified": 1,
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => Some(UserRef {
-                    id: doc.get_str("_id").unwrap().to_string(),
-                    username: doc.get_str("username").unwrap().to_string(),
-                    email_verified: doc
-                        .get_document("email_verification")
-                        .unwrap()
-                        .get_bool("verified")
-                        .unwrap(),
-                }),
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch user from database.")
-    }
-
-    pub fn fetch_relationships(&self) -> Option<Vec<UserRelationship>> {
-        let user = database::get_collection("users")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder()
-                    .projection(doc! { "relations": 1 })
-                    .build(),
-            )
-            .expect("Failed to fetch user relationships from database.")
-            .expect("Missing user document.");
-
-        if let Ok(arr) = user.get_array("relations") {
-            let mut relationships = vec![];
-            for item in arr {
-                relationships.push(from_bson(item.clone()).unwrap());
-            }
-
-            Some(relationships)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum AuthError {
-    BadCount,
-    Missing,
-    Invalid,
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for UserRef {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let result = database::get_collection("users")
-                    .find_one(
-                        doc! { "access_token": key },
-                        FindOneOptions::builder()
-                            .projection(doc! {
-                                "_id": 1,
-                                "username": 1,
-                                "email_verification.verified": 1,
-                            })
-                            .build(),
-                    )
-                    .unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(UserRef {
-                        id: user.get_str("_id").unwrap().to_string(),
-                        username: user.get_str("username").unwrap().to_string(),
-                        email_verified: user
-                            .get_document("email_verification")
-                            .unwrap()
-                            .get_bool("verified")
-                            .unwrap(),
-                    })
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for User {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let keys: Vec<_> = request.headers().get("x-auth-token").collect();
-        match keys.len() {
-            0 => Outcome::Failure((Status::Forbidden, AuthError::Missing)),
-            1 => {
-                let key = keys[0];
-                let col = database::get_collection("users");
-                let result = col.find_one(doc! { "access_token": key }, None).unwrap();
-
-                if let Some(user) = result {
-                    Outcome::Success(
-                        from_bson(bson::Bson::Document(user)).expect("Failed to unwrap user."),
-                    )
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                }
-            }
-            _ => Outcome::Failure((Status::BadRequest, AuthError::BadCount)),
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for UserRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(user) = UserRef::from(param.to_string()) {
-            Ok(user)
-        } else {
-            Err(param)
-        }
-    }
-}

src/guards/channel.rs

@@ -1,91 +0,0 @@
-use bson::{doc, from_bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-
-use database::channel::LastMessage;
-use database::message::Message;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ChannelRef {
-    #[serde(rename = "_id")]
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: u8,
-
-    pub name: Option<String>,
-    pub last_message: Option<LastMessage>,
-
-    // information required for permission calculations
-    pub recipients: Option<Vec<String>>,
-    pub guild: Option<String>,
-    pub owner: Option<String>,
-}
-
-impl ChannelRef {
-    pub fn from(id: String) -> Option<ChannelRef> {
-        match database::get_collection("channels").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "type": 1,
-                    "name": 1,
-                    "last_message": 1,
-                    "recipients": 1,
-                    "guild": 1,
-                    "owner": 1,
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => {
-                    Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap channel."))
-                }
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("channels")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch channel from database.")
-    }
-}
-
-impl<'r> FromParam<'r> for ChannelRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(channel) = ChannelRef::from(param.to_string()) {
-            Ok(channel)
-        } else {
-            Err(param)
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for Message {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        let col = database::get_collection("messages");
-        let result = col
-            .find_one(doc! { "_id": param.to_string() }, None)
-            .unwrap();
-
-        if let Some(message) = result {
-            Ok(from_bson(bson::Bson::Document(message)).expect("Failed to unwrap message."))
-        } else {
-            Err(param)
-        }
-    }
-}

src/guards/guild.rs

@@ -1,153 +0,0 @@
-use bson::{doc, from_bson, Bson, Document};
-use mongodb::options::FindOneOptions;
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-use crate::database;
-use crate::database::guild::{Ban, Invite, Member};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct GuildRef {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub owner: String,
-
-    pub bans: Vec<Ban>,
-
-    pub default_permissions: i32,
-}
-
-impl GuildRef {
-    pub fn from(id: String) -> Option<GuildRef> {
-        match database::get_collection("guilds").find_one(
-            doc! { "_id": id },
-            FindOneOptions::builder()
-                .projection(doc! {
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                    "bans": 1,
-                    "default_permissions": 1
-                })
-                .build(),
-        ) {
-            Ok(result) => match result {
-                Some(doc) => {
-                    Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap guild."))
-                }
-                None => None,
-            },
-            Err(_) => None,
-        }
-    }
-
-    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
-        database::get_collection("guilds")
-            .find_one(
-                doc! { "_id": &self.id },
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-
-    pub fn fetch_data_given(&self, mut filter: Document, projection: Document) -> Option<Document> {
-        filter.insert("_id", self.id.clone());
-        database::get_collection("guilds")
-            .find_one(
-                filter,
-                FindOneOptions::builder().projection(projection).build(),
-            )
-            .expect("Failed to fetch guild from database.")
-    }
-}
-
-impl<'r> FromParam<'r> for GuildRef {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Some(guild) = GuildRef::from(param.to_string()) {
-            Ok(guild)
-        } else {
-            Err(param)
-        }
-    }
-}
-
-pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
-    if let Ok(result) = database::get_collection("members").find_one(
-        doc! {
-            "_id.guild": &guild_id,
-            "_id.user": &member,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            Some(from_bson(Bson::Document(doc)).expect("Failed to unwrap member."))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-pub fn get_invite<U: Into<Option<String>>>(
-    code: &String,
-    user: U,
-) -> Option<(String, String, Invite)> {
-    let mut doc = doc! {
-        "invites": {
-            "$elemMatch": {
-                "code": &code
-            }
-        }
-    };
-
-    if let Some(user_id) = user.into() {
-        doc.insert(
-            "bans",
-            doc! {
-                "$not": {
-                    "$elemMatch": {
-                        "id": user_id
-                    }
-                }
-            },
-        );
-    }
-
-    if let Ok(result) = database::get_collection("guilds").find_one(
-        doc,
-        FindOneOptions::builder()
-            .projection(doc! {
-                "_id": 1,
-                "name": 1,
-                "invites.$": 1,
-            })
-            .build(),
-    ) {
-        if let Some(doc) = result {
-            let invite = doc
-                .get_array("invites")
-                .unwrap()
-                .iter()
-                .next()
-                .unwrap()
-                .as_document()
-                .unwrap();
-
-            Some((
-                doc.get_str("_id").unwrap().to_string(),
-                doc.get_str("name").unwrap().to_string(),
-                from_bson(Bson::Document(invite.clone())).unwrap(),
-            ))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}

src/guards/mod.rs

@@ -1,3 +0,0 @@
-pub mod auth;
-pub mod channel;
-pub mod guild;

src/main.rs

@@ -1,36 +1,103 @@
 #![feature(proc_macro_hygiene, decl_macro)]
+#![feature(async_closure)]
+
 #[macro_use]
 extern crate rocket;
 #[macro_use]
 extern crate rocket_contrib;
 #[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate impl_ops;
+#[macro_use]
 extern crate bitfield;
+extern crate ctrlc;
 
 pub mod database;
-pub mod email;
-pub mod guards;
+pub mod notifications;
 pub mod routes;
 pub mod util;
-pub mod websocket;
 
-use dotenv;
+use log::info;
+use futures::join;
+use chrono::Duration;
+use rauth::auth::Auth;
 use rocket_cors::AllowedOrigins;
-use std::thread;
+use rocket_prometheus::PrometheusMetrics;
+use rauth::options::{EmailVerification, Options, SMTP};
+use util::variables::{PUBLIC_URL, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME, USE_EMAIL, USE_PROMETHEUS};
 
-fn main() {
+#[async_std::main]
+async fn main() {
     dotenv::dotenv().ok();
-    database::connect();
+    env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "info"));
 
-    thread::spawn(|| {
-        websocket::launch_server();
-    });
+    info!("Starting REVOLT server.");
 
+    util::variables::preflight_checks();
+    database::connect().await;
+    notifications::hive::init_hive().await;
+
+    ctrlc::set_handler(move || {
+        // Force ungraceful exit to avoid hang.
+        std::process::exit(0);
+    })
+    .expect("Error setting Ctrl-C handler");
+
+    join!(
+        launch_web(),
+        notifications::websocket::launch_server(),
+        notifications::hive::listen(),
+    );
+}
+
+async fn launch_web() {
     let cors = rocket_cors::CorsOptions {
         allowed_origins: AllowedOrigins::All,
         ..Default::default()
     }
     .to_cors()
-    .unwrap();
+    .expect("Failed to create CORS.");
 
-    routes::mount(rocket::ignite()).attach(cors).launch();
+    let auth = Auth::new(
+        database::get_collection("accounts"),
+        Options::new()
+            .base_url(format!("{}/auth", *PUBLIC_URL))
+            .email_verification(if *USE_EMAIL {
+                EmailVerification::Enabled {
+                    success_redirect_uri: format!("{}/welcome", *PUBLIC_URL),
+                    verification_expiry: Duration::days(1),
+                    verification_ratelimit: Duration::minutes(1),
+
+                    smtp: SMTP {
+                        from: (*SMTP_FROM).to_string(),
+                        host: (*SMTP_HOST).to_string(),
+                        username: (*SMTP_USERNAME).to_string(),
+                        password: (*SMTP_PASSWORD).to_string(),
+                    },
+                }
+            } else {
+                EmailVerification::Disabled
+            }),
+    );
+
+    let mut rocket = rocket::ignite();
+
+    if *USE_PROMETHEUS {
+        info!("Enabled Prometheus metrics!");
+        let prometheus = PrometheusMetrics::new();
+        rocket = rocket
+            .attach(prometheus.clone())
+            .mount("/metrics", prometheus);
+    }
+
+    routes::mount(rocket)
+        .mount("/", rocket_cors::catch_all_options_routes())
+        .mount("/auth", rauth::routes::routes())
+        .manage(auth)
+        .manage(cors.clone())
+        .attach(cors)
+        .launch()
+        .await
+        .unwrap();
 }

src/notifications/events.rs

@@ -0,0 +1,133 @@
+use hive_pubsub::PubSub;
+use rauth::auth::Session;
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+use snafu::Snafu;
+
+use super::hive::{get_hive, subscribe_if_exists};
+use crate::database::*;
+
+#[derive(Serialize, Deserialize, Debug, Snafu)]
+#[serde(tag = "error")]
+pub enum WebSocketError {
+    #[snafu(display("This error has not been labelled."))]
+    LabelMe,
+    #[snafu(display("Internal server error."))]
+    InternalError { at: String },
+    #[snafu(display("Invalid session."))]
+    InvalidSession,
+    #[snafu(display("User hasn't completed onboarding."))]
+    OnboardingNotFinished,
+    #[snafu(display("Already authenticated with server."))]
+    AlreadyAuthenticated,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(tag = "type")]
+pub enum ServerboundNotification {
+    Authenticate(Session),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "type")]
+pub enum ClientboundNotification {
+    Error(WebSocketError),
+    Authenticated,
+    Ready {
+        users: Vec<User>,
+        channels: Vec<Channel>,
+    },
+
+    Message(Message),
+    MessageUpdate {
+        id: String,
+        data: JsonValue,
+    },
+    MessageDelete {
+        id: String,
+    },
+
+    ChannelCreate(Channel),
+    ChannelUpdate {
+        id: String,
+        data: JsonValue,
+    },
+    ChannelGroupJoin {
+        id: String,
+        user: String,
+    },
+    ChannelGroupLeave {
+        id: String,
+        user: String,
+    },
+    ChannelDelete {
+        id: String,
+    },
+
+    UserRelationship {
+        id: String,
+        user: String,
+        status: RelationshipStatus,
+    },
+    UserPresence {
+        id: String,
+        online: bool,
+    },
+}
+
+impl ClientboundNotification {
+    pub async fn publish(self, topic: String) -> Result<(), String> {
+        prehandle_hook(&self); // ! TODO: this should be moved to pubsub
+        hive_pubsub::backend::mongo::publish(get_hive(), &topic, self).await
+    }
+}
+
+pub fn prehandle_hook(notification: &ClientboundNotification) {
+    match &notification {
+        ClientboundNotification::ChannelGroupJoin { id, user } => {
+            subscribe_if_exists(user.clone(), id.clone()).ok();
+        }
+        ClientboundNotification::ChannelCreate(channel) => {
+            let channel_id = channel.id();
+            match &channel {
+                Channel::SavedMessages { user, .. } => {
+                    subscribe_if_exists(user.clone(), channel_id.to_string()).ok();
+                }
+                Channel::DirectMessage { recipients, .. } | Channel::Group { recipients, .. } => {
+                    for recipient in recipients {
+                        subscribe_if_exists(recipient.clone(), channel_id.to_string()).ok();
+                    }
+                }
+            }
+        }
+        ClientboundNotification::UserRelationship { id, user, status } => {
+            if status != &RelationshipStatus::None {
+                subscribe_if_exists(id.clone(), user.clone()).ok();
+            }
+        }
+        _ => {}
+    }
+}
+
+pub fn posthandle_hook(notification: &ClientboundNotification) {
+    match &notification {
+        ClientboundNotification::ChannelDelete { id } => {
+            get_hive().hive.drop_topic(&id).ok();
+        }
+        ClientboundNotification::UserRelationship { id, user, status } => {
+            if status == &RelationshipStatus::None {
+                get_hive()
+                    .hive
+                    .unsubscribe(&id.to_string(), &user.to_string())
+                    .ok();
+            }
+        }
+        ClientboundNotification::ChannelGroupLeave { id, user } => {
+            get_hive()
+                .hive
+                .unsubscribe(&user.to_string(), &id.to_string())
+                .ok();
+        }
+        _ => {}
+    }
+}

src/notifications/hive.rs

@@ -0,0 +1,63 @@
+use super::{events::ClientboundNotification, websocket};
+use crate::database::*;
+
+use futures::FutureExt;
+use hive_pubsub::backend::mongo::MongodbPubSub;
+use hive_pubsub::PubSub;
+use log::{debug, error};
+use once_cell::sync::OnceCell;
+use serde_json::to_string;
+
+type Hive = MongodbPubSub<String, String, ClientboundNotification>;
+static HIVE: OnceCell<Hive> = OnceCell::new();
+
+pub async fn init_hive() {
+    let hive = MongodbPubSub::new(
+        |ids, notification| {
+            super::events::posthandle_hook(&notification);
+
+            if let Ok(data) = to_string(&notification) {
+                debug!("Pushing out notification. {}", data);
+                websocket::publish(ids, notification);
+            } else {
+                error!("Failed to serialise notification.");
+            }
+        },
+        get_collection("pubsub"),
+    );
+
+    if HIVE.set(hive).is_err() {
+        panic!("Failed to set global pubsub instance.");
+    }
+}
+
+pub async fn listen() {
+    HIVE.get()
+        .unwrap()
+        .listen()
+        .fuse()
+        .await
+        .expect("Hive hit an error");
+}
+
+pub fn subscribe_multiple(user: String, topics: Vec<String>) -> Result<(), String> {
+    let hive = HIVE.get().unwrap();
+    for topic in topics {
+        hive.subscribe(user.clone(), topic)?;
+    }
+
+    Ok(())
+}
+
+pub fn subscribe_if_exists(user: String, topic: String) -> Result<(), String> {
+    let hive = HIVE.get().unwrap();
+    if hive.hive.map.lock().unwrap().get_left(&user).is_some() {
+        hive.subscribe(user, topic)?;
+    }
+
+    Ok(())
+}
+
+pub fn get_hive() -> &'static Hive {
+    HIVE.get().unwrap()
+}

src/notifications/mod.rs

@@ -0,0 +1,5 @@
+pub mod events;
+pub mod hive;
+pub mod payload;
+pub mod subscriptions;
+pub mod websocket;

src/notifications/payload.rs

@@ -0,0 +1,114 @@
+use std::collections::HashSet;
+
+use crate::{database::*, notifications::events::ClientboundNotification};
+use crate::{
+    database::{entities::User, get_collection},
+    util::result::{Error, Result},
+};
+use futures::StreamExt;
+use mongodb::{
+    bson::{doc, from_document},
+    options::FindOptions,
+};
+
+pub async fn generate_ready(mut user: User) -> Result<ClientboundNotification> {
+    let mut users = vec![];
+    let mut user_ids: HashSet<String> = HashSet::new();
+
+    if let Some(relationships) = &user.relations {
+        user_ids.extend(
+            relationships
+                .iter()
+                .map(|relationship| relationship.id.clone()),
+        );
+    }
+
+    let mut cursor = get_collection("channels")
+        .find(
+            doc! {
+                "$or": [
+                    {
+                        "channel_type": "SavedMessages",
+                        "user": &user.id
+                    },
+                    {
+                        "channel_type": "DirectMessage",
+                        "recipients": &user.id
+                    },
+                    {
+                        "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 {
+            let channel = from_document(doc).map_err(|_| Error::DatabaseError {
+                operation: "from_document",
+                with: "channel",
+            })?;
+
+            if let Channel::Group { recipients, .. } = &channel {
+                user_ids.extend(recipients.iter().cloned());
+            }
+
+            channels.push(channel);
+        }
+    }
+
+    user_ids.remove(&user.id);
+    if user_ids.len() > 0 {
+        let mut cursor = get_collection("users")
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": user_ids.into_iter().collect::<Vec<String>>()
+                    }
+                },
+                FindOptions::builder()
+                    .projection(doc! { "_id": 1, "username": 1 })
+                    .build(),
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "users",
+            })?;
+
+        while let Some(result) = cursor.next().await {
+            if let Ok(doc) = result {
+                let other: User = from_document(doc).map_err(|_| Error::DatabaseError {
+                    operation: "from_document",
+                    with: "user",
+                })?;
+
+                let permissions = PermissionCalculator::new(&user)
+                    .with_mutual_connection()
+                    .with_user(&other)
+                    .for_user_given()
+                    .await?;
+
+                users.push(
+                    other
+                        .from(&user)
+                        .with(permissions)
+                );
+            }
+        }
+    }
+
+    user.relationship = Some(RelationshipStatus::User);
+    user.online = Some(true);
+    users.push(user);
+
+    Ok(ClientboundNotification::Ready { users, channels })
+}

src/notifications/subscriptions.rs

@@ -0,0 +1,49 @@
+use crate::database::*;
+
+use super::hive::get_hive;
+use futures::StreamExt;
+use hive_pubsub::PubSub;
+use mongodb::bson::doc;
+use mongodb::options::FindOptions;
+
+pub async fn generate_subscriptions(user: &User) -> Result<(), String> {
+    let hive = get_hive();
+    hive.subscribe(user.id.clone(), user.id.clone())?;
+
+    if let Some(relations) = &user.relations {
+        for relation in relations {
+            hive.subscribe(user.id.clone(), relation.id.clone())?;
+        }
+    }
+
+    let mut cursor = get_collection("channels")
+        .find(
+            doc! {
+                "$or": [
+                    {
+                        "channel_type": "SavedMessages",
+                        "user": &user.id
+                    },
+                    {
+                        "channel_type": "DirectMessage",
+                        "recipients": &user.id
+                    },
+                    {
+                        "channel_type": "Group",
+                        "recipients": &user.id
+                    }
+                ]
+            },
+            FindOptions::builder().projection(doc! { "_id": 1 }).build(),
+        )
+        .await
+        .map_err(|_| "Failed to fetch channels.".to_string())?;
+
+    while let Some(result) = cursor.next().await {
+        if let Ok(doc) = result {
+            hive.subscribe(user.id.clone(), doc.get_str("_id").unwrap().to_string())?;
+        }
+    }
+
+    Ok(())
+}

src/notifications/websocket.rs

@@ -0,0 +1,219 @@
+use crate::database::*;
+use crate::util::variables::WS_HOST;
+
+use super::subscriptions;
+
+use async_std::net::{TcpListener, TcpStream};
+use async_std::task;
+use async_tungstenite::tungstenite::Message;
+use futures::channel::mpsc::{unbounded, UnboundedSender};
+use futures::stream::TryStreamExt;
+use futures::{pin_mut, prelude::*};
+use hive_pubsub::PubSub;
+use log::{debug, info};
+use many_to_many::ManyToMany;
+use rauth::{
+    auth::{Auth, Session},
+    options::Options,
+};
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::sync::{Arc, Mutex, RwLock};
+
+use super::{
+    events::{ClientboundNotification, ServerboundNotification, WebSocketError},
+    hive::get_hive,
+};
+
+type Tx = UnboundedSender<Message>;
+type PeerMap = Arc<Mutex<HashMap<SocketAddr, Tx>>>;
+
+lazy_static! {
+    static ref CONNECTIONS: PeerMap = Arc::new(Mutex::new(HashMap::new()));
+    static ref USERS: Arc<RwLock<ManyToMany<String, SocketAddr>>> =
+        Arc::new(RwLock::new(ManyToMany::new()));
+}
+
+pub async fn launch_server() {
+    let try_socket = TcpListener::bind(WS_HOST.to_string()).await;
+    let listener = try_socket.expect("Failed to bind");
+    info!("Listening on: {}", *WS_HOST);
+
+    while let Ok((stream, _)) = listener.accept().await {
+        task::spawn(accept(stream));
+    }
+}
+
+async fn accept(stream: TcpStream) {
+    let addr = stream
+        .peer_addr()
+        .expect("Connected streams should have a peer address.");
+    let ws_stream = async_tungstenite::accept_async(stream)
+        .await
+        .expect("Error during websocket handshake.");
+
+    info!("User established WebSocket connection from {}.", &addr);
+
+    let (write, read) = ws_stream.split();
+    let (tx, rx) = unbounded();
+    CONNECTIONS.lock().unwrap().insert(addr, tx.clone());
+
+    let send = |notification: ClientboundNotification| {
+        if let Ok(response) = serde_json::to_string(&notification) {
+            if let Err(_) = tx.unbounded_send(Message::Text(response)) {
+                debug!("Failed unbounded_send to websocket stream.");
+            }
+        }
+    };
+
+    let session: Arc<Mutex<Option<Session>>> = Arc::new(Mutex::new(None));
+    let mutex_generator = || session.clone();
+    let fwd = rx.map(Ok).forward(write);
+    let incoming = read.try_for_each(async move |msg| {
+        let mutex = mutex_generator();
+        //dbg!(&mutex.lock().unwrap());
+
+        if let Message::Text(text) = msg {
+            if let Ok(notification) = serde_json::from_str::<ServerboundNotification>(&text) {
+                match notification {
+                    ServerboundNotification::Authenticate(new_session) => {
+                        {
+                            if mutex.lock().unwrap().is_some() {
+                                send(ClientboundNotification::Error(
+                                    WebSocketError::AlreadyAuthenticated,
+                                ));
+
+                                return Ok(());
+                            }
+                        }
+
+                        if let Ok(validated_session) =
+                            Auth::new(get_collection("accounts"), Options::new())
+                                .verify_session(new_session)
+                                .await
+                        {
+                            let id = validated_session.user_id.clone();
+                            if let Ok(user) = (Ref { id: id.clone() }).fetch_user().await {
+                                let was_online = is_online(&id);
+                                {
+                                    match USERS.write() {
+                                        Ok(mut map) => {
+                                            map.insert(id.clone(), addr);
+                                        }
+                                        Err(_) => {
+                                            send(ClientboundNotification::Error(
+                                                WebSocketError::InternalError {
+                                                    at: "Writing users map.".to_string(),
+                                                },
+                                            ));
+
+                                            return Ok(());
+                                        }
+                                    }
+                                }
+
+                                *mutex.lock().unwrap() = Some(validated_session);
+
+                                if let Err(_) = subscriptions::generate_subscriptions(&user).await {
+                                    send(ClientboundNotification::Error(
+                                        WebSocketError::InternalError {
+                                            at: "Generating subscriptions.".to_string(),
+                                        },
+                                    ));
+
+                                    return Ok(());
+                                }
+
+                                send(ClientboundNotification::Authenticated);
+
+                                match super::payload::generate_ready(user).await {
+                                    Ok(payload) => {
+                                        send(payload);
+
+                                        if !was_online {
+                                            ClientboundNotification::UserPresence {
+                                                id: id.clone(),
+                                                online: true,
+                                            }
+                                            .publish(id)
+                                            .await
+                                            .ok();
+                                        }
+                                    }
+                                    Err(_) => {
+                                        send(ClientboundNotification::Error(
+                                            WebSocketError::InternalError {
+                                                at: "Generating payload.".to_string(),
+                                            },
+                                        ));
+
+                                        return Ok(());
+                                    }
+                                }
+                            } else {
+                                send(ClientboundNotification::Error(
+                                    WebSocketError::OnboardingNotFinished,
+                                ));
+                            }
+                        } else {
+                            send(ClientboundNotification::Error(
+                                WebSocketError::InvalidSession,
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    });
+
+    pin_mut!(fwd, incoming);
+    future::select(fwd, incoming).await;
+
+    info!("User {} disconnected.", &addr);
+    CONNECTIONS.lock().unwrap().remove(&addr);
+
+    let session = session.lock().unwrap();
+    if let Some(session) = session.as_ref() {
+        let mut users = USERS.write().unwrap();
+        users.remove(&session.user_id, &addr);
+        if users.get_left(&session.user_id).is_none() {
+            get_hive().drop_client(&session.user_id).unwrap();
+        }
+    }
+}
+
+pub fn publish(ids: Vec<String>, notification: ClientboundNotification) {
+    let mut targets = vec![];
+    {
+        let users = USERS.read().unwrap();
+        for id in ids {
+            // Block certain notifications from reaching users that aren't meant to see them.
+            if let ClientboundNotification::UserRelationship { id: user_id, .. } = &notification {
+                if &id != user_id {
+                    continue;
+                }
+            }
+
+            if let Some(mut arr) = users.get_left(&id) {
+                targets.append(&mut arr);
+            }
+        }
+    }
+
+    let msg = Message::Text(serde_json::to_string(&notification).unwrap());
+
+    let connections = CONNECTIONS.lock().unwrap();
+    for target in targets {
+        if let Some(conn) = connections.get(&target) {
+            if let Err(_) = conn.unbounded_send(msg.clone()) {
+                debug!("Failed unbounded_send.");
+            }
+        }
+    }
+}
+
+pub fn is_online(user: &String) -> bool {
+    USERS.read().unwrap().get_left(&user).is_some()
+}

src/routes/account.rs

@@ -1,293 +0,0 @@
-use super::Response;
-use crate::database;
-use crate::email;
-use crate::util::gen_token;
-
-use bcrypt::{hash, verify};
-use bson::{doc, from_bson, Bson::UtcDatetime};
-use chrono::prelude::*;
-use database::user::User;
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-use validator::validate_email;
-
-#[derive(Serialize, Deserialize)]
-pub struct Create {
-    username: String,
-    password: String,
-    email: String,
-}
-
-/// create a new Revolt account
-/// (1) validate input
-/// 	[username] 2 to 32 characters
-/// 	[password] 8 to 72 characters
-/// 	[email]    validate against RFC
-/// (2) check email existence
-/// (3) add user and send email verification
-#[post("/create", data = "<info>")]
-pub fn create(info: Json<Create>) -> Response {
-    let col = database::get_collection("users");
-
-    if info.username.len() < 2 || info.username.len() > 32 {
-        return Response::NotAcceptable(
-            json!({ "error": "Username needs to be at least 2 chars and less than 32 chars." }),
-        );
-    }
-
-    if info.password.len() < 8 || info.password.len() > 72 {
-        return Response::NotAcceptable(
-            json!({ "error": "Password needs to be at least 8 chars and at most 72." }),
-        );
-    }
-
-    if !validate_email(info.email.clone()) {
-        return Response::UnprocessableEntity(json!({ "error": "Invalid email." }));
-    }
-
-    if let Some(_) = col
-        .find_one(doc! { "email": info.email.clone() }, None)
-        .expect("Failed user lookup")
-    {
-        return Response::Conflict(json!({ "error": "Email already in use!" }));
-    }
-
-    if let Ok(hashed) = hash(info.password.clone(), 10) {
-        let access_token = gen_token(92);
-        let code = gen_token(48);
-
-        match col.insert_one(
-            doc! {
-                "_id": Ulid::new().to_string(),
-                "email": info.email.clone(),
-                "username": info.username.clone(),
-                "password": hashed,
-                "access_token": access_token,
-                "email_verification": {
-                    "verified": false,
-                    "target": info.email.clone(),
-                    "expiry": UtcDatetime(Utc::now() + chrono::Duration::days(1)),
-                    "rate_limit": UtcDatetime(Utc::now() + chrono::Duration::minutes(1)),
-                    "code": code.clone(),
-                }
-            },
-            None,
-        ) {
-            Ok(_) => {
-                let sent = email::send_verification_email(info.email.clone(), code);
-
-                Response::Success(json!({
-                    "success": true,
-                    "email_sent": sent,
-                }))
-            }
-            Err(_) => {
-                Response::InternalServerError(json!({ "error": "Failed to create account." }))
-            }
-        }
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed to hash." }))
-    }
-}
-
-/// verify an email for a Revolt account
-/// (1) check if code is valid
-/// (2) check if it expired yet
-/// (3) set account as verified
-#[get("/verify/<code>")]
-pub fn verify_email(code: String) -> Response {
-    let col = database::get_collection("users");
-
-    if let Some(u) = col
-        .find_one(doc! { "email_verification.code": code.clone() }, None)
-        .expect("Failed user lookup")
-    {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
-        let ev = user.email_verification;
-
-        if Utc::now() > *ev.expiry.unwrap() {
-            Response::Gone(json!({
-                "success": false,
-                "error": "Token has expired!",
-            }))
-        } else {
-            let target = ev.target.unwrap();
-            col.update_one(
-                doc! { "_id": user.id },
-                doc! {
-                    "$unset": {
-                        "email_verification.code": "",
-                        "email_verification.expiry": "",
-                        "email_verification.target": "",
-                        "email_verification.rate_limit": "",
-                    },
-                    "$set": {
-                        "email_verification.verified": true,
-                        "email": target.clone(),
-                    },
-                },
-                None,
-            )
-            .expect("Failed to update user!");
-
-            email::send_welcome_email(target.to_string(), user.username);
-
-            Response::Redirect(
-                super::Redirect::to("https://example.com"), // ! FIXME; redirect to landing page
-            )
-        }
-    } else {
-        Response::BadRequest(json!({ "error": "Invalid code." }))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Resend {
-    email: String,
-}
-
-/// resend a verification email
-/// (1) check if verification is pending for x email
-/// (2) check for rate limit
-/// (3) resend the email
-#[post("/resend", data = "<info>")]
-pub fn resend_email(info: Json<Resend>) -> Response {
-    let col = database::get_collection("users");
-
-    if let Some(u) = col
-        .find_one(
-            doc! { "email_verification.target": info.email.clone() },
-            None,
-        )
-        .expect("Failed user lookup.")
-    {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
-        let ev = user.email_verification;
-
-        let expiry = ev.expiry.unwrap();
-        let rate_limit = ev.rate_limit.unwrap();
-
-        if Utc::now() < *rate_limit {
-            Response::TooManyRequests(
-                json!({ "error": "You are being rate limited, please try again in a while." }),
-            )
-        } else {
-            let mut new_expiry = UtcDatetime(Utc::now() + chrono::Duration::days(1));
-            if info.email.clone() != user.email {
-                if Utc::now() > *expiry {
-                    return Response::Gone(
-                        json!({ "error": "To help protect your account, please login and change your email again. The original request was made over one day ago." }),
-                    );
-                }
-
-                new_expiry = UtcDatetime(*expiry);
-            }
-
-            let code = gen_token(48);
-            col.update_one(
-					doc! { "_id": user.id },
-					doc! {
-						"$set": {
-							"email_verification.code": code.clone(),
-							"email_verification.expiry": new_expiry,
-							"email_verification.rate_limit": UtcDatetime(Utc::now() + chrono::Duration::minutes(1)),
-						},
-					},
-					None,
-				).expect("Failed to update user!");
-
-            match email::send_verification_email(info.email.to_string(), code) {
-                true => Response::Result(super::Status::Ok),
-                false => Response::InternalServerError(
-                    json!({ "success": false, "error": "Failed to send email! Likely an issue with the backend API." }),
-                ),
-            }
-        }
-    } else {
-        Response::NotFound(
-            json!({ "success": false, "error": "Email not found or pending verification!" }),
-        )
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Login {
-    email: String,
-    password: String,
-}
-
-/// login to a Revolt account
-/// (1) find user by email
-/// (2) verify password
-/// (3) return access token
-#[post("/login", data = "<info>")]
-pub fn login(info: Json<Login>) -> Response {
-    let col = database::get_collection("users");
-
-    if let Some(u) = col
-        .find_one(doc! { "email": info.email.clone() }, None)
-        .expect("Failed user lookup")
-    {
-        let user: User = from_bson(bson::Bson::Document(u)).expect("Failed to unwrap user.");
-
-        match verify(info.password.clone(), &user.password)
-            .expect("Failed to check hash of password.")
-        {
-            true => {
-                let token = match user.access_token {
-                    Some(t) => t.to_string(),
-                    None => {
-                        let token = gen_token(92);
-                        if col
-                            .update_one(
-                                doc! { "_id": &user.id },
-                                doc! { "$set": { "access_token": token.clone() } },
-                                None,
-                            )
-                            .is_err()
-                        {
-                            return Response::InternalServerError(
-                                json!({ "error": "Failed database operation." }),
-                            );
-                        }
-
-                        token
-                    }
-                };
-
-                Response::Success(json!({ "access_token": token, "id": user.id }))
-            }
-            false => Response::Unauthorized(json!({ "error": "Invalid password." })),
-        }
-    } else {
-        Response::NotFound(json!({ "error": "Email is not registered." }))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Token {
-    token: String,
-}
-
-/// login to a Revolt account via token
-#[post("/token", data = "<info>")]
-pub fn token(info: Json<Token>) -> Response {
-    let col = database::get_collection("users");
-
-    if let Ok(result) = col.find_one(doc! { "access_token": info.token.clone() }, None) {
-        if let Some(user) = result {
-            Response::Success(json!({
-                "id": user.get_str("_id").unwrap(),
-            }))
-        } else {
-            Response::Unauthorized(json!({
-                "error": "Invalid token!",
-            }))
-        }
-    } else {
-        Response::InternalServerError(json!({
-            "error": "Failed database query.",
-        }))
-    }
-}

src/routes/channel.rs

@@ -1,663 +0,0 @@
-use super::Response;
-use crate::database::{
-    self, get_relationship, get_relationship_internal, message::Message, Permission,
-    PermissionCalculator, Relationship,
-};
-use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::util::vec_to_set;
-
-use bson::{doc, from_bson, Bson, Bson::UtcDatetime};
-use chrono::prelude::*;
-use mongodb::options::FindOptions;
-use num_enum::TryFromPrimitive;
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-const MAXGROUPSIZE: usize = 50;
-
-#[derive(Debug, TryFromPrimitive)]
-#[repr(usize)]
-pub enum ChannelType {
-    DM = 0,
-    GROUPDM = 1,
-    GUILDCHANNEL = 2,
-}
-
-macro_rules! with_permissions {
-    ($user: expr, $target: expr) => {{
-        let permissions = PermissionCalculator::new($user.clone())
-            .channel($target.clone())
-            .fetch_data();
-
-        let value = permissions.as_permission();
-        if !value.get_access() {
-            return None;
-        }
-
-        value
-    }};
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct CreateGroup {
-    name: String,
-    nonce: String,
-    users: Vec<String>,
-}
-
-/// create a new group
-#[post("/create", data = "<info>")]
-pub fn create_group(user: UserRef, info: Json<CreateGroup>) -> Response {
-    let name: String = info.name.chars().take(32).collect();
-    let nonce: String = info.nonce.chars().take(32).collect();
-
-    let mut set = vec_to_set(&info.users);
-    set.insert(user.id.clone());
-
-    if set.len() > MAXGROUPSIZE {
-        return Response::BadRequest(json!({ "error": "Maximum group size is 50." }));
-    }
-
-    let col = database::get_collection("channels");
-    if let Some(_) = col.find_one(doc! { "nonce": nonce.clone() }, None).unwrap() {
-        return Response::BadRequest(json!({ "error": "Group already created!" }));
-    }
-
-    let mut query = vec![];
-    for item in &set {
-        if item == &user.id {
-            continue;
-        }
-
-        query.push(Bson::String(item.clone()));
-    }
-
-    if let Ok(result) = database::get_collection("users").find(
-        doc! {
-            "_id": {
-                "$in": &query
-            }
-        },
-        FindOptions::builder().limit(query.len() as i64).build(),
-    ) {
-        if result.count() != query.len() {
-            return Response::BadRequest(json!({ "error": "Specified non-existant user(s)." }));
-        }
-
-        let relationships = user.fetch_relationships();
-        for item in set {
-            if item == user.id {
-                continue;
-            }
-
-            if get_relationship_internal(&user.id, &item, &relationships) != Relationship::Friend {
-                return Response::BadRequest(json!({ "error": "Not friends with user(s)." }));
-            }
-        }
-
-        query.push(Bson::String(user.id.clone()));
-
-        let id = Ulid::new().to_string();
-        if col
-            .insert_one(
-                doc! {
-                    "_id": id.clone(),
-                    "nonce": nonce,
-                    "type": ChannelType::GROUPDM as u32,
-                    "recipients": &query,
-                    "name": name,
-                    "owner": &user.id,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            Response::Success(json!({ "id": id }))
-        } else {
-            Response::InternalServerError(json!({ "error": "Failed to create guild channel." }))
-        }
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed to validate users." }))
-    }
-}
-
-/// fetch channel information
-#[get("/<target>")]
-pub fn channel(user: UserRef, target: ChannelRef) -> Option<Response> {
-    with_permissions!(user, target);
-
-    match target.channel_type {
-        0 => Some(Response::Success(json!({
-            "id": target.id,
-            "type": target.channel_type,
-            "last_message": target.last_message,
-            "recipients": target.recipients,
-        }))),
-        1 => {
-            if let Some(info) = target.fetch_data(doc! {
-                "name": 1,
-                "description": 1,
-                "owner": 1,
-            }) {
-                Some(Response::Success(json!({
-                    "id": target.id,
-                    "type": target.channel_type,
-                    "last_message": target.last_message,
-                    "recipients": target.recipients,
-                    "name": info.get_str("name").unwrap(),
-                    "owner": info.get_str("owner").unwrap(),
-                    "description": info.get_str("description").unwrap_or(""),
-                })))
-            } else {
-                None
-            }
-        }
-        2 => {
-            if let Some(info) = target.fetch_data(doc! {
-                "name": 1,
-                "description": 1,
-            }) {
-                Some(Response::Success(json!({
-                    "id": target.id,
-                    "type": target.channel_type,
-                    "guild": target.guild,
-                    "name": info.get_str("name").unwrap(),
-                    "description": info.get_str("description").unwrap_or(""),
-                })))
-            } else {
-                None
-            }
-        }
-        _ => unreachable!(),
-    }
-}
-
-/// [groups] add user to channel
-#[put("/<target>/recipients/<member>")]
-pub fn add_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<Response> {
-    if target.channel_type != 1 {
-        return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
-    }
-
-    with_permissions!(user, target);
-
-    let recp = target.recipients.unwrap();
-    if recp.len() == 50 {
-        return Some(Response::BadRequest(
-            json!({ "error": "Maximum group size is 50." }),
-        ));
-    }
-
-    let set = vec_to_set(&recp);
-    if set.get(&member.id).is_some() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User already in group!" }),
-        ));
-    }
-
-    match get_relationship(&user, &member) {
-        Relationship::Friend => {
-            if database::get_collection("channels")
-                .update_one(
-                    doc! { "_id": &target.id },
-                    doc! {
-                        "$push": {
-                            "recipients": &member.id
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                Some(Response::Result(super::Status::Ok))
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to add user to group." }),
-                ))
-            }
-        }
-        _ => Some(Response::BadRequest(
-            json!({ "error": "Not friends with user." }),
-        )),
-    }
-}
-
-/// [groups] remove user from channel
-#[delete("/<target>/recipients/<member>")]
-pub fn remove_member(user: UserRef, target: ChannelRef, member: UserRef) -> Option<Response> {
-    if target.channel_type != 1 {
-        return Some(Response::BadRequest(json!({ "error": "Not a group DM." })));
-    }
-
-    if &user.id == &member.id {
-        return Some(Response::BadRequest(
-            json!({ "error": "Cannot kick yourself, leave the channel instead." }),
-        ));
-    }
-
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_kick_members() {
-        return Some(Response::LackingPermission(Permission::KickMembers));
-    }
-
-    let set = vec_to_set(&target.recipients.unwrap());
-    if set.get(&member.id).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not in group!" }),
-        ));
-    }
-
-    if database::get_collection("channels")
-        .update_one(
-            doc! { "_id": &target.id },
-            doc! {
-                "$pull": {
-                    "recipients": &member.id
-                }
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Some(Response::Result(super::Status::Ok))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to add user to group." }),
-        ))
-    }
-}
-
-/// delete channel
-/// or leave group DM
-/// or close DM conversation
-#[delete("/<target>")]
-pub fn delete(user: UserRef, target: ChannelRef) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_manage_channels() {
-        return Some(Response::LackingPermission(Permission::ManageChannels));
-    }
-
-    let col = database::get_collection("channels");
-    let target_id = target.id.clone();
-
-    let try_delete = || {
-        let messages = database::get_collection("messages");
-
-        if messages
-            .delete_many(doc! { "channel": &target_id }, None)
-            .is_ok()
-        {
-            if col.delete_one(doc! { "_id": &target_id }, None).is_ok() {
-                Some(Response::Result(super::Status::Ok))
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to delete group." }),
-                ))
-            }
-        } else {
-            Some(Response::InternalServerError(
-                json!({ "error": "Failed to delete messages." }),
-            ))
-        }
-    };
-
-    match target.channel_type {
-        0 => {
-            if col
-                .update_one(
-                    doc! { "_id": &target_id },
-                    doc! { "$set": { "active": false } },
-                    None,
-                )
-                .is_ok()
-            {
-                Some(Response::Result(super::Status::Ok))
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to close channel." }),
-                ))
-            }
-        }
-        1 => {
-            let mut recipients =
-                vec_to_set(&target.recipients.expect("Missing recipients on Group DM."));
-            let owner = target.owner.expect("Missing owner on Group DM.");
-
-            if recipients.len() == 1 {
-                try_delete()
-            } else {
-                recipients.remove(&user.id);
-                let new_owner = if owner == user.id {
-                    recipients.iter().next().unwrap()
-                } else {
-                    &owner
-                };
-
-                if col
-                    .update_one(
-                        doc! { "_id": target_id },
-                        doc! {
-                            "$set": {
-                                "owner": new_owner,
-                            },
-                            "$pull": {
-                                "recipients": &user.id,
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Some(Response::Result(super::Status::Ok))
-                } else {
-                    Some(Response::InternalServerError(
-                        json!({ "error": "Failed to remove you from the group." }),
-                    ))
-                }
-            }
-        }
-        2 => {
-            if database::get_collection("guilds")
-                .update_one(
-                    doc! { "_id": target.guild.unwrap() },
-                    doc! {
-                        "$pull": {
-                            "invites": {
-                                "channel": &target.id
-                            }
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                try_delete()
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to remove invites." }),
-                ))
-            }
-        }
-        _ => Some(Response::InternalServerError(
-            json!({ "error": "Unknown error has occurred." }),
-        )),
-    }
-}
-
-/// fetch channel messages
-#[get("/<target>/messages")]
-pub fn messages(user: UserRef, target: ChannelRef) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_read_messages() {
-        return Some(Response::LackingPermission(Permission::ReadMessages));
-    }
-
-    let col = database::get_collection("messages");
-    let result = col.find(doc! { "channel": target.id }, None).unwrap();
-
-    let mut messages = Vec::new();
-    for item in result {
-        let message: Message =
-            from_bson(bson::Bson::Document(item.unwrap())).expect("Failed to unwrap message.");
-        messages.push(json!({
-            "id": message.id,
-            "author": message.author,
-            "content": message.content,
-            "edited": if let Some(t) = message.edited { Some(t.timestamp()) } else { None }
-        }));
-    }
-
-    Some(Response::Success(json!(messages)))
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SendMessage {
-    content: String,
-    nonce: String,
-}
-
-/// send a message to a channel
-#[post("/<target>/messages", data = "<message>")]
-pub fn send_message(
-    user: UserRef,
-    target: ChannelRef,
-    message: Json<SendMessage>,
-) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_send_messages() {
-        if target.channel_type == 0 {
-            return Some(Response::LackingPermission(Permission::SendDirectMessages));
-        }
-
-        return Some(Response::LackingPermission(Permission::SendMessages));
-    }
-
-    let content: String = message.content.chars().take(2000).collect();
-    let nonce: String = message.nonce.chars().take(32).collect();
-
-    let col = database::get_collection("messages");
-    if col
-        .find_one(doc! { "nonce": nonce.clone() }, None)
-        .unwrap()
-        .is_some()
-    {
-        return Some(Response::BadRequest(
-            json!({ "error": "Message already sent!" }),
-        ));
-    }
-
-    let id = Ulid::new().to_string();
-    Some(
-        if col
-            .insert_one(
-                doc! {
-                    "_id": &id,
-                    "nonce": nonce,
-                    "channel": &target.id,
-                    "author": &user.id,
-                    "content": &content,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            let short_content: String = content.chars().take(24).collect();
-            let col = database::get_collection("channels");
-
-            // !! this stuff can be async
-            if target.channel_type == ChannelType::DM as u8
-                || target.channel_type == ChannelType::GROUPDM as u8
-            {
-                let mut update = doc! {
-                    "$set": {
-                        "last_message": {
-                            "id": &id,
-                            "user_id": &user.id,
-                            "short_content": short_content,
-                        }
-                    }
-                };
-
-                if target.channel_type == ChannelType::DM as u8 {
-                    update
-                        .get_document_mut("$set")
-                        .unwrap()
-                        .insert("active", true);
-                }
-
-                if col
-                    .update_one(doc! { "_id": &target.id }, update, None)
-                    .is_ok()
-                {
-                    Response::Success(json!({ "id": id }))
-                } else {
-                    Response::InternalServerError(json!({ "error": "Failed to update channel." }))
-                }
-            } else {
-                Response::Success(json!({ "id": id }))
-            }
-
-        /*websocket::queue_message(
-            get_recipients(&target),
-            json!({
-                "type": "message",
-                "data": {
-                    "id": id.clone(),
-                    "nonce": nonce,
-                    "channel": target.id,
-                    "author": user.id,
-                    "content": content,
-                },
-            })
-            .to_string(),
-        );*/
-        } else {
-            Response::InternalServerError(json!({
-                "error": "Failed database query."
-            }))
-        },
-    )
-}
-
-/// get a message
-#[get("/<target>/messages/<message>")]
-pub fn get_message(user: UserRef, target: ChannelRef, message: Message) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_read_messages() {
-        return Some(Response::LackingPermission(Permission::ReadMessages));
-    }
-
-    let prev =
-        // ! CHECK IF USER HAS PERMISSION TO VIEW EDITS OF MESSAGES
-        if let Some(previous) = message.previous_content {
-            let mut entries = vec![];
-            for entry in previous {
-                entries.push(json!({
-                    "content": entry.content,
-                    "time": entry.time.timestamp(),
-                }));
-            }
-
-            Some(entries)
-        } else {
-            None
-        };
-
-    Some(Response::Success(json!({
-        "id": message.id,
-        "author": message.author,
-        "content": message.content,
-        "edited": if let Some(t) = message.edited { Some(t.timestamp()) } else { None },
-        "previous_content": prev,
-    })))
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct EditMessage {
-    content: String,
-}
-
-/// edit a message
-#[patch("/<target>/messages/<message>", data = "<edit>")]
-pub fn edit_message(
-    user: UserRef,
-    target: ChannelRef,
-    message: Message,
-    edit: Json<EditMessage>,
-) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if message.author != user.id {
-        return Some(Response::Unauthorized(
-            json!({ "error": "You did not send this message." }),
-        ));
-    }
-
-    let col = database::get_collection("messages");
-    let time = if let Some(edited) = message.edited {
-        edited.0
-    } else {
-        Ulid::from_string(&message.id).unwrap().datetime()
-    };
-
-    let edited = Utc::now();
-    match col.update_one(
-        doc! { "_id": message.id.clone() },
-        doc! {
-            "$set": {
-                "content": edit.content.clone(),
-                "edited": UtcDatetime(edited)
-            },
-            "$push": {
-                "previous_content": {
-                    "content": message.content,
-                    "time": time,
-                }
-            },
-        },
-        None,
-    ) {
-        Ok(_) => {
-            /*websocket::queue_message(
-                get_recipients(&target),
-                json!({
-                    "type": "message_update",
-                    "data": {
-                        "id": message.id,
-                        "channel": target.id,
-                        "content": edit.content.clone(),
-                        "edited": edited.timestamp()
-                    },
-                })
-                .to_string(),
-            );*/
-
-            Some(Response::Result(super::Status::Ok))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to update message." }),
-        )),
-    }
-}
-
-/// delete a message
-#[delete("/<target>/messages/<message>")]
-pub fn delete_message(user: UserRef, target: ChannelRef, message: Message) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_manage_messages() {
-        if message.author != user.id {
-            return Some(Response::LackingPermission(Permission::ManageMessages));
-        }
-    }
-
-    let col = database::get_collection("messages");
-
-    match col.delete_one(doc! { "_id": &message.id }, None) {
-        Ok(_) => {
-            /*websocket::queue_message(
-                get_recipients(&target),
-                json!({
-                    "type": "message_delete",
-                    "data": {
-                        "id": message.id,
-                        "channel": target.id
-                    },
-                })
-                .to_string(),
-            );*/
-
-            Some(Response::Result(super::Status::Ok))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to delete message." }),
-        )),
-    }
-}

src/routes/channels/delete_channel.rs

@@ -0,0 +1,114 @@
+use crate::util::result::{Error, Result};
+use crate::{database::*, notifications::events::ClientboundNotification};
+
+use mongodb::bson::doc;
+
+#[delete("/<target>")]
+pub async fn req(user: User, target: Ref) -> Result<()> {
+    let target = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    match &target {
+        Channel::SavedMessages { .. } => Err(Error::NoEffect),
+        Channel::DirectMessage { .. } => {
+            get_collection("channels")
+                .update_one(
+                    doc! {
+                        "_id": target.id()
+                    },
+                    doc! {
+                        "$set": {
+                            "active": false
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "channel",
+                })?;
+
+            Ok(())
+        }
+        Channel::Group {
+            id,
+            owner,
+            recipients,
+            ..
+        } => {
+            if &user.id == owner {
+                if let Some(new_owner) = recipients.iter().find(|x| *x != &user.id) {
+                    get_collection("channels")
+                        .update_one(
+                            doc! {
+                                "_id": &id
+                            },
+                            doc! {
+                                "$set": {
+                                    "owner": new_owner
+                                },
+                                "$pull": {
+                                    "recipients": &user.id
+                                }
+                            },
+                            None,
+                        )
+                        .await
+                        .map_err(|_| Error::DatabaseError {
+                            operation: "update_one",
+                            with: "channel",
+                        })?;
+
+                    target.publish_update(json!({ "owner": new_owner })).await?;
+                } else {
+                    return target.delete().await;
+                }
+            } else {
+                get_collection("channels")
+                    .update_one(
+                        doc! {
+                            "_id": &id
+                        },
+                        doc! {
+                            "$pull": {
+                                "recipients": &user.id
+                            }
+                        },
+                        None,
+                    )
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "update_one",
+                        with: "channel",
+                    })?;
+            }
+
+            ClientboundNotification::ChannelGroupLeave {
+                id: id.clone(),
+                user: user.id.clone(),
+            }
+            .publish(id.clone())
+            .await
+            .ok();
+
+            Message::create(
+                "00000000000000000000000000".to_string(),
+                id.clone(),
+                format!("<@{}> left the group.", user.id),
+            )
+            .publish(&target)
+            .await
+            .ok();
+
+            Ok(())
+        }
+    }
+}

src/routes/channels/fetch_channel.rs

@@ -0,0 +1,19 @@
+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_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    Ok(json!(target))
+}

src/routes/channels/group_add_member.rs

@@ -0,0 +1,72 @@
+use crate::util::result::{Error, Result};
+use crate::util::variables::MAX_GROUP_SIZE;
+use crate::{database::*, notifications::events::ClientboundNotification};
+
+use mongodb::bson::doc;
+
+#[put("/<target>/recipients/<member>")]
+pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
+    if get_relationship(&user, &member.id) != RelationshipStatus::Friend {
+        Err(Error::NotFriends)?
+    }
+
+    let channel = target.fetch_channel().await?;
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&channel)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    if let Channel::Group { id, recipients, .. } = &channel {
+        if recipients.len() >= *MAX_GROUP_SIZE {
+            Err(Error::GroupTooLarge {
+                max: *MAX_GROUP_SIZE,
+            })?
+        }
+
+        if recipients.iter().find(|x| *x == &member.id).is_some() {
+            Err(Error::AlreadyInGroup)?
+        }
+
+        get_collection("channels")
+            .update_one(
+                doc! {
+                    "_id": &id
+                },
+                doc! {
+                    "$push": {
+                        "recipients": &member.id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "channel",
+            })?;
+
+        ClientboundNotification::ChannelGroupJoin {
+            id: id.clone(),
+            user: member.id.clone(),
+        }
+        .publish(id.clone())
+        .await
+        .ok();
+
+        Message::create(
+            "00000000000000000000000000".to_string(),
+            id.clone(),
+            format!("<@{}> added <@{}> to the group.", user.id, member.id),
+        )
+        .publish(&channel)
+        .await
+        .ok();
+
+        Ok(())
+    } else {
+        Err(Error::InvalidOperation)
+    }
+}

src/routes/channels/group_create.rs

@@ -0,0 +1,79 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+use crate::util::variables::MAX_GROUP_SIZE;
+
+use mongodb::bson::doc;
+use rocket_contrib::json::{Json, JsonValue};
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::iter::FromIterator;
+use ulid::Ulid;
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate(length(min = 1, max = 32))]
+    name: String,
+    #[validate(length(min = 0, max = 1024))]
+    description: Option<String>,
+    // Maximum length of 36 allows both ULIDs and UUIDs.
+    #[validate(length(min = 1, max = 36))]
+    nonce: String,
+    users: Vec<String>,
+}
+
+#[post("/create", data = "<info>")]
+pub async fn req(user: User, info: Json<Data>) -> Result<JsonValue> {
+    info.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    let mut set: HashSet<String> = HashSet::from_iter(info.users.iter().cloned());
+    set.insert(user.id.clone());
+
+    if set.len() > *MAX_GROUP_SIZE {
+        Err(Error::GroupTooLarge {
+            max: *MAX_GROUP_SIZE,
+        })?
+    }
+
+    for target in &set {
+        if get_relationship(&user, target) != RelationshipStatus::Friend {
+            Err(Error::NotFriends)?
+        }
+    }
+
+    if get_collection("channels")
+        .find_one(
+            doc! {
+                "nonce": &info.nonce
+            },
+            None,
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find_one",
+            with: "channel",
+        })?
+        .is_some()
+    {
+        Err(Error::DuplicateNonce)?
+    }
+
+    let id = Ulid::new().to_string();
+    let channel = Channel::Group {
+        id,
+        nonce: Some(info.nonce.clone()),
+        name: info.name.clone(),
+        description: info
+            .description
+            .clone()
+            .unwrap_or_else(|| "A group.".to_string()),
+        owner: user.id,
+        recipients: set.into_iter().collect::<Vec<String>>(),
+        last_message: None,
+    };
+
+    channel.clone().publish().await?;
+
+    Ok(json!(channel))
+}

src/routes/channels/group_remove_member.rs

@@ -0,0 +1,69 @@
+use crate::util::result::{Error, Result};
+use crate::{database::*, notifications::events::ClientboundNotification};
+
+use mongodb::bson::doc;
+
+#[delete("/<target>/recipients/<member>")]
+pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
+    if &user.id == &member.id {
+        Err(Error::CannotRemoveYourself)?
+    }
+
+    let channel = target.fetch_channel().await?;
+
+    if let Channel::Group {
+        id,
+        owner,
+        recipients,
+        ..
+    } = &channel
+    {
+        if &user.id != owner {
+            // figure out if we want to use perm system here
+            Err(Error::LabelMe)?
+        }
+
+        if recipients.iter().find(|x| *x == &member.id).is_none() {
+            Err(Error::NotInGroup)?
+        }
+
+        get_collection("channels")
+            .update_one(
+                doc! {
+                    "_id": &id
+                },
+                doc! {
+                    "$pull": {
+                        "recipients": &member.id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "channel",
+            })?;
+
+        ClientboundNotification::ChannelGroupLeave {
+            id: id.clone(),
+            user: member.id.clone(),
+        }
+        .publish(id.clone())
+        .await
+        .ok();
+
+        Message::create(
+            "00000000000000000000000000".to_string(),
+            id.clone(),
+            format!("<@{}> removed <@{}> from the group.", user.id, member.id),
+        )
+        .publish(&channel)
+        .await
+        .ok();
+
+        Ok(())
+    } else {
+        Err(Error::InvalidOperation)
+    }
+}

src/routes/channels/message_delete.rs

@@ -0,0 +1,27 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+
+#[delete("/<target>/messages/<msg>")]
+pub async fn req(user: User, target: Ref, msg: Ref) -> Result<()> {
+    let channel = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&channel)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    let message = msg.fetch_message(&channel).await?;
+    if message.author != user.id && !perm.get_manage_messages() {
+        match channel {
+            Channel::SavedMessages { .. } => unreachable!(),
+            _ => Err(Error::CannotEditMessage)?,
+        }
+    }
+
+    message.delete().await
+}

src/routes/channels/message_edit.rs

@@ -0,0 +1,58 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use chrono::Utc;
+use mongodb::bson::{doc, Bson, DateTime};
+use rocket_contrib::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate(length(min = 1, max = 2000))]
+    content: String,
+}
+
+#[patch("/<target>/messages/<msg>", data = "<edit>")]
+pub async fn req(user: User, target: Ref, msg: Ref, edit: Json<Data>) -> Result<()> {
+    edit.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    let channel = target.fetch_channel().await?;
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&channel)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    let message = msg.fetch_message(&channel).await?;
+    if message.author != user.id {
+        Err(Error::CannotEditMessage)?
+    }
+
+    let edited = Utc::now();
+    get_collection("messages")
+        .update_one(
+            doc! {
+                "_id": &message.id
+            },
+            doc! {
+                "$set": {
+                    "content": &edit.content,
+                    "edited": Bson::DateTime(edited)
+                }
+            },
+            None,
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "update_one",
+            with: "message",
+        })?;
+
+    message
+        .publish_update(json!({ "content": edit.content, "edited": DateTime(edited) }))
+        .await
+}

src/routes/channels/message_fetch.rs

@@ -0,0 +1,20 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>/messages/<msg>")]
+pub async fn req(user: User, target: Ref, msg: Ref) -> Result<JsonValue> {
+    let channel = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&channel)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    let message = msg.fetch_message(&channel).await?;
+    Ok(json!(message))
+}

src/routes/channels/message_query.rs

@@ -0,0 +1,79 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use futures::StreamExt;
+use mongodb::{
+    bson::{doc, from_document},
+    options::FindOptions,
+};
+use rocket::request::Form;
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize, FromForm)]
+pub struct Options {
+    #[validate(range(min = 1, max = 100))]
+    limit: Option<i64>,
+    #[validate(length(min = 26, max = 26))]
+    before: Option<String>,
+    #[validate(length(min = 26, max = 26))]
+    after: Option<String>,
+}
+
+#[get("/<target>/messages?<options..>")]
+pub async fn req(user: User, target: Ref, options: Form<Options>) -> Result<JsonValue> {
+    options
+        .validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    let target = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::LabelMe)?
+    }
+
+    let mut query = doc! { "channel": target.id() };
+
+    if let Some(before) = &options.before {
+        query.insert("_id", doc! { "$lt": before });
+    }
+
+    if let Some(after) = &options.after {
+        query.insert("_id", doc! { "$gt": after });
+    }
+
+    let mut cursor = get_collection("messages")
+        .find(
+            query,
+            FindOptions::builder()
+                .limit(options.limit.unwrap_or(50))
+                .sort(doc! {
+                    "_id": -1
+                })
+                .build(),
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find",
+            with: "messages",
+        })?;
+
+    let mut messages = vec![];
+    while let Some(result) = cursor.next().await {
+        if let Ok(doc) = result {
+            messages.push(
+                from_document::<Message>(doc).map_err(|_| Error::DatabaseError {
+                    operation: "from_document",
+                    with: "message",
+                })?,
+            );
+        }
+    }
+
+    Ok(json!(messages))
+}

src/routes/channels/message_send.rs

@@ -0,0 +1,65 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use rocket_contrib::json::{Json, JsonValue};
+use serde::{Deserialize, Serialize};
+use ulid::Ulid;
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate(length(min = 1, max = 2000))]
+    content: String,
+    // Maximum length of 36 allows both ULIDs and UUIDs.
+    #[validate(length(min = 1, max = 36))]
+    nonce: String,
+}
+
+#[post("/<target>/messages", data = "<message>")]
+pub async fn req(user: User, target: Ref, message: Json<Data>) -> Result<JsonValue> {
+    message
+        .validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    let target = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+    if !perm.get_send_message() {
+        Err(Error::LabelMe)?
+    }
+
+    if get_collection("messages")
+        .find_one(
+            doc! {
+                "nonce": &message.nonce
+            },
+            None,
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find_one",
+            with: "message",
+        })?
+        .is_some()
+    {
+        Err(Error::DuplicateNonce)?
+    }
+
+    let msg = Message {
+        id: Ulid::new().to_string(),
+        channel: target.id().to_string(),
+        author: user.id,
+
+        content: message.content.clone(),
+        nonce: Some(message.nonce.clone()),
+        edited: None,
+    };
+
+    msg.clone().publish(&target).await?;
+
+    Ok(json!(msg))
+}

src/routes/channels/mod.rs

@@ -0,0 +1,27 @@
+use rocket::Route;
+
+mod delete_channel;
+mod fetch_channel;
+mod group_add_member;
+mod group_create;
+mod group_remove_member;
+mod message_delete;
+mod message_edit;
+mod message_fetch;
+mod message_query;
+mod message_send;
+
+pub fn routes() -> Vec<Route> {
+    routes![
+        fetch_channel::req,
+        delete_channel::req,
+        message_send::req,
+        message_query::req,
+        message_fetch::req,
+        message_edit::req,
+        message_delete::req,
+        group_create::req,
+        group_add_member::req,
+        group_remove_member::req
+    ]
+}

src/routes/guild.rs

@@ -1,778 +0,0 @@
-use super::channel::ChannelType;
-use super::Response;
-use crate::database::{self, channel::Channel, Permission, PermissionCalculator};
-use crate::guards::auth::UserRef;
-use crate::guards::channel::ChannelRef;
-use crate::guards::guild::{get_invite, get_member, GuildRef};
-use crate::util::gen_token;
-
-use bson::{doc, from_bson, Bson};
-use mongodb::options::{FindOneOptions, FindOptions};
-use rocket::request::Form;
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-macro_rules! with_permissions {
-    ($user: expr, $target: expr) => {{
-        let permissions = PermissionCalculator::new($user.clone())
-            .guild($target.clone())
-            .fetch_data();
-
-        let value = permissions.as_permission();
-        if !value.get_access() {
-            return None;
-        }
-
-        (value, permissions.member.unwrap())
-    }};
-}
-
-/// fetch your guilds
-#[get("/@me")]
-pub fn my_guilds(user: UserRef) -> Response {
-    if let Ok(result) = database::get_collection("members").find(
-        doc! {
-            "_id.user": &user.id
-        },
-        None,
-    ) {
-        let mut guilds = vec![];
-        for item in result {
-            if let Ok(entry) = item {
-                guilds.push(Bson::String(
-                    entry
-                        .get_document("_id")
-                        .unwrap()
-                        .get_str("guild")
-                        .unwrap()
-                        .to_string(),
-                ));
-            }
-        }
-
-        if let Ok(result) = database::get_collection("guilds").find(
-            doc! {
-                "_id": {
-                    "$in": guilds
-                }
-            },
-            FindOptions::builder()
-                .projection(doc! {
-                    "_id": 1,
-                    "name": 1,
-                    "description": 1,
-                    "owner": 1,
-                })
-                .build(),
-        ) {
-            let mut parsed = vec![];
-            for item in result {
-                let doc = item.unwrap();
-                parsed.push(json!({
-                    "id": doc.get_str("_id").unwrap(),
-                    "name": doc.get_str("name").unwrap(),
-                    "description": doc.get_str("description").unwrap(),
-                    "owner": doc.get_str("owner").unwrap(),
-                }));
-            }
-
-            Response::Success(json!(parsed))
-        } else {
-            Response::InternalServerError(json!({ "error": "Failed to fetch guilds." }))
-        }
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed to fetch memberships." }))
-    }
-}
-
-/// fetch a guild
-#[get("/<target>")]
-pub fn guild(user: UserRef, target: GuildRef) -> Option<Response> {
-    with_permissions!(user, target);
-
-    let col = database::get_collection("channels");
-    match col.find(
-        doc! {
-            "type": 2,
-            "guild": &target.id,
-        },
-        None,
-    ) {
-        Ok(results) => {
-            let mut channels = vec![];
-            for item in results {
-                if let Ok(entry) = item {
-                    if let Ok(channel) =
-                        from_bson(bson::Bson::Document(entry)) as Result<Channel, _>
-                    {
-                        channels.push(json!({
-                            "id": channel.id,
-                            "name": channel.name,
-                            "description": channel.description,
-                        }));
-                    }
-                }
-            }
-
-            Some(Response::Success(json!({
-                "id": target.id,
-                "name": target.name,
-                "description": target.description,
-                "owner": target.owner,
-                "channels": channels,
-            })))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch channels." }),
-        )),
-    }
-}
-
-/// delete or leave a guild
-#[delete("/<target>")]
-pub fn remove_guild(user: UserRef, target: GuildRef) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if user.id == target.owner {
-        let channels = database::get_collection("channels");
-        if let Ok(result) = channels.find(
-            doc! {
-                "type": 2,
-                "guild": &target.id
-            },
-            FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-        ) {
-            let mut values = vec![];
-            for item in result {
-                if let Ok(doc) = item {
-                    values.push(Bson::String(doc.get_str("_id").unwrap().to_string()));
-                }
-            }
-
-            if database::get_collection("messages")
-                .delete_many(
-                    doc! {
-                        "channel": {
-                            "$in": values
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if channels
-                    .delete_many(
-                        doc! {
-                            "type": 2,
-                            "guild": &target.id,
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    if database::get_collection("guilds")
-                        .delete_one(
-                            doc! {
-                                "_id": &target.id
-                            },
-                            None,
-                        )
-                        .is_ok()
-                    {
-                        Some(Response::Result(super::Status::Ok))
-                    } else {
-                        Some(Response::InternalServerError(
-                            json!({ "error": "Failed to delete guild." }),
-                        ))
-                    }
-                } else {
-                    Some(Response::InternalServerError(
-                        json!({ "error": "Failed to delete guild channels." }),
-                    ))
-                }
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to delete guild messages." }),
-                ))
-            }
-        } else {
-            Some(Response::InternalServerError(
-                json!({ "error": "Could not fetch channels." }),
-            ))
-        }
-    } else {
-        if database::get_collection("members")
-            .delete_one(
-                doc! {
-                    "_id.guild": &target.id,
-                    "_id.user": &user.id,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            Some(Response::Result(super::Status::Ok))
-        } else {
-            Some(Response::InternalServerError(
-                json!({ "error": "Failed to remove you from the guild." }),
-            ))
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct CreateChannel {
-    nonce: String,
-    name: String,
-    description: Option<String>,
-}
-
-/// create a new channel
-#[post("/<target>/channels", data = "<info>")]
-pub fn create_channel(
-    user: UserRef,
-    target: GuildRef,
-    info: Json<CreateChannel>,
-) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if !permissions.get_manage_channels() {
-        return Some(Response::LackingPermission(Permission::ManageChannels));
-    }
-
-    let nonce: String = info.nonce.chars().take(32).collect();
-    let name: String = info.name.chars().take(32).collect();
-    let description: String = info
-        .description
-        .clone()
-        .unwrap_or(String::new())
-        .chars()
-        .take(255)
-        .collect();
-
-    if let Ok(result) =
-        database::get_collection("channels").find_one(doc! { "nonce": &nonce }, None)
-    {
-        if result.is_some() {
-            return Some(Response::BadRequest(
-                json!({ "error": "Channel already created." }),
-            ));
-        }
-
-        let id = Ulid::new().to_string();
-        if database::get_collection("channels")
-            .insert_one(
-                doc! {
-                    "_id": &id,
-                    "nonce": &nonce,
-                    "type": 2,
-                    "guild": &target.id,
-                    "name": name,
-                    "description": description,
-                },
-                None,
-            )
-            .is_ok()
-        {
-            Some(Response::Success(json!({ "id": &id })))
-        } else {
-            Some(Response::BadRequest(
-                json!({ "error": "Couldn't create channel." }),
-            ))
-        }
-    } else {
-        Some(Response::BadRequest(
-            json!({ "error": "Failed to check if channel was made." }),
-        ))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct InviteOptions {
-    // ? TODO: add options
-}
-
-/// create a new invite
-#[post("/<target>/channels/<channel>/invite", data = "<_options>")]
-pub fn create_invite(
-    user: UserRef,
-    target: GuildRef,
-    channel: ChannelRef,
-    _options: Json<InviteOptions>,
-) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if !permissions.get_create_invite() {
-        return Some(Response::LackingPermission(Permission::CreateInvite));
-    }
-
-    let code = gen_token(7);
-    if database::get_collection("guilds")
-        .update_one(
-            doc! { "_id": target.id },
-            doc! {
-                "$push": {
-                    "invites": {
-                        "code": &code,
-                        "creator": user.id,
-                        "channel": channel.id,
-                    }
-                }
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Some(Response::Success(json!({ "code": code })))
-    } else {
-        Some(Response::BadRequest(
-            json!({ "error": "Failed to create invite." }),
-        ))
-    }
-}
-
-/// remove an invite
-#[delete("/<target>/invites/<code>")]
-pub fn remove_invite(user: UserRef, target: GuildRef, code: String) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if let Some((guild_id, _, invite)) = get_invite(&code, None) {
-        if invite.creator != user.id {
-            if !permissions.get_manage_server() {
-                return Some(Response::LackingPermission(Permission::ManageServer));
-            }
-        }
-
-        if database::get_collection("guilds")
-            .update_one(
-                doc! {
-                    "_id": &guild_id,
-                },
-                doc! {
-                    "$pull": {
-                        "invites": {
-                            "code": &code
-                        }
-                    }
-                },
-                None,
-            )
-            .is_ok()
-        {
-            Some(Response::Result(super::Status::Ok))
-        } else {
-            Some(Response::BadRequest(
-                json!({ "error": "Failed to delete invite." }),
-            ))
-        }
-    } else {
-        Some(Response::NotFound(
-            json!({ "error": "Failed to fetch invite or code is invalid." }),
-        ))
-    }
-}
-
-/// fetch all guild invites
-#[get("/<target>/invites")]
-pub fn fetch_invites(user: UserRef, target: GuildRef) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if !permissions.get_manage_server() {
-        return Some(Response::LackingPermission(Permission::ManageServer));
-    }
-
-    if let Some(doc) = target.fetch_data(doc! {
-        "invites": 1,
-    }) {
-        Some(Response::Success(json!(doc.get_array("invites").unwrap())))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch invites." }),
-        ))
-    }
-}
-
-/// view an invite before joining
-#[get("/join/<code>", rank = 1)]
-pub fn fetch_invite(user: UserRef, code: String) -> Response {
-    if let Some((guild_id, name, invite)) = get_invite(&code, user.id) {
-        if let Some(channel) = ChannelRef::from(invite.channel) {
-            Response::Success(json!({
-                "guild": {
-                    "id": guild_id,
-                    "name": name,
-                },
-                "channel": {
-                    "id": channel.id,
-                    "name": channel.name,
-                }
-            }))
-        } else {
-            Response::BadRequest(json!({ "error": "Failed to fetch channel." }))
-        }
-    } else {
-        Response::NotFound(json!({ "error": "Failed to fetch invite or code is invalid." }))
-    }
-}
-
-/// join a guild using an invite
-#[post("/join/<code>", rank = 1)]
-pub fn use_invite(user: UserRef, code: String) -> Response {
-    if let Some((guild_id, _, invite)) = get_invite(&code, Some(user.id.clone())) {
-        if let Ok(result) = database::get_collection("members").find_one(
-            doc! {
-                "_id.guild": &guild_id,
-                "_id.user": &user.id
-            },
-            FindOneOptions::builder()
-                .projection(doc! { "_id": 1 })
-                .build(),
-        ) {
-            if result.is_none() {
-                if database::get_collection("members")
-                    .insert_one(
-                        doc! {
-                            "_id": {
-                                "guild": &guild_id,
-                                "user": &user.id
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({
-                        "guild": &guild_id,
-                        "channel": &invite.channel,
-                    }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to add you to the guild." }),
-                    )
-                }
-            } else {
-                Response::BadRequest(json!({ "error": "Already in the guild." }))
-            }
-        } else {
-            Response::InternalServerError(
-                json!({ "error": "Failed to check if you're in the guild." }),
-            )
-        }
-    } else {
-        Response::NotFound(json!({ "error": "Failed to fetch invite or code is invalid." }))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct CreateGuild {
-    name: String,
-    description: Option<String>,
-    nonce: String,
-}
-
-/// create a new guild
-#[post("/create", data = "<info>")]
-pub fn create_guild(user: UserRef, info: Json<CreateGuild>) -> Response {
-    if !user.email_verified {
-        return Response::Unauthorized(json!({ "error": "Email not verified!" }));
-    }
-
-    let name: String = info.name.chars().take(32).collect();
-    let description: String = info
-        .description
-        .clone()
-        .unwrap_or("No description.".to_string())
-        .chars()
-        .take(255)
-        .collect();
-    let nonce: String = info.nonce.chars().take(32).collect();
-
-    let channels = database::get_collection("channels");
-    let col = database::get_collection("guilds");
-    if col
-        .find_one(doc! { "nonce": nonce.clone() }, None)
-        .unwrap()
-        .is_some()
-    {
-        return Response::BadRequest(json!({ "error": "Guild already created!" }));
-    }
-
-    let id = Ulid::new().to_string();
-    let channel_id = Ulid::new().to_string();
-    if channels
-        .insert_one(
-            doc! {
-                "_id": channel_id.clone(),
-                "type": ChannelType::GUILDCHANNEL as u32,
-                "name": "general",
-                "description": "",
-                "guild": id.clone(),
-            },
-            None,
-        )
-        .is_err()
-    {
-        return Response::InternalServerError(
-            json!({ "error": "Failed to create guild channel." }),
-        );
-    }
-
-    if database::get_collection("members")
-        .insert_one(
-            doc! {
-                "_id": {
-                    "guild": &id,
-                    "user": &user.id
-                }
-            },
-            None,
-        )
-        .is_err()
-    {
-        return Response::InternalServerError(
-            json!({ "error": "Failed to add you to members list." }),
-        );
-    }
-
-    if col
-        .insert_one(
-            doc! {
-                "_id": &id,
-                "nonce": nonce,
-                "name": name,
-                "description": description,
-                "owner": &user.id,
-                "invites": [],
-                "bans": [],
-                "default_permissions": 51,
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Response::Success(json!({ "id": id }))
-    } else {
-        channels
-            .delete_one(doc! { "_id": channel_id }, None)
-            .expect("Failed to delete the channel we just made.");
-
-        Response::InternalServerError(json!({ "error": "Failed to create guild." }))
-    }
-}
-
-/// fetch a guild's member
-#[get("/<target>/members")]
-pub fn fetch_members(user: UserRef, target: GuildRef) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if let Ok(result) =
-        database::get_collection("members").find(doc! { "_id.guild": target.id }, None)
-    {
-        let mut users = vec![];
-
-        for item in result {
-            if let Ok(doc) = item {
-                users.push(json!({
-                    "id": doc.get_document("_id").unwrap().get_str("user").unwrap(),
-                    "nickname": doc.get_str("nickname").ok(),
-                }));
-            }
-        }
-
-        Some(Response::Success(json!(users)))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch members." }),
-        ))
-    }
-}
-
-/// fetch a guild member
-#[get("/<target>/members/<other>")]
-pub fn fetch_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if let Some(member) = get_member(&target.id, &other) {
-        Some(Response::Success(json!({
-            "id": member.id.user,
-            "nickname": member.nickname,
-        })))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch member or user does not exist." }),
-        ))
-    }
-}
-
-/// kick a guild member
-#[delete("/<target>/members/<other>")]
-pub fn kick_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if user.id == other {
-        return Some(Response::BadRequest(
-            json!({ "error": "Cannot kick yourself." }),
-        ));
-    }
-
-    if !permissions.get_kick_members() {
-        return Some(Response::LackingPermission(Permission::KickMembers));
-    }
-
-    if get_member(&target.id, &other).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
-        ));
-    }
-
-    if database::get_collection("members")
-        .delete_one(
-            doc! {
-                "_id.guild": &target.id,
-                "_id.user": &other,
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Some(Response::Result(super::Status::Ok))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to kick member." }),
-        ))
-    }
-}
-
-#[derive(Serialize, Deserialize, FromForm)]
-pub struct BanOptions {
-    reason: Option<String>,
-}
-
-/// ban a guild member
-#[put("/<target>/members/<other>/ban?<options..>")]
-pub fn ban_member(
-    user: UserRef,
-    target: GuildRef,
-    other: String,
-    options: Form<BanOptions>,
-) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-    let reason: String = options
-        .reason
-        .clone()
-        .unwrap_or("No reason specified.".to_string())
-        .chars()
-        .take(64)
-        .collect();
-
-    if user.id == other {
-        return Some(Response::BadRequest(
-            json!({ "error": "Cannot ban yourself." }),
-        ));
-    }
-
-    if !permissions.get_ban_members() {
-        return Some(Response::LackingPermission(Permission::BanMembers));
-    }
-
-    if get_member(&target.id, &other).is_none() {
-        return Some(Response::BadRequest(
-            json!({ "error": "User not part of guild." }),
-        ));
-    }
-
-    if database::get_collection("guilds")
-        .update_one(
-            doc! { "_id": &target.id },
-            doc! {
-                "$push": {
-                    "bans": {
-                        "id": &other,
-                        "reason": reason,
-                    }
-                }
-            },
-            None,
-        )
-        .is_err()
-    {
-        return Some(Response::BadRequest(
-            json!({ "error": "Failed to add ban to guild." }),
-        ));
-    }
-
-    if database::get_collection("members")
-        .delete_one(
-            doc! {
-                "_id.guild": &target.id,
-                "_id.user": &other,
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Some(Response::Result(super::Status::Ok))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to kick member after adding to ban list." }),
-        ))
-    }
-}
-
-/// unban a guild member
-#[delete("/<target>/members/<other>/ban")]
-pub fn unban_member(user: UserRef, target: GuildRef, other: String) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if user.id == other {
-        return Some(Response::BadRequest(
-            json!({ "error": "Cannot unban yourself (not checking if you're banned)." }),
-        ));
-    }
-
-    if !permissions.get_ban_members() {
-        return Some(Response::LackingPermission(Permission::BanMembers));
-    }
-
-    if target
-        .fetch_data_given(
-            doc! {
-                "bans": {
-                    "$elemMatch": {
-                        "id": &other
-                    }
-                }
-            },
-            doc! {},
-        )
-        .is_none()
-    {
-        return Some(Response::BadRequest(json!({ "error": "User not banned." })));
-    }
-
-    if database::get_collection("guilds")
-        .update_one(
-            doc! {
-                "_id": &target.id
-            },
-            doc! {
-                "$pull": {
-                    "bans": {
-                        "$elemMatch": {
-                            "id": &other
-                        }
-                    }
-                }
-            },
-            None,
-        )
-        .is_ok()
-    {
-        Some(Response::Result(super::Status::Ok))
-    } else {
-        Some(Response::BadRequest(
-            json!({ "error": "Failed to remove ban." }),
-        ))
-    }
-}

src/routes/guild/mod.rs

@@ -0,0 +1,5 @@
+use rocket::Route;
+
+pub fn routes() -> Vec<Route> {
+    routes![]
+}

src/routes/mod.rs

@@ -1,125 +1,18 @@
 pub use rocket::http::Status;
 pub use rocket::response::Redirect;
 use rocket::Rocket;
-use rocket_contrib::json::JsonValue;
 
-use crate::database::Permission;
-
-pub mod account;
-pub mod channel;
-pub mod guild;
-pub mod root;
-pub mod user;
-
-#[derive(Responder)]
-pub enum Response {
-    #[response()]
-    Result(Status),
-    #[response()]
-    Success(JsonValue),
-    #[response()]
-    Redirect(Redirect),
-    #[response(status = 400)]
-    BadRequest(JsonValue),
-    #[response(status = 401)]
-    Unauthorized(JsonValue),
-    #[response(status = 401)]
-    LackingPermission(Permission),
-    #[response(status = 404)]
-    NotFound(JsonValue),
-    #[response(status = 406)]
-    NotAcceptable(JsonValue),
-    #[response(status = 409)]
-    Conflict(JsonValue),
-    #[response(status = 410)]
-    Gone(JsonValue),
-    #[response(status = 422)]
-    UnprocessableEntity(JsonValue),
-    #[response(status = 429)]
-    TooManyRequests(JsonValue),
-    #[response(status = 500)]
-    InternalServerError(JsonValue),
-}
-
-use rocket::http::ContentType;
-use rocket::request::Request;
-use std::io::Cursor;
-
-impl<'a> rocket::response::Responder<'a> for Permission {
-    fn respond_to(self, _: &Request) -> rocket::response::Result<'a> {
-        rocket::response::Response::build()
-            .header(ContentType::JSON)
-            .sized_body(Cursor::new(format!(
-                "{{\"error\":\"Lacking permission: {:?}.\",\"permission\":{}}}",
-                self,
-                self as u32,
-            )))
-            .ok()
-    }
-}
+mod channels;
+mod guild;
+mod onboard;
+mod root;
+mod users;
 
 pub fn mount(rocket: Rocket) -> Rocket {
     rocket
-        .mount("/api", routes![root::root])
-        .mount(
-            "/api/account",
-            routes![
-                account::create,
-                account::verify_email,
-                account::resend_email,
-                account::login,
-                account::token
-            ],
-        )
-        .mount(
-            "/api/users",
-            routes![
-                user::me,
-                user::user,
-                user::lookup,
-                user::dms,
-                user::dm,
-                user::get_friends,
-                user::get_friend,
-                user::add_friend,
-                user::remove_friend,
-                user::block_user,
-                user::unblock_user
-            ],
-        )
-        .mount(
-            "/api/channels",
-            routes![
-                channel::create_group,
-                channel::channel,
-                channel::add_member,
-                channel::remove_member,
-                channel::delete,
-                channel::messages,
-                channel::get_message,
-                channel::send_message,
-                channel::edit_message,
-                channel::delete_message
-            ],
-        )
-        .mount(
-            "/api/guild",
-            routes![
-                guild::my_guilds,
-                guild::guild,
-                guild::remove_guild,
-                guild::create_channel,
-                guild::create_invite,
-                guild::remove_invite,
-                guild::fetch_invites,
-                guild::fetch_invite,
-                guild::use_invite,
-                guild::create_guild,
-                guild::fetch_members,
-                guild::fetch_member,
-                guild::kick_member,
-                guild::ban_member,
-                guild::unban_member
-            ],
-        )
+        .mount("/", routes![root::root])
+        .mount("/onboard", onboard::routes())
+        .mount("/users", users::routes())
+        .mount("/channels", channels::routes())
+        .mount("/guild", guild::routes())
 }

src/routes/onboard/complete.rs

@@ -0,0 +1,69 @@
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use mongodb::options::{Collation, FindOneOptions};
+use rauth::auth::Session;
+use regex::Regex;
+use rocket_contrib::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+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: String,
+}
+
+#[post("/complete", data = "<data>")]
+pub async fn req(session: Session, user: Option<User>, data: Json<Data>) -> Result<()> {
+    if user.is_some() {
+        Err(Error::AlreadyOnboarded)?
+    }
+
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    if data.username == "revolt" {
+        Err(Error::UsernameTaken)?
+    }
+
+    let col = get_collection("users");
+    if col
+        .find_one(
+            doc! {
+                "username": &data.username
+            },
+            FindOneOptions::builder()
+                .collation(Collation::builder().locale("en").strength(2).build())
+                .build(),
+        )
+        .await
+        .map_err(|_| Error::DatabaseError {
+            operation: "find_one",
+            with: "user",
+        })?
+        .is_some()
+    {
+        Err(Error::UsernameTaken)?
+    }
+
+    col.insert_one(
+        doc! {
+            "_id": session.user_id,
+            "username": &data.username
+        },
+        None,
+    )
+    .await
+    .map_err(|_| Error::DatabaseError {
+        operation: "insert_one",
+        with: "user",
+    })?;
+
+    Ok(())
+}

src/routes/onboard/hello.rs

@@ -0,0 +1,11 @@
+use crate::database::*;
+
+use rauth::auth::Session;
+use rocket_contrib::json::JsonValue;
+
+#[get("/hello")]
+pub async fn req(_session: Session, user: Option<User>) -> JsonValue {
+    json!({
+        "onboarding": user.is_none()
+    })
+}

src/routes/onboard/mod.rs

@@ -0,0 +1,8 @@
+use rocket::Route;
+
+mod complete;
+mod hello;
+
+pub fn routes() -> Vec<Route> {
+    routes![hello::req, complete::req]
+}

src/routes/root.rs

@@ -1,11 +1,22 @@
-use super::Response;
+use crate::util::variables::{
+    DISABLE_REGISTRATION, EXTERNAL_WS_URL, HCAPTCHA_SITEKEY, USE_EMAIL, USE_HCAPTCHA,
+};
 
-use bson::doc;
+use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
 
-/// root
 #[get("/")]
-pub fn root() -> Response {
-    Response::Success(json!({
-        "revolt": "0.0.1"
-    }))
+pub async fn root() -> JsonValue {
+    json!({
+        "revolt": "0.3.3-alpha.0",
+        "features": {
+            "registration": !*DISABLE_REGISTRATION,
+            "captcha": {
+                "enabled": *USE_HCAPTCHA,
+                "key": HCAPTCHA_SITEKEY.to_string()
+            },
+            "email": *USE_EMAIL,
+        },
+        "ws": *EXTERNAL_WS_URL,
+    })
 }

src/routes/user.rs

@@ -1,529 +0,0 @@
-use super::Response;
-use crate::database::{self, get_relationship, get_relationship_internal, mutual, Relationship};
-use crate::guards::auth::UserRef;
-use crate::routes::channel;
-
-use bson::doc;
-use mongodb::options::FindOptions;
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-/// retrieve your user information
-#[get("/@me")]
-pub fn me(user: UserRef) -> Response {
-    if let Some(info) = user.fetch_data(doc! { "email": 1 }) {
-        Response::Success(json!({
-            "id": user.id,
-            "username": user.username,
-            "email": info.get_str("email").unwrap(),
-            "verified": user.email_verified,
-        }))
-    } else {
-        Response::InternalServerError(
-            json!({ "error": "Failed to fetch information from database." }),
-        )
-    }
-}
-
-/// retrieve another user's information
-#[get("/<target>")]
-pub fn user(user: UserRef, target: UserRef) -> Response {
-    Response::Success(json!({
-        "id": target.id,
-        "username": target.username,
-        "relationship": get_relationship(&user, &target) as u8,
-        "mutual": {
-            "guilds": mutual::find_mutual_guilds(&user.id, &target.id),
-            "friends": mutual::find_mutual_friends(&user.id, &target.id),
-            "groups": mutual::find_mutual_groups(&user.id, &target.id),
-        }
-    }))
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct LookupQuery {
-    username: String,
-}
-
-/// lookup a user on Revolt
-/// currently only supports exact username searches
-#[post("/lookup", data = "<query>")]
-pub fn lookup(user: UserRef, query: Json<LookupQuery>) -> Response {
-    let relationships = user.fetch_relationships();
-    let col = database::get_collection("users");
-
-    if let Ok(users) = col.find(
-        doc! { "username": query.username.clone() },
-        FindOptions::builder()
-            .projection(doc! { "_id": 1, "username": 1 })
-            .limit(10)
-            .build(),
-    ) {
-        let mut results = Vec::new();
-        for item in users {
-            if let Ok(doc) = item {
-                let id = doc.get_str("id").unwrap();
-                results.push(json!({
-                    "id": id,
-                    "username": doc.get_str("username").unwrap(),
-                    "relationship": get_relationship_internal(&user.id, &id, &relationships) as u8
-                }));
-            }
-        }
-
-        Response::Success(json!(results))
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed database query." }))
-    }
-}
-
-/// retrieve all of your DMs
-#[get("/@me/dms")]
-pub fn dms(user: UserRef) -> Response {
-    let col = database::get_collection("channels");
-
-    if let Ok(results) = col.find(
-        doc! {
-            "$or": [
-                {
-                    "type": channel::ChannelType::DM as i32
-                },
-                {
-                    "type": channel::ChannelType::GROUPDM as i32
-                }
-            ],
-            "recipients": user.id
-        },
-        FindOptions::builder().projection(doc! {}).build(),
-    ) {
-        let mut channels = Vec::new();
-        for item in results {
-            if let Ok(doc) = item {
-                let id = doc.get_str("_id").unwrap();
-                let recipients = doc.get_array("recipients").unwrap();
-
-                match doc.get_i32("type").unwrap() {
-                    0 => {
-                        channels.push(json!({
-                            "id": id,
-                            "type": 0,
-                            "recipients": recipients,
-                        }));
-                    }
-                    1 => {
-                        channels.push(json!({
-                            "id": id,
-                            "type": 1,
-                            "recipients": recipients,
-                            "name": doc.get_str("name").unwrap(),
-                            "owner": doc.get_str("owner").unwrap(),
-                            "description": doc.get_str("description").unwrap_or(""),
-                        }));
-                    }
-                    _ => unreachable!(),
-                }
-            }
-        }
-
-        Response::Success(json!(channels))
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed database query." }))
-    }
-}
-
-/// open a DM with a user
-#[get("/<target>/dm")]
-pub fn dm(user: UserRef, target: UserRef) -> Response {
-    let col = database::get_collection("channels");
-
-    if let Ok(result) = col.find_one(
-		doc! { "type": channel::ChannelType::DM as i32, "recipients": { "$all": [ user.id.clone(), target.id.clone() ] } },
-		None
-	) {
-        if let Some(channel) = result {
-            Response::Success( json!({ "id": channel.get_str("_id").unwrap() }))
-        } else {
-			let id = Ulid::new();
-
-			if col.insert_one(
-				doc! {
-					"_id": id.to_string(),
-					"type": channel::ChannelType::DM as i32,
-					"recipients": [ user.id, target.id ],
-					"active": false
-				},
-				None
-			).is_ok() {
-                Response::Success(json!({ "id": id.to_string() }))
-            } else {
-                Response::InternalServerError(json!({ "error": "Failed to create new channel." }))
-            }
-		}
-	} else {
-        Response::InternalServerError(json!({ "error": "Failed server query." }))
-    }
-}
-
-/// retrieve all of your friends
-#[get("/@me/friend")]
-pub fn get_friends(user: UserRef) -> Response {
-    let relationships = user.fetch_relationships();
-
-    let mut results = Vec::new();
-    if let Some(arr) = relationships {
-        for item in arr {
-            results.push(json!({
-                "id": item.id,
-                "status": item.status
-            }))
-        }
-    }
-
-    Response::Success(json!(results))
-}
-
-/// retrieve friend status with user
-#[get("/<target>/friend")]
-pub fn get_friend(user: UserRef, target: UserRef) -> Response {
-    Response::Success(json!({ "status": get_relationship(&user, &target) as u8 }))
-}
-
-/// create or accept a friend request
-#[put("/<target>/friend")]
-pub fn add_friend(user: UserRef, target: UserRef) -> Response {
-    let col = database::get_collection("users");
-
-    match get_relationship(&user, &target) {
-        Relationship::Friend => Response::BadRequest(json!({ "error": "Already friends." })),
-        Relationship::Outgoing => {
-            Response::BadRequest(json!({ "error": "Already sent a friend request." }))
-        }
-        Relationship::Incoming => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone(),
-                        "relations.id": target.id.clone()
-                    },
-                    doc! {
-                        "$set": {
-                            "relations.$.status": Relationship::Friend as i32
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": target.id,
-                            "relations.id": user.id
-                        },
-                        doc! {
-                            "$set": {
-                                "relations.$.status": Relationship::Friend as i32
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({ "status": Relationship::Friend as u8 }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit! Try re-adding them as a friend." }),
-                    )
-                }
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::Blocked => {
-            Response::BadRequest(json!({ "error": "You have blocked this person." }))
-        }
-        Relationship::BlockedOther => {
-            Response::Conflict(json!({ "error": "You have been blocked by this person." }))
-        }
-        Relationship::NONE => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone()
-                    },
-                    doc! {
-                        "$push": {
-                            "relations": {
-                                "id": target.id.clone(),
-                                "status": Relationship::Outgoing as i32
-                            }
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": target.id
-                        },
-                        doc! {
-                            "$push": {
-                                "relations": {
-                                    "id": user.id,
-                                    "status": Relationship::Incoming as i32
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({ "status": Relationship::Outgoing as u8 }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit! Try re-adding them as a friend." }),
-                    )
-                }
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::SELF => {
-            Response::BadRequest(json!({ "error": "You're already friends with yourself, no? c:" }))
-        }
-    }
-}
-
-/// remove a friend or deny a request
-#[delete("/<target>/friend")]
-pub fn remove_friend(user: UserRef, target: UserRef) -> Response {
-    let col = database::get_collection("users");
-
-    match get_relationship(&user, &target) {
-        Relationship::Friend | Relationship::Outgoing | Relationship::Incoming => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone()
-                    },
-                    doc! {
-                        "$pull": {
-                            "relations": {
-                                "id": target.id.clone()
-                            }
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": target.id
-                        },
-                        doc! {
-                            "$pull": {
-                                "relations": {
-                                    "id": user.id
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({ "status": Relationship::NONE as u8 }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit! Target remains in same state." }),
-                    )
-                }
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::Blocked
-        | Relationship::BlockedOther
-        | Relationship::NONE
-        | Relationship::SELF => Response::BadRequest(json!({ "error": "This has no effect." })),
-    }
-}
-
-/// block a user
-#[put("/<target>/block")]
-pub fn block_user(user: UserRef, target: UserRef) -> Response {
-    let col = database::get_collection("users");
-
-    match get_relationship(&user, &target) {
-        Relationship::Friend | Relationship::Incoming | Relationship::Outgoing => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone(),
-                        "relations.id": target.id.clone()
-                    },
-                    doc! {
-                        "$set": {
-                            "relations.$.status": Relationship::Blocked as i32
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": target.id,
-                            "relations.id": user.id
-                        },
-                        doc! {
-                            "$set": {
-                                "relations.$.status": Relationship::BlockedOther as i32
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({ "status": Relationship::Blocked as u8 }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit! Try blocking the user again, remove it first." }),
-                    )
-                }
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::Blocked => {
-            Response::BadRequest(json!({ "error": "Already blocked this person." }))
-        }
-        Relationship::BlockedOther => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone(),
-                        "relations.id": target.id.clone()
-                    },
-                    doc! {
-                        "$set": {
-                            "relations.$.status": Relationship::Blocked as i32
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                Response::Success(json!({ "status": Relationship::Blocked as u8 }))
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::SELF | Relationship::NONE => {
-            Response::BadRequest(json!({ "error": "This has no effect." }))
-        }
-    }
-}
-
-/// unblock a user
-#[delete("/<target>/block")]
-pub fn unblock_user(user: UserRef, target: UserRef) -> Response {
-    let col = database::get_collection("users");
-
-    match get_relationship(&user, &target) {
-        Relationship::Blocked => match get_relationship(&target, &user) {
-            Relationship::Blocked => {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": user.id.clone(),
-                            "relations.id": target.id.clone()
-                        },
-                        doc! {
-                            "$set": {
-                                "relations.$.status": Relationship::BlockedOther as i32
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    Response::Success(json!({ "status": Relationship::BlockedOther as u8 }))
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit to database, try again." }),
-                    )
-                }
-            }
-            Relationship::BlockedOther => {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": user.id.clone()
-                        },
-                        doc! {
-                            "$pull": {
-                                "relations": {
-                                    "id": target.id.clone()
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    if col
-                        .update_one(
-                            doc! {
-                                "_id": target.id
-                            },
-                            doc! {
-                                "$pull": {
-                                    "relations": {
-                                        "id": user.id
-                                    }
-                                }
-                            },
-                            None,
-                        )
-                        .is_ok()
-                    {
-                        Response::Success(json!({ "status": Relationship::NONE as u8 }))
-                    } else {
-                        Response::InternalServerError(
-                            json!({ "error": "Failed to commit! Target remains in same state." }),
-                        )
-                    }
-                } else {
-                    Response::InternalServerError(
-                        json!({ "error": "Failed to commit to database, try again." }),
-                    )
-                }
-            }
-            _ => unreachable!(),
-        },
-        Relationship::BlockedOther => {
-            Response::BadRequest(json!({ "error": "Cannot remove block by other user." }))
-        }
-        Relationship::Friend
-        | Relationship::Incoming
-        | Relationship::Outgoing
-        | Relationship::SELF
-        | Relationship::NONE => Response::BadRequest(json!({ "error": "This has no effect." })),
-    }
-}

src/routes/users/add_friend.rs

@@ -0,0 +1,149 @@
+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+
+use futures::try_join;
+use mongodb::bson::doc;
+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 target_id = doc.get_str("_id").map_err(|_| Error::DatabaseError {
+        operation: "get_str(_id)",
+        with: "user",
+    })?;
+
+    match get_relationship(&user, &target_id) {
+        RelationshipStatus::User => return Err(Error::NoEffect),
+        RelationshipStatus::Friend => return Err(Error::AlreadyFriends),
+        RelationshipStatus::Outgoing => return Err(Error::AlreadySentRequest),
+        RelationshipStatus::Blocked => return Err(Error::Blocked),
+        RelationshipStatus::BlockedOther => return Err(Error::BlockedByOther),
+        RelationshipStatus::Incoming => {
+            match try_join!(
+                col.update_one(
+                    doc! {
+                        "_id": &user.id,
+                        "relations._id": target_id
+                    },
+                    doc! {
+                        "$set": {
+                            "relations.$.status": "Friend"
+                        }
+                    },
+                    None
+                ),
+                col.update_one(
+                    doc! {
+                        "_id": target_id,
+                        "relations._id": &user.id
+                    },
+                    doc! {
+                        "$set": {
+                            "relations.$.status": "Friend"
+                        }
+                    },
+                    None
+                )
+            ) {
+                Ok(_) => {
+                    try_join!(
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target_id.to_string(),
+                            status: RelationshipStatus::Friend
+                        }
+                        .publish(user.id.clone()),
+                        ClientboundNotification::UserRelationship {
+                            id: target_id.to_string(),
+                            user: user.id.clone(),
+                            status: RelationshipStatus::Friend
+                        }
+                        .publish(target_id.to_string())
+                    )
+                    .ok();
+
+                    Ok(json!({ "status": "Friend" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+        RelationshipStatus::None => {
+            match try_join!(
+                col.update_one(
+                    doc! {
+                        "_id": &user.id
+                    },
+                    doc! {
+                        "$push": {
+                            "relations": {
+                                "_id": target_id,
+                                "status": "Outgoing"
+                            }
+                        }
+                    },
+                    None
+                ),
+                col.update_one(
+                    doc! {
+                        "_id": target_id
+                    },
+                    doc! {
+                        "$push": {
+                            "relations": {
+                                "_id": &user.id,
+                                "status": "Incoming"
+                            }
+                        }
+                    },
+                    None
+                )
+            ) {
+                Ok(_) => {
+                    try_join!(
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target_id.to_string(),
+                            status: RelationshipStatus::Outgoing
+                        }
+                        .publish(user.id.clone()),
+                        ClientboundNotification::UserRelationship {
+                            id: target_id.to_string(),
+                            user: user.id.clone(),
+                            status: RelationshipStatus::Incoming
+                        }
+                        .publish(target_id.to_string())
+                    )
+                    .ok();
+
+                    Ok(json!({ "status": "Outgoing" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+    }
+}

src/routes/users/block_user.rs

@@ -0,0 +1,156 @@
+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");
+
+    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.id.clone(),
+                status: RelationshipStatus::Blocked,
+            }
+            .publish(user.id.clone())
+            .await
+            .ok();
+
+            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(_) => {
+                    try_join!(
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: RelationshipStatus::Blocked
+                        }
+                        .publish(user.id.clone()),
+                        ClientboundNotification::UserRelationship {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: RelationshipStatus::BlockedOther
+                        }
+                        .publish(target.id.clone())
+                    )
+                    .ok();
+
+                    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(_) => {
+                    try_join!(
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: RelationshipStatus::Blocked
+                        }
+                        .publish(user.id.clone()),
+                        ClientboundNotification::UserRelationship {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: RelationshipStatus::BlockedOther
+                        }
+                        .publish(target.id.clone())
+                    )
+                    .ok();
+
+                    Ok(json!({ "status": "Blocked" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+    }
+}

src/routes/users/fetch_dms.rs

@@ -0,0 +1,40 @@
+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_relationship.rs

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,24 @@
+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::LabelMe)?
+    }
+
+    Ok(json!(
+        target
+            .from(&user)
+            .with(perm)
+    ))
+}

src/routes/users/get_avatar.rs

@@ -0,0 +1,48 @@
+use mongodb::options::FindOneOptions;
+use rocket::response::Redirect;
+use mongodb::bson::doc;
+use urlencoding;
+use md5;
+
+use crate::util::result::{Error, Result};
+use crate::util::variables::PUBLIC_URL;
+use crate::database::*;
+
+#[get("/<target>/avatar")]
+pub async fn req(target: Ref) -> Result<Redirect> {
+    let doc = get_collection("accounts")
+        .find_one(
+            doc! {
+                "_id": &target.id
+            },
+            FindOneOptions::builder()
+                .projection(doc! { "email": 1 })
+                .build()
+        )
+        .await
+        .map_err(|_| Error::DatabaseError { operation: "find_one", with: "user" })?
+        .ok_or_else(|| Error::UnknownUser)?;
+    
+    let email = doc
+        .get_str("email")
+        .map_err(|_| Error::DatabaseError { operation: "get_str(email)", with: "user" })?
+        .to_lowercase();
+
+        let url = format!(
+            "https://www.gravatar.com/avatar/{:x}?s=128&d={}",
+            md5::compute(email),
+            urlencoding::encode(
+                &format!(
+                    "{}/users/{}/default_avatar",
+                    *PUBLIC_URL,
+                    &target.id
+                )
+            )
+        );
+
+        dbg!(&url);
+
+    Ok(
+        Redirect::to(url)
+    )
+}

src/routes/users/get_default_avatar.rs

@@ -0,0 +1,29 @@
+use rocket::response::NamedFile;
+use std::path::Path;
+
+use crate::database::Ref;
+
+#[get("/<target>/default_avatar")]
+pub async fn req(target: Ref) -> Option<NamedFile> {
+    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()
+        }
+        '8' | '9' | 'A' | 'C' | 'B' | 'D' | 'E' | 'F' => {
+            NamedFile::open(Path::new("assets/user_green.png"))
+                .await
+                .ok()
+        }
+        'G' | 'H' | 'J' | 'K' | 'M' | 'N' | 'P' | 'Q' => {
+            NamedFile::open(Path::new("assets/user_blue.png"))
+                .await
+                .ok()
+        }
+        'R' | 'S' | 'T' | 'V' | 'W' | 'X' | 'Y' | 'Z' => {
+            NamedFile::open(Path::new("assets/user_yellow.png"))
+                .await
+                .ok()
+        }
+        _ => unreachable!(),
+    }
+}

src/routes/users/mod.rs

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

src/routes/users/open_dm.rs

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,72 @@
+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");
+
+    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(_) => {
+                    try_join!(
+                        ClientboundNotification::UserRelationship {
+                            id: user.id.clone(),
+                            user: target.id.clone(),
+                            status: RelationshipStatus::None
+                        }
+                        .publish(user.id.clone()),
+                        ClientboundNotification::UserRelationship {
+                            id: target.id.clone(),
+                            user: user.id.clone(),
+                            status: RelationshipStatus::None
+                        }
+                        .publish(target.id.clone())
+                    )
+                    .ok();
+
+                    Ok(json!({ "status": "None" }))
+                }
+                Err(_) => Err(Error::DatabaseError {
+                    operation: "update_one",
+                    with: "user",
+                }),
+            }
+        }
+        _ => Err(Error::NoEffect),
+    }
+}

src/routes/users/unblock_user.rs

@@ -0,0 +1,105 @@
+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");
+
+    match get_relationship(&user, &target.id) {
+        RelationshipStatus::Blocked => {
+            match get_relationship(&target.fetch_user().await?, &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",
+                    })?;
+
+                    ClientboundNotification::UserRelationship {
+                        id: user.id.clone(),
+                        user: target.id.clone(),
+                        status: RelationshipStatus::BlockedOther,
+                    }
+                    .publish(user.id.clone())
+                    .await
+                    .ok();
+
+                    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(_) => {
+                            try_join!(
+                                ClientboundNotification::UserRelationship {
+                                    id: user.id.clone(),
+                                    user: target.id.clone(),
+                                    status: RelationshipStatus::None
+                                }
+                                .publish(user.id.clone()),
+                                ClientboundNotification::UserRelationship {
+                                    id: target.id.clone(),
+                                    user: user.id.clone(),
+                                    status: RelationshipStatus::None
+                                }
+                                .publish(target.id.clone())
+                            )
+                            .ok();
+
+                            Ok(json!({ "status": "None" }))
+                        }
+                        Err(_) => Err(Error::DatabaseError {
+                            operation: "update_one",
+                            with: "user",
+                        }),
+                    }
+                }
+                _ => Err(Error::InternalError),
+            }
+        }
+        _ => Err(Error::NoEffect),
+    }
+}

src/util/captcha.rs

@@ -0,0 +1,45 @@
+use crate::util::variables::{HCAPTCHA_KEY, USE_HCAPTCHA};
+
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Serialize, Deserialize)]
+struct CaptchaResponse {
+    success: bool,
+}
+
+pub async fn verify(user_token: &Option<String>) -> Result<(), String> {
+    if *USE_HCAPTCHA {
+        if let Some(token) = user_token {
+            let mut map = HashMap::new();
+            map.insert("secret", HCAPTCHA_KEY.to_string());
+            map.insert("response", token.to_string());
+
+            let client = Client::new();
+            if let Ok(response) = client
+                .post("https://hcaptcha.com/siteverify")
+                .form(&map)
+                .send()
+                .await
+            {
+                let result: CaptchaResponse = response
+                    .json()
+                    .await
+                    .map_err(|_| "Failed to deserialise captcha result.".to_string())?;
+
+                if result.success {
+                    Ok(())
+                } else {
+                    Err("Unsuccessful captcha verification".to_string())
+                }
+            } else {
+                Err("Failed to verify with hCaptcha".to_string())
+            }
+        } else {
+            Err("Missing hCaptcha token!".to_string())
+        }
+    } else {
+        Ok(())
+    }
+}

src/util/email.rs

@@ -0,0 +1,96 @@
+use lettre::message::{header, MultiPart, SinglePart};
+use lettre::transport::smtp::authentication::Credentials;
+use lettre::{Message, SmtpTransport, Transport};
+
+use super::variables::{PUBLIC_URL, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME};
+
+lazy_static! {
+    static ref MAILER: lettre::transport::smtp::SmtpTransport =
+        SmtpTransport::relay(SMTP_HOST.as_ref())
+            .unwrap()
+            .credentials(Credentials::new(
+                SMTP_USERNAME.to_string(),
+                SMTP_PASSWORD.to_string()
+            ))
+            .build();
+}
+
+fn send(message: Message) -> Result<(), String> {
+    MAILER
+        .send(&message)
+        .map_err(|err| format!("Failed to send email! {}", err.to_string()))?;
+
+    Ok(())
+}
+
+fn generate_multipart(text: &str, html: &str) -> MultiPart {
+    MultiPart::mixed().multipart(
+        MultiPart::alternative()
+            .singlepart(
+                SinglePart::quoted_printable()
+                    .header(header::ContentType(
+                        "text/plain; charset=utf8".parse().unwrap(),
+                    ))
+                    .body(text),
+            )
+            .multipart(
+                MultiPart::related().singlepart(
+                    SinglePart::eight_bit()
+                        .header(header::ContentType(
+                            "text/html; charset=utf8".parse().unwrap(),
+                        ))
+                        .body(html),
+                ),
+            ),
+    )
+}
+
+pub fn send_verification_email(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/verify/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Verify your email!")
+        .multipart(generate_multipart(
+            &format!("Verify your email here: {}", url),
+            &format!("<a href=\"{}\">Click to verify your email!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_password_reset(email: String, code: String) -> Result<(), String> {
+    let url = format!("{}/api/account/reset/{}", PUBLIC_URL.to_string(), code);
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Reset your password.")
+        .multipart(generate_multipart(
+            &format!("Reset your password here: {}", url),
+            &format!("<a href=\"{}\">Click to reset your password!</a>", url),
+        ))
+        .unwrap();
+
+    send(email)
+}
+
+pub fn send_welcome_email(email: String, username: String) -> Result<(), String> {
+    let email = Message::builder()
+        .from(SMTP_FROM.to_string().parse().unwrap())
+        .to(email.parse().unwrap())
+        .subject("Welcome to REVOLT!")
+        .multipart(
+        generate_multipart(
+            &format!("Welcome, {}! You can now use REVOLT.", username),
+            &format!(
+                    "<b>Welcome, {}!</b><br/>You can now use REVOLT.<br/><a href=\"{}\">Go to REVOLT</a>",
+                    username,
+                    PUBLIC_URL.to_string()
+                )
+            )
+        )
+        .unwrap();
+
+    send(email)
+}

src/util/mod.rs

@@ -1,7 +1,12 @@
-use hashbrown::HashSet;
 use rand::{distributions::Alphanumeric, Rng};
+use std::collections::HashSet;
 use std::iter::FromIterator;
 
+pub mod captcha;
+pub mod email;
+pub mod result;
+pub mod variables;
+
 pub fn vec_to_set<T: Clone + Eq + std::hash::Hash>(data: &[T]) -> HashSet<T> {
     HashSet::from_iter(data.iter().cloned())
 }

src/util/result.rs

@@ -0,0 +1,111 @@
+use json;
+use rocket::http::{ContentType, Status};
+use rocket::request::Request;
+use rocket::response::{self, Responder, Response};
+use serde::Serialize;
+use snafu::Snafu;
+use std::io::Cursor;
+use validator::ValidationErrors;
+
+#[derive(Serialize, Debug, Snafu)]
+#[serde(tag = "type")]
+pub enum Error {
+    #[snafu(display("This error has not been labelled."))]
+    LabelMe,
+
+    // ? Onboarding related errors.
+    #[snafu(display("Already finished onboarding."))]
+    AlreadyOnboarded,
+
+    // ? User related errors.
+    #[snafu(display("Username has already been taken."))]
+    UsernameTaken,
+    #[snafu(display("This user does not exist!"))]
+    UnknownUser,
+    #[snafu(display("Already friends with this user."))]
+    AlreadyFriends,
+    #[snafu(display("Already sent a request to this user."))]
+    AlreadySentRequest,
+    #[snafu(display("You have blocked this user."))]
+    Blocked,
+    #[snafu(display("You have been blocked by this user."))]
+    BlockedByOther,
+    #[snafu(display("Not friends with target user."))]
+    NotFriends,
+
+    // ? Channel related errors.
+    #[snafu(display("This channel does not exist!"))]
+    UnknownChannel,
+    #[snafu(display("Cannot edit someone else's message."))]
+    CannotEditMessage,
+    #[snafu(display("Cannot remove yourself from a group, use delete channel instead."))]
+    CannotRemoveYourself,
+    #[snafu(display("Group size is too large."))]
+    GroupTooLarge { max: usize },
+    #[snafu(display("User already part of group."))]
+    AlreadyInGroup,
+    #[snafu(display("User is not part of the group."))]
+    NotInGroup,
+
+    // ? General errors.
+    #[snafu(display("Failed to validate fields."))]
+    FailedValidation { error: ValidationErrors },
+    #[snafu(display("Encountered a database error."))]
+    DatabaseError {
+        operation: &'static str,
+        with: &'static str,
+    },
+    #[snafu(display("Internal server error."))]
+    InternalError,
+    #[snafu(display("Operation cannot be performed on this object."))]
+    InvalidOperation,
+    #[snafu(display("Already created an object with this nonce."))]
+    DuplicateNonce,
+    #[snafu(display("This request had no effect."))]
+    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::CannotEditMessage => Status::Forbidden,
+            Error::CannotRemoveYourself => Status::BadRequest,
+            Error::GroupTooLarge { .. } => Status::Forbidden,
+            Error::AlreadyInGroup => Status::Conflict,
+            Error::NotInGroup => Status::NotFound,
+
+            Error::FailedValidation { .. } => Status::UnprocessableEntity,
+            Error::DatabaseError { .. } => Status::InternalServerError,
+            Error::InternalError => Status::InternalServerError,
+            Error::InvalidOperation => Status::BadRequest,
+            Error::DuplicateNonce => Status::Conflict,
+            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

@@ -0,0 +1,67 @@
+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 PUBLIC_URL: String =
+        env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_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 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 WS_HOST: String =
+        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9000".to_string());
+
+    // Application Flags
+    pub static ref DISABLE_REGISTRATION: bool = env::var("REVOLT_DISABLE_REGISTRATION").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");
+
+    // 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 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!("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/websocket/mod.rs

@@ -1,193 +0,0 @@
-extern crate ws;
-
-use crate::database;
-
-use hashbrown::HashMap;
-use std::sync::RwLock;
-use ulid::Ulid;
-
-use bson::doc;
-use serde_json::{from_str, json, Value};
-
-use ws::{listen, CloseCode, Error, Handler, Handshake, Message, Result, Sender};
-
-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 self.id.is_some() {
-                            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 CLIENTS.set(RwLock::new(HashMap::new())).is_err() {
-            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 item.out.send(message.clone()).is_err() {
-                    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");
-    }
-}