refactor(delta): port routes to core webhook models

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

@@ -1,5 +1,9 @@
-use revolt_quark::{models::{User, Webhook, File, Channel}, perms, Db, Error, Permission, Ref, Result};
-use rocket::serde::json::Json;
+use revolt_database::{Database, Webhook};
+use revolt_quark::{
+    models::{Channel, User},
+    perms, Db, Error, Permission, Ref, Result,
+};
+use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 use validator::Validate;
@@ -10,46 +14,56 @@ pub struct CreateWebhookBody {
     name: String,
 
     #[validate(length(min = 1, max = 128))]
-    avatar: Option<String>
+    avatar: Option<String>,
 }
 
 /// # Creates a webhook
 ///
-/// creates a webhook which 3rd party platforms can use to send messages
+/// Creates a webhook which 3rd party platforms can use to send messages
 #[openapi(tag = "Webhooks")]
 #[post("/<target>/webhooks", data = "<data>")]
-pub async fn req(db: &Db, user: User, target: Ref, data: Json<CreateWebhookBody>) -> Result<Json<Webhook>> {
+pub async fn req(
+    db: &State<Database>,
+    legacy_db: &Db,
+    user: User,
+    target: Ref,
+    data: Json<CreateWebhookBody>,
+) -> Result<Json<revolt_models::v0::Webhook>> {
     let data = data.into_inner();
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
-    let channel = target.as_channel(db).await?;
+    let channel = target.as_channel(legacy_db).await?;
 
     if !matches!(channel, Channel::TextChannel { .. } | Channel::Group { .. }) {
-        return Err(Error::InvalidOperation)
+        return Err(Error::InvalidOperation);
     }
 
     let mut permissions = perms(&user).channel(&channel);
     permissions
-        .has_permission(db, Permission::ManageWebhooks)
+        .has_permission(legacy_db, Permission::ManageWebhooks)
         .await?;
 
     let webhook_id = Ulid::new().to_string();
 
     let avatar = match &data.avatar {
-        Some(id) => Some(File::use_avatar(db, id, &webhook_id).await?),
-        None => None
+        Some(id) => Some(
+            db.find_and_use_attachment(id, "avatars", "user", &webhook_id)
+                .await
+                .map_err(Error::from_core)?,
+        ),
+        None => None,
     };
 
     let webhook = Webhook {
         id: webhook_id,
         name: data.name,
         avatar,
-        channel: channel.id().to_string(),
-        token: Some(nanoid::nanoid!(64))
+        channel_id: channel.id().to_string(),
+        token: Some(nanoid::nanoid!(64)),
     };
 
-    webhook.create(db).await?;
+    webhook.create(db).await.map_err(Error::from_core)?;
 
-    Ok(Json(webhook))
+    Ok(Json(webhook.into()))
 }

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

@@ -1,19 +1,31 @@
-use revolt_quark::{models::{User, Webhook}, perms, Db, Permission, Ref, Result};
-use rocket::serde::json::Json;
+use revolt_database::Database;
+use revolt_models::v0::Webhook;
+use revolt_quark::{models::User, perms, Db, Error, Permission, Ref, Result};
+use rocket::{serde::json::Json, State};
 
 /// # Gets all webhooks
 ///
-/// gets all webhooks inside the channel
+/// Gets all webhooks inside the channel
 #[openapi(tag = "Webhooks")]
-#[get("/<target>/webhooks")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Webhook>>> {
-    let channel = target.as_channel(db).await?;
+#[get("/<channel_id>/webhooks")]
+pub async fn req(
+    db: &State<Database>,
+    legacy_db: &Db,
+    user: User,
+    channel_id: Ref,
+) -> Result<Json<Vec<Webhook>>> {
+    let channel = channel_id.as_channel(legacy_db).await?;
     let mut permissions = perms(&user).channel(&channel);
     permissions
-        .has_permission(db, Permission::ManageWebhooks)
+        .has_permission(legacy_db, Permission::ManageWebhooks)
         .await?;
 
-    let webhooks = db.fetch_webhooks_for_channel(channel.id()).await?;
-
-    Ok(Json(webhooks))
+    Ok(Json(
+        db.fetch_webhooks_for_channel(channel.id())
+            .await
+            .map_err(Error::from_core)?
+            .into_iter()
+            .map(|v| v.into())
+            .collect::<Vec<Webhook>>(),
+    ))
 }