refactor(quark): port message_react, message_send, message_unreact, permissions_set_default, permissions_set

#283

crates/core/database/src/models/messages/model.rs

@@ -18,7 +18,7 @@ use crate::{
     events::client::EventV1,
     tasks::{self, ack::AckEvent},
     util::idempotency::IdempotencyKey,
-    Channel, Database, Emoji, File,
+    Channel, Database, Emoji, File, User,
 };
 
 auto_derived_partial!(
@@ -542,6 +542,40 @@ impl Message {
         Ok(())
     }
 
+    /// Add a reaction to a message
+    pub async fn add_reaction(&self, db: &Database, user: &User, emoji: &str) -> Result<()> {
+        // Check how many reactions are already on the message
+        let config = config().await;
+        if self.reactions.len() >= config.features.limits.default.message_reactions
+            && !self.reactions.contains_key(emoji)
+        {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Check if the emoji is whitelisted
+        if !self.interactions.can_use(emoji) {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Check if the emoji is usable by us
+        if !Emoji::can_use(db, emoji).await? {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        // Send reaction event
+        EventV1::MessageReact {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            user_id: user.id.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        // Add emoji
+        db.add_reaction(&self.id, emoji, &user.id).await
+    }
+
     /// Validate the sum of content of a message is under threshold
     pub fn validate_sum(
         content: &Option<String>,
@@ -607,6 +641,53 @@ impl Message {
         .await;
         Ok(())
     }
+
+    /// Remove a reaction from a message
+    pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
+        // Check if it actually exists
+        let empty = if let Some(users) = self.reactions.get(emoji) {
+            if !users.contains(user) {
+                return Err(create_error!(NotFound));
+            }
+
+            users.len() == 1
+        } else {
+            return Err(create_error!(NotFound));
+        };
+
+        // Send reaction event
+        EventV1::MessageUnreact {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            user_id: user.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        if empty {
+            // If empty, remove the reaction entirely
+            db.clear_reaction(&self.id, emoji).await
+        } else {
+            // Otherwise only remove that one reaction
+            db.remove_reaction(&self.id, emoji, user).await
+        }
+    }
+
+    /// Remove a reaction from a message
+    pub async fn clear_reaction(&self, db: &Database, emoji: &str) -> Result<()> {
+        // Send reaction event
+        EventV1::MessageRemoveReaction {
+            id: self.id.to_string(),
+            channel_id: self.channel.to_string(),
+            emoji_id: emoji.to_string(),
+        }
+        .p(self.channel.to_string())
+        .await;
+
+        // Write to database
+        db.clear_reaction(&self.id, emoji).await
+    }
 }
 
 impl SystemMessage {

crates/core/database/src/util/permissions.rs

@@ -464,6 +464,13 @@ impl<'a> DatabasePermissionQuery<'a> {
     pub fn member_ref(&self) -> &Option<Cow<Member>> {
         &self.member
     }
+
+    /// Get the known member's current ranking
+    pub fn get_member_rank(&self) -> Option<i64> {
+        self.member
+            .as_ref()
+            .map(|member| member.get_ranking(self.server.as_ref().unwrap()))
+    }
 }
 
 /// Short-hand for creating a permission calculator

crates/core/models/src/v0/channels.rs

@@ -1,6 +1,6 @@
 use super::File;
 
-use revolt_permissions::OverrideField;
+use revolt_permissions::{Override, OverrideField};
 use std::collections::{HashMap, HashSet};
 
 #[cfg(feature = "rocket")]
@@ -262,6 +262,25 @@ auto_derived!(
         pub nsfw: Option<bool>,
     }
 
+    /// New default permissions
+    #[serde(untagged)]
+    pub enum DataDefaultChannelPermissions {
+        Value {
+            /// Permission values to set for members in a `Group`
+            permissions: u64,
+        },
+        Field {
+            /// Allow / deny values to set for members in this `TextChannel` or `VoiceChannel`
+            permissions: Override,
+        },
+    }
+
+    /// New role permissions
+    pub struct DataSetRolePermissions {
+        /// Allow / deny values to set for this role
+        pub permissions: Override,
+    }
+
     /// Options when deleting a channel
     #[cfg_attr(feature = "rocket", derive(FromForm))]
     pub struct OptionsChannelDelete {

crates/core/models/src/v0/messages.rs

@@ -272,7 +272,7 @@ auto_derived!(
     }
 
     /// Options for searching for messages
-    pub struct OptionsMessageSearch {
+    pub struct DataMessageSearch {
         /// Full-text search query
         ///
         /// See [MongoDB documentation](https://docs.mongodb.com/manual/text-search/#-text-operator) for more information.
@@ -318,6 +318,15 @@ auto_derived!(
         #[validate(length(min = 1, max = 100))]
         pub ids: Vec<String>,
     }
+
+    /// Options for removing reaction
+    #[cfg_attr(feature = "rocket", derive(FromForm))]
+    pub struct OptionsUnreact {
+        /// Remove a specific user's reaction
+        pub user_id: Option<String>,
+        /// Remove all reactions
+        pub remove_all: Option<bool>,
+    }
 );
 
 /// Message Author Abstraction

crates/core/permissions/src/models/mod.rs

@@ -63,6 +63,37 @@ impl PermissionValue {
             }))
         }
     }
+
+    /// Throw an error if we cannot grant permissions on either allows or denies
+    /// going from the previous given value to the next given value.
+    ///
+    /// We need to check any:
+    /// - allows added (permissions now granted)
+    /// - denies removed (permissions now neutral or granted)
+    pub async fn throw_permission_override<C>(
+        &self,
+        current_value: C,
+        next_value: &Override,
+    ) -> Result<()>
+    where
+        C: Into<Option<Override>>,
+    {
+        let current_value = current_value.into();
+
+        if let Some(current_value) = current_value {
+            if !self.has(!current_value.allows() & next_value.allows())
+                || !self.has(current_value.denies() & !next_value.denies())
+            {
+                return Err(create_error!(CannotGiveMissingPermissions));
+            }
+        } else {
+            if !self.has(next_value.allows()) {
+                return Err(create_error!(CannotGiveMissingPermissions));
+            }
+        }
+
+        Ok(())
+    }
 }
 
 impl From<i64> for PermissionValue {

crates/delta/src/routes/channels/message_react.rs

@@ -1,4 +1,11 @@
-use revolt_quark::{models::User, perms, Db, EmptyResponse, Permission, Ref, Result};
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
+};
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
+use revolt_result::Result;
+use rocket::State;
+use rocket_empty::EmptyResponse;
 
 /// # Add Reaction to Message
 ///
@@ -6,20 +13,20 @@ use revolt_quark::{models::User, perms, Db, EmptyResponse, Permission, Ref, Resu
 #[openapi(tag = "Interactions")]
 #[put("/<target>/messages/<msg>/reactions/<emoji>")]
 pub async fn react_message(
-    db: &Db,
+    db: &State<Database>,
     user: User,
-    target: Ref,
+    target: Reference,
-    msg: Ref,
+    msg: Reference,
-    emoji: Ref,
+    emoji: Reference,
 ) -> Result<EmptyResponse> {
     let channel = target.as_channel(db).await?;
-    perms(&user)
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
-        .channel(&channel)
+    calculate_channel_permissions(&mut query)
-        .throw_permission_and_view_channel(db, Permission::React)
+        .await
-        .await?;
+        .throw_if_lacking_channel_permission(ChannelPermission::React)?;
 
     // Fetch relevant message
-    let message = msg.as_message_in(db, channel.id()).await?;
+    let message = msg.as_message_in_channel(db, &channel.id()).await?;
 
     // Add the reaction
     message

crates/delta/src/routes/channels/message_send.rs

@@ -32,7 +32,6 @@ pub async fn message_send(
 
     // Ensure we have permissions to send a message
     let channel = target.as_channel(db).await?;
-
     let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
     let permissions = calculate_channel_permissions(&mut query).await;
     permissions.throw_if_lacking_channel_permission(ChannelPermission::SendMessage)?;

crates/delta/src/routes/channels/message_unreact.rs

@@ -1,14 +1,12 @@
-use revolt_quark::{models::User, perms, Db, EmptyResponse, Permission, Ref, Result};
+use revolt_database::{
-use serde::{Deserialize, Serialize};
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
-
+    Database, User,
-/// # Query Parameters
+};
-#[derive(Serialize, Deserialize, JsonSchema, FromForm)]
+use revolt_models::v0;
-pub struct OptionsUnreact {
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
-    /// Remove a specific user's reaction
+use revolt_result::Result;
-    user_id: Option<String>,
+use rocket::State;
-    /// Remove all reactions
+use rocket_empty::EmptyResponse;
-    remove_all: Option<bool>,
-}
 
 /// # Remove Reaction(s) to Message
 ///
@@ -18,29 +16,27 @@ pub struct OptionsUnreact {
 #[openapi(tag = "Interactions")]
 #[delete("/<target>/messages/<msg>/reactions/<emoji>?<options..>")]
 pub async fn unreact_message(
-    db: &Db,
+    db: &State<Database>,
     user: User,
-    target: Ref,
+    target: Reference,
-    msg: Ref,
+    msg: Reference,
-    emoji: Ref,
+    emoji: Reference,
-    options: OptionsUnreact,
+    options: v0::OptionsUnreact,
 ) -> Result<EmptyResponse> {
     let channel = target.as_channel(db).await?;
-    let mut permissions = perms(&user).channel(&channel);
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
-    permissions
+    let permissions = calculate_channel_permissions(&mut query).await;
-        .throw_permission_and_view_channel(db, Permission::React)
+
-        .await?;
+    permissions.throw_if_lacking_channel_permission(ChannelPermission::React)?;
 
     // Check if we need to escalate permissions
     let remove_all = options.remove_all.unwrap_or_default();
     if options.user_id.is_some() || remove_all {
-        permissions
+        permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageMessages)?;
-            .throw_permission(db, Permission::ManageMessages)
-            .await?;
     }
 
     // Fetch relevant message
-    let message = msg.as_message_in(db, channel.id()).await?;
+    let message = msg.as_message_in_channel(db, &channel.id()).await?;
 
     // Check if we should wipe all of this reaction
     if remove_all {

crates/delta/src/routes/channels/mod.rs

@@ -45,8 +45,8 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         group_add_member::add_member,
         group_remove_member::remove_member,
         voice_join::call,
-        permissions_set::req,
+        permissions_set::set_role_permissions,
-        permissions_set_default::req,
+        permissions_set_default::set_default_permissions,
         message_react::react_message,
         message_unreact::unreact_message,
         message_clear_reactions::clear_reactions,

crates/delta/src/routes/channels/permissions_set.rs

@@ -1,17 +1,12 @@
-use rocket::serde::json::Json;
+use revolt_database::{
-use serde::Deserialize;
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
-
+    Channel, Database, User,
-use revolt_quark::{
-    models::{Channel, User},
-    perms, Db, Error, Override, Permission, Ref, Result,
 };
-
+use revolt_models::v0;
-/// # Permission Value
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission, Override};
-#[derive(Deserialize, JsonSchema)]
+use revolt_result::{create_error, Result};
-pub struct Data {
+use rocket::{serde::json::Json, State};
-    /// Allow / deny values to set for this role
+use serde::Deserialize;
-    permissions: Override,
-}
 
 /// # Set Role Permission
 ///
@@ -20,40 +15,39 @@ pub struct Data {
 /// Channel must be a `TextChannel` or `VoiceChannel`.
 #[openapi(tag = "Channel Permissions")]
 #[put("/<target>/permissions/<role_id>", data = "<data>", rank = 2)]
-pub async fn req(
+pub async fn set_role_permissions(
-    db: &Db,
+    db: &State<Database>,
     user: User,
-    target: Ref,
+    target: Reference,
     role_id: String,
-    data: Json<Data>,
+    data: Json<v0::DataSetRolePermissions>,
-) -> Result<Json<Channel>> {
+) -> Result<Json<v0::Channel>> {
     let mut channel = target.as_channel(db).await?;
-    let mut permissions = perms(&user).channel(&channel);
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    let permissions = calculate_channel_permissions(&mut query).await;
 
-    permissions
+    permissions.throw_if_lacking_channel_permission(ChannelPermission::ManagePermissions)?;
-        .throw_permission_and_view_channel(db, Permission::ManagePermissions)
-        .await?;
 
-    if let Some(server) = permissions.server.get() {
+    if let Some(server) = query.server_ref() {
         if let Some(role) = server.roles.get(&role_id) {
-            if role.rank <= permissions.get_member_rank().unwrap_or(i64::MIN) {
+            if role.rank <= query.get_member_rank().unwrap_or(i64::MIN) {
-                return Err(Error::NotElevated);
+                return Err(create_error!(NotElevated));
             }
 
             let current_value: Override = role.permissions.into();
             permissions
-                .throw_permission_override(db, current_value, data.permissions)
+                .throw_permission_override(current_value, &data.permissions)
                 .await?;
 
             channel
-                .set_role_permission(db, &role_id, data.permissions.into())
+                .set_role_permission(db, &role_id, data.permissions.clone().into())
                 .await?;
 
-            Ok(Json(channel))
+            Ok(Json(channel.into()))
         } else {
-            Err(Error::NotFound)
+            Err(create_error!(NotFound))
         }
     } else {
-        Err(Error::InvalidOperation)
+        Err(create_error!(InvalidOperation))
     }
 }

crates/delta/src/routes/channels/permissions_set_default.rs

@@ -1,24 +1,11 @@
-use rocket::serde::json::Json;
+use revolt_database::{
-use serde::Deserialize;
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
-
+    Channel, Database, PartialChannel, User,
-use revolt_quark::{
-    models::{channel::PartialChannel, Channel, User},
-    perms, Db, Error, Override, Permission, Ref, Result,
 };
-
+use revolt_models::v0::{self, DataDefaultChannelPermissions};
-/// # Permission Value
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
-#[derive(Deserialize, JsonSchema)]
+use revolt_result::{create_error, Result};
-#[serde(untagged)]
+use rocket::{serde::json::Json, State};
-pub enum DataDefaultChannelPermissions {
-    Value {
-        /// Permission values to set for members in a `Group`
-        permissions: u64,
-    },
-    Field {
-        /// Allow / deny values to set for members in this `TextChannel` or `VoiceChannel`
-        permissions: Override,
-    },
-}
 
 /// # Set Default Permission
 ///
@@ -27,19 +14,19 @@ pub enum DataDefaultChannelPermissions {
 /// Channel must be a `Group`, `TextChannel` or `VoiceChannel`.
 #[openapi(tag = "Channel Permissions")]
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
-pub async fn req(
+pub async fn set_default_permissions(
-    db: &Db,
+    db: &State<Database>,
     user: User,
-    target: Ref,
+    target: Reference,
-    data: Json<DataDefaultChannelPermissions>,
+    data: Json<v0::DataDefaultChannelPermissions>,
-) -> Result<Json<Channel>> {
+) -> Result<Json<v0::Channel>> {
     let data = data.into_inner();
 
     let mut channel = target.as_channel(db).await?;
-    let mut perm = perms(&user).channel(&channel);
+    let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
+    let permissions = calculate_channel_permissions(&mut query).await;
 
-    perm.throw_permission_and_view_channel(db, Permission::ManagePermissions)
+    permissions.throw_if_lacking_channel_permission(ChannelPermission::ManagePermissions)?;
-        .await?;
 
     match &channel {
         Channel::Group { .. } => {
@@ -55,7 +42,7 @@ pub async fn req(
                     )
                     .await?;
             } else {
-                return Err(Error::InvalidOperation);
+                return Err(create_error!(InvalidOperation));
             }
         }
         Channel::TextChannel {
@@ -66,30 +53,27 @@ pub async fn req(
             default_permissions,
             ..
         } => {
-            if let DataDefaultChannelPermissions::Field { permissions } = data {
+            if let DataDefaultChannelPermissions::Field { permissions: field } = data {
-                perm.throw_permission_override(
+                permissions
-                    db,
+                    .throw_permission_override(default_permissions.map(|x| x.into()), &field)
-                    default_permissions.map(|x| x.into()),
-                    permissions,
-                )
                     .await?;
 
                 channel
                     .update(
                         db,
                         PartialChannel {
-                            default_permissions: Some(permissions.into()),
+                            default_permissions: Some(field.into()),
                             ..Default::default()
                         },
                         vec![],
                     )
                     .await?;
             } else {
-                return Err(Error::InvalidOperation);
+                return Err(create_error!(InvalidOperation));
             }
         }
-        _ => return Err(Error::InvalidOperation),
+        _ => return Err(create_error!(InvalidOperation)),
     }
 
-    Ok(Json(channel))
+    Ok(Json(channel.into()))
 }