Add utility function for including relationship on User.

Code cleanup/formatting

See merge request revolt/delta!2

.gitignore

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

Cargo.toml

@@ -1,33 +1,44 @@
 [package]
 name = "revolt"
-version = "0.2.10"
+version = "0.3.2"
 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 = { version = "1.1.0", default-features = false, features = ["sync"] } # FIXME: rewrite database with async API
+futures = "0.3.8"
-rocket = { version = "0.4.5", default-features = false }
+many-to-many = "0.1.2"
+impl_ops = "0.1.1"
+ctrlc = { version = "3.0", features = ["termination"] }
+async-tungstenite = { version = "0.10.0", features = ["async-std-runtime"] }
+rauth = { git = "https://gitlab.insrt.uk/insert/rauth", rev = "8f3ea627" }
+async-std = { version = "1.8.0", features = ["tokio02", "attributes"] }
+
+hive_pubsub = { version = "0.4.3", features = ["mongo"] }
+rocket_cors = { git = "https://github.com/insertish/rocket_cors", branch = "master" }
+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.4.0"
+ulid = "0.4.1"
+
 serde = { version = "1.0.115", features = ["derive"] }
-rocket_contrib = "0.4.5"
+validator = { version = "0.11", features = ["derive"] }
-validator = "0.10.1"
+snafu = { version = "0.6.9" }
-bcrypt = "0.8.2"
-chrono = "0.4.15"
-rand = "0.7.3"
-time = "0.2.16"
-reqwest = { version = "0.10.8", features = ["blocking", "json"] }
-num_enum = "0.5.1"
-ws = "0.9.1"
-hashbrown = "0.8.2"
 serde_json = "1.0.57"
-rocket_cors = "0.5.2"
 bitfield = "0.13.2"
-lru = "0.6.0"
+
+reqwest = { version = "0.10.8", features = ["json"] }
 lazy_static = "1.4.0"
-log = "0.4.11"
+num_enum = "0.5.1"
-env_logger = "0.7.1"
+chrono = "0.4.15"
+time = "0.2.16"
+rand = "0.7.3"
+regex = "1"
+
 lettre = "0.10.0-alpha.1"
+env_logger = "0.7.1"
+log = "0.4.11"

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM ekidd/rust-musl-builder:nightly-2020-08-26 AS builder
+FROM ekidd/rust-musl-builder:nightly-2020-11-19 AS builder
 WORKDIR /home/rust/src
 
 RUN USER=root cargo new --bin revolt

build.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-docker build -t revolt --progress plain .

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"
+      - "9999:9999"
+    restart: unless-stopped

monitor.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-docker logs -f revolt

remove.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-echo "Removing Revolt container."
-docker kill revolt
-docker rm revolt

