refactor(quark): port report_content & code clean-up

#283

crates/delta/src/routes/invites/invite_join.rs

@@ -36,7 +36,7 @@ pub async fn join(
             channel.add_user_to_group(db, &user, creator).await?;
             if let Channel::Group { recipients, .. } = &channel {
                 Ok(Json(InviteJoinResponse::Group {
-                    users: User::fetch_many_ids_as_mutuals(db, &user, &recipients).await?,
+                    users: User::fetch_many_ids_as_mutuals(db, &user, recipients).await?,
                     channel: channel.into(),
                 }))
             } else {

crates/delta/src/routes/safety/report_content.rs

@@ -1,13 +1,11 @@
-use revolt_quark::events::client::EventV1;
-use revolt_quark::models::report::{ReportStatus, ReportedContent};
-use revolt_quark::models::snapshot::{Snapshot, SnapshotContent};
-use revolt_quark::models::{Report, User};
-use revolt_quark::{Db, Error, Result};
+use revolt_database::{events::client::EventV1, Database, Report, Snapshot, SnapshotContent, User};
+use revolt_models::v0::{ReportStatus, ReportedContent};
+use revolt_result::{create_error, Result};
 use serde::Deserialize;
 use ulid::Ulid;
 use validator::Validate;
 
-use rocket::serde::json::Json;
+use rocket::{serde::json::Json, State};
 
 /// # Report Data
 #[derive(Validate, Deserialize, JsonSchema)]
@@ -25,14 +23,21 @@ pub struct DataReportContent {
 /// Report a piece of content to the moderation team.
 #[openapi(tag = "User Safety")]
 #[post("/report", data = "<data>")]
-pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>) -> Result<()> {
+pub async fn report_content(
+    db: &State<Database>,
+    user: User,
+    data: Json<DataReportContent>,
+) -> Result<()> {
     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()
+        })
+    })?;
 
     // Bots cannot create reports
     if user.bot.is_some() {
-        return Err(Error::IsBot);
+        return Err(create_error!(IsBot));
     }
 
     // Find the content and create a snapshot of it
@@ -43,7 +48,7 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
             // Users cannot report themselves
             if message.author == user.id {
-                return Err(Error::CannotReportYourself);
+                return Err(create_error!(CannotReportYourself));
             }
 
             let (snapshot, files) = SnapshotContent::generate_from_message(db, message).await?;
@@ -54,7 +59,7 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
             // Users cannot report their own server
             if server.owner == user.id {
-                return Err(Error::CannotReportYourself);
+                return Err(create_error!(CannotReportYourself));
             }
 
             let (snapshot, files) = SnapshotContent::generate_from_server(server)?;
@@ -65,7 +70,7 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
             // Users cannot report themselves
             if reported_user.id == user.id {
-                return Err(Error::CannotReportYourself);
+                return Err(create_error!(CannotReportYourself));
             }
 
             // Determine if there is a message provided as context
@@ -122,7 +127,7 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
     db.insert_report(&report).await?;
 
-    EventV1::ReportCreate(report).global().await;
+    EventV1::ReportCreate(report.into()).global().await;
 
     Ok(())
 }

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

@@ -48,7 +48,7 @@ pub async fn ban(
 
     // If member exists, check privileges against them
     if let Ok(member) = target.as_member(db, &server.id).await {
-        if member.get_ranking(&query.server_ref().as_ref().unwrap())
+        if member.get_ranking(query.server_ref().as_ref().unwrap())
             <= query.get_member_rank().unwrap_or(i64::MIN)
         {
             return Err(create_error!(NotElevated));

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

@@ -31,7 +31,7 @@ pub async fn create(
     let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
     calculate_server_permissions(&mut query)
         .await
-        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole)?;
 
     let config = config().await;
     if server.roles.len() >= config.features.limits.default.server_roles {

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

@@ -22,7 +22,7 @@ pub async fn delete(
     let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
     calculate_server_permissions(&mut query)
         .await
-        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole)?;
 
     let member_rank = query.get_member_rank().unwrap_or(i64::MIN);
 

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

@@ -32,7 +32,7 @@ pub async fn edit(
     let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
     calculate_server_permissions(&mut query)
         .await
-        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
+        .throw_if_lacking_channel_permission(ChannelPermission::ManageRole)?;
 
     let member_rank = query.get_member_rank().unwrap_or(i64::MIN);