Merge pull request #41 from AltF02/buttons

Add buttons instead of reactions

Author: AltF02

Cargo.toml

@@ -27,7 +27,7 @@ features = ["colored"]
 
 [dependencies.serenity]
 version = "0.11"
-features = ["framework", "standard_framework", "rustls_backend", "cache", "collector", "utils", "unstable_discord_api", "chrono"]
+features = ["framework", "standard_framework", "rustls_backend", "cache", "collector", "utils", "unstable_discord_api", "chrono", "model"]
 
 [dependencies.tokio]
 version = "1"

src/bot.rs

@@ -22,6 +22,7 @@ use std::collections::HashSet;
 use std::sync::Arc;
 
 mod commands;
+pub mod components;
 pub mod embeds;
 mod events;
 mod hooks;

src/bot/components.rs

@@ -0,0 +1,39 @@
+use crate::models::launch::LaunchID;
+use serenity::builder::{CreateActionRow, CreateButton, CreateComponents};
+use serenity::model::prelude::message_component::ButtonStyle;
+
+pub struct RemindComponent<'a> {
+    launch_id: &'a LaunchID,
+}
+
+impl<'a> RemindComponent<'a> {
+    pub fn new(launch_id: &'a LaunchID) -> RemindComponent {
+        Self { launch_id }
+    }
+
+    fn button(&self) -> CreateButton {
+        let mut b = CreateButton::default();
+        b.custom_id(self.launch_id);
+        b.label("Remind Me");
+        b.style(ButtonStyle::Primary);
+        b
+    }
+
+    fn action_row(&self) -> CreateActionRow {
+        let mut ar = CreateActionRow::default();
+        ar.add_button(self.button());
+        ar
+    }
+}
+
+pub fn create_basic_components() -> CreateComponents {
+    CreateComponents::default()
+}
+
+pub fn create_launch_components(launch_id: &LaunchID) -> CreateComponents {
+    let mut c = create_basic_components();
+
+    let rc = RemindComponent::new(launch_id);
+    c.add_action_row(rc.action_row());
+    c
+}

src/bot/events.rs

@@ -1,11 +1,11 @@
 mod guild_create;
-mod reaction_add;
+mod interaction_create;
 mod ready;
 
 use crate::bot::loops::launches_loop;
 
 use crate::bot::events::guild_create::GuildCreateEvent;
-use crate::bot::events::reaction_add::ReactionAddEvent;
+use crate::bot::events::interaction_create::InteractionCreateEvent;
 use crate::bot::events::ready::ReadyEvent;
 use log::info;
 use serenity::{async_trait, model::prelude::*, prelude::*};
@@ -27,10 +27,6 @@ impl EventHandler for Handler {
         GuildCreateEvent::run(&ctx, &guild, &is_new).await;
     }
 
-    async fn reaction_add(&self, ctx: Context, reaction: Reaction) {
-        ReactionAddEvent::run(&ctx, &reaction).await;
-    }
-
     async fn ready(&self, ctx: Context, ready: Ready) {
         ReadyEvent::run(&ctx, &ready).await;
 
@@ -47,4 +43,8 @@ impl EventHandler for Handler {
             *self.run_loops.lock().await = false;
         }
     }
+
+    async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
+        InteractionCreateEvent::run(&ctx, interaction).await;
+    }
 }

src/bot/events/interaction_create.rs

@@ -0,0 +1,81 @@
+use crate::extensions::ClientContextExt;
+use anyhow::Result;
+use log::error;
+use serenity::client::Context;
+use serenity::model::interactions::InteractionResponseType;
+use serenity::model::prelude::message_component::ComponentType;
+use serenity::model::prelude::{Interaction, InteractionApplicationCommandCallbackDataFlags};
+
+pub struct InteractionCreateEvent;
+
+impl InteractionCreateEvent {
+    pub async fn run(ctx: &Context, interaction: Interaction) -> Result<()> {
+        let db = ctx.get_db().await;
+        let mc = interaction.message_component();
+
+        if mc.is_none() {
+            return Ok(());
+        }
+
+        let component = mc.unwrap();
+
+        if component.data.component_type != ComponentType::Button
+            || component.message.embeds.is_empty()
+        {
+            return Ok(());
+        }
+
+        let reminder =
+            sqlx::query("SELECT * FROM astra.reminders WHERE user_id = $1 AND launch_id = $2")
+                .bind(component.user.id.0 as i64)
+                .bind(&component.data.custom_id)
+                .fetch_optional(&db.pool)
+                .await;
+
+        if let Err(e) = reminder {
+            error!("Failed to query, {:?}", e);
+            return Ok(());
+        }
+
+        let reminder_exists = reminder.unwrap().is_some();
+
+        let launch_name = component.message.embeds[0].title.as_ref().unwrap();
+
+        let mut content = if reminder_exists {
+            format!("I will stop reminding you for **{}**", launch_name)
+        } else {
+            format!("I will remind you for **{}**! If you want me to stop from reminding you, hit the button again", launch_name)
+        };
+
+        let dm_channel = component.user.create_dm_channel(&ctx).await;
+
+        if dm_channel.is_err() {
+            content = String::from("Your DM's are closed, please open them and try again.");
+        } else {
+            let query = if reminder_exists {
+                "DELETE FROM astra.reminders WHERE user_id = $1 AND launch_id = $2"
+            } else {
+                "INSERT INTO astra.reminders (user_id, launch_id) VALUES ($1, $2)"
+            };
+
+            sqlx::query(query)
+                .bind(component.user.id.0 as i64)
+                .bind(&component.data.custom_id)
+                .execute(&db.pool)
+                .await?;
+        }
+
+        component
+            .create_interaction_response(&ctx, |r| {
+                r.kind(InteractionResponseType::ChannelMessageWithSource);
+                r.interaction_response_data(|d| {
+                    d.content(content);
+                    d.flags(InteractionApplicationCommandCallbackDataFlags::EPHEMERAL)
+                });
+                r
+            })
+            .await?;
+
+        Ok(())
+    }
+}

src/bot/events/reaction_add.rs

@@ -8,7 +8,6 @@ use chrono::{DateTime, Utc};
 
 use log::warn;
 
-use serenity::model::channel::ReactionType::Unicode;
 use serenity::prelude::Context;
 use std::error::Error;
 use std::sync::Arc;
@@ -21,7 +20,7 @@ pub async fn dispatch_to_guilds(
 ) -> Result<(), Box<dyn Error>> {
     let guilds = db.get_guilds_queried(true, Query::Launches).await;
 
-    let remaining_str = (dt - chrono::offset::Utc::now()).create_24h();
+    let remaining_str = (dt - Utc::now()).create_24h();
     for guild in guilds {
         let channel = match guild.channel_id.fetch(ctx).await {
             Some(channel) => channel,
@@ -30,9 +29,11 @@ pub async fn dispatch_to_guilds(
             }
         };
 
-        if let Ok(m) = channel.send_launch(ctx, next_launch, &remaining_str).await {
-            m.react(&ctx, Unicode("🔔".to_string())).await?;
-        } else {
+        if channel
+            .send_launch(ctx, next_launch, &remaining_str)
+            .await
+            .is_err()
+        {
             warn!("Failed to send Launch to {}", channel.id());
         }
     }
@@ -67,10 +68,10 @@ pub async fn check_future_launch(ctx: Arc<Context>) -> Result<(), Box<dyn Error>
             }
         }
 
-        let mut dblaunch = DBLaunch::from(next_launch);
-        dblaunch.dispatched = dispatched;
+        let mut db_launch = DBLaunch::from(next_launch);
+        db_launch.dispatched = dispatched;
 
-        db.set_launch(dblaunch).await?;
+        db.set_launch(db_launch).await?;
     }
 
     Ok(())

src/bot/loops/launches.rs

@@ -1,3 +1,4 @@
+use crate::bot::components::create_launch_components;
 use crate::bot::embeds::{create_apod_embed, create_basic_embed, create_launch_embed};
 use crate::models::apod::Apod;
 use crate::models::launch::Launch;
@@ -37,8 +38,15 @@ impl ChannelExt for Channel {
 
     async fn send_launch(&self, ctx: &client::Context, n: &Launch, r: &String) -> Result<Message> {
         let e = create_launch_embed(n, r);
+        let c = create_launch_components(&n.id);
 
-        self.id().send_message(ctx, move |m| m.set_embed(e)).await
+        self.id()
+            .send_message(ctx, move |m| {
+                m.set_embed(e);
+                m.set_components(c);
+                m
+            })
+            .await
     }
 
     async fn send_apod(&self, ctx: &client::Context, n: &Apod) -> Result<Message> {