run.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-# Split at \n instead of space.
-# https://unix.stackexchange.com/a/39482
-set -f
-IFS='
-'
-
-input=($(egrep -v '^#' .env))
-prepended=(${input[@]/#/-e\"})
-variables=${prepended[@]/%/\"}
-
-unset IFS
-set +f
-
-echo "Running Revolt in detached mode."
-docker run \
-    -d \
-    --name revolt \
-    -p 8000:8000 \
-    -p 9000:9000 \
-    $variables \
-    revolt

src/database/channel.rs

@@ -1,215 +0,0 @@
-use super::get_collection;
-
-use lru::LruCache;
-use mongodb::bson::{doc, from_bson, Bson};
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use rocket_contrib::json::JsonValue;
-use serde::{Deserialize, Serialize};
-use std::sync::{Arc, Mutex};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct LastMessage {
-    // message id
-    id: String,
-    // author's id
-    user_id: String,
-    // truncated content with author's name prepended (for GDM / GUILD)
-    short_content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Channel {
-    #[serde(rename = "_id")]
-    pub id: String,
-    #[serde(rename = "type")]
-    pub channel_type: u8,
-
-    // DM: whether the DM is active
-    pub active: Option<bool>,
-    // DM + GDM: last message in channel
-    pub last_message: Option<LastMessage>,
-    // DM + GDM: recipients for channel
-    pub recipients: Option<Vec<String>>,
-    // GDM: owner of group
-    pub owner: Option<String>,
-    // GUILD: channel parent
-    pub guild: Option<String>,
-    // GUILD + GDM: channel name
-    pub name: Option<String>,
-    // GUILD + GDM: channel description
-    pub description: Option<String>,
-}
-
-impl Channel {
-    pub fn serialise(self) -> JsonValue {
-        match self.channel_type {
-            0 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "last_message": self.last_message,
-                "recipients": self.recipients,
-            }),
-            1 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "last_message": self.last_message,
-                "recipients": self.recipients,
-                "name": self.name,
-                "owner": self.owner,
-                "description": self.description,
-            }),
-            2 => json!({
-                "id": self.id,
-                "type": self.channel_type,
-                "guild": self.guild,
-                "name": self.name,
-                "description": self.description,
-            }),
-            _ => unreachable!(),
-        }
-    }
-}
-
-lazy_static! {
-    static ref CACHE: Arc<Mutex<LruCache<String, Channel>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-}
-
-pub fn fetch_channel(id: &str) -> Result<Option<Channel>, String> {
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            let existing = cache.get(&id.to_string());
-
-            if let Some(channel) = existing {
-                return Ok(Some((*channel).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("channels");
-    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
-        if let Some(doc) = result {
-            if let Ok(channel) = from_bson(Bson::Document(doc)) as Result<Channel, _> {
-                let mut cache = CACHE.lock().unwrap();
-                cache.put(id.to_string(), channel.clone());
-
-                Ok(Some(channel))
-            } else {
-                Err("Failed to deserialize channel!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-pub fn fetch_channels(ids: &Vec<String>) -> Result<Vec<Channel>, String> {
-    let mut missing = vec![];
-    let mut channels = vec![];
-
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            for id in ids {
-                let existing = cache.get(id);
-
-                if let Some(channel) = existing {
-                    channels.push((*channel).clone());
-                } else {
-                    missing.push(id);
-                }
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    if missing.len() == 0 {
-        return Ok(channels);
-    }
-
-    let col = get_collection("channels");
-    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
-        for item in result {
-            let mut cache = CACHE.lock().unwrap();
-            if let Ok(doc) = item {
-                if let Ok(channel) = from_bson(Bson::Document(doc)) as Result<Channel, _> {
-                    cache.put(channel.id.clone(), channel.clone());
-                    channels.push(channel);
-                } else {
-                    return Err("Failed to deserialize channel!".to_string());
-                }
-            } else {
-                return Err("Failed to fetch channel.".to_string());
-            }
-        }
-
-        Ok(channels)
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-impl<'r> FromParam<'r> for Channel {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Ok(result) = fetch_channel(param) {
-            if let Some(channel) = result {
-                Ok(channel)
-            } else {
-                Err(param)
-            }
-        } else {
-            Err(param)
-        }
-    }
-}
-
-use crate::notifications::events::Notification;
-
-pub fn process_event(event: &Notification) {
-    match event {
-        Notification::group_user_join(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            if let Some(channel) = cache.peek_mut(&ev.id) {
-                channel.recipients.as_mut().unwrap().push(ev.user.clone());
-            }
-        }
-        Notification::group_user_leave(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            if let Some(channel) = cache.peek_mut(&ev.id) {
-                let recipients = channel.recipients.as_mut().unwrap();
-                if let Some(pos) = recipients.iter().position(|x| *x == ev.user) {
-                    recipients.remove(pos);
-                }
-            }
-        }
-        Notification::guild_channel_create(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.put(
-                ev.id.clone(),
-                Channel {
-                    id: ev.channel.clone(),
-                    channel_type: 2,
-                    active: None,
-                    last_message: None,
-                    recipients: None,
-                    owner: None,
-                    guild: Some(ev.id.clone()),
-                    name: Some(ev.name.clone()),
-                    description: Some(ev.description.clone()),
-                },
-            );
-        }
-        Notification::guild_channel_delete(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.pop(&ev.channel);
-        }
-        _ => {}
-    }
-}

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

@@ -0,0 +1,43 @@
+// use serde::{Deserialize, Serialize};
+
+/*#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberCompositeKey {
+    pub guild: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Member {
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+    pub nickname: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Invite {
+    pub code: String,
+    pub creator: String,
+    pub channel: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Ban {
+    pub id: String,
+    pub reason: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Guild {
+    #[serde(rename = "_id")]
+    pub id: String,
+    // pub nonce: String, used internally
+    pub name: String,
+    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/guild.rs

@@ -1,336 +0,0 @@
-use super::channel::fetch_channels;
-use super::get_collection;
-
-use lru::LruCache;
-use mongodb::bson::{doc, from_bson, Bson};
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use rocket_contrib::json::JsonValue;
-use serde::{Deserialize, Serialize};
-use std::sync::{Arc, Mutex};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct MemberRef {
-    pub guild: String,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Member {
-    #[serde(rename = "_id")]
-    pub id: MemberRef,
-    pub nickname: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Invite {
-    pub code: String,
-    pub creator: String,
-    pub channel: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Ban {
-    pub id: String,
-    pub reason: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Guild {
-    #[serde(rename = "_id")]
-    pub id: String,
-    // pub nonce: String, used internally
-    pub name: String,
-    pub description: String,
-    pub owner: String,
-
-    pub channels: Vec<String>,
-    pub invites: Vec<Invite>,
-    pub bans: Vec<Ban>,
-
-    pub default_permissions: u32,
-}
-
-impl Guild {
-    pub fn serialise(self) -> JsonValue {
-        json!({
-            "id": self.id,
-            "name": self.name,
-            "description": self.description,
-            "owner": self.owner
-        })
-    }
-
-    pub fn fetch_channels(&self) -> Result<Vec<super::channel::Channel>, String> {
-        super::channel::fetch_channels(&self.channels)
-    }
-
-    pub fn seralise_with_channels(self) -> Result<JsonValue, String> {
-        let channels = self
-            .fetch_channels()?
-            .into_iter()
-            .map(|x| x.serialise())
-            .collect();
-
-        let mut value = self.serialise();
-        value
-            .as_object_mut()
-            .unwrap()
-            .insert("channels".to_string(), channels);
-        Ok(value)
-    }
-}
-
-#[derive(Hash, Eq, PartialEq)]
-pub struct MemberKey(pub String, pub String);
-
-lazy_static! {
-    static ref CACHE: Arc<Mutex<LruCache<String, Guild>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-    static ref MEMBER_CACHE: Arc<Mutex<LruCache<MemberKey, Member>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-}
-
-pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            let existing = cache.get(&id.to_string());
-
-            if let Some(guild) = existing {
-                return Ok(Some((*guild).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("guilds");
-    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
-        if let Some(doc) = result {
-            if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
-                let mut cache = CACHE.lock().unwrap();
-                cache.put(id.to_string(), guild.clone());
-
-                Ok(Some(guild))
-            } else {
-                Err("Failed to deserialize guild!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch guild from database.".to_string())
-    }
-}
-
-pub fn fetch_guilds(ids: &Vec<String>) -> Result<Vec<Guild>, String> {
-    let mut missing = vec![];
-    let mut guilds = vec![];
-
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            for id in ids {
-                let existing = cache.get(id);
-
-                if let Some(guild) = existing {
-                    guilds.push((*guild).clone());
-                } else {
-                    missing.push(id);
-                }
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    if missing.len() == 0 {
-        return Ok(guilds);
-    }
-
-    let col = get_collection("guilds");
-    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
-        for item in result {
-            let mut cache = CACHE.lock().unwrap();
-            if let Ok(doc) = item {
-                if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
-                    cache.put(guild.id.clone(), guild.clone());
-                    guilds.push(guild);
-                } else {
-                    return Err("Failed to deserialize guild!".to_string());
-                }
-            } else {
-                return Err("Failed to fetch guild.".to_string());
-            }
-        }
-
-        Ok(guilds)
-    } else {
-        Err("Failed to fetch channel from database.".to_string())
-    }
-}
-
-pub fn serialise_guilds_with_channels(ids: &Vec<String>) -> Result<Vec<JsonValue>, String> {
-    let guilds = fetch_guilds(&ids)?;
-    let cids: Vec<String> = guilds.iter().flat_map(|x| x.channels.clone()).collect();
-
-    let channels = fetch_channels(&cids)?;
-    Ok(guilds
-        .into_iter()
-        .map(|x| {
-            let id = x.id.clone();
-            let mut obj = x.serialise();
-            obj.as_object_mut().unwrap().insert(
-                "channels".to_string(),
-                channels
-                    .iter()
-                    .filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
-                    .map(|x| x.clone().serialise())
-                    .collect(),
-            );
-            obj
-        })
-        .collect())
-}
-
-pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
-    {
-        if let Ok(mut cache) = MEMBER_CACHE.lock() {
-            let existing = cache.get(&key);
-
-            if let Some(member) = existing {
-                return Ok(Some((*member).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("members");
-    if let Ok(result) = col.find_one(
-        doc! {
-            "_id.guild": &key.0,
-            "_id.user": &key.1,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            if let Ok(member) = from_bson(Bson::Document(doc)) as Result<Member, _> {
-                let mut cache = MEMBER_CACHE.lock().unwrap();
-                cache.put(key, member.clone());
-
-                Ok(Some(member))
-            } else {
-                Err("Failed to deserialize member!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch member from database.".to_string())
-    }
-}
-
-impl<'r> FromParam<'r> for Guild {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Ok(result) = fetch_guild(param) {
-            if let Some(channel) = result {
-                Ok(channel)
-            } else {
-                Err(param)
-            }
-        } else {
-            Err(param)
-        }
-    }
-}
-
-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) = get_collection("guilds").find_one(
-        doc,
-        mongodb::options::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
-    }
-}
-
-use crate::notifications::events::Notification;
-
-pub fn process_event(event: &Notification) {
-    match event {
-        Notification::guild_channel_create(_ev) => {} // ? for later use
-        Notification::guild_channel_delete(_ev) => {} // ? for later use
-        Notification::guild_delete(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            cache.pop(&ev.id);
-        }
-        Notification::guild_user_join(ev) => {
-            let mut cache = MEMBER_CACHE.lock().unwrap();
-            cache.put(
-                MemberKey(ev.id.clone(), ev.user.clone()),
-                Member {
-                    id: MemberRef {
-                        guild: ev.id.clone(),
-                        user: ev.user.clone(),
-                    },
-                    nickname: None,
-                },
-            );
-        }
-        Notification::guild_user_leave(ev) => {
-            let mut cache = MEMBER_CACHE.lock().unwrap();
-            cache.pop(&MemberKey(ev.id.clone(), ev.user.clone()));
-        }
-        _ => {}
-    }
-}

src/database/message.rs

@@ -1,109 +0,0 @@
-use super::get_collection;
-use crate::database::channel::Channel;
-use crate::notifications;
-use crate::notifications::events::message::Create;
-use crate::notifications::events::Notification;
-use crate::routes::channel::ChannelType;
-
-use mongodb::bson::from_bson;
-use mongodb::bson::{doc, to_bson, Bson, DateTime};
-use rocket::http::RawStr;
-use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PreviousEntry {
-    pub content: String,
-    pub time: DateTime,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Message {
-    #[serde(rename = "_id")]
-    pub id: String,
-    pub nonce: Option<String>,
-    pub channel: String,
-    pub author: String,
-
-    pub content: String,
-    pub edited: Option<DateTime>,
-
-    pub previous_content: Vec<PreviousEntry>,
-}
-
-// ? TODO: write global send message
-// ? pub fn send_message();
-// ? handle websockets?
-impl Message {
-    pub fn send(&self, target: &Channel) -> bool {
-        if get_collection("messages")
-            .insert_one(to_bson(&self).unwrap().as_document().unwrap().clone(), None)
-            .is_ok()
-        {
-            notifications::send_message_given_channel(
-                Notification::message_create(Create {
-                    id: self.id.clone(),
-                    nonce: self.nonce.clone(),
-                    channel: self.channel.clone(),
-                    author: self.author.clone(),
-                    content: self.content.clone(),
-                }),
-                &target,
-            );
-
-            let short_content: String = self.content.chars().take(24).collect();
-
-            // !! 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": &self.id,
-                            "user_id": &self.author,
-                            "short_content": short_content,
-                        }
-                    }
-                };
-
-                if target.channel_type == ChannelType::DM as u8 {
-                    update
-                        .get_document_mut("$set")
-                        .unwrap()
-                        .insert("active", true);
-                }
-
-                if get_collection("channels")
-                    .update_one(doc! { "_id": &target.id }, update, None)
-                    .is_ok()
-                {
-                    true
-                } else {
-                    false
-                }
-            } else {
-                true
-            }
-        } else {
-            false
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for Message {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        let col = get_collection("messages");
-        let result = col
-            .find_one(doc! { "_id": param.to_string() }, None)
-            .unwrap();
-
-        if let Some(message) = result {
-            Ok(from_bson(Bson::Document(message)).expect("Failed to unwrap message."))
-        } else {
-            Err(param)
-        }
-    }
-}

src/database/migrations/init.rs

@@ -5,21 +5,28 @@ use log::info;
 use mongodb::bson::doc;
 use mongodb::options::CreateCollectionOptions;
 
-pub fn create_database() {
+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("guilds", None)
+
-        .expect("Failed to create guilds collection.");
-    db.create_collection("members", None)
-        .expect("Failed to create members 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(
@@ -29,8 +36,64 @@ pub fn create_database() {
             .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! {
@@ -39,6 +102,7 @@ pub fn create_database() {
             },
             None,
         )
+        .await
         .expect("Failed to save migration info.");
 
     info!("Created database.");

src/database/migrations/mod.rs

@@ -3,16 +3,17 @@ use super::get_connection;
 pub mod init;
 pub mod scripts;
 
-pub fn run_migrations() {
+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();
+        init::create_database().await;
     } else {
-        scripts::migrate_database();
+        scripts::migrate_database().await;
     }
 }

src/database/migrations/scripts.rs

@@ -1,8 +1,7 @@
-use super::super::get_collection;
+use crate::database::get_collection;
 
 use log::info;
-use mongodb::bson::{doc, from_bson, Bson};
+use mongodb::bson::{doc, from_document};
-use mongodb::options::FindOptions;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -11,19 +10,20 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 2;
+pub const LATEST_REVISION: i32 = 0;
 
-pub fn migrate_database() {
+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_bson(Bson::Document(doc)).expect("Failed to read migration information.");
+            from_document(doc).expect("Failed to read migration information.");
 
-        let revision = run_migrations(info.revision);
+        let revision = run_migrations(info.revision).await;
 
         migrations
             .update_one(
@@ -37,6 +37,7 @@ pub fn migrate_database() {
                 },
                 None,
             )
+            .await
             .expect("Failed to commit migration information.");
 
         info!("Migration complete. Currently at revision {}.", revision);
@@ -45,75 +46,13 @@ pub fn migrate_database() {
     }
 }
 
-pub fn run_migrations(revision: i32) -> i32 {
+pub async fn run_migrations(revision: i32) -> i32 {
     info!("Starting database migration.");
 
     if revision <= 0 {
         info!("Running migration [revision 0]: Test migration system.");
     }
 
-    if revision <= 1 {
-        info!("Running migration [revision 1]: Add channels to guild object.");
-
-        let col = get_collection("guilds");
-        let guilds = col
-            .find(
-                None,
-                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-            )
-            .expect("Failed to fetch guilds.");
-
-        let result = get_collection("channels")
-            .find(
-                doc! {
-                    "type": 2
-                },
-                FindOptions::builder()
-                    .projection(doc! { "_id": 1, "guild": 1 })
-                    .build(),
-            )
-            .expect("Failed to fetch channels.");
-
-        let mut channels = vec![];
-        for doc in result {
-            let channel = doc.expect("Failed to fetch channel.");
-            let id = channel
-                .get_str("_id")
-                .expect("Failed to get channel id.")
-                .to_string();
-            let gid = channel
-                .get_str("guild")
-                .expect("Failed to get guild id.")
-                .to_string();
-
-            channels.push((id, gid));
-        }
-
-        for doc in guilds {
-            let guild = doc.expect("Failed to fetch guild.");
-            let id = guild.get_str("_id").expect("Failed to get guild id.");
-
-            let list: Vec<String> = channels
-                .iter()
-                .filter(|x| x.1 == id)
-                .map(|x| x.0.clone())
-                .collect();
-
-            col.update_one(
-                doc! {
-                    "_id": id
-                },
-                doc! {
-                    "$set": {
-                        "channels": list
-                    }
-                },
-                None,
-            )
-            .expect("Failed to update guild.");
-        }
-    }
-
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION
 }

src/database/mod.rs

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

src/database/mutual.rs

@@ -1,129 +0,0 @@
-use super::{get_collection, MemberPermissions};
-
-use mongodb::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,228 +0,0 @@
-use super::mutual::has_mutual_connection;
-use crate::database::channel::Channel;
-use crate::database::guild::{fetch_guild, fetch_member, Guild, Member, MemberKey};
-use crate::database::user::{User, UserRelationship};
-
-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: &User, b: &User) -> Relationship {
-    if a.id == b.id {
-        return Relationship::SELF;
-    }
-
-    get_relationship_internal(&a.id, &b.id, &a.relations)
-}
-
-pub struct PermissionCalculator {
-    pub user: User,
-    pub channel: Option<Channel>,
-    pub guild: Option<Guild>,
-    pub member: Option<Member>,
-}
-
-impl PermissionCalculator {
-    pub fn new(user: User) -> PermissionCalculator {
-        PermissionCalculator {
-            user,
-            channel: None,
-            guild: None,
-            member: None,
-        }
-    }
-
-    pub fn channel(self, channel: Channel) -> PermissionCalculator {
-        PermissionCalculator {
-            channel: Some(channel),
-            ..self
-        }
-    }
-
-    pub fn guild(self, guild: Guild) -> 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 {
-                        if let Ok(result) = fetch_guild(id) {
-                            result
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    }
-                }
-                _ => None,
-            }
-        } else {
-            None
-        };
-
-        if let Some(guild) = &guild {
-            if let Ok(result) = fetch_member(MemberKey(guild.id.clone(), self.user.id.clone())) {
-                self.member = result;
-            }
-        }
-
-        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 = None;
-                        for item in arr {
-                            if item != &self.user.id {
-                                other_user = Some(item);
-                            }
-                        }
-
-                        if let Some(other) = other_user {
-                            let relationship = get_relationship_internal(
-                                &self.user.id,
-                                &other,
-                                &self.user.relations,
-                            );
-
-                            if relationship == Relationship::Friend {
-                                permissions = 1024 + 128 + 32 + 16 + 1;
-                            } else if relationship == Relationship::Blocked
-                                || relationship == Relationship::BlockedOther
-                            {
-                                permissions = 1;
-                            } else if has_mutual_connection(&self.user.id, other, true) {
-                                permissions = 1024 + 128 + 32 + 16 + 1;
-                            } else {
-                                permissions = 1;
-                            }
-                        } else {
-                            // ? In this case, it is a "self DM".
-                            return 1024 + 128 + 32 + 16 + 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,300 +0,0 @@
-use super::channel::fetch_channels;
-use super::get_collection;
-use super::guild::serialise_guilds_with_channels;
-
-use lru::LruCache;
-use mongodb::bson::{doc, from_bson, Bson, DateTime};
-use mongodb::options::FindOptions;
-use rocket::http::{RawStr, Status};
-use rocket::request::{self, FromParam, FromRequest, Request};
-use rocket::Outcome;
-use rocket_contrib::json::JsonValue;
-use serde::{Deserialize, Serialize};
-use std::sync::{Arc, Mutex};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserEmailVerification {
-    pub verified: bool,
-    pub target: Option<String>,
-    pub expiry: Option<DateTime>,
-    pub rate_limit: Option<DateTime>,
-    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 display_name: String,
-    pub access_token: Option<String>,
-    pub email_verification: UserEmailVerification,
-    pub relations: Option<Vec<UserRelationship>>,
-}
-
-impl User {
-    pub fn serialise(self, relationship: i32) -> JsonValue {
-        if relationship == super::Relationship::SELF as i32 {
-            json!({
-                "id": self.id,
-                "username": self.username,
-                "display_name": self.display_name,
-                "email": self.email,
-                "verified": self.email_verification.verified,
-            })
-        } else {
-            json!({
-                "id": self.id,
-                "username": self.username,
-                "display_name": self.display_name,
-                "relationship": relationship
-            })
-        }
-    }
-
-    pub fn find_guilds(&self) -> Result<Vec<String>, String> {
-        let members = get_collection("members")
-            .find(
-                doc! {
-                    "_id.user": &self.id
-                },
-                None,
-            )
-            .map_err(|_| "Failed to fetch members.")?;
-
-        Ok(members
-            .into_iter()
-            .filter_map(|x| match x {
-                Ok(doc) => match doc.get_document("_id") {
-                    Ok(id) => match id.get_str("guild") {
-                        Ok(value) => Some(value.to_string()),
-                        Err(_) => None,
-                    },
-                    Err(_) => None,
-                },
-                Err(_) => None,
-            })
-            .collect())
-    }
-
-    pub fn find_dms(&self) -> Result<Vec<String>, String> {
-        let channels = get_collection("channels")
-            .find(
-                doc! {
-                    "recipients": &self.id
-                },
-                FindOptions::builder().projection(doc! { "_id": 1 }).build(),
-            )
-            .map_err(|_| "Failed to fetch channel ids.")?;
-
-        Ok(channels
-            .into_iter()
-            .filter_map(|x| x.ok())
-            .filter_map(|x| match x.get_str("_id") {
-                Ok(value) => Some(value.to_string()),
-                Err(_) => None,
-            })
-            .collect())
-    }
-
-    pub fn create_payload(self) -> Result<JsonValue, String> {
-        let v = vec![];
-        let relations = self.relations.as_ref().unwrap_or(&v);
-
-        let users: Vec<JsonValue> = fetch_users(&relations.iter().map(|x| x.id.clone()).collect())?
-            .into_iter()
-            .map(|x| {
-                let id = x.id.clone();
-                x.serialise(relations.iter().find(|y| y.id == id).unwrap().status as i32)
-            })
-            .collect();
-
-        let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
-            .into_iter()
-            .map(|x| x.serialise())
-            .collect();
-
-        Ok(json!({
-            "users": users,
-            "channels": channels,
-            "guilds": serialise_guilds_with_channels(&self.find_guilds()?)?,
-            "user": self.serialise(super::Relationship::SELF as i32)
-        }))
-    }
-}
-
-lazy_static! {
-    static ref CACHE: Arc<Mutex<LruCache<String, User>>> =
-        Arc::new(Mutex::new(LruCache::new(4_000_000)));
-}
-
-pub fn fetch_user(id: &str) -> Result<Option<User>, String> {
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            let existing = cache.get(&id.to_string());
-
-            if let Some(user) = existing {
-                return Ok(Some((*user).clone()));
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    let col = get_collection("users");
-    if let Ok(result) = col.find_one(doc! { "_id": id }, None) {
-        if let Some(doc) = result {
-            if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
-                let mut cache = CACHE.lock().unwrap();
-                cache.put(id.to_string(), user.clone());
-
-                Ok(Some(user))
-            } else {
-                Err("Failed to deserialize user!".to_string())
-            }
-        } else {
-            Ok(None)
-        }
-    } else {
-        Err("Failed to fetch user from database.".to_string())
-    }
-}
-
-pub fn fetch_users(ids: &Vec<String>) -> Result<Vec<User>, String> {
-    let mut missing = vec![];
-    let mut users = vec![];
-
-    {
-        if let Ok(mut cache) = CACHE.lock() {
-            for id in ids {
-                let existing = cache.get(id);
-
-                if let Some(user) = existing {
-                    users.push((*user).clone());
-                } else {
-                    missing.push(id);
-                }
-            }
-        } else {
-            return Err("Failed to lock cache.".to_string());
-        }
-    }
-
-    if missing.len() == 0 {
-        return Ok(users);
-    }
-
-    let col = get_collection("users");
-    if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
-        for item in result {
-            let mut cache = CACHE.lock().unwrap();
-            if let Ok(doc) = item {
-                if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
-                    cache.put(user.id.clone(), user.clone());
-                    users.push(user);
-                } else {
-                    return Err("Failed to deserialize user!".to_string());
-                }
-            } else {
-                return Err("Failed to fetch user.".to_string());
-            }
-        }
-
-        Ok(users)
-    } else {
-        Err("Failed to fetch user from database.".to_string())
-    }
-}
-
-#[derive(Debug)]
-pub enum AuthError {
-    Failed,
-    Missing,
-    Invalid,
-}
-
-impl<'a, 'r> FromRequest<'a, 'r> for User {
-    type Error = AuthError;
-
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let u = request.headers().get("x-user").next();
-        let t = request.headers().get("x-auth-token").next();
-
-        if let Some(uid) = u {
-            if let Some(token) = t {
-                if let Ok(result) = fetch_user(uid) {
-                    if let Some(user) = result {
-                        if let Some(access_token) = &user.access_token {
-                            if access_token == token {
-                                Outcome::Success(user)
-                            } else {
-                                Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                            }
-                        } else {
-                            Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                        }
-                    } else {
-                        Outcome::Failure((Status::Forbidden, AuthError::Invalid))
-                    }
-                } else {
-                    Outcome::Failure((Status::Forbidden, AuthError::Failed))
-                }
-            } else {
-                Outcome::Failure((Status::Forbidden, AuthError::Missing))
-            }
-        } else {
-            Outcome::Failure((Status::Forbidden, AuthError::Missing))
-        }
-    }
-}
-
-impl<'r> FromParam<'r> for User {
-    type Error = &'r RawStr;
-
-    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
-        if let Ok(result) = fetch_user(&param.to_string()) {
-            if let Some(user) = result {
-                Ok(user)
-            } else {
-                Err(param)
-            }
-        } else {
-            Err(param)
-        }
-    }
-}
-
-use crate::notifications::events::Notification;
-
-pub fn process_event(event: &Notification) {
-    match event {
-        Notification::user_friend_status(ev) => {
-            let mut cache = CACHE.lock().unwrap();
-            if let Some(user) = cache.peek_mut(&ev.id) {
-                if let Some(relations) = user.relations.as_mut() {
-                    if ev.status == 0 {
-                        if let Some(pos) = relations.iter().position(|x| x.id == ev.user) {
-                            relations.remove(pos);
-                        }
-                    } else if let Some(entry) = relations.iter_mut().find(|x| x.id == ev.user) {
-                        entry.status = ev.status as u8;
-                    } else {
-                        relations.push(UserRelationship {
-                            id: ev.id.clone(),
-                            status: ev.status as u8,
-                        });
-                    }
-                }
-            }
-        }
-        _ => {}
-    }
-}

src/main.rs

@@ -1,50 +1,92 @@
 #![feature(proc_macro_hygiene, decl_macro)]
+#![feature(async_closure)]
 
 #[macro_use]
 extern crate rocket;
 #[macro_use]
 extern crate rocket_contrib;
 #[macro_use]
-extern crate bitfield;
-#[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 notifications;
 pub mod routes;
 pub mod util;
 
-use rocket_cors::AllowedOrigins;
+use chrono::Duration;
-use std::thread;
+use futures::join;
 use log::info;
+use rauth::auth::Auth;
+use rauth::options::{EmailVerification, Options, SMTP};
+use rocket_cors::AllowedOrigins;
+use util::variables::{PUBLIC_URL, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME, USE_EMAIL};
 
-fn main() {
+#[async_std::main]
+async fn main() {
     dotenv::dotenv().ok();
-    env_logger::init_from_env(
+    env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "info"));
-        env_logger::Env::default()
-            .filter_or("RUST_LOG", "info")
-    );
 
     info!("Starting REVOLT server.");
 
     util::variables::preflight_checks();
-    database::connect();
+    database::connect().await;
-    notifications::start_worker();
+    notifications::hive::init_hive().await;
 
-    thread::spawn(|| {
+    ctrlc::set_handler(move || {
-        notifications::pubsub::launch_subscriber();
+        // Force ungraceful exit to avoid hang.
-    });
+        std::process::exit(0);
+    })
+    .expect("Error setting Ctrl-C handler");
 
-    thread::spawn(|| {
+    join!(
-        notifications::ws::launch_server();
+        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
+            }),
+    );
+
+    routes::mount(rocket::ignite())
+        .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/events/groups.rs

@@ -1,13 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserJoin {
-    pub id: String,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserLeave {
-    pub id: String,
-    pub user: String,
-}

src/notifications/events/guilds.rs

@@ -1,33 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserJoin {
-    pub id: String,
-    pub user: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserLeave {
-    pub id: String,
-    pub user: String,
-    pub banned: bool,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ChannelCreate {
-    pub id: String,
-    pub channel: String,
-    pub name: String,
-    pub description: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ChannelDelete {
-    pub id: String,
-    pub channel: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Delete {
-    pub id: String,
-}

src/notifications/events/message.rs

@@ -1,23 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Create {
-    pub id: String,
-    pub nonce: Option<String>,
-    pub channel: String,
-    pub author: String,
-    pub content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Edit {
-    pub id: String,
-    pub channel: String,
-    pub author: String,
-    pub content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Delete {
-    pub id: String,
-}

src/notifications/events/mod.rs

@@ -1,47 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-
-pub mod groups;
-pub mod guilds;
-pub mod message;
-pub mod users;
-
-#[allow(non_camel_case_types)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Notification {
-    message_create(message::Create),
-    message_edit(message::Edit),
-    message_delete(message::Delete),
-    group_user_join(groups::UserJoin),
-    group_user_leave(groups::UserLeave),
-    guild_user_join(guilds::UserJoin),
-    guild_user_leave(guilds::UserLeave),
-    guild_channel_create(guilds::ChannelCreate),
-    guild_channel_delete(guilds::ChannelDelete),
-    guild_delete(guilds::Delete),
-    user_friend_status(users::FriendStatus),
-}
-
-impl Notification {
-    pub fn serialize(self) -> String {
-        if let Value::Object(obj) = json!(self) {
-            let (key, value) = obj.iter().next().unwrap();
-
-            if let Value::Object(data) = value {
-                let mut data = data.clone();
-                data.insert("type".to_string(), Value::String(key.to_string()));
-                json!(data).to_string()
-            } else {
-                unreachable!()
-            }
-        } else {
-            unreachable!()
-        }
-    }
-
-    pub fn push_to_cache(&self) {
-        crate::database::channel::process_event(&self);
-        crate::database::guild::process_event(&self);
-        crate::database::user::process_event(&self);
-    }
-}

src/notifications/events/users.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct FriendStatus {
-    pub id: String,
-    pub user: String,
-    pub status: i32,
-}

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

@@ -1,76 +1,5 @@
-use crate::database::channel::Channel;
-
-use once_cell::sync::OnceCell;
-use std::sync::mpsc::{channel, Sender};
-use std::thread;
-
 pub mod events;
-pub mod pubsub;
+pub mod hive;
-pub mod state;
+pub mod payload;
-pub mod ws;
+pub mod subscriptions;
-
+pub mod websocket;
-pub fn send_message<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
-    users: U,
-    guild: G,
-    data: events::Notification,
-) -> bool {
-    let users = users.into();
-    let guild = guild.into();
-
-    data.push_to_cache();
-
-    if pubsub::send_message(users.clone(), guild.clone(), data.clone()) {
-        state::send_message(users, guild, data.serialize());
-
-        true
-    } else {
-        false
-    }
-}
-
-struct NotificationArguments {
-    users: Option<Vec<String>>,
-    guild: Option<String>,
-    data: events::Notification,
-}
-
-static mut SENDER: OnceCell<Sender<NotificationArguments>> = OnceCell::new();
-
-pub fn start_worker() {
-    let (sender, receiver) = channel();
-    unsafe {
-        SENDER.set(sender).unwrap();
-    }
-
-    thread::spawn(move || {
-        while let Ok(data) = receiver.recv() {
-            send_message(data.users, data.guild, data.data);
-        }
-    });
-}
-
-pub fn send_message_threaded<U: Into<Option<Vec<String>>>, G: Into<Option<String>>>(
-    users: U,
-    guild: G,
-    data: events::Notification,
-) -> bool {
-    unsafe {
-        SENDER
-            .get()
-            .unwrap()
-            .send(NotificationArguments {
-                users: users.into(),
-                guild: guild.into(),
-                data,
-            })
-            .is_ok()
-    }
-}
-
-pub fn send_message_given_channel(data: events::Notification, channel: &Channel) {
-    match channel.channel_type {
-        0..=1 => send_message_threaded(channel.recipients.clone(), None, data),
-        2 => send_message_threaded(None, channel.guild.clone(), data),
-        _ => unreachable!(),
-    };
-}

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/pubsub.rs

@@ -1,102 +0,0 @@
-use super::events::Notification;
-use crate::database::get_collection;
-
-use mongodb::bson::{doc, from_bson, to_bson, Bson};
-use mongodb::options::{CursorType, FindOneOptions, FindOptions};
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use ulid::Ulid;
-
-use once_cell::sync::OnceCell;
-static SOURCEID: OnceCell<String> = OnceCell::new();
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct PubSubMessage {
-    #[serde(rename = "_id")]
-    id: String,
-    source: String,
-
-    user_recipients: Option<Vec<String>>,
-    target_guild: Option<String>,
-    data: Notification,
-}
-
-pub fn send_message(users: Option<Vec<String>>, guild: Option<String>, data: Notification) -> bool {
-    let message = PubSubMessage {
-        id: Ulid::new().to_string(),
-        source: SOURCEID.get().unwrap().to_string(),
-        user_recipients: users.into(),
-        target_guild: guild.into(),
-        data,
-    };
-
-    if get_collection("pubsub")
-        .insert_one(
-            to_bson(&message)
-                .expect("Failed to serialize pubsub message.")
-                .as_document()
-                .expect("Failed to convert to a document.")
-                .clone(),
-            None,
-        )
-        .is_ok()
-    {
-        true
-    } else {
-        false
-    }
-}
-
-pub fn launch_subscriber() {
-    let source = Ulid::new().to_string();
-    SOURCEID
-        .set(source.clone())
-        .expect("Failed to create and set source ID.");
-
-    let pubsub = get_collection("pubsub");
-    if let Ok(result) = pubsub.find_one(
-        doc! {},
-        FindOneOptions::builder().sort(doc! { "_id": -1 }).build(),
-    ) {
-        let query = if let Some(doc) = result {
-            doc! { "_id": { "$gt": doc.get_str("_id").unwrap() } }
-        } else {
-            doc! {}
-        };
-
-        if let Ok(mut cursor) = pubsub.find(
-            query,
-            FindOptions::builder()
-                .cursor_type(CursorType::TailableAwait)
-                .no_cursor_timeout(true)
-                .max_await_time(Duration::from_secs(1200))
-                .build(),
-        ) {
-            loop {
-                while let Some(item) = cursor.next() {
-                    if let Ok(doc) = item {
-                        if let Ok(message) =
-                            from_bson(Bson::Document(doc)) as Result<PubSubMessage, _>
-                        {
-                            if &message.source != &source {
-                                super::state::send_message(
-                                    message.user_recipients,
-                                    message.target_guild,
-                                    message.data.serialize(),
-                                );
-                            }
-                        } else {
-                            eprintln!("Failed to deserialize pubsub message.");
-                        }
-                    } else {
-                        eprintln!("Failed to unwrap a document from pubsub.");
-                    }
-                }
-            }
-        } else {
-            eprintln!("Failed to open subscriber cursor.");
-        }
-    } else {
-        eprintln!("Failed to fetch latest document from pubsub collection.");
-    }
-}

src/notifications/state.rs

@@ -1,205 +0,0 @@
-use crate::database;
-use crate::util::vec_to_set;
-
-use hashbrown::{HashMap, HashSet};
-use mongodb::bson::doc;
-use mongodb::options::FindOneOptions;
-use once_cell::sync::OnceCell;
-use std::sync::RwLock;
-use ws::Sender;
-
-pub enum StateResult {
-    DatabaseError,
-    InvalidToken,
-    Success(String),
-}
-
-static mut CONNECTIONS: OnceCell<RwLock<HashMap<String, Sender>>> = OnceCell::new();
-
-pub fn add_connection(id: String, sender: Sender) {
-    unsafe {
-        CONNECTIONS
-            .get()
-            .unwrap()
-            .write()
-            .unwrap()
-            .insert(id, sender);
-    }
-}
-
-pub struct User {
-    connections: HashSet<String>,
-    guilds: HashSet<String>,
-}
-
-impl User {
-    pub fn new() -> User {
-        User {
-            connections: HashSet::new(),
-            guilds: HashSet::new(),
-        }
-    }
-}
-
-pub struct Guild {
-    users: HashSet<String>,
-}
-
-impl Guild {
-    pub fn new() -> Guild {
-        Guild {
-            users: HashSet::new(),
-        }
-    }
-}
-
-pub struct GlobalState {
-    users: HashMap<String, User>,
-    guilds: HashMap<String, Guild>,
-}
-
-impl GlobalState {
-    pub fn new() -> GlobalState {
-        GlobalState {
-            users: HashMap::new(),
-            guilds: HashMap::new(),
-        }
-    }
-
-    pub fn push_to_guild(&mut self, guild: String, user: String) {
-        if !self.guilds.contains_key(&guild) {
-            self.guilds.insert(guild.clone(), Guild::new());
-        }
-
-        self.guilds.get_mut(&guild).unwrap().users.insert(user);
-    }
-
-    pub fn try_authenticate(&mut self, connection: String, access_token: String) -> StateResult {
-        if let Ok(result) = database::get_collection("users").find_one(
-            doc! {
-                "access_token": access_token,
-            },
-            FindOneOptions::builder()
-                .projection(doc! { "_id": 1 })
-                .build(),
-        ) {
-            if let Some(user) = result {
-                let user_id = user.get_str("_id").unwrap();
-
-                if self.users.contains_key(user_id) {
-                    self.users
-                        .get_mut(user_id)
-                        .unwrap()
-                        .connections
-                        .insert(connection);
-
-                    return StateResult::Success(user_id.to_string());
-                }
-
-                if let Ok(results) =
-                    database::get_collection("members").find(doc! { "_id.user": &user_id }, None)
-                {
-                    let mut guilds = vec![];
-                    for result in results {
-                        if let Ok(entry) = result {
-                            guilds.push(
-                                entry
-                                    .get_document("_id")
-                                    .unwrap()
-                                    .get_str("guild")
-                                    .unwrap()
-                                    .to_string(),
-                            );
-                        }
-                    }
-
-                    let mut user = User::new();
-                    for guild in guilds {
-                        user.guilds.insert(guild.clone());
-                        self.push_to_guild(guild, user_id.to_string());
-                    }
-
-                    user.connections.insert(connection);
-                    self.users.insert(user_id.to_string(), user);
-
-                    StateResult::Success(user_id.to_string())
-                } else {
-                    StateResult::DatabaseError
-                }
-            } else {
-                StateResult::InvalidToken
-            }
-        } else {
-            StateResult::DatabaseError
-        }
-    }
-
-    pub fn disconnect<U: Into<Option<String>>>(&mut self, user_id: U, connection: String) {
-        if let Some(user_id) = user_id.into() {
-            let user = self.users.get_mut(&user_id).unwrap();
-            user.connections.remove(&connection);
-
-            if user.connections.len() == 0 {
-                for guild in &user.guilds {
-                    self.guilds.get_mut(guild).unwrap().users.remove(&user_id);
-                }
-
-                self.users.remove(&user_id);
-            }
-        }
-
-        unsafe {
-            CONNECTIONS
-                .get()
-                .unwrap()
-                .write()
-                .unwrap()
-                .remove(&connection);
-        }
-    }
-}
-
-pub static mut DATA: OnceCell<RwLock<GlobalState>> = OnceCell::new();
-
-pub fn init() {
-    unsafe {
-        if CONNECTIONS.set(RwLock::new(HashMap::new())).is_err() {
-            panic!("Failed to set global connections map.");
-        }
-
-        if DATA.set(RwLock::new(GlobalState::new())).is_err() {
-            panic!("Failed to set global state.");
-        }
-    }
-}
-
-pub fn send_message(users: Option<Vec<String>>, guild: Option<String>, data: String) {
-    let state = unsafe { DATA.get().unwrap().read().unwrap() };
-    let mut connections = HashSet::new();
-
-    let mut users = vec_to_set(&users.unwrap_or(vec![]));
-    if let Some(guild) = guild {
-        if let Some(entry) = state.guilds.get(&guild) {
-            for user in &entry.users {
-                users.insert(user.to_string());
-            }
-        }
-    }
-
-    for user in users {
-        if let Some(entry) = state.users.get(&user) {
-            for connection in &entry.connections {
-                connections.insert(connection.clone());
-            }
-        }
-    }
-
-    let targets = unsafe { CONNECTIONS.get().unwrap().read().unwrap() };
-    for conn in connections {
-        if let Some(sender) = targets.get(&conn) {
-            if sender.send(data.clone()).is_err() {
-                eprintln!("Failed to send a notification to a websocket. [{}]", &conn);
-            }
-        }
-    }
-}

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/notifications/ws.rs

@@ -1,135 +0,0 @@
-use super::state::{self, StateResult};
-use crate::util::variables::WS_HOST;
-
-use serde_json::{from_str, json, Value};
-use ulid::Ulid;
-use ws::{listen, CloseCode, Error, Handler, Handshake, Message, Result, Sender};
-
-struct Server {
-    sender: Sender,
-    user_id: Option<String>,
-    id: String,
-}
-
-impl Handler for Server {
-    fn on_open(&mut self, _: Handshake) -> Result<()> {
-        state::add_connection(self.id.clone(), self.sender.clone());
-        Ok(())
-    }
-
-    fn on_message(&mut self, msg: Message) -> Result<()> {
-        if let Message::Text(text) = msg {
-            if let Ok(data) = from_str(&text) as std::result::Result<Value, _> {
-                if let Value::String(packet_type) = &data["type"] {
-                    if packet_type == "authenticate" {
-                        if self.user_id.is_some() {
-                            self.sender.send(
-                                json!({
-                                    "type": "authenticate",
-                                    "success": false,
-                                    "error": "Already authenticated!"
-                                })
-                                .to_string(),
-                            )
-                        } else if let Value::String(token) = &data["token"] {
-                            let mut state = unsafe { state::DATA.get().unwrap().write().unwrap() };
-
-                            match state.try_authenticate(self.id.clone(), token.to_string()) {
-                                StateResult::Success(user_id) => {
-                                    let user = crate::database::user::fetch_user(&user_id)
-                                        .unwrap()
-                                        .unwrap();
-                                    self.user_id = Some(user_id);
-
-                                    self.sender.send(
-                                        json!({
-                                            "type": "authenticate",
-                                            "success": true,
-                                        })
-                                        .to_string(),
-                                    )?;
-
-                                    if let Ok(payload) = user.create_payload() {
-                                        self.sender.send(
-                                            json!({
-                                                "type": "ready",
-                                                "data": payload
-                                            })
-                                            .to_string(),
-                                        )
-                                    } else {
-                                        // ! TODO: FIXME: ALL THE NOTIFICATIONS CODE NEEDS TO BE
-                                        // ! RESTRUCTURED, IT IS UTTER GARBAGE. :)))))
-
-                                        Ok(())
-                                    }
-                                }
-                                StateResult::DatabaseError => self.sender.send(
-                                    json!({
-                                        "type": "authenticate",
-                                        "success": false,
-                                        "error": "Had database error."
-                                    })
-                                    .to_string(),
-                                ),
-                                StateResult::InvalidToken => self.sender.send(
-                                    json!({
-                                        "type": "authenticate",
-                                        "success": false,
-                                        "error": "Invalid token."
-                                    })
-                                    .to_string(),
-                                ),
-                            }
-                        } else {
-                            self.sender.send(
-                                json!({
-                                    "type": "authenticate",
-                                    "success": false,
-                                    "error": "Token not present."
-                                })
-                                .to_string(),
-                            )
-                        }
-                    } else {
-                        Ok(())
-                    }
-                } else {
-                    Ok(())
-                }
-            } else {
-                Ok(())
-            }
-        } else {
-            Ok(())
-        }
-    }
-
-    fn on_close(&mut self, _code: CloseCode, _reason: &str) {
-        unsafe {
-            state::DATA
-                .get()
-                .unwrap()
-                .write()
-                .unwrap()
-                .disconnect(self.user_id.clone(), self.id.clone());
-        }
-
-        println!("User disconnected. [{}]", self.id);
-    }
-
-    fn on_error(&mut self, err: Error) {
-        println!("The server encountered an error: {:?}", err);
-    }
-}
-
-pub fn launch_server() {
-    state::init();
-
-    listen(WS_HOST.to_string(), |sender| Server {
-        sender,
-        user_id: None,
-        id: Ulid::new().to_string(),
-    })
-    .unwrap()
-}

src/routes/account.rs

@@ -1,355 +0,0 @@
-use super::Response;
-use crate::database;
-use crate::util::{captcha, email, gen_token};
-use crate::util::variables::{DISABLE_REGISTRATION, USE_EMAIL};
-
-use bcrypt::{hash, verify};
-use chrono::prelude::*;
-use database::user::User;
-use log::error;
-use mongodb::bson::{doc, from_bson, Bson};
-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,
-    captcha: Option<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 {
-    if let Err(error) = captcha::verify(&info.captcha) {
-        return Response::BadRequest(json!({ "error": error }));
-    }
-
-    if *DISABLE_REGISTRATION {
-        return Response::BadRequest(json!({ "error": "Registration disabled." }));
-    }
-
-    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 Some(_) = col
-        .find_one(doc! { "username": info.username.clone() }, None)
-        .expect("Failed user lookup")
-    {
-        return Response::Conflict(json!({ "error": "Username already in use!" }));
-    }
-
-    if let Ok(hashed) = hash(info.password.clone(), 10) {
-        let access_token = gen_token(92);
-        let code = gen_token(48);
-
-        let email_verification = match *USE_EMAIL {
-            true => doc! {
-                "verified": false,
-                "target": info.email.clone(),
-                "expiry": Bson::DateTime(Utc::now() + chrono::Duration::days(1)),
-                "rate_limit": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
-                "code": code.clone(),
-            },
-            false => doc! {
-                "verified": true
-            }
-        };
-
-        let id = Ulid::new().to_string();
-        match col.insert_one(
-            doc! {
-                "_id": &id,
-                "email": info.email.clone(),
-                "username": info.username.clone(),
-                "display_name": info.username.clone(),
-                "password": hashed,
-                "access_token": &access_token,
-                "email_verification": email_verification
-            },
-            None,
-        ) {
-            Ok(_) => {
-                if *USE_EMAIL {
-                    let sent = email::send_verification_email(info.email.clone(), code);
-
-                    Response::Success(json!({
-                        "email_sent": sent,
-                    }))
-                } else {
-                    Response::Success(json!({
-                        "id": id,
-                        "access_token": access_token
-                    }))
-                }
-            }
-            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::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!");
-
-            if *USE_EMAIL {
-                if let Err(err) = email::send_welcome_email(target.to_string(), user.username) {
-                    error!("Failed to send welcome email! {}", err);
-                }
-            }
-
-            Response::Redirect(super::Redirect::to("https://app.revolt.chat"))
-        }
-    } else {
-        Response::BadRequest(json!({ "error": "Invalid code." }))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Resend {
-    email: String,
-    captcha: Option<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 {
-    if let Err(error) = captcha::verify(&info.captcha) {
-        return Response::BadRequest(json!({ "error": error }));
-    }
-
-    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::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 = Bson::DateTime(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 = Bson::DateTime(*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": Bson::DateTime(Utc::now() + chrono::Duration::minutes(1)),
-						},
-					},
-					None,
-				).expect("Failed to update user!");
-
-            if let Err(err) = email::send_verification_email(info.email.clone(), code) {
-                return Response::InternalServerError(json!({ "error": err }));
-            }
-
-            Response::Result(super::Status::Ok)
-        }
-    } else {
-        Response::NotFound(json!({ "error": "Email not found or pending verification!" }))
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Login {
-    email: String,
-    password: String,
-    captcha: Option<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 {
-    if let Err(error) = captcha::verify(&info.captcha) {
-        return Response::BadRequest(json!({ "error": error }));
-    }
-
-    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::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.",
-        }))
-    }
-}
-
-#[options("/create")]
-pub fn create_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/verify/<_code>")]
-pub fn verify_email_preflight(_code: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/resend")]
-pub fn resend_email_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/login")]
-pub fn login_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/token")]
-pub fn token_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}

src/routes/channel.rs

@@ -1,698 +0,0 @@
-use super::Response;
-use crate::database::{
-    self, channel::Channel, get_relationship, get_relationship_internal, message::Message,
-    user::User, Permission, PermissionCalculator, Relationship,
-};
-use crate::notifications::{
-    self,
-    events::{groups::*, guilds::ChannelDelete, message::*, Notification},
-};
-use crate::util::vec_to_set;
-
-use chrono::prelude::*;
-use mongodb::bson::{doc, from_bson, Bson};
-use mongodb::options::FindOptions;
-use num_enum::TryFromPrimitive;
-use rocket::request::Form;
-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: User, 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)." }));
-        }
-
-        for item in set {
-            if item == user.id {
-                continue;
-            }
-
-            if get_relationship_internal(&user.id, &item, &user.relations) != 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: User, target: Channel) -> Option<Response> {
-    with_permissions!(user, target);
-    Some(Response::Success(target.serialise()))
-}
-
-/// [groups] add user to channel
-#[put("/<target>/recipients/<member>")]
-pub fn add_member(user: User, target: Channel, member: User) -> 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.as_ref().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.clone() },
-                    doc! {
-                        "$push": {
-                            "recipients": &member.id
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if (Message {
-                    id: Ulid::new().to_string(),
-                    nonce: None,
-                    channel: target.id.clone(),
-                    author: "system".to_string(),
-                    content: format!("<@{}> added <@{}> to the group.", &user.id, &member.id),
-                    edited: None,
-                    previous_content: vec![],
-                })
-                .send(&target)
-                {
-                    notifications::send_message_given_channel(
-                        Notification::group_user_join(UserJoin {
-                            id: target.id.clone(),
-                            user: member.id.clone(),
-                        }),
-                        &target,
-                    );
-
-                    Some(Response::Result(super::Status::Ok))
-                } else {
-                    Some(Response::PartialStatus(
-                        json!({ "error": "Failed to send join message, but user has been added." }),
-                    ))
-                }
-            } 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: User, target: Channel, member: User) -> 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.as_ref().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()
-    {
-        if (Message {
-            id: Ulid::new().to_string(),
-            nonce: None,
-            channel: target.id.clone(),
-            author: "system".to_string(),
-            content: format!("<@{}> removed <@{}> from the group.", &user.id, &member.id),
-            edited: None,
-            previous_content: vec![],
-        })
-        .send(&target)
-        {
-            notifications::send_message_given_channel(
-                Notification::group_user_leave(UserLeave {
-                    id: target.id.clone(),
-                    user: member.id.clone(),
-                }),
-                &target,
-            );
-
-            Some(Response::Result(super::Status::Ok))
-        } else {
-            Some(Response::PartialStatus(
-                json!({ "error": "Failed to send join message, but user has been removed." }),
-            ))
-        }
-    } 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: User, target: Channel) -> 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 channel." }),
-                ))
-            }
-        } 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
-                    .as_ref()
-                    .expect("Missing recipients on Group DM."),
-            );
-            let owner = target.owner.as_ref().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()
-                {
-                    if (Message {
-                        id: Ulid::new().to_string(),
-                        nonce: None,
-                        channel: target.id.clone(),
-                        author: "system".to_string(),
-                        content: format!("<@{}> left the group.", &user.id),
-                        edited: None,
-                        previous_content: vec![],
-                    })
-                    .send(&target)
-                    {
-                        notifications::send_message_given_channel(
-                            Notification::group_user_leave(UserLeave {
-                                id: target.id.clone(),
-                                user: user.id.clone(),
-                            }),
-                            &target,
-                        );
-
-                        Some(Response::Result(super::Status::Ok))
-                    } else {
-                        Some(Response::PartialStatus(
-                            json!({ "error": "Failed to send leave message, but you have left the group." }),
-                        ))
-                    }
-                } else {
-                    Some(Response::InternalServerError(
-                        json!({ "error": "Failed to remove you from the group." }),
-                    ))
-                }
-            }
-        }
-        2 => {
-            let guild_id = target.guild.unwrap();
-            if database::get_collection("guilds")
-                .update_one(
-                    doc! { "_id": &guild_id },
-                    doc! {
-                        "$pull": {
-                            "invites": {
-                                "channel": &target.id
-                            },
-                            "channels": &target.id
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                notifications::send_message_threaded(
-                    None,
-                    guild_id.clone(),
-                    Notification::guild_channel_delete(ChannelDelete {
-                        id: guild_id.clone(),
-                        channel: target.id.clone(),
-                    }),
-                );
-
-                try_delete()
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Failed to remove invites." }),
-                ))
-            }
-        }
-        _ => Some(Response::InternalServerError(
-            json!({ "error": "Unknown error has occurred." }),
-        )),
-    }
-}
-
-#[derive(Serialize, Deserialize, FromForm)]
-pub struct MessageFetchOptions {
-    limit: Option<i64>,
-    before: Option<String>,
-    after: Option<String>,
-}
-
-/// fetch channel messages
-#[get("/<target>/messages?<options..>")]
-pub fn messages(
-    user: User,
-    target: Channel,
-    options: Form<MessageFetchOptions>,
-) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_read_messages() {
-        return Some(Response::LackingPermission(Permission::ReadMessages));
-    }
-
-    // ! FIXME: update wiki to reflect changes
-    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 limit = if let Some(limit) = options.limit {
-        limit.min(100).max(0)
-    } else {
-        50
-    };
-
-    let col = database::get_collection("messages");
-    let result = col
-        .find(
-            query,
-            FindOptions::builder()
-                .limit(limit)
-                .sort(doc! {
-                    "_id": -1
-                })
-                .build(),
-        )
-        .unwrap();
-
-    let mut messages = Vec::new();
-    for item in result {
-        let message: Message =
-            from_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: User, target: Channel, 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();
-
-    if content.len() == 0 {
-        return Some(Response::NotAcceptable(
-            json!({ "error": "No message content!" }),
-        ));
-    }
-
-    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();
-    let message = Message {
-        id: id.clone(),
-        nonce: Some(nonce),
-        channel: target.id.clone(),
-        author: user.id,
-        content,
-        edited: None,
-        previous_content: vec![],
-    };
-
-    if message.send(&target) {
-        Some(Response::Success(json!({ "id": id })))
-    } else {
-        Some(Response::BadRequest(
-            json!({ "error": "Failed to send message." }),
-        ))
-    }
-}
-
-/// get a message
-#[get("/<target>/messages/<message>")]
-pub fn get_message(user: User, target: Channel, message: Message) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_read_messages() {
-        return Some(Response::LackingPermission(Permission::ReadMessages));
-    }
-
-    // ! CHECK IF USER HAS PERMISSION TO VIEW EDITS OF MESSAGES
-    let mut entries = vec![];
-    for entry in message.previous_content {
-        entries.push(json!({
-            "content": entry.content,
-            "time": entry.time.timestamp(),
-        }));
-    }
-
-    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": entries,
-    })))
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct EditMessage {
-    content: String,
-}
-
-/// edit a message
-#[patch("/<target>/messages/<message>", data = "<edit>")]
-pub fn edit_message(
-    user: User,
-    target: Channel,
-    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,
-                "edited": Bson::DateTime(edited)
-            },
-            "$push": {
-                "previous_content": {
-                    "content": &message.content,
-                    "time": time,
-                }
-            },
-        },
-        None,
-    ) {
-        Ok(_) => {
-            notifications::send_message_given_channel(
-                Notification::message_edit(Edit {
-                    id: message.id.clone(),
-                    channel: target.id.clone(),
-                    author: message.author.clone(),
-                    content: edit.content.clone(),
-                }),
-                &target,
-            );
-
-            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: User, target: Channel, message: Message) -> Option<Response> {
-    let permissions = with_permissions!(user, target);
-
-    if !permissions.get_manage_messages() && 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(_) => {
-            notifications::send_message_given_channel(
-                Notification::message_delete(Delete {
-                    id: message.id.clone(),
-                }),
-                &target,
-            );
-
-            Some(Response::Result(super::Status::Ok))
-        }
-        Err(_) => Some(Response::InternalServerError(
-            json!({ "error": "Failed to delete message." }),
-        )),
-    }
-}
-
-#[options("/create")]
-pub fn create_group_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>")]
-pub fn channel_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/recipients/<_member>")]
-pub fn member_preflight(_target: String, _member: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/messages")]
-pub fn messages_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/messages/<_message>")]
-pub fn message_preflight(_target: String, _message: String) -> Response {
-    Response::Result(super::Status::Ok)
-}

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,839 +0,0 @@
-use super::channel::ChannelType;
-use super::Response;
-use crate::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
-use crate::database::{
-    self, channel::fetch_channel, channel::Channel, guild::serialise_guilds_with_channels,
-    user::User, Permission, PermissionCalculator,
-};
-use crate::notifications::{
-    self,
-    events::{guilds::*, Notification},
-};
-use crate::util::gen_token;
-
-use mongodb::bson::{doc, Bson};
-use mongodb::options::{FindOneOptions, FindOptions};
-use rocket::request::Form;
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-// ! FIXME: GET RID OF THIS
-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: User) -> Response {
-    if let Ok(gids) = user.find_guilds() {
-        if let Ok(data) = serialise_guilds_with_channels(&gids) {
-            Response::Success(json!(data))
-        } 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: User, target: Guild) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if let Ok(result) = target.seralise_with_channels() {
-        Some(Response::Success(result))
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch channels!" }),
-        ))
-    }
-}
-
-/// delete or leave a guild
-#[delete("/<target>")]
-pub fn remove_guild(user: User, target: Guild) -> 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("members")
-                        .delete_many(
-                            doc! {
-                                "_id.guild": &target.id,
-                            },
-                            None,
-                        )
-                        .is_ok()
-                    {
-                        if database::get_collection("guilds")
-                            .delete_one(
-                                doc! {
-                                    "_id": &target.id
-                                },
-                                None,
-                            )
-                            .is_ok()
-                        {
-                            notifications::send_message_threaded(
-                                None,
-                                target.id.clone(),
-                                Notification::guild_delete(Delete {
-                                    id: target.id.clone(),
-                                }),
-                            );
-
-                            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 members." }),
-                        ))
-                    }
-                } 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()
-    {
-        notifications::send_message_threaded(
-            None,
-            target.id.clone(),
-            Notification::guild_user_leave(UserLeave {
-                id: target.id.clone(),
-                user: user.id.clone(),
-                banned: false,
-            }),
-        );
-
-        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: User, target: Guild, 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()
-        {
-            if database::get_collection("guilds")
-                .update_one(
-                    doc! {
-                        "_id": &target.id
-                    },
-                    doc! {
-                        "$addToSet": {
-                            "channels": &id
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                notifications::send_message_threaded(
-                    None,
-                    target.id.clone(),
-                    Notification::guild_channel_create(ChannelCreate {
-                        id: target.id.clone(),
-                        channel: id.clone(),
-                        name: name.clone(),
-                        description: description.clone(),
-                    }),
-                );
-
-                Some(Response::Success(json!({ "id": &id })))
-            } else {
-                Some(Response::InternalServerError(
-                    json!({ "error": "Couldn't save channel list." }),
-                ))
-            }
-        } else {
-            Some(Response::InternalServerError(
-                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: User,
-    target: Guild,
-    channel: Channel,
-    _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: User, target: Guild, 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 && !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: User, target: Guild) -> Option<Response> {
-    let (permissions, _) = with_permissions!(user, target);
-
-    if !permissions.get_manage_server() {
-        return Some(Response::LackingPermission(Permission::ManageServer));
-    }
-
-    Some(Response::Success(json!(target.invites)))
-}
-
-/// view an invite before joining
-#[get("/join/<code>", rank = 1)]
-pub fn fetch_invite(user: User, code: String) -> Response {
-    if let Some((guild_id, name, invite)) = get_invite(&code, user.id) {
-        match fetch_channel(&invite.channel) {
-            Ok(result) => {
-                if let Some(channel) = result {
-                    Response::Success(json!({
-                        "guild": {
-                            "id": guild_id,
-                            "name": name,
-                        },
-                        "channel": {
-                            "id": channel.id,
-                            "name": channel.name,
-                        }
-                    }))
-                } else {
-                    Response::NotFound(json!({ "error": "Channel does not exist." }))
-                }
-            }
-            Err(err) => Response::InternalServerError(json!({ "error": err })),
-        }
-    } 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: User, 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()
-                {
-                    notifications::send_message_threaded(
-                        None,
-                        guild_id.clone(),
-                        Notification::guild_user_join(UserJoin {
-                            id: guild_id.clone(),
-                            user: user.id.clone(),
-                        }),
-                    );
-
-                    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: User, info: Json<CreateGuild>) -> Response {
-    if !user.email_verification.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,
-                "channels": [ channel_id.clone() ],
-                "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: User, target: Guild) -> 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: User, target: Guild, other: String) -> Option<Response> {
-    with_permissions!(user, target);
-
-    if let Ok(result) = get_member(MemberKey(target.id, other)) {
-        if let Some(member) = result {
-            Some(Response::Success(json!({
-                "id": member.id.user,
-                "nickname": member.nickname,
-            })))
-        } else {
-            Some(Response::NotFound(
-                json!({ "error": "Member does not exist!" }),
-            ))
-        }
-    } else {
-        Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch member." }),
-        ))
-    }
-}
-
-/// kick a guild member
-#[delete("/<target>/members/<other>")]
-pub fn kick_member(user: User, target: Guild, 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 let Ok(result) = get_member(MemberKey(target.id.clone(), other.clone())) {
-        if result.is_none() {
-            return Some(Response::BadRequest(
-                json!({ "error": "User not part of guild." }),
-            ));
-        }
-    } else {
-        return Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch member." }),
-        ));
-    }
-
-    if database::get_collection("members")
-        .delete_one(
-            doc! {
-                "_id.guild": &target.id,
-                "_id.user": &other,
-            },
-            None,
-        )
-        .is_ok()
-    {
-        notifications::send_message_threaded(
-            None,
-            target.id.clone(),
-            Notification::guild_user_leave(UserLeave {
-                id: target.id.clone(),
-                user: other.clone(),
-                banned: false,
-            }),
-        );
-
-        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: User,
-    target: Guild,
-    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 let Ok(result) = get_member(MemberKey(target.id.clone(), other.clone())) {
-        if result.is_none() {
-            return Some(Response::BadRequest(
-                json!({ "error": "User not part of guild." }),
-            ));
-        }
-    } else {
-        return Some(Response::InternalServerError(
-            json!({ "error": "Failed to fetch member." }),
-        ));
-    }
-
-    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()
-    {
-        notifications::send_message_threaded(
-            None,
-            target.id.clone(),
-            Notification::guild_user_leave(UserLeave {
-                id: target.id.clone(),
-                user: other.clone(),
-                banned: true,
-            }),
-        );
-
-        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: User, target: Guild, 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.bans.iter().any(|v| v.id == other) {
-        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." }),
-        ))
-    }
-}
-
-#[options("/<_target>")]
-pub fn guild_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/channels")]
-pub fn create_channel_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/channels/<_channel>/invite")]
-pub fn create_invite_preflight(_target: String, _channel: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/invites/<_code>")]
-pub fn remove_invite_preflight(_target: String, _code: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/invites")]
-pub fn fetch_invites_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/join/<_code>", rank = 1)]
-pub fn invite_preflight(_code: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/create")]
-pub fn create_guild_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/members")]
-pub fn fetch_members_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/members/<_other>")]
-pub fn fetch_member_preflight(_target: String, _other: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/members/<_other>/ban")]
-pub fn ban_member_preflight(_target: String, _other: String) -> Response {
-    Response::Result(super::Status::Ok)
-}

src/routes/guild/mod.rs

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

src/routes/mod.rs

@@ -1,154 +1,18 @@
 pub use rocket::http::Status;
 pub use rocket::response::Redirect;
 use rocket::Rocket;
-use rocket_contrib::json::JsonValue;
 
-use crate::database::Permission;
+mod channels;
-
+mod guild;
-pub mod account;
+mod onboard;
-pub mod channel;
+mod root;
-pub mod guild;
+mod users;
-pub mod root;
-pub mod user;
-
-#[derive(Responder)]
-pub enum Response {
-    #[response()]
-    Result(Status),
-    #[response()]
-    Success(JsonValue),
-    #[response()]
-    Redirect(Redirect),
-    #[response(status = 207)]
-    PartialStatus(JsonValue),
-    #[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 = 418)]
-    Teapot(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()
-    }
-}
 
 pub fn mount(rocket: Rocket) -> Rocket {
     rocket
-        .mount("/", routes![root::root, root::root_preflight, root::teapot])
+        .mount("/", routes![root::root])
-        .mount(
+        .mount("/onboard", onboard::routes())
-            "/account",
+        .mount("/users", users::routes())
-            routes![
+        .mount("/channels", channels::routes())
-                account::create,
+        .mount("/guild", guild::routes())
-                account::verify_email,
-                account::resend_email,
-                account::login,
-                account::token,
-                account::create_preflight,
-                account::verify_email_preflight,
-                account::resend_email_preflight,
-                account::login_preflight,
-                account::token_preflight,
-            ],
-        )
-        .mount(
-            "/users",
-            routes![
-                user::me,
-                user::user,
-                user::query,
-                user::dms,
-                user::dm,
-                user::get_friends,
-                user::get_friend,
-                user::add_friend,
-                user::remove_friend,
-                user::block_user,
-                user::unblock_user,
-                user::user_preflight,
-                user::query_preflight,
-                user::dms_preflight,
-                user::dm_preflight,
-                user::friend_preflight,
-                user::block_user_preflight,
-            ],
-        )
-        .mount(
-            "/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,
-                channel::create_group_preflight,
-                channel::channel_preflight,
-                channel::member_preflight,
-                channel::messages_preflight,
-                channel::message_preflight,
-            ],
-        )
-        .mount(
-            "/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,
-                guild::guild_preflight,
-                guild::create_channel_preflight,
-                guild::create_invite_preflight,
-                guild::remove_invite_preflight,
-                guild::fetch_invites_preflight,
-                guild::invite_preflight,
-                guild::create_guild_preflight,
-                guild::fetch_members_preflight,
-                guild::fetch_member_preflight,
-                guild::ban_member_preflight,
-            ],
-        )
 }

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,36 +1,22 @@
-use super::Response;
+use crate::util::variables::{
-use crate::util::variables::{USE_EMAIL, DISABLE_REGISTRATION, USE_HCAPTCHA};
+    DISABLE_REGISTRATION, EXTERNAL_WS_URL, HCAPTCHA_SITEKEY, USE_EMAIL, USE_HCAPTCHA,
+};
 
 use mongodb::bson::doc;
+use rocket_contrib::json::JsonValue;
 
-/// root
 #[get("/")]
-pub fn root() -> Response {
+pub async fn root() -> JsonValue {
-    Response::Success(json!({
+    json!({
-        "revolt": "0.2.10",
+        "revolt": "0.3.1",
-        "version": {
-            "major": 0,
-            "minor": 2,
-            "patch": 10
-        },
         "features": {
             "registration": !*DISABLE_REGISTRATION,
-            "captcha": *USE_HCAPTCHA,
+            "captcha": {
+                "enabled": *USE_HCAPTCHA,
+                "key": HCAPTCHA_SITEKEY.to_string()
+            },
             "email": *USE_EMAIL,
-        }
+        },
-    }))
+        "ws": *EXTERNAL_WS_URL,
-}
+    })
-
-#[options("/")]
-pub fn root_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-
-/// I'm a teapot.
-#[delete("/")]
-pub fn teapot() -> Response {
-    Response::Teapot(json!({
-        "teapot": true,
-        "can_delete": false
-    }))
 }

src/routes/user.rs

@@ -1,761 +0,0 @@
-use super::Response;
-use crate::database::{
-    self, get_relationship, get_relationship_internal, user::User, Relationship,
-};
-use crate::notifications::{
-    self,
-    events::{users::*, Notification},
-};
-use crate::routes::channel;
-
-use mongodb::bson::doc;
-use mongodb::options::{Collation, FindOneOptions, FindOptions};
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-/// retrieve your user information
-#[get("/@me")]
-pub fn me(user: User) -> Response {
-    Response::Success(user.serialise(Relationship::SELF as i32))
-}
-
-/// retrieve another user's information
-#[get("/<target>")]
-pub fn user(user: User, target: User) -> Response {
-    let relationship = get_relationship(&user, &target) as i32;
-    Response::Success(user.serialise(relationship))
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct UserQuery {
-    username: String,
-}
-
-/// find a user by their username
-#[post("/query", data = "<query>")]
-pub fn query(user: User, query: Json<UserQuery>) -> Response {
-    let col = database::get_collection("users");
-
-    if let Ok(result) = col.find_one(
-        doc! { "username": query.username.clone() },
-        FindOneOptions::builder()
-            .collation(Collation::builder().locale("en").strength(2).build())
-            .build(),
-    ) {
-        if let Some(doc) = result {
-            let id = doc.get_str("_id").unwrap();
-            Response::Success(json!({
-                "id": id,
-                "username": doc.get_str("username").unwrap(),
-                "display_name": doc.get_str("display_name").unwrap(),
-                "relationship": get_relationship_internal(&user.id, &id, &user.relations) as i32
-            }))
-        } else {
-            Response::NotFound(json!({
-                "error": "User not found!"
-            }))
-        }
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed database query." }))
-    }
-}
-
-/*#[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: User, 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 i32
-                }));
-            }
-        }
-
-        Response::Success(json!(results))
-    } else {
-        Response::InternalServerError(json!({ "error": "Failed database query." }))
-    }
-}*/
-
-/// retrieve all of your DMs
-#[get("/@me/dms")]
-pub fn dms(user: User) -> Response {
-    let col = database::get_collection("channels");
-
-    if let Ok(results) = col.find(
-        doc! {
-            "$or": [
-                {
-                    "type": channel::ChannelType::DM as i32,
-                    "active": true
-                },
-                {
-                    "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 last_message = doc.get_document("last_message").unwrap();
-                let recipients = doc.get_array("recipients").unwrap();
-
-                match doc.get_i32("type").unwrap() {
-                    0 => {
-                        channels.push(json!({
-                            "id": id,
-                            "type": 0,
-                            "last_message": last_message,
-                            "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: User, target: User) -> 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: User) -> Response {
-    let mut results = Vec::new();
-    if let Some(arr) = user.relations {
-        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: User, target: User) -> Response {
-    Response::Success(json!({ "status": get_relationship(&user, &target) as i32 }))
-}
-
-/// create or accept a friend request
-#[put("/<target>/friend")]
-pub fn add_friend(user: User, target: User) -> 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.clone(),
-                            "relations.id": user.id.clone()
-                        },
-                        doc! {
-                            "$set": {
-                                "relations.$.status": Relationship::Friend as i32
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    notifications::send_message_threaded(
-                        vec![target.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
-                            user: user.id.clone(),
-                            status: Relationship::Friend as i32,
-                        }),
-                    );
-
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::Friend as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::Friend as i32 }))
-                } 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.clone()
-                        },
-                        doc! {
-                            "$push": {
-                                "relations": {
-                                    "id": user.id.clone(),
-                                    "status": Relationship::Incoming as i32
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::Outgoing as i32,
-                        }),
-                    );
-
-                    notifications::send_message_threaded(
-                        vec![target.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
-                            user: user.id.clone(),
-                            status: Relationship::Incoming as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::Outgoing as i32 }))
-                } 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: User, target: User) -> 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.clone()
-                        },
-                        doc! {
-                            "$pull": {
-                                "relations": {
-                                    "id": user.id.clone()
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::NONE as i32,
-                        }),
-                    );
-
-                    notifications::send_message_threaded(
-                        vec![target.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
-                            user: user.id.clone(),
-                            status: Relationship::NONE as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::NONE as i32 }))
-                } 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: User, target: User) -> 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.clone(),
-                            "relations.id": user.id.clone()
-                        },
-                        doc! {
-                            "$set": {
-                                "relations.$.status": Relationship::BlockedOther as i32
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::Blocked as i32,
-                        }),
-                    );
-
-                    notifications::send_message_threaded(
-                        vec![target.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
-                            user: user.id.clone(),
-                            status: Relationship::BlockedOther as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::Blocked as i32 }))
-                } 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::NONE => {
-            if col
-                .update_one(
-                    doc! {
-                        "_id": user.id.clone(),
-                    },
-                    doc! {
-                        "$push": {
-                            "relations": {
-                                "id": target.id.clone(),
-                                "status": Relationship::Blocked as i32,
-                            }
-                        }
-                    },
-                    None,
-                )
-                .is_ok()
-            {
-                if col
-                    .update_one(
-                        doc! {
-                            "_id": target.id.clone(),
-                        },
-                        doc! {
-                            "$push": {
-                                "relations": {
-                                    "id": user.id.clone(),
-                                    "status": Relationship::BlockedOther as i32,
-                                }
-                            }
-                        },
-                        None,
-                    )
-                    .is_ok()
-                {
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::Blocked as i32,
-                        }),
-                    );
-
-                    notifications::send_message_threaded(
-                        vec![target.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: target.id.clone(),
-                            user: user.id.clone(),
-                            status: Relationship::BlockedOther as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::Blocked as i32 }))
-                } 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()
-            {
-                notifications::send_message_threaded(
-                    vec![user.id.clone()],
-                    None,
-                    Notification::user_friend_status(FriendStatus {
-                        id: user.id.clone(),
-                        user: target.id.clone(),
-                        status: Relationship::Blocked as i32,
-                    }),
-                );
-
-                Response::Success(json!({ "status": Relationship::Blocked as i32 }))
-            } else {
-                Response::InternalServerError(
-                    json!({ "error": "Failed to commit to database, try again." }),
-                )
-            }
-        }
-        Relationship::SELF => Response::BadRequest(json!({ "error": "This has no effect." })),
-    }
-}
-
-/// unblock a user
-#[delete("/<target>/block")]
-pub fn unblock_user(user: User, target: User) -> 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()
-                {
-                    notifications::send_message_threaded(
-                        vec![user.id.clone()],
-                        None,
-                        Notification::user_friend_status(FriendStatus {
-                            id: user.id.clone(),
-                            user: target.id.clone(),
-                            status: Relationship::BlockedOther as i32,
-                        }),
-                    );
-
-                    Response::Success(json!({ "status": Relationship::BlockedOther as i32 }))
-                } 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.clone()
-                            },
-                            doc! {
-                                "$pull": {
-                                    "relations": {
-                                        "id": user.id.clone()
-                                    }
-                                }
-                            },
-                            None,
-                        )
-                        .is_ok()
-                    {
-                        notifications::send_message_threaded(
-                            vec![user.id.clone()],
-                            None,
-                            Notification::user_friend_status(FriendStatus {
-                                id: user.id.clone(),
-                                user: target.id.clone(),
-                                status: Relationship::NONE as i32,
-                            }),
-                        );
-
-                        notifications::send_message_threaded(
-                            vec![target.id.clone()],
-                            None,
-                            Notification::user_friend_status(FriendStatus {
-                                id: target.id.clone(),
-                                user: user.id.clone(),
-                                status: Relationship::NONE as i32,
-                            }),
-                        );
-
-                        Response::Success(json!({ "status": Relationship::NONE as i32 }))
-                    } 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." })),
-    }
-}
-
-#[options("/<_target>")]
-pub fn user_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/query")]
-pub fn query_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/@me/dms")]
-pub fn dms_preflight() -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/dm")]
-pub fn dm_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/friend")]
-pub fn friend_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}
-#[options("/<_target>/block")]
-pub fn block_user_preflight(_target: String) -> Response {
-    Response::Result(super::Status::Ok)
-}

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,29 @@
+use rocket::response::NamedFile;
+use std::path::Path;
+
+use crate::database::Ref;
+
+#[get("/<target>/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,30 @@
+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 open_dm;
+mod remove_friend;
+mod unblock_user;
+
+pub fn routes() -> Vec<Route> {
+    routes![
+        // User Information
+        fetch_user::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

@@ -1,6 +1,6 @@
 use crate::util::variables::{HCAPTCHA_KEY, USE_HCAPTCHA};
 
-use reqwest::blocking::Client;
+use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -9,7 +9,7 @@ struct CaptchaResponse {
     success: bool,
 }
 
-pub fn verify(user_token: &Option<String>) -> Result<(), String> {
+pub async fn verify(user_token: &Option<String>) -> Result<(), String> {
     if *USE_HCAPTCHA {
         if let Some(token) = user_token {
             let mut map = HashMap::new();
@@ -21,9 +21,11 @@ pub fn verify(user_token: &Option<String>) -> Result<(), String> {
                 .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 {

src/util/mod.rs

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

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

@@ -9,11 +9,15 @@ lazy_static! {
         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(|_| "".to_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:9999".to_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(
@@ -29,22 +33,21 @@ lazy_static! {
     pub static ref SMTP_HOST: String =
         env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string());
     pub static ref SMTP_USERNAME: String =
-        env::var("SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
+        env::var("REVOLT_SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
     pub static ref SMTP_PASSWORD: String =
-        env::var("SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
+        env::var("REVOLT_SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
-    pub static ref SMTP_FROM: String = env::var("SMTP_FROM").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") {
-            if !env::var("REVOLT_UNSAFE_NO_EMAIL")
+            panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
-                .map_or(false, |v| v == *"1") {
-                panic!(
-                    "Not letting you run this in production, set REVOLT_UNSAFE_NO_EMAIL=1 to run."
-                );
-            }
         }
 
         #[cfg(debug_assertions)]
@@ -53,11 +56,8 @@ pub fn preflight_checks() {
 
     if *USE_HCAPTCHA == false {
         #[cfg(not(debug_assertions))]
-        {
+        if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
-            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA")
+            panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
-                .map_or(false, |v| v == *"1") {
-                panic!("Not letting you run this in production, set REVOLT_UNSAFE_NO_CAPTCHA=1 to run.");
-            }
         }
 
         #[cfg(debug_assertions)]