Add onboarding and FromRequest for User.

src/database/entities/mod.rs

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

src/database/entities/user.rs

@@ -1,4 +1,9 @@
+use mongodb::bson::{doc, from_bson, Bson};
+use rauth::auth::Session;
+use rocket::http::Status;
 use serde::{Deserialize, Serialize};
+use crate::database::get_collection;
+use rocket::request::{self, FromRequest, Outcome, Request};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Relationship {
@@ -10,6 +15,63 @@ pub struct Relationship {
 pub struct User {
     #[serde(rename = "_id")]
     pub id: String,
-    pub username: Option<String>,
+    pub username: String,
     pub relations: Option<Vec<Relationship>>,
 }
+
+#[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_bson(Bson::Document(doc)).unwrap()
+                )
+            } else {
+                Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
+            }
+        } else {
+            Outcome::Failure((Status::InternalServerError, rauth::util::Error::DatabaseError))
+        }
+
+        /*Outcome::Success(
+            User {
+                id: "gaming".to_string(),
+                username: None,
+                relations: None
+            }
+        )*/
+
+        /*match (
+            request.managed_state::<Auth>(),
+            header_user_id,
+            header_session_token,
+        ) {
+            (Some(auth), Some(user_id), Some(session_token)) => {
+                let session = Session {
+                    id: None,
+                    user_id,
+                    session_token,
+                };
+
+                if let Ok(session) = auth.verify_session(session).await {
+                    Outcome::Success(session)
+                } else {
+                    Outcome::Failure((Status::Forbidden, Error::InvalidSession))
+                }
+            }
+            (None, _, _) => Outcome::Failure((Status::InternalServerError, Error::InternalError)),
+            (_, _, _) => Outcome::Failure((Status::Forbidden, Error::MissingHeaders)),
+        }*/
+    }
+}

src/database/guards/mod.rs

@@ -1,4 +1,7 @@
-/**
+pub mod user;
+pub mod reference;
+
+/*
 // ! FIXME
 impl<'r> FromParam<'r> for User {
     type Error = &'r RawStr;

src/database/migrations/init.rs

@@ -10,28 +10,28 @@ pub async fn create_database() {
     let db = get_db();
 
     db.create_collection("users", None)
-        .await
-        .expect("Failed to create users collection.");
+    .await
+    .expect("Failed to create users collection.");
     
     db.create_collection("channels", None)
-        .await
-        .expect("Failed to create channels collection.");
+    .await
+    .expect("Failed to create channels collection.");
     
     db.create_collection("guilds", None)
-        .await
-        .expect("Failed to create guilds collection.");
+    .await
+    .expect("Failed to create guilds collection.");
     
     db.create_collection("members", None)
-        .await
-        .expect("Failed to create members collection.");
+    .await
+    .expect("Failed to create members collection.");
     
     db.create_collection("messages", None)
-        .await
-        .expect("Failed to create messages collection.");
+    .await
+    .expect("Failed to create messages collection.");
     
     db.create_collection("migrations", None)
-        .await
-        .expect("Failed to create migrations collection.");
+    .await
+    .expect("Failed to create migrations collection.");
 
     db.create_collection(
         "pubsub",
@@ -40,19 +40,41 @@ pub async fn create_database() {
             .size(1_000_000)
             .build(),
     )
-        .await
-        .expect("Failed to create pubsub collection.");
+    .await
+    .expect("Failed to create pubsub collection.");
+
+    db.run_command(
+        doc! {
+            "createIndexes": "users",
+            "indexes": [
+                {
+                    "key": {
+                        "username": 1
+                    },
+                    "name": "username",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2
+                    }
+                }
+            ]
+        },
+        None
+    )
+    .await
+    .expect("Failed to create username index.");
 
     db.collection("migrations")
-        .insert_one(
-            doc! {
-                "_id": 0,
-                "revision": LATEST_REVISION
-            },
-            None,
-        )
-        .await
-        .expect("Failed to save migration info.");
+    .insert_one(
+        doc! {
+            "_id": 0,
+            "revision": LATEST_REVISION
+        },
+        None,
+    )
+    .await
+    .expect("Failed to save migration info.");
 
     info!("Created database.");
 }

src/database/migrations/scripts.rs

@@ -1,4 +1,4 @@
-use super::super::get_collection;
+use super::super::{get_db, get_collection};
 
 use log::info;
 use mongodb::options::FindOptions;
@@ -12,7 +12,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 2;
+pub const LATEST_REVISION: i32 = 3;
 
 pub async fn migrate_database() {
     let migrations = get_collection("migrations");
@@ -121,6 +121,32 @@ pub async fn run_migrations(revision: i32) -> i32 {
         }
     }
 
+    if revision <= 2 {
+        info!("Running migration [revision 2]: Add username index to users.");
+
+        get_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.");
+    }
+
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION
 }

src/database/mod.rs

@@ -28,3 +28,4 @@ pub fn get_collection(collection: &str) -> Collection {
 
 pub mod migrations;
 pub mod entities;
+pub mod guards;