src/database/entities/guild.rs

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

+use mongodb::bson::doc;
+use mongodb::bson::from_document;
+use mongodb::bson::to_document;
+use serde::{Deserialize, Serialize};
+
+use crate::database::get_collection;
+use crate::util::result::Error;
+use crate::util::result::Result;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Invite {
+    Server {
+        #[serde(rename = "_id")]
+        code: String,
+        server: String,
+        creator: String,
+        channel: String,
+    },
+    Group {
+        #[serde(rename = "_id")]
+        code: String,
+        creator: String,
+        channel: String,
+    }, /* User {
+           code: String,
+           user: String
+       } */
+}
+
+impl Invite {
+    pub fn code(&self) -> &String {
+        match &self {
+            Invite::Server { code, .. } => code,
+            Invite::Group { code, .. } => code,
+        }
+    }
+
+    pub fn creator(&self) -> &String {
+        match &self {
+            Invite::Server { creator, .. } => creator,
+            Invite::Group { creator, .. } => creator,
+        }
+    }
+
+    pub async fn get(code: &str) -> Result<Invite> {
+        let doc = get_collection("channel_invites")
+            .find_one(doc! { "_id": code }, None)
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "invite",
+            })?
+            .ok_or_else(|| Error::UnknownServer)?;
+
+        from_document::<Invite>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: "invite",
+        })
+    }
+
+    pub async fn save(self) -> Result<()> {
+        get_collection("channel_invites")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "invite",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "invite",
+            })?;
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        get_collection("channel_invites")
+            .delete_one(
+                doc! {
+                    "_id": self.code()
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "invite",
+            })?;
+
+        Ok(())
+    }
+}

src/database/entities/message.rs

-// use mongodb::bson::DateTime;
-// use serde::{Deserialize, Serialize};
+use crate::util::variables::{USE_JANUARY, VAPID_PRIVATE_KEY};
+use crate::{
+    database::*,
+    notifications::{events::ClientboundNotification, websocket::is_online},
+    util::result::{Error, Result},
+};
 
