feat: refactor discord webhooks

Author: Fleeym

src/database/repository/developers.rs

@@ -0,0 +1,35 @@
+use crate::types::api::ApiError;
+use crate::types::models::developer::FetchedDeveloper;
+use sqlx::PgConnection;
+
+pub async fn get_owner_for_mod(
+    mod_id: &str,
+    conn: &mut PgConnection,
+) -> Result<FetchedDeveloper, ApiError> {
+    Ok(sqlx::query_as!(
+        FetchedDeveloper,
+        "SELECT
+            dev.id,
+            dev.username,
+            dev.display_name,
+            dev.verified,
+            dev.admin
+        FROM developers dev
+        INNER JOIN mods_developers md ON md.developer_id = dev.id
+        WHERE md.mod_id = $1
+        AND md.is_owner = true",
+        mod_id
+    )
+    .fetch_one(&mut *conn)
+    .await
+    .map_err(|e| match e {
+        sqlx::Error::RowNotFound => {
+            log::error!("Mod {} doesn't have an owner!", mod_id);
+            ApiError::InternalError
+        }
+        _ => {
+            log::error!("Failed to fetch owner for mod {}", mod_id);
+            ApiError::InternalError
+        }
+    })?)
+}

src/database/repository/mod.rs

@@ -1,2 +1,3 @@
 pub mod mod_tags;
-pub mod mods;
+pub mod mods;
+pub mod developers;

src/endpoints/mod_versions.rs

@@ -4,6 +4,11 @@ use actix_web::{dev::ConnectionInfo, get, post, put, web, HttpResponse, Responde
 use serde::Deserialize;
 use sqlx::{types::ipnetwork::IpNetwork, Acquire};
 
+use crate::database::repository::developers;
+use crate::events::mod_created::{
+    NewModAcceptedEvent, NewModVersionAcceptedEvent, NewModVersionVerification,
+};
+use crate::webhook::discord::DiscordWebhook;
 use crate::{
     extractors::auth::Auth,
     types::{
@@ -18,7 +23,6 @@ use crate::{
             mod_version_status::ModVersionStatusEnum,
         },
     },
-    webhook::send_webhook,
     AppData,
 };
 
@@ -300,30 +304,27 @@ pub async fn create_version(
             .or(Err(ApiError::TransactionError))?;
         return Err(e);
     }
-
-    if dev.verified {
-        send_webhook(
-            json.id.clone(),
-            json.name.clone(),
-            json.version.clone(),
-            true,
-            Developer {
-                id: dev.id,
-                username: dev.username.clone(),
-                display_name: dev.display_name.clone(),
-                is_owner: true,
-            },
-            dev.clone(),
-            data.webhook_url.clone(),
-            data.app_url.clone(),
-        )
-        .await;
-    }
-
     transaction
         .commit()
         .await
         .or(Err(ApiError::TransactionError))?;
+
+    let approved_count = ModVersion::get_accepted_count(&json.id, &mut pool).await?;
+
+    if dev.verified && approved_count != 0 {
+        let owner = developers::get_owner_for_mod(&json.id, &mut *pool).await?;
+
+        NewModVersionAcceptedEvent {
+            id: json.id.clone(),
+            name: json.name.clone(),
+            version: json.version.clone(),
+            owner,
+            verified: NewModVersionVerification::Admin(dev),
+            base_url: data.app_url.clone(),
+        }
+        .to_discord_webhook()
+        .send(&data.webhook_url);
+    }
     Ok(HttpResponse::NoContent())
 }
 
