src/bin/dummy.rs

+fn main() {}

src/database/entities/microservice/mod.rs

+pub mod autumn;
+pub mod january;

src/database/entities/mod.rs

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

src/notifications/events/groups.rs → 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 UserJoin {
-    pub id: String,
+pub struct ChannelCompositeKey {
+    pub channel: String,
     pub user: String,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct UserLeave {
-    pub id: String,
-    pub user: String,
+pub struct ChannelUnread {
+    #[serde(rename = "_id")]
+    pub id: ChannelCompositeKey,
+
+    pub last_id: Option<String>,
+    pub mentions: Option<Vec<String>>,
 }

src/database/guards/mod.rs

+pub mod reference;
+pub mod user;
+
+pub use reference::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",
+                },
+            ))
+        }
+    }
+}