-/*#[derive(Serialize, Deserialize, Debug)]
-pub struct PreviousEntry {
-    pub content: String,
-    pub time: DateTime,
+use futures::StreamExt;
+use mongodb::options::UpdateOptions;
+use mongodb::{
+    bson::{doc, to_bson, DateTime},
+    options::FindOptions,
+};
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+use ulid::Ulid;
+use web_push::{
+    ContentEncoding, SubscriptionInfo, VapidSignatureBuilder, WebPushClient, WebPushMessageBuilder,
+};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum SystemMessage {
+    #[serde(rename = "text")]
+    Text { content: String },
+    #[serde(rename = "user_added")]
+    UserAdded { id: String, by: String },
+    #[serde(rename = "user_remove")]
+    UserRemove { id: String, by: String },
+    #[serde(rename = "user_joined")]
+    UserJoined { id: String },
+    #[serde(rename = "user_left")]
+    UserLeft { id: String },
+    #[serde(rename = "user_kicked")]
+    UserKicked { id: String },
+    #[serde(rename = "user_banned")]
+    UserBanned { id: String },
+    #[serde(rename = "channel_renamed")]
+    ChannelRenamed { name: String, by: String },
+    #[serde(rename = "channel_description_changed")]
+    ChannelDescriptionChanged { by: String },
+    #[serde(rename = "channel_icon_changed")]
+    ChannelIconChanged { by: String },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum Content {
+    Text(String),
+    SystemMessage(SystemMessage),
+}
+
+impl Content {
+    pub async fn send_as_system(self, target: &Channel) -> Result<()> {
+        Message::create(
+            "00000000000000000000000000".to_string(),
+            target.id().to_string(),
+            self,
+            None,
+            None
+        )
+        .publish(&target, false)
+        .await
+    }
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[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,
+    pub content: Content,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<Vec<File>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub edited: Option<DateTime>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub embeds: Option<Vec<Embed>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mentions: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub replies: Option<Vec<String>>
+}
+
+impl Message {
+    pub fn create(
+        author: String,
+        channel: String,
+        content: Content,
+        mentions: Option<Vec<String>>,
+        replies: Option<Vec<String>>,
+    ) -> Message {
+        Message {
+            id: Ulid::new().to_string(),
+            nonce: None,
+            channel,
+            author,
+
+            content,
+            attachments: None,
+            edited: None,
+            embeds: None,
+            mentions,
+            replies
+        }
+    }
+
+    pub async fn publish(self, channel: &Channel, process_embeds: bool) -> 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: all this code is legitimately crap
+        // ! rewrite when can be asked
+
+        let ss = self.clone();
+        let c_clone = channel.clone();
+        async_std::task::spawn(async move {
+            let mut set = if let Content::Text(text) = &ss.content {
+                doc! {
+                    "last_message": {
+                        "_id": ss.id.clone(),
+                        "author": ss.author.clone(),
+                        "short": text.chars().take(128).collect::<String>()
+                    }
+                }
+            } else {
+                doc! {}
+            };
+
+            // ! MARK AS ACTIVE
+            // ! FIXME: temp code
+            let channels = get_collection("channels");
+            match &c_clone {
+                Channel::DirectMessage { id, .. } => {
+                    set.insert("active", true);
+                    channels
+                        .update_one(
+                            doc! { "_id": id },
+                            doc! {
+                                "$set": set
+                            },
+                            None,
+                        )
+                        .await
+                        /*.map_err(|_| Error::DatabaseError {
+                            operation: "update_one",
+                            with: "channel",
+                        })?;*/
+                        .unwrap();
+                }
+                Channel::Group { id, .. } => {
+                    if let Content::Text(_) = &ss.content {
+                        channels
+                            .update_one(
+                                doc! { "_id": id },
+                                doc! {
+                                    "$set": set
+                                },
+                                None,
+                            )
+                            .await
+                            /*.map_err(|_| Error::DatabaseError {
+                                operation: "update_one",
+                                with: "channel",
+                            })?;*/
+                            .unwrap();
+                    }
+                }
+                Channel::TextChannel { id, .. } => {
+                    if let Content::Text(_) = &ss.content {
+                        channels
+                            .update_one(
+                                doc! { "_id": id },
+                                doc! {
+                                    "$set": {
+                                        "last_message": &ss.id
+                                    }
+                                },
+                                None,
+                            )
+                            .await
+                            /*.map_err(|_| Error::DatabaseError {
+                                operation: "update_one",
+                                with: "channel",
+                            })?;*/
+                            .unwrap();
+                    }
+                }
+                _ => {}
+            }
+        });
+
+        // ! FIXME: also temp code
+        // ! THIS ADDS ANY MENTIONS
+        if let Some(mentions) = &self.mentions {
+            let message = self.id.clone();
+            let channel = self.channel.clone();
+            let mentions = mentions.clone();
+            async_std::task::spawn(async move {
+                get_collection("channel_unreads")
+                    .update_many(
+                        doc! {
+                            "_id.channel": channel,
+                            "_id.user": {
+                                "$in": mentions
+                            }
+                        },
+                        doc! {
+                            "$push": {
+                                "mentions": message
+                            }
+                        },
+                        UpdateOptions::builder().upsert(true).build(),
+                    )
+                    .await
+                    /*.map_err(|_| Error::DatabaseError {
+                        operation: "update_many",
+                        with: "channel_unreads",
+                    })?;*/
+                    .unwrap();
+            });
+        }
+
+        if process_embeds {
+            self.process_embed();
+        }
+
+        let mentions = self.mentions.clone();
+        let enc = serde_json::to_string(&self).unwrap();
+        ClientboundNotification::Message(self).publish(channel.id().to_string());
 