@@ -391,22 +392,31 @@ pub async fn update_version(
     if payload.status == ModVersionStatusEnum::Accepted {
         let is_update = approved_count > 0;
 
-        let owner = Developer::fetch_for_mod(version.mod_id.as_str(), &mut pool)
-            .await?
-            .into_iter()
-            .find(|dev| dev.is_owner);
-
-        send_webhook(
-            version.mod_id,
-            version.name.clone(),
-            version.version.clone(),
-            is_update,
-            owner.as_ref().unwrap().clone(),
-            dev.clone(),
-            data.webhook_url.clone(),
-            data.app_url.clone(),
-        )
-        .await;
+        let owner = developers::get_owner_for_mod(&version.mod_id, &mut pool).await?;
+
+        if !is_update {
+            NewModAcceptedEvent {
+                id: version.mod_id,
+                name: version.name.clone(),
+                version: version.version.clone(),
+                owner,
+                verified_by: dev,
+                base_url: data.app_url.clone(),
+            }
+            .to_discord_webhook()
+            .send(&data.webhook_url);
+        } else {
+            NewModVersionAcceptedEvent {
+                id: version.mod_id,
+                name: version.name.clone(),
+                version: version.version.clone(),
+                owner,
+                verified: NewModVersionVerification::Admin(dev),
+                base_url: data.app_url.clone(),
+            }
+            .to_discord_webhook()
+            .send(&data.webhook_url);
+        }
     }
 
     Ok(HttpResponse::NoContent())

src/events/mod.rs

@@ -0,0 +1 @@
+pub mod mod_created;

src/events/mod_created.rs

@@ -0,0 +1,57 @@
+use crate::types::models::developer::FetchedDeveloper;
+use crate::webhook::discord::{DiscordMessage, DiscordWebhook};
+
+pub struct NewModAcceptedEvent {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    pub owner: FetchedDeveloper,
+    pub verified_by: FetchedDeveloper,
+    pub base_url: String,
+}
+
+pub enum NewModVersionVerification {
+    VerifiedDev,
+    Admin(FetchedDeveloper),
+}
+
+pub struct NewModVersionAcceptedEvent {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    pub owner: FetchedDeveloper,
+    pub verified: NewModVersionVerification,
+    pub base_url: String,
+}
+
+impl DiscordWebhook for NewModAcceptedEvent {
+    fn to_discord_webhook(&self) -> DiscordMessage {
+        DiscordMessage::new().embed(
+            &format!("New mod accepted: {} {}", self.name, self.version),
+            Some(&format!("https://geode-sdk.org/mods/{}\n\nOwned by: [{}](https://github.com/{})\nAccepted by: [{}](https://github.com/{}))",
+                          self.id, self.owner.display_name, self.owner.username, self.verified_by.display_name, self.verified_by.username)),
+            Some(&format!("{}/v1/mods/{}/logo", self.base_url, self.id)),
+        )
+    }
+}
+
+impl DiscordWebhook for NewModVersionAcceptedEvent {
+    fn to_discord_webhook(&self) -> DiscordMessage {
+        let accepted_msg = match &self.verified {
+            NewModVersionVerification::VerifiedDev => String::from("Developer is verified"),
+            NewModVersionVerification::Admin(admin) => format!(
+                "Verified by [{}](https://github.com/{})",
+                admin.display_name, admin.username
+            ),
+        };
+
+        DiscordMessage::new().embed(
+            &format!("Mod update accepted: {} {}", self.name, self.version),
+            Some(&format!(
+                "https://geode-sdk.org/mods/{}\n\nOwned by: [{}](https://github.com/{})\n{})",
+                self.id, self.owner.display_name, self.owner.username, accepted_msg
+            )),
+            Some(&format!("{}/v1/mods/{}/logo", self.base_url, self.id)),
+        )
+    }
+}

src/main.rs

@@ -1,19 +1,17 @@
 use actix_cors::Cors;
 use actix_web::{
-    get,
     middleware::Logger,
     web::{self, QueryConfig},
-    App, HttpServer, Responder,
+    App, HttpServer
 };
-use clap::Parser;
 
 use crate::types::api;
-use crate::types::api::ApiError;
 
 mod auth;
 mod cli;
 mod database;
 mod endpoints;
+mod events;
 mod extractors;
 mod jobs;
 mod types;
@@ -30,18 +28,6 @@ pub struct AppData {
     max_download_mb: u32,
 }
 
-#[derive(Debug, Parser)]
-struct Args {
-    /// Name of the script to run
-    #[arg(short, long)]
-    script: Option<String>,
-}
-
-#[get("/")]
-async fn health() -> Result<impl Responder, ApiError> {
-    Ok(web::Json("The Geode Index is running"))
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     log4rs::init_file("config/log4rs.yaml", Default::default())