Merge branch 'revoltchat:master' into patch-1

set_version.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
-export version=0.5.3-alpha.4
+export version=0.5.3-alpha.4-patch.0
 echo "pub const VERSION: &str = \"${version}\";" > src/version.rs

src/database/guards/user.rs

@@ -10,90 +10,72 @@ impl<'r> FromRequest<'r> for User {
     type Error = rauth::util::Error;
 
     async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
-        let header_bot_token = request
+        let user: &Option<User> = request.local_cache_async(async {
-            .headers()
+            let header_bot_token = request
-            .get("x-bot-token")
+                .headers()
-            .next()
+                .get("x-bot-token")
-            .map(|x| x.to_string());
+                .next()
+                .map(|x| x.to_string());
 
-        if let Some(bot_token) = header_bot_token {
+            if let Some(bot_token) = header_bot_token {
-            return if let Ok(result) = get_collection("bots")
+                if let Ok(result) = get_collection("bots")
-                .find_one(
-                    doc! {
-                        "token": bot_token
-                    },
-                    None,
-                )
-                .await
-            {
-                if let Some(doc) = result {
-                    let id = doc.get_str("_id").unwrap();
-                    if let Ok(result) = get_collection("users")
-                        .find_one(
-                            doc! {
-                                "_id": &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",
-                            },
-                        ))
-                    }
-                } else {
-                    Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
-                }
-            } else {
-                Outcome::Failure((
-                    Status::InternalServerError,
-                    rauth::util::Error::DatabaseError {
-                        operation: "find_one",
-                        with: "bot",
-                    },
-                ))
-            };
-        } else {
-            if let Outcome::Success(session) = request.guard::<Session>().await {
-                if let Ok(result) = get_collection("users")
                     .find_one(
                         doc! {
-                            "_id": &session.user_id
+                            "token": bot_token
                         },
                         None,
                     )
                     .await
                 {
                     if let Some(doc) = result {
-                        Outcome::Success(from_document(doc).unwrap())
+                        let id = doc.get_str("_id").unwrap();
-                    } else {
+                        if let Ok(result) = get_collection("users")
-                        Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
+                            .find_one(
+                                doc! {
+                                    "_id": &id
+                                },
+                                None,
+                            )
+                            .await
+                        {
+                            if let Some(doc) = result {
+                                if let Ok(user) = from_document(doc) {
+                                    return Some(user)
+                                }
+                            }
+                        }
                     }
-                } else {
-                    Outcome::Failure((
-                        Status::InternalServerError,
-                        rauth::util::Error::DatabaseError {
-                            operation: "find_one",
-                            with: "user",
-                        },
-                    ))
                 }
             } else {
-                Outcome::Failure((Status::Forbidden, rauth::util::Error::InvalidSession))
+                if let Outcome::Success(session) = 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 {
+                            if let Ok(user) = from_document(doc) {
+                                return Some(user)
+                            }
+                        }
+                    }
+                }
             }
+
+            None
+        }).await;
+
+        if let Some(user) = user {
+            Outcome::Success(user.clone())
+        } else {
+            Outcome::Failure((
+                Status::Forbidden,
+                rauth::util::Error::InvalidSession,
+            ))
         }
     }
 }

src/routes/channels/message_send.rs

@@ -35,7 +35,7 @@ lazy_static! {
 }
 
 #[post("/<target>/messages", data = "<message>")]
-pub async fn message_send(_r: Ratelimiter, user: User, target: Ref, message: Json<Data>) -> Result<RatelimitResponse<Value>> {
+pub async fn message_send(user: User, _r: Ratelimiter, target: Ref, message: Json<Data>) -> Result<RatelimitResponse<Value>> {
     let message = message.into_inner();
     message
         .validate()

src/util/ratelimit.rs

@@ -1,7 +1,6 @@
 use rocket::{async_trait, http::Status, request::{Outcome, FromRequest}, response};
 use std::{collections::{HashMap, hash_map::DefaultHasher}, time};
-use rauth::entities::Session;
+use crate::{database::User, util::result::Error};
-use crate::util::result::Error;
 use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Mutex};
 
@@ -121,14 +120,15 @@ impl<'r> FromRequest<'r> for Ratelimiter {
         let res = request.local_cache_async(async {
             if let Some(route) = request.route() {
                 if let Some(route_name) = &route.name {
-                    let session = request.guard::<Session>().await.unwrap();
+                    let user = request.guard::<User>().await.unwrap();
+
                     let state = request.guard::<&rocket::State<RatelimitState>>().await.unwrap().inner();
                     let arc = Arc::clone(&state.0);
                     let mut mutex = arc.lock().unwrap();
                     let mapping = mutex.get_mut(route_name.as_ref()).unwrap();
 
                     // create a unique key tied to the user id and route they use
-                    let key = format!("{}:{}:{}", session.user_id, route.method.as_str(), route.uri.as_str());
+                    let key = format!("{}:{}:{}", user.id, route.method.as_str(), route.uri.as_str());
                     let mut hasher = DefaultHasher::new();
 
                     key.hash(&mut hasher);

src/version.rs

@@ -1 +1 @@
-pub const VERSION: &str = "0.5.3-alpha.4";
+pub const VERSION: &str = "0.5.3-alpha.4-patch.0";