-    pub previous_content: Vec<PreviousEntry>,
-}*/
+        /*
+           Web Push Test Code
+        */
+        let c_clone = channel.clone();
+        async_std::task::spawn(async move {
+            // Find all offline users.
+            let mut target_ids = vec![];
+            match &c_clone {
+                Channel::DirectMessage { recipients, .. } | Channel::Group { recipients, .. } => {
+                    for recipient in recipients {
+                        if !is_online(recipient) {
+                            target_ids.push(recipient.clone());
+                        }
+                    }
+                }
+                Channel::TextChannel { .. } => {
+                    if let Some(mut mentions) = mentions {
+                        target_ids.append(&mut mentions);
+                    }
+                }
+                _ => {}
+            }
+
+            // Fetch their corresponding sessions.
+            if let Ok(mut cursor) = get_collection("accounts")
+                .find(
+                    doc! {
+                        "_id": {
+                            "$in": target_ids
+                        },
+                        "sessions.subscription": {
+                            "$exists": true
+                        }
+                    },
+                    FindOptions::builder()
+                        .projection(doc! { "sessions": 1 })
+                        .build(),
+                )
+                .await
+            {
+                let mut subscriptions = vec![];
+                while let Some(result) = cursor.next().await {
+                    if let Ok(doc) = result {
+                        if let Ok(sessions) = doc.get_array("sessions") {
+                            for session in sessions {
+                                if let Some(doc) = session.as_document() {
+                                    if let Ok(sub) = doc.get_document("subscription") {
+                                        let endpoint = sub.get_str("endpoint").unwrap().to_string();
+                                        let p256dh = sub.get_str("p256dh").unwrap().to_string();
+                                        let auth = sub.get_str("auth").unwrap().to_string();
+
+                                        subscriptions
+                                            .push(SubscriptionInfo::new(endpoint, p256dh, auth));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if subscriptions.len() > 0 {
+                    let client = WebPushClient::new();
+                    let key =
+                        base64::decode_config(VAPID_PRIVATE_KEY.clone(), base64::URL_SAFE).unwrap();
+
+                    for subscription in subscriptions {
+                        let mut builder = WebPushMessageBuilder::new(&subscription).unwrap();
+                        let sig_builder = VapidSignatureBuilder::from_pem(
+                            std::io::Cursor::new(&key),
+                            &subscription,
+                        )
+                        .unwrap();
+                        let signature = sig_builder.build().unwrap();
+                        builder.set_vapid_signature(signature);
+                        builder.set_payload(ContentEncoding::AesGcm, enc.as_bytes());
+                        let m = builder.build().unwrap();
+                        client.send(m).await.ok();
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    pub async fn publish_update(self, data: JsonValue) -> Result<()> {
+        let channel = self.channel.clone();
+        ClientboundNotification::MessageUpdate {
+            id: self.id.clone(),
+            channel: self.channel.clone(),
+            data,
+        }
+        .publish(channel);
+        self.process_embed();
+
+        Ok(())
+    }
+
+    pub fn process_embed(&self) {
+        if !*USE_JANUARY {
+            return;
+        }
+
+        if let Content::Text(text) = &self.content {
+            // ! FIXME: re-write this at some point,
+            // ! or just before we allow user generated embeds
+            let id = self.id.clone();
+            let content = text.clone();
+            let channel = self.channel.clone();
+            async_std::task::spawn(async move {
+                if let Ok(embeds) = Embed::generate(content).await {
+                    if let Ok(bson) = to_bson(&embeds) {
+                        if let Ok(_) = get_collection("messages")
+                            .update_one(
+                                doc! {
+                                    "_id": &id
+                                },
+                                doc! {
+                                    "$set": {
+                                        "embeds": bson
+                                    }
+                                },
+                                None,
+                            )
+                            .await
+                        {
+                            ClientboundNotification::MessageUpdate {
+                                id,
+                                channel: channel.clone(),
+                                data: json!({ "embeds": embeds }),
+                            }
+                            .publish(channel);
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        if let Some(attachments) = &self.attachments {
+            for attachment in attachments {
+                attachment.delete().await?;
+            }
+        }
+
+        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(),
+            channel: self.channel.clone(),
+        }
+        .publish(channel);
+
+        if let Some(attachments) = &self.attachments {
+            let attachment_ids: Vec<String> =
+                attachments.iter().map(|f| f.id.to_string()).collect();
+            get_collection("attachments")
+                .update_one(
+                    doc! {
+                        "_id": {
+                            "$in": attachment_ids
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "attachment",
+                })?;
+        }
+
+        Ok(())
+    }
+}

src/database/entities/microservice/autumn.rs

+use mongodb::bson::{doc, from_document};
+use serde::{Deserialize, Serialize};
+
+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+enum Metadata {
+    File,
+    Text,
+    Image { width: isize, height: isize },
+    Video { width: isize, height: isize },
+    Audio,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct File {
+    #[serde(rename = "_id")]
+    pub id: String,
+    tag: String,
+    filename: String,
+    metadata: Metadata,
+    content_type: String,
+    size: isize,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    deleted: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    message_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    user_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    server_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    object_id: Option<String>,
+}
+
+impl File {
+    pub async fn find_and_use(
+        attachment_id: &str,
+        tag: &str,
+        parent_type: &str,
+        parent_id: &str,
+    ) -> Result<File> {
+        let attachments = get_collection("attachments");
+        let key = format!("{}_id", parent_type);
+        if let Some(doc) = attachments
+            .find_one(
+                doc! {
+                    "_id": attachment_id,
+                    "tag": &tag,
+                    key.clone(): {
+                        "$exists": false
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "attachment",
+            })?
+        {
+            let attachment = from_document::<File>(doc).map_err(|_| Error::DatabaseError {
+                operation: "from_document",
+                with: "attachment",
+            })?;
+
+            attachments
+                .update_one(
+                    doc! {
+                        "_id": &attachment.id
+                    },
+                    doc! {
+                        "$set": {
+                            key: &parent_id
+                        }
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "update_one",
+                    with: "attachment",
+                })?;
+
+            Ok(attachment)
+        } else {
+            Err(Error::UnknownAttachment)
+        }
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        get_collection("attachments")
+            .update_one(
+                doc! {
+                    "_id": &self.id
+                },
+                doc! {
+                    "$set": {
+                        "deleted": true
+                    }
+                },
+                None,
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| Error::DatabaseError {
+                operation: "update_one",
+                with: "attachment",
+            })
+    }
+}

src/database/entities/microservice/january.rs

+use crate::util::{
+    result::{Error, Result},
+    variables::JANUARY_URL,
+};
+use linkify::{LinkFinder, LinkKind};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum ImageSize {
+    Large,
+    Preview,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Image {
+    pub url: String,
+    pub width: isize,
+    pub height: isize,
+    pub size: ImageSize,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Video {
+    pub url: String,
+    pub width: isize,
+    pub height: isize,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum TwitchType {
+    Channel,
+    Video,
+    Clip,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum BandcampType {
+    Album,
+    Track,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Special {
+    None,
+    YouTube {
+        id: String,
+    },
+    Twitch {
+        content_type: TwitchType,
+        id: String,
+    },
+    Spotify {
+        content_type: String,
+        id: String,
+    },
+    Soundcloud,
+    Bandcamp {
+        content_type: BandcampType,
+        id: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Metadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    special: Option<Special>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    image: Option<Image>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    video: Option<Video>,
+
+    // #[serde(skip_serializing_if = "Option::is_none")]
+    // opengraph_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    site_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    icon_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    color: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum Embed {
+    Website(Metadata),
+    Image(Image),
+    None,
+}
+
+impl Embed {
+    pub async fn generate(content: String) -> Result<Vec<Embed>> {
+        lazy_static! {
+            static ref RE_CODE: Regex = Regex::new("```(?:.|\n)+?```|`(?:.|\n)+?`").unwrap();
+        }
+
+        // Ignore code blocks.
+        let content = RE_CODE.replace_all(&content, "");
+
+        let content = content
+            // Ignore quoted lines.
+            .split("\n")
+            .map(|v| {
+                if let Some(c) = v.chars().next() {
+                    if c == '>' {
+                        return "";
+                    }
+                }
+
+                v
+            })
+            .collect::<Vec<&str>>()
+            .join("\n");
+
+        // ! FIXME: allow multiple links
+        // ! FIXME: prevent generation if link is surrounded with < >
+        let mut finder = LinkFinder::new();
+        finder.kinds(&[LinkKind::Url]);
+        let links: Vec<_> = finder.links(&content).collect();
+
+        if links.len() == 0 {
+            return Err(Error::LabelMe);
+        }
+
+        let link = &links[0];
+
+        let client = reqwest::Client::new();
+        let result = client
+            .get(&format!("{}/embed", *JANUARY_URL))
+            .query(&[("url", link.as_str())])
+            .send()
+            .await;
+
+        match result {
+            Err(_) => return Err(Error::LabelMe),
+            Ok(result) => match result.status() {
+                reqwest::StatusCode::OK => {
+                    let res: Embed = result.json().await.map_err(|_| Error::InvalidOperation)?;
+
+                    Ok(vec![res])
+                }
+                _ => return Err(Error::LabelMe),
+            },
+        }
+    }
+}

src/database/entities/microservice/mod.rs

+pub mod autumn;
+pub mod january;

src/database/entities/mod.rs

 mod channel;
-mod guild;
+mod invites;
 mod message;
+mod microservice;
+mod server;
+mod sync;
 mod user;
 
+use microservice::*;
+
+pub use autumn::*;
 pub use channel::*;
-pub use guild::*;
+pub use invites::*;
+pub use january::*;
 pub use message::*;
+pub use server::*;
+pub use sync::*;
 pub use user::*;

src/database/entities/server.rs

+use std::collections::HashMap;
+
+use crate::database::*;
+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+use futures::StreamExt;
+use mongodb::bson::{Bson, doc};
+use mongodb::bson::from_document;
+use mongodb::bson::to_document;
+use mongodb::bson::Document;
+use rocket_contrib::json::JsonValue;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberCompositeKey {
+    pub server: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Member {
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nickname: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<File>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub roles: Option<Vec<String>>
+}
+
+pub type PermissionTuple = (
+    i32, // server permission
+    i32  // channel permission
+);
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Role {
+    pub name: String,
+    pub permissions: PermissionTuple,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub colour: Option<String>
+    // Bri'ish API conventions
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Category {
+    pub id: String,
+    pub title: String,
+    pub channels: Vec<String>
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Ban {
+    #[serde(rename = "_id")]
+    pub id: MemberCompositeKey,
+    pub reason: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct SystemMessageChannels {
+    pub user_joined: Option<String>,
+    pub user_left: Option<String>,
+    pub user_kicked: Option<String>,
+    pub user_banned: Option<String>,
+}
+
+pub enum RemoveMember {
+    Leave,
+    Kick,
+    Ban,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Server {
+    #[serde(rename = "_id")]
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<String>,
+    pub owner: String,
+
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    
+    pub channels: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub categories: Option<Vec<Category>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_messages: Option<SystemMessageChannels>,
+
+    #[serde(default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+    pub roles: HashMap<String, Role>,
+    pub default_permissions: PermissionTuple,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub icon: Option<File>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub banner: Option<File>,
+}
+
+impl Server {
+    pub async fn create(self) -> Result<()> {
+        get_collection("servers")
+            .insert_one(
+                to_document(&self).map_err(|_| Error::DatabaseError {
+                    operation: "to_bson",
+                    with: "channel",
+                })?,
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "server",
+            })?;
+
+        Ok(())
+    }
+
+    pub async fn publish_update(&self, data: JsonValue) -> Result<()> {
+        ClientboundNotification::ServerUpdate {
+            id: self.id.clone(),
+            data,
+            clear: None,
+        }
+        .publish(self.id.clone());
+
+        Ok(())
+    }
+
+    pub async fn delete(&self) -> Result<()> {
+        // Check if there are any attachments we need to delete.
+        Channel::delete_messages(Bson::Document(doc! { "$in": &self.channels })).await?;
+
+        // Delete all channels.
+        get_collection("channels")
+            .delete_many(
+                doc! {
+                    "server": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_many",
+                with: "channels",
+            })?;
+
+        // Delete any associated objects, e.g. unreads and invites.
+        Channel::delete_associated_objects(Bson::Document(doc! { "$in": &self.channels })).await?;
+
+        // Delete members and bans.
+        for with in &["server_members", "server_bans"] {
+            get_collection(with)
+                .delete_many(
+                    doc! {
+                        "_id.server": &self.id
+                    },
+                    None,
+                )
+                .await
+                .map_err(|_| Error::DatabaseError {
+                    operation: "delete_many",
+                    with,
+                })?;
+        }
+
+        // Delete server icon / banner.
+        if let Some(attachment) = &self.icon {
+            attachment.delete().await?;
+        }
+
+        if let Some(attachment) = &self.banner {
+            attachment.delete().await?;
+        }
+
+        // Delete the server
+        get_collection("servers")
+            .delete_one(
+                doc! {
+                    "_id": &self.id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "server",
+            })?;
+
+        ClientboundNotification::ServerDelete {
+            id: self.id.clone(),
+        }
+        .publish(self.id.clone());
+
+        Ok(())
+    }
+
+    pub async fn fetch_members(id: &str) -> Result<Vec<Member>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| from_document(x).ok())
+            .collect::<Vec<Member>>())
+    }
+
+    pub async fn fetch_member_ids(id: &str) -> Result<Vec<String>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                x.get_document("_id")
+                    .ok()
+                    .map(|i| i.get_str("user").ok().map(|x| x.to_string()))
+            })
+            .flatten()
+            .collect::<Vec<String>>())
+    }
+
+    pub async fn join_member(&self, id: &str) -> Result<()> {
+        if get_collection("server_bans")
+            .find_one(
+                doc! {
+                    "_id.server": &self.id,
+                    "_id.user": &id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_bans",
+            })?
+            .is_some()
+        {
+            return Err(Error::Banned);
+        }
+
+        get_collection("server_members")
+            .insert_one(
+                doc! {
+                    "_id": {
+                        "server": &self.id,
+                        "user": &id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "insert_one",
+                with: "server_members",
+            })?;
+
+        ClientboundNotification::ServerMemberJoin {
+            id: self.id.clone(),
+            user: id.to_string(),
+        }
+        .publish(self.id.clone());
+
+        if let Some(channels) = &self.system_messages {
+            if let Some(cid) = &channels.user_joined {
+                let channel = Ref::from_unchecked(cid.clone()).fetch_channel().await?;
+                Content::SystemMessage(SystemMessage::UserJoined { id: id.to_string() })
+                    .send_as_system(&channel)
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn remove_member(&self, id: &str, removal: RemoveMember) -> Result<()> {
+        let result = get_collection("server_members")
+            .delete_one(
+                doc! {
+                    "_id": {
+                        "server": &self.id,
+                        "user": &id
+                    }
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "delete_one",
+                with: "server_members",
+            })?;
+
+        if result.deleted_count > 0 {
+            ClientboundNotification::ServerMemberLeave {
+                id: self.id.clone(),
+                user: id.to_string(),
+            }
+            .publish(self.id.clone());
+
+            if let Some(channels) = &self.system_messages {
+                let message = match removal {
+                    RemoveMember::Leave => {
+                        if let Some(cid) = &channels.user_left {
+                            Some((cid.clone(), SystemMessage::UserLeft { id: id.to_string() }))
+                        } else {
+                            None
+                        }
+                    }
+                    RemoveMember::Kick => {
+                        if let Some(cid) = &channels.user_kicked {
+                            Some((
+                                cid.clone(),
+                                SystemMessage::UserKicked { id: id.to_string() },
+                            ))
+                        } else {
+                            None
+                        }
+                    }
+                    RemoveMember::Ban => {
+                        if let Some(cid) = &channels.user_banned {
+                            Some((
+                                cid.clone(),
+                                SystemMessage::UserBanned { id: id.to_string() },
+                            ))
+                        } else {
+                            None
+                        }
+                    }
+                };
+
+                if let Some((cid, message)) = message {
+                    let channel = Ref::from_unchecked(cid).fetch_channel().await?;
+                    Content::SystemMessage(message)
+                        .send_as_system(&channel)
+                        .await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn get_member_count(id: &str) -> Result<i64> {
+        Ok(get_collection("server_members")
+            .count_documents(
+                doc! {
+                    "_id.server": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "count_documents",
+                with: "server_members",
+            })?)
+    }
+}

src/database/entities/sync.rs

+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+pub type UserSettings = HashMap<String, (i64, String)>;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChannelCompositeKey {
+    pub channel: String,
+    pub user: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ChannelUnread {
+    #[serde(rename = "_id")]
+    pub id: ChannelCompositeKey,
+
+    pub last_id: Option<String>,
+    pub mentions: Option<Vec<String>>,
+}

src/database/entities/user.rs

-use crate::{database::get_collection, notifications::events::ClientboundNotification, util::result::{Error, Result}};
-use crate::database::guards::reference::Ref;
-use mongodb::{bson::{doc, from_bson, Bson}, options::FindOptions};
-use rauth::auth::Session;
-use rocket::http::Status;
-use rocket::request::{self, FromRequest, Outcome, Request};
-use serde::{Deserialize, Serialize};
 use futures::StreamExt;
+use mongodb::bson::Document;
+use mongodb::options::{Collation, FindOneOptions};
+use mongodb::{
+    bson::{doc, from_document},
+    options::FindOptions,
+};
+use num_enum::TryFromPrimitive;
+use serde::{Deserialize, Serialize};
+use std::ops;
+use ulid::Ulid;
+use validator::Validate;
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+use crate::database::permissions::user::UserPermissions;
+use crate::database::*;
+use crate::notifications::websocket::is_online;
+use crate::util::result::{Error, Result};
+use crate::util::variables::EARLY_ADOPTER_BADGE;
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub enum RelationshipStatus {
     None,
     User,
@@ -18,107 +28,273 @@ pub enum RelationshipStatus {
     BlockedOther,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Relationship {
     #[serde(rename = "_id")]
     pub id: String,
     pub status: RelationshipStatus,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Presence {
+    Online,
+    Idle,
+    Busy,
+    Invisible,
+}
+
+#[derive(Validate, Serialize, Deserialize, Debug, Clone)]
+pub struct UserStatus {
+    #[validate(length(min = 1, max = 128))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presence: Option<Presence>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct UserProfile {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub background: Option<File>,
+}
+
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, Copy, Clone)]
+#[repr(i32)]
+pub enum Badges {
+    Developer = 1,
+    Translator = 2,
+    Supporter = 4,
+    ResponsibleDisclosure = 8,
+    RevoltTeam = 16,
+    EarlyAdopter = 256,
+}
+
+impl_op_ex_commutative!(+ |a: &i32, b: &Badges| -> i32 { *a | *b as i32 });
+
+// When changing this struct, update notifications/payload.rs#80
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct User {
     #[serde(rename = "_id")]
     pub id: String,
     pub username: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<File>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub relations: Option<Vec<Relationship>>,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub badges: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status: Option<UserStatus>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub profile: Option<UserProfile>,
+
     // ? This should never be pushed to the collection.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub relationship: Option<RelationshipStatus>
+    pub relationship: Option<RelationshipStatus>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub online: Option<bool>,
 }
 
-#[rocket::async_trait]
-impl<'a, 'r> FromRequest<'a, 'r> for User {
-    type Error = rauth::util::Error;
+impl User {
+    /// Mutate the user object to include relationship as seen by user.
+    pub fn from(mut self, user: &User) -> User {
+        self.relationship = Some(RelationshipStatus::None);
+
+        if self.id == user.id {
+            self.relationship = Some(RelationshipStatus::User);
+            return self;
+        }
+
+        self.relations = None;
+        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 {
+        let mut badges = self.badges.unwrap_or_else(|| 0);
+        if let Ok(id) = Ulid::from_string(&self.id) {
+            if id.datetime().timestamp_millis() < *EARLY_ADOPTER_BADGE {
+                badges = badges + Badges::EarlyAdopter;
+            }
+        }
+
+        self.badges = Some(badges);
+
+        if permissions.get_view_profile() {
+            self.online = Some(is_online(&self.id));
+        } else {
+            self.status = None;
+        }
+
+        self.profile = None;
+        self
+    }
+
+    /// Mutate the user object to appear as seen by user.
+    /// Also overrides the relationship status.
+    pub async fn from_override(
+        mut self,
+        user: &User,
+        relationship: RelationshipStatus,
+    ) -> Result<User> {
+        let permissions = PermissionCalculator::new(&user)
+            .with_relationship(&relationship)
+            .for_user(&self.id)
+            .await?;
 
-    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
-        let session: Session = try_outcome!(request.guard::<Session>().await);
+        self.relations = None;
+        self.relationship = Some(relationship);
+        Ok(self.with(permissions))
+    }
+
+    /// Utility function for checking claimed usernames.
+    pub async fn is_username_taken(username: &str) -> Result<bool> {
+        if username.to_lowercase() == "revolt" || username.to_lowercase() == "admin" || username.to_lowercase() == "system" {
+            return Ok(true);
+        }
 
-        if let Ok(result) = get_collection("users")
+        if get_collection("users")
             .find_one(
                 doc! {
-                    "_id": &session.user_id
+                    "username": username
                 },
-                None,
+                FindOneOptions::builder()
+                    .collation(Collation::builder().locale("en").strength(2).build())
+                    .build(),
             )
             .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "user",
+            })?
+            .is_some()
         {
-            if let Some(doc) = result {
-                Outcome::Success(from_bson(Bson::Document(doc)).unwrap())
-            } else {
-                Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
-            }
+            Ok(true)
         } else {
-            Outcome::Failure((
-                Status::InternalServerError,
-                rauth::util::Error::DatabaseError,
-            ))
+            Ok(false)
         }
     }
-}
 
-impl User {
-    pub fn as_ref(&self) -> Ref {
-        Ref {
-            id: self.id.to_string(),
-        }
-    }
-
-    pub async fn generate_ready_payload(self) -> Result<ClientboundNotification> {
+    /// Utility function for fetching multiple users from the perspective of one.
+    /// Assumes user has a mutual connection with others.
+    pub async fn fetch_multiple_users(&self, user_ids: Vec<String>) -> Result<Vec<User>> {
         let mut users = vec![];
-        
-        if let Some(relationships) = &self.relations {
-            let user_ids: Vec<String> = relationships
-                .iter()
-                .map(|relationship| relationship.id.clone())
-                .collect();
-            
-            let mut cursor = get_collection("users")
-                .find(
-                    doc! {
-                        "_id": {
-                            "$in": user_ids
-                        }
-                    },
-                    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 mut user: User = from_bson(Bson::Document(doc))
-                        .map_err(|_| Error::DatabaseError { operation: "from_bson", with: "user" })?;
-                    
-                    user.relationship = Some(
-                        relationships
-                            .iter()
-                            .find(|x| user.id == x.id)
-                            .ok_or_else(|| Error::InternalError)?
-                            .status
-                            .clone()
-                    );
-
-                    users.push(user);
-                }
+        let mut cursor = get_collection("users")
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": user_ids
+                    }
+                },
+                FindOptions::builder()
+                    .projection(
+                        doc! { "_id": 1, "username": 1, "avatar": 1, "badges": 1, "status": 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(&self)
+                    .with_mutual_connection()
+                    .with_user(&other)
+                    .for_user_given()
+                    .await?;
+
+                users.push(other.from(&self).with(permissions));
             }
         }
 
-        users.push(self);
+        Ok(users)
+    }
+
+    /// Utility function to get all of a user's memberships.
+    pub async fn fetch_memberships(id: &str) -> Result<Vec<Member>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                from_document(x).ok()
+            })
+            .collect::<Vec<Member>>())
+    }
 
-        Ok(ClientboundNotification::Ready { users })
+    /// Utility function to get all the server IDs the user is in.
+    pub async fn fetch_server_ids(id: &str) -> Result<Vec<String>> {
+        Ok(get_collection("server_members")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find",
+                with: "server_members",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await
+            .into_iter()
+            .filter_map(|x| {
+                x.get_document("_id")
+                    .ok()
+                    .map(|i| i.get_str("server").ok().map(|x| x.to_string()))
+            })
+            .flatten()
+            .collect::<Vec<String>>())
+    }
+
+    /// Utility function to fetch unread objects for user.
+    pub async fn fetch_unreads(id: &str) -> Result<Vec<Document>> {
+        Ok(get_collection("channel_unreads")
+            .find(
+                doc! {
+                    "_id.user": id
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "user_settings",
+            })?
+            .filter_map(async move |s| s.ok())
+            .collect::<Vec<Document>>()
+            .await)
     }
 }

src/database/guards/mod.rs

 pub mod reference;
 pub mod user;
+
+pub use reference::Ref;

src/database/guards/reference.rs

-use crate::database::entities::*;
-use crate::database::get_collection;
+use crate::database::*;
 use crate::util::result::{Error, Result};
-use mongodb::bson::{doc, from_bson, Bson};
+
+use mongodb::bson::{doc, from_document};
 use rocket::http::RawStr;
 use rocket::request::FromParam;
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use validator::Validate;
 
 #[derive(Validate, Serialize, Deserialize)]
 pub struct Ref {
-    #[validate(length(min = 26, max = 26))]
+    #[validate(length(min = 1, max = 26))]
     pub id: String,
 }
 
 impl Ref {
+    pub fn from_unchecked(id: String) -> Ref {
+        Ref { id }
+    }
+
     pub fn from(id: String) -> Result<Ref> {
-        Ok(Ref { id })
+        let r = Ref { id };
+        r.validate()
+            .map_err(|error| Error::FailedValidation { error })?;
+        Ok(r)
     }
 
-    pub async fn fetch_user(&self) -> Result<User> {
-        let doc = get_collection("users")
+    async fn fetch<T: DeserializeOwned>(&self, collection: &'static str) -> Result<T> {
+        let doc = get_collection(&collection)
             .find_one(
                 doc! {
                     "_id": &self.id
@@ -29,17 +36,94 @@ impl Ref {
             .await
             .map_err(|_| Error::DatabaseError {
                 operation: "find_one",
-                with: "user",
+                with: &collection,
+            })?
+            .ok_or_else(|| Error::NotFound)?;
+
+        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_server(&self) -> Result<Server> {
+        self.fetch("servers").await
+    }
+
+    pub async fn fetch_invite(&self) -> Result<Invite> {
+        self.fetch("channel_invites").await
+    }
+
+    pub async fn fetch_member(&self, server: &str) -> Result<Member> {
+        let doc = get_collection("server_members")
+            .find_one(
+                doc! {
+                    "_id.user": &self.id,
+                    "_id.server": server
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_member",
             })?
-            .ok_or_else(|| Error::UnknownUser)?;
+            .ok_or_else(|| Error::NotFound)?;
 
         Ok(
-            from_bson(Bson::Document(doc)).map_err(|_| Error::DatabaseError {
-                operation: "from_bson",
-                with: "user",
+            from_document::<Member>(doc).map_err(|_| Error::DatabaseError {
+                operation: "from_document",
+                with: "server_member",
             })?,
         )
     }
+
+    pub async fn fetch_ban(&self, server: &str) -> Result<Ban> {
+        let doc = get_collection("server_bans")
+            .find_one(
+                doc! {
+                    "_id.user": &self.id,
+                    "_id.server": server
+                },
+                None,
+            )
+            .await
+            .map_err(|_| Error::DatabaseError {
+                operation: "find_one",
+                with: "server_ban",
+            })?
+            .ok_or_else(|| Error::NotFound)?;
+
+        Ok(from_document::<Ban>(doc).map_err(|_| Error::DatabaseError {
+            operation: "from_document",
+            with: "server_ban",
+        })?)
+    }
+
+    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 {

src/database/guards/user.rs

+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/mod.rs

@@ -30,3 +30,7 @@ pub mod entities;
 pub mod guards;
 pub mod migrations;
 pub mod permissions;
+
+pub use entities::*;
+pub use guards::*;
+pub use permissions::*;