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

#283

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)
 }