refactor rollout + implement ephemeral errors

Author: xyloflake

src/db/rollout.rs

@@ -264,6 +264,7 @@ pub struct Rollout {
 // temporary implementation - so that there is no warning
 impl Rollout {
     #[allow(dead_code)]
+
     pub fn get_created_at(
         &self
     ) -> &str {

src/discord.rs

@@ -1,4 +1,5 @@
 pub mod commands;
+pub mod utils;
 
 use poise::{
     framework,

src/discord/commands/rollout.rs

@@ -14,41 +14,12 @@ pub async fn create_rollout(
     crate::discord::commands::Error
 > {
 
-    let guild = ctx
-        .http()
-        .get_guild(
-            crate::env::GUILD_ID
-                .as_str()
-                .parse()
-                .unwrap()
-        )
-        .await?;
-
-    let role = guild
-        .roles
-        .get(
-            &crate::env::ROLE_ID
-                .as_str()
-                .parse()
-                .unwrap()
-        )
-        .unwrap();
-
-    if !ctx
-        .author()
-        .has_role(
-            ctx.http(),
-            &guild,
-            role
-        )
-        .await?
-    {
-
-        ctx.say("You don't have permission to use this command")
-            .await?;
-
+    if !crate::discord::utils::no_perm::check_and_send_no_perm(
+        ctx,
+        ctx.author()
+    ).await? {
         return Ok(());
-    }
+    };
 
     // Add rollout to queue
     let build_queue = ctx
@@ -95,51 +66,51 @@ pub async fn create_rollout(
 
     ctx.send(response).await?;
 
-    while let Some(mci) = serenity_prelude::ComponentInteractionCollector::new(ctx.serenity_context())
+    while let Some(component_interaction) = serenity_prelude::ComponentInteractionCollector::new(ctx.serenity_context())
         .timeout(std::time::Duration::from_secs(120))
         .filter(move |mci| mci.data.custom_id.starts_with("approve-") || mci.data.custom_id.starts_with("reject-"))
         .await
     {
 
         // check permissions
 
-        if !mci.
-            user
-            .has_role(
-                ctx.http(),
-                &guild,
-                role
-            )
-            .await?
-        {
-
-            let embed = serenity_prelude::CreateEmbed::default()
-                .title("Oops!")
-                .description("You don't have permission to use this interaction".to_string())
-                .author(
-                    serenity_prelude::CreateEmbedAuthor::new(&mci.user.name)
-                        .icon_url(mci.user.avatar_url().unwrap_or_default())
-                        .url(mci.user.avatar_url().unwrap_or_default())
+        crate::discord::utils::no_perm::check_and_send_no_perm(ctx, &component_interaction.user).await?;
+
+        // If interactor and creator are same, disregard it because
+        // author can't approve or deny their own rollout
+        if component_interaction.user.id == ctx.author().id {
+            ctx
+            .send(
+                poise::CreateReply::default()
+                .embed(
+                    poise::serenity_prelude::CreateEmbed::new()
+                    .title("Invalid action")
+                    .description(
+                        "You are not allowed to approve or deny your own rollout"
+                    )
+                    .color(0xFF0000)
                 )
-                .color(0xFF0000);
-
-            let reply = serenity_prelude::CreateInteractionResponseMessage::new()
-                .embed(embed);
+                .ephemeral(true)
+            ).await?;
 
-            mci.create_response(ctx, serenity_prelude::CreateInteractionResponse::Message(reply)).await?;
+            component_interaction
+                .create_response(
+                    ctx,
+                    serenity_prelude::CreateInteractionResponse::Acknowledge
+                ).await?;
 
-            continue;
+            return Ok(());
         }
 
-        if mci.data.custom_id == format!("approve-{}", version) {
+        if component_interaction.data.custom_id == format!("approve-{}", version) {
             let build_queue = ctx
                 .data()
                 .build_queue
                 .lock()
                 .await;
 
             let success = build_queue
-                .approve_rollout(&version, mci.user.id.get())
+                .approve_rollout(&version, component_interaction.user.id.get())
                 .expect(
                     "failed to approve rollout",
                 );
@@ -152,15 +123,15 @@ pub async fn create_rollout(
 
             if !success {
                 let embed = serenity_prelude::CreateEmbed::default()
-                    .title("Oops!")
-                    .description("There was an error approving the rollout. This version may have already been approved or rejected or it was your own rollout.")
+                    .title("Invalid action")
+                    .description("There was an error approving the rollout. This version may have already been approved.")
                     .color(0xFF0000);
 
                 let reply = poise::CreateReply::default()
                     .embed(embed);
 
                 ctx.send(reply).await?;
-                mci.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
+                component_interaction.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
                 continue;
             }
 
@@ -173,30 +144,30 @@ pub async fn create_rollout(
                 ". The rollout has not been started because it has not been approved by enough people."
             };
 
-            let embed_author = serenity_prelude::CreateEmbedAuthor::new(&mci.user.name)
-                .icon_url(mci.user.avatar_url().unwrap_or_default())
-                .url(mci.user.avatar_url().unwrap_or_default());
+            let embed_author = serenity_prelude::CreateEmbedAuthor::new(&component_interaction.user.name)
+                .icon_url(component_interaction.user.avatar_url().unwrap_or_default())
+                .url(component_interaction.user.avatar_url().unwrap_or_default());
 
             let embed = serenity_prelude::CreateEmbed::default()
                 .title("Rollout Approved")
-                .description(format!("Rollout of version {} has been approved by {}{} FUCK THIS SHIT {}", version, &mci.user.name, extra, &mci.data.custom_id))
+                .description(format!("Rollout of version {} has been approved by {}{}. ID: {}", version, &component_interaction.user.name, extra, &component_interaction.data.custom_id))
                 .author(embed_author)
                 .color(0x00FF00);
 
             let reply = poise::CreateReply::default()
                 .embed(embed);
 
             ctx.send(reply).await?;
-            mci.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
-        } else if mci.data.custom_id == format!("reject-{}", version) {
+            component_interaction.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
+        } else if component_interaction.data.custom_id == format!("reject-{}", version) {
             let build_queue = ctx
                 .data()
                 .build_queue
                 .lock()
                 .await;
 
             let success = build_queue
-                .reject_rollout(&version, mci.user.id.get())
+                .reject_rollout(&version, component_interaction.user.id.get())
                 .expect(
                     "failed to reject rollout",
                 );
@@ -205,33 +176,33 @@ pub async fn create_rollout(
 
             if !success {
                 let embed = serenity_prelude::CreateEmbed::default()
-                    .title("Oops!")
-                    .description("There was an error rejecting the rollout. This version may have already been approved or rejected or it was your own rollout.")
+                    .title("Invalid action")
+                    .description("There was an error rejecting the rollout. This version may have already been rejected.")
                     .color(0xFF0000);
 
                 let reply = poise::CreateReply::default()
                     .embed(embed);
 
                 ctx.send(reply).await?;
-                mci.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
+                component_interaction.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
                 continue;
             }
 
-            let embed_author = serenity_prelude::CreateEmbedAuthor::new(&mci.user.name)
-                .icon_url(mci.user.avatar_url().unwrap_or_default())
-                .url(mci.user.avatar_url().unwrap_or_default());
+            let embed_author = serenity_prelude::CreateEmbedAuthor::new(&component_interaction.user.name)
+                .icon_url(component_interaction.user.avatar_url().unwrap_or_default())
+                .url(component_interaction.user.avatar_url().unwrap_or_default());
 
             let embed = serenity_prelude::CreateEmbed::default()
                 .title("Rollout Rejected")
-                .description(format!("Rollout of version {} has been rejected by {}. Cancelling rollout", version, &mci.user.name))
+                .description(format!("Rollout of version {} has been rejected by {}. Cancelling rollout", version, &component_interaction.user.name))
                 .author(embed_author)
                 .color(0xFF0000);
 
             let reply = poise::CreateReply::default()
                 .embed(embed);
 
             ctx.send(reply).await?;
-            mci.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
+            component_interaction.create_response(ctx, serenity_prelude::CreateInteractionResponse::Acknowledge).await?;
         }
     }
 

src/discord/utils.rs

@@ -0,0 +1,33 @@
+pub mod no_perm;
+
+use poise::serenity_prelude;
+
+pub async fn get_guild(
+    ctx: crate::discord::commands::Context<'_>
+) -> serenity_prelude::PartialGuild {
+
+    ctx.http()
+        .get_guild(
+            crate::env::GUILD_ID
+                .as_str()
+                .parse()
+                .unwrap()
+        )
+        .await
+        .unwrap()
+}
+
+fn get_role<'a>(
+    guild: &'a serenity_prelude::PartialGuild
+) -> &'a serenity_prelude::Role {
+
+    guild
+        .roles
+        .get(
+            &crate::env::ROLE_ID
+                .as_str()
+                .parse()
+                .unwrap()
+        )
+        .unwrap()
+}

src/discord/utils/no_perm.rs

@@ -0,0 +1,73 @@
+use poise::serenity_prelude;
+
+// check if there is permission or not
+// returns true if user has role (which is what determines the permissions)
+// returns false if user doesn't have the role (unauthorized)
+pub async fn check_perms(
+    ctx: crate::discord::commands::Context<'_>,
+    user: &poise::serenity_prelude::User
+) -> bool {
+
+    let guild: serenity_prelude::PartialGuild = crate::discord::utils::get_guild(ctx).await;
+
+    let role: &serenity_prelude::Role =
+        &crate::discord::utils::get_role(
+            &guild
+        );
+
+    if !user
+        .has_role(
+            ctx.http(),
+            &guild,
+            role
+        )
+        .await
+        .unwrap()
+    {
+
+        return false;
+    }
+
+    true
+}
+
+// Send no permission message
+pub async fn send_no_perm(
+    ctx: crate::discord::commands::Context<'_>
+) -> Result<
+    (),
+    crate::discord::commands::Error
+> {
+
+    ctx
+        .send(
+            poise::CreateReply::default()
+            .embed(
+                poise::serenity_prelude::CreateEmbed::new()
+                .title("Permission denied")
+                .description("You are not allowed to perform this action.")
+                .color(0xFF0000)
+            )
+            .ephemeral(true)
+        ).await?;
+
+    Ok(())
+}
+
+pub async fn check_and_send_no_perm(
+    ctx: crate::discord::commands::Context<'_>,
+    user: &poise::serenity_prelude::User
+) -> Result<
+    bool,
+    crate::discord::commands::Error
+> {
+
+    if !check_perms(ctx, user).await {
+
+        send_no_perm(ctx).await?;
+
+        return Ok(false);
+    }
+
+    Ok(true)
+}