Refractor to use UserRef.

src/guards/auth.rs

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

src/guards/channel.rs

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

src/guards/guild.rs

@@ -1,10 +1,73 @@
-use bson::{bson, doc, from_bson};
+use bson::{bson, doc, from_bson, Document};
+use mongodb::options::FindOneOptions;
 use rocket::http::RawStr;
 use rocket::request::FromParam;
+use serde::{Deserialize, Serialize};
 
 use crate::database;
+use crate::database::guild::Guild;
 
-use database::guild::Guild;
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct GuildRef {
+    #[serde(rename = "_id")]
+    pub id: String,
+
+    pub owner: String,
+    pub default_permissions: i32,
+}
+
+impl GuildRef {
+    pub fn from(id: String) -> Option<GuildRef> {
+        match database::get_collection("guilds").find_one(
+            doc! { "_id": id },
+            FindOneOptions::builder()
+                .projection(doc! {
+                    "owner": 1,
+                    "default_permissions": 1
+                })
+                .build(),
+        ) {
+            Ok(result) => match result {
+                Some(doc) => {
+                    Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap guild."))
+                }
+                None => None,
+            },
+            Err(_) => None,
+        }
+    }
+
+    pub fn fetch_data(&self, projection: Document) -> Option<Document> {
+        database::get_collection("guilds")
+            .find_one(
+                doc! { "_id": &self.id },
+                FindOneOptions::builder().projection(projection).build(),
+            )
+            .expect("Failed to fetch guild from database.")
+    }
+
+    pub fn fetch_data_given(&self, mut filter: Document, projection: Document) -> Option<Document> {
+        filter.insert("_id", self.id.clone());
+        database::get_collection("guilds")
+            .find_one(
+                filter,
+                FindOneOptions::builder().projection(projection).build(),
+            )
+            .expect("Failed to fetch guild from database.")
+    }
+}
+
+impl<'r> FromParam<'r> for GuildRef {
+    type Error = &'r RawStr;
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        if let Some(guild) = GuildRef::from(param.to_string()) {
+            Ok(guild)
+        } else {
+            Err(param)
+        }
+    }
+}
 
 impl<'r> FromParam<'r> for Guild {
     type Error = &'r RawStr;