refactor(quark): port ban_create, ban_list, ban_remove, emoji_list, invites_fetch

#283

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

@@ -1,4 +1,6 @@
-use crate::MemberCompositeKey;
+use revolt_result::Result;
+
+use crate::{Database, MemberCompositeKey, Server};
 
 auto_derived!(
     /// Server Ban
@@ -10,3 +12,24 @@ auto_derived!(
         pub reason: Option<String>,
     }
 );
+
+impl ServerBan {
+    /// Create ban
+    pub async fn create(
+        db: &Database,
+        server: &Server,
+        user_id: &str,
+        reason: Option<String>,
+    ) -> Result<ServerBan> {
+        let ban = ServerBan {
+            id: MemberCompositeKey {
+                server: server.id.to_string(),
+                user: user_id.to_string(),
+            },
+            reason,
+        };
+
+        db.insert_ban(&ban).await?;
+        Ok(ban)
+    }
+}

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

@@ -215,4 +215,47 @@ impl Member {
             false
         }
     }
+
+    /// Remove member from server
+    pub async fn remove(
+        self,
+        db: &Database,
+        server: &Server,
+        intention: RemovalIntention,
+        silent: bool,
+    ) -> Result<()> {
+        db.delete_member(&self.id).await?;
+
+        EventV1::ServerMemberLeave {
+            id: self.id.server.to_string(),
+            user: self.id.user.to_string(),
+        }
+        .p(self.id.server.to_string())
+        .await;
+
+        if !silent {
+            if let Some(id) = server
+                .system_messages
+                .as_ref()
+                .and_then(|x| match intention {
+                    RemovalIntention::Leave => x.user_left.as_ref(),
+                    RemovalIntention::Kick => x.user_kicked.as_ref(),
+                    RemovalIntention::Ban => x.user_banned.as_ref(),
+                })
+            {
+                match intention {
+                    RemovalIntention::Leave => SystemMessage::UserLeft { id: self.id.user },
+                    RemovalIntention::Kick => SystemMessage::UserKicked { id: self.id.user },
+                    RemovalIntention::Ban => SystemMessage::UserBanned { id: self.id.user },
+                }
+                .into_message(id.to_string())
+                // TODO: support notifications here in the future?
+                .send_without_notifications(db, false, false)
+                .await
+                .ok();
+            }
+        }
+
+        Ok(())
+    }
 }

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

@@ -255,71 +255,6 @@ impl Server {
             Err(create_error!(NotFound))
         }
     }
-
-    /*
-
-    /// Remove a member from a server
-    pub async fn remove_member(
-        &self,
-        db: &Database,
-        member: Member,
-        intention: RemovalIntention,
-        silent: bool,
-    ) -> Result<()> {
-        db.delete_member(&member.id).await?;
-
-        /* // TODO: EventV1::ServerMemberLeave {
-            id: self.id.to_string(),
-            user: member.id.user.clone(),
-        }
-        .p(member.id.server)
-        .await; */
-
-        if !silent {
-            if let Some(id) = self.system_messages.as_ref().and_then(|x| match intention {
-                RemovalIntention::Leave => x.user_left.as_ref(),
-                RemovalIntention::Kick => x.user_kicked.as_ref(),
-                RemovalIntention::Ban => x.user_banned.as_ref(),
-            }) {
-                match intention {
-                    RemovalIntention::Leave => SystemMessage::UserLeft { id: member.id.user },
-                    RemovalIntention::Kick => SystemMessage::UserKicked { id: member.id.user },
-                    RemovalIntention::Ban => SystemMessage::UserBanned { id: member.id.user },
-                }
-                .into_message(id.to_string())
-                .create_no_web_push(db, id, false)
-                .await
-                .ok();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Create ban
-    pub async fn ban_user(
-        self,
-        db: &Database,
-        id: MemberCompositeKey,
-        reason: Option<String>,
-    ) -> Result<ServerBan> {
-        let ban = ServerBan { id, reason };
-        db.insert_ban(&ban).await?;
-        Ok(ban)
-    }
-
-    /// Ban a member from a server
-    pub async fn ban_member(
-        self,
-        db: &Database,
-        member: Member,
-        reason: Option<String>,
-    ) -> Result<ServerBan> {
-        self.remove_member(db, member.clone(), RemovalIntention::Ban, false)
-            .await?;
-
-        self.ban_user(db, member.id, reason).await
-    } */
 }
 
 impl Role {

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

@@ -7,7 +7,9 @@ use schemars::{
     JsonSchema,
 };
 
-use crate::{Bot, Channel, Database, Emoji, Invite, Message, Server, User, Webhook};
+use crate::{
+    Bot, Channel, Database, Emoji, Invite, Member, Message, Server, ServerBan, User, Webhook,
+};
 
 /// Reference to some object in the database
 #[derive(Serialize, Deserialize)]
@@ -22,6 +24,11 @@ impl Reference {
         Reference { id }
     }
 
+    /// Fetch ban from Ref
+    pub async fn as_ban(&self, db: &Database, server: &str) -> Result<ServerBan> {
+        db.fetch_ban(server, &self.id).await
+    }
+
     /// Fetch bot from Ref
     pub async fn as_bot(&self, db: &Database) -> Result<Bot> {
         db.fetch_bot(&self.id).await
@@ -57,6 +64,11 @@ impl Reference {
         Ok(msg)
     }
 
+    /// Fetch member from Ref
+    pub async fn as_member(&self, db: &Database, server: &str) -> Result<Member> {
+        db.fetch_member(server, &self.id).await
+    }
+
     /// Fetch server from Ref
     pub async fn as_server(&self, db: &Database) -> Result<Server> {
         db.fetch_server(&self.id).await

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

@@ -1,4 +1,7 @@
-use super::MemberCompositeKey;
+use super::{File, MemberCompositeKey, User};
+
+#[cfg(feature = "validator")]
+use validator::Validate;
 
 auto_derived!(
     /// Server Ban
@@ -9,4 +12,44 @@ auto_derived!(
         /// Reason for ban creation
         pub reason: Option<String>,
     }
+
+    /// Information for new server ban
+    #[cfg_attr(feature = "validator", derive(Validate))]
+    pub struct DataBanCreate {
+        /// Ban reason
+        #[cfg_attr(feature = "validator", validate(length(min = 0, max = 1024)))]
+        pub reason: Option<String>,
+    }
+
+    /// Just enough information to list a ban
+    pub struct BannedUser {
+        /// Id of the banned user
+        #[cfg_attr(feature = "serde", serde(rename = "_id"))]
+        pub id: String,
+        /// Username of the banned user
+        pub username: String,
+        /// Discriminator of the banned user
+        pub discriminator: String,
+        /// Avatar of the banned user
+        pub avatar: Option<File>,
+    }
+
+    /// Ban list result
+    pub struct BanListResult {
+        /// Users objects
+        pub users: Vec<BannedUser>,
+        /// Ban objects
+        pub bans: Vec<ServerBan>,
+    }
 );
+
+impl From<User> for BannedUser {
+    fn from(user: User) -> Self {
+        BannedUser {
+            id: user.id,
+            username: user.username,
+            discriminator: user.discriminator,
+            avatar: user.avatar,
+        }
+    }
+}

crates/delta/src/routes/servers/ban_create.rs

@@ -1,73 +1,66 @@
-use revolt_quark::{
-    models::{server_member::MemberCompositeKey, ServerBan, User},
-    perms, Db, Error, Permission, Ref, Result,
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, RemovalIntention, ServerBan, User,
 };
+use revolt_models::v0;
 
-use rocket::serde::json::Json;
+use revolt_permissions::{
+    calculate_channel_permissions, calculate_server_permissions, ChannelPermission,
+};
+use revolt_result::{create_error, Result};
+use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
 
-/// # Ban Information
-#[derive(Validate, Serialize, Deserialize, JsonSchema)]
-pub struct DataBanCreate {
-    /// Ban reason
-    #[validate(length(min = 1, max = 1024))]
-    reason: Option<String>,
-}
-
 /// # Ban User
 ///
 /// Ban a user by their id.
 #[openapi(tag = "Server Members")]
 #[put("/<server>/bans/<target>", data = "<data>")]
-pub async fn req(
-    db: &Db,
+pub async fn ban(
+    db: &State<Database>,
     user: User,
-    server: Ref,
-    target: Ref,
-    data: Json<DataBanCreate>,
-) -> Result<Json<ServerBan>> {
+    server: Reference,
+    target: Reference,
+    data: Json<v0::DataBanCreate>,
+) -> Result<Json<v0::ServerBan>> {
     let data = data.into_inner();
-    data.validate()
-        .map_err(|error| Error::FailedValidation { error })?;
+    data.validate().map_err(|error| {
+        create_error!(FailedValidation {
+            error: error.to_string()
+        })
+    })?;
 
     let server = server.as_server(db).await?;
 
     if target.id == user.id {
-        return Err(Error::CannotRemoveYourself);
+        return Err(create_error!(CannotRemoveYourself));
     }
 
     if target.id == server.owner {
-        return Err(Error::InvalidOperation);
+        return Err(create_error!(InvalidOperation));
     }
 
-    let mut permissions = perms(&user).server(&server);
-
-    permissions
-        .throw_permission(db, Permission::BanMembers)
-        .await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    calculate_server_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::BanMembers)?;
 
     // If member exists, check privileges against them
     if let Ok(member) = target.as_member(db, &server.id).await {
-        if member.get_ranking(permissions.server.get().unwrap())
-            <= permissions.get_member_rank().unwrap_or(i64::MIN)
+        if member.get_ranking(&query.server_ref().as_ref().unwrap())
+            <= query.get_member_rank().unwrap_or(i64::MIN)
         {
-            return Err(Error::NotElevated);
+            return Err(create_error!(NotElevated));
         }
 
-        server.ban_member(db, member, data.reason).await.map(Json)
-    } else {
-        let server_id = server.id.to_string();
-        server
-            .ban_user(
-                db,
-                MemberCompositeKey {
-                    server: server_id,
-                    user: target.id,
-                },
-                data.reason,
-            )
-            .await
-            .map(Json)
+        member
+            .remove(db, &server, RemovalIntention::Ban, false)
+            .await?;
     }
+
+    ServerBan::create(db, &server, &target.id, data.reason)
+        .await
+        .map(Into::into)
+        .map(Json)
 }

crates/delta/src/routes/servers/ban_list.rs

@@ -1,60 +1,33 @@
-use revolt_quark::models::{File, ServerBan, User};
-use revolt_quark::{perms, Db, Permission, Ref, Result};
+use futures::future::join_all;
+use revolt_database::util::permissions::DatabasePermissionQuery;
+use revolt_database::util::reference::Reference;
+use revolt_database::{Database, User};
+use revolt_models::v0;
 
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::Result;
 use rocket::serde::json::Json;
-use serde::{Deserialize, Serialize};
-
-/// # Banned User
-///
-/// Just enoguh user information to list bans.
-#[derive(Serialize, Deserialize, JsonSchema)]
-struct BannedUser {
-    /// Id of the banned user
-    #[serde(rename = "_id")]
-    pub id: String,
-    /// Username of the banned user
-    pub username: String,
-    /// Discriminator of the banned user
-    pub discriminator: String,
-    /// Avatar of the banned user
-    pub avatar: Option<File>,
-}
-
-/// # Ban List Result
-#[derive(Serialize, Deserialize, JsonSchema)]
-pub struct BanListResult {
-    /// Users objects
-    users: Vec<BannedUser>,
-    /// Ban objects
-    bans: Vec<ServerBan>,
-}
-
-impl From<User> for BannedUser {
-    fn from(user: User) -> Self {
-        BannedUser {
-            id: user.id,
-            username: user.username,
-            discriminator: user.discriminator,
-            avatar: user.avatar,
-        }
-    }
-}
+use rocket::State;
 
 /// # Fetch Bans
 ///
 /// Fetch all bans on a server.
 #[openapi(tag = "Server Members")]
 #[get("/<target>/bans")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<BanListResult>> {
+pub async fn list(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+) -> Result<Json<v0::BanListResult>> {
     let server = target.as_server(db).await?;
-    perms(&user)
-        .server(&server)
-        .throw_permission(db, Permission::BanMembers)
-        .await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    calculate_server_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::BanMembers)?;
 
     let bans = db.fetch_bans(&server.id).await?;
-    let users = db
-        .fetch_users(
+    let users = join_all(
+        db.fetch_users(
             &bans
                 .iter()
                 .map(|x| &x.id.user)
@@ -63,8 +36,12 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<BanListResult>
         )
         .await?
         .into_iter()
-        .map(|x| x.into())
-        .collect();
+        .map(|u| u.into_self()),
+    )
+    .await;
 
-    Ok(Json(BanListResult { users, bans }))
+    Ok(Json(v0::BanListResult {
+        users: users.into_iter().map(Into::into).collect(),
+        bans: bans.into_iter().map(Into::into).collect(),
+    }))
 }

crates/delta/src/routes/servers/ban_remove.rs

@@ -1,16 +1,28 @@
-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_server_permissions, ChannelPermission};
+use revolt_result::Result;
+use rocket::State;
+use rocket_empty::EmptyResponse;
 
 /// # Unban user
 ///
 /// Remove a user's ban.
 #[openapi(tag = "Server Members")]
 #[delete("/<server>/bans/<target>")]
-pub async fn req(db: &Db, user: User, server: Ref, target: Ref) -> Result<EmptyResponse> {
+pub async fn unban(
+    db: &State<Database>,
+    user: User,
+    server: Reference,
+    target: Reference,
+) -> Result<EmptyResponse> {
     let server = server.as_server(db).await?;
-    perms(&user)
-        .server(&server)
-        .throw_permission(db, Permission::BanMembers)
-        .await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    calculate_server_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::BanMembers)?;
 
     let ban = target.as_ban(db, &server.id).await?;
     db.delete_ban(&ban.id).await.map(|_| EmptyResponse)

crates/delta/src/routes/servers/emoji_list.rs

@@ -1,17 +1,31 @@
-use revolt_quark::models::{Emoji, User};
-use revolt_quark::{perms, Db, Ref, Result};
-
-use rocket::serde::json::Json;
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
+};
+use revolt_models::v0;
+use revolt_permissions::PermissionQuery;
+use revolt_result::{create_error, Result};
+use rocket::{serde::json::Json, State};
 
 /// # Fetch Server Emoji
 ///
 /// Fetch all emoji on a server.
 #[openapi(tag = "Server Customisation")]
 #[get("/<target>/emojis")]
-pub async fn list_emoji(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Emoji>>> {
+pub async fn list_emoji(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+) -> Result<Json<Vec<v0::Emoji>>> {
     let server = target.as_server(db).await?;
-    perms(&user).server(&server).calc(db).await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    if !query.are_we_a_member().await {
+        return Err(create_error!(NotFound));
+    }
 
     // Fetch all emoji from server if we can view it
-    db.fetch_emoji_by_parent_id(&server.id).await.map(Json)
+    db.fetch_emoji_by_parent_id(&server.id)
+        .await
+        .map(|v| v.into_iter().map(Into::into).collect())
+        .map(Json)
 }

crates/delta/src/routes/servers/invites_fetch.rs

@@ -1,21 +1,30 @@
-use revolt_quark::{
-    models::{Invite, User},
-    perms, Db, Permission, Ref, Result,
+use revolt_database::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    Database, User,
 };
-
-use rocket::serde::json::Json;
+use revolt_models::v0;
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::Result;
+use rocket::{serde::json::Json, State};
 
 /// # Fetch Invites
 ///
 /// Fetch all server invites.
 #[openapi(tag = "Server Members")]
 #[get("/<target>/invites")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Invite>>> {
+pub async fn invites(
+    db: &State<Database>,
+    user: User,
+    target: Reference,
+) -> Result<Json<Vec<v0::Invite>>> {
     let server = target.as_server(db).await?;
-    perms(&user)
-        .server(&server)
-        .throw_permission(db, Permission::ManageServer)
-        .await?;
+    let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
+    calculate_server_permissions(&mut query)
+        .await
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageServer)?;
 
-    db.fetch_invites_for_server(&server.id).await.map(Json)
+    db.fetch_invites_for_server(&server.id)
+        .await
+        .map(|v| v.into_iter().map(Into::into).collect())
+        .map(Json)
 }

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

@@ -37,10 +37,10 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         member_fetch::req,
         member_edit::req,
         member_experimental_query::member_experimental_query,
-        ban_create::req,
-        ban_remove::req,
-        ban_list::req,
-        invites_fetch::req,
+        ban_create::ban,
+        ban_remove::unban,
+        ban_list::list,
+        invites_fetch::invites,
         roles_create::req,
         roles_edit::req,
         roles_fetch::req,