Added reminders

+ Users can react to an event message, when they do they get reminders about the event

migrations/2020-04-22-222856_create_events/down.sql

@@ -1,2 +1,2 @@
 -- This file should undo anything in `up.sql`
-DROP TABLe events;
+DROP TABLE events;

migrations/2020-04-22-222856_create_events/up.sql

@@ -5,5 +5,6 @@ CREATE TABLE events (
   event_desc VARCHAR(255) NOT NULL,
   event_time DATETIME NOT NULL,
   message_id VARCHAR(255) NOT NULL,
-  thumbnail_link VARCHAR(255) NOT NULL
+  thumbnail_link VARCHAR(255) NOT NULL,
+  reminder_sent INTEGER NOT NULL
 )

src/database/mod.rs

@@ -3,6 +3,9 @@ pub mod models;
 
 use diesel::prelude::*;
 use models::{Event, NewEvent};
+use diesel::result::Error;
+use diesel::update;
+use std::vec::Vec;
 
 pub fn establish_connection(database_url: String) -> MysqlConnection {
     MysqlConnection::establish(&database_url)
@@ -21,3 +24,35 @@ pub fn insert_event(databse_url: String, new_event: &NewEvent) -> Event {
 
     events.order(id).first(&connection).unwrap()
 }
+
+pub fn get_event_by_name(database_url: String, name: String) -> Result<Event, Error> {
+    use schema::events::dsl::{event_name, events};
+
+    let connection = establish_connection(database_url);
+
+    events.filter(event_name.eq(&name)).get_result::<Event>(&connection)
+}
+
+pub fn get_event_by_msg_id(database_url: String, msg_id: String) -> Result<Event, Error> {
+    use schema::events::dsl::{message_id, events};
+
+    let connection = establish_connection(database_url);
+
+    events.filter(message_id.eq(&msg_id)).get_result::<Event>(&connection)
+}
+
+pub fn get_all_events(database_url: String) -> Result<Vec<Event>, Error> {
+    use schema::events::dsl::{event_time, events};
+
+    let connection = establish_connection(database_url);
+
+    events.order(event_time).load(&connection)
+}
+
+pub fn set_reminder(database_url: String, event_id: i32) -> Result<usize, Error> {
+    use schema::events::dsl::{events, id, reminder_sent};
+    let connection = establish_connection(database_url);
+
+    let target = events.filter(id.eq(event_id));
+    update(target).set(reminder_sent.eq(1)).execute(&connection)
+}

src/database/models.rs

@@ -9,6 +9,7 @@ pub struct Event {
     pub event_time: NaiveDateTime,
     pub message_id: String,
     pub thumbnail_link: String,
+    pub reminder_sent: i32,
 }
 
 #[derive(Insertable)]
@@ -19,4 +20,5 @@ pub struct NewEvent {
     pub event_time: NaiveDateTime,
     pub message_id: String,
     pub thumbnail_link: String,
+    pub reminder_sent: i32,
 }

src/database/schema.rs

@@ -6,5 +6,6 @@ table! {
         event_time -> Datetime,
         message_id -> Varchar,
         thumbnail_link -> Varchar,
+        reminder_sent -> Integer,
     }
 }

src/main.rs

@@ -7,10 +7,10 @@ extern crate diesel_migrations;
 extern crate serde;
 
 use serenity::client::Client;
-use serenity::model::channel::{Message};
+use serenity::Result;
-use serenity::prelude::{EventHandler, Context};
+use serenity::model::channel::{Message, Reaction};
+use serenity::prelude::{EventHandler, Context, ShareMap, RwLock};
 use serenity::utils::{content_safe, ContentSafeOptions, Colour};
-use serenity::model::gateway::Ready;
 use serenity::framework::standard::StandardFramework;
 use serenity::framework::standard::CommandResult;
 use serenity::framework::standard::macros::{command, group,};
@@ -21,13 +21,23 @@ use clap::{Arg, App};
 use chrono::{DateTime, Utc, NaiveDateTime, Datelike, Timelike, TimeZone};
 use chrono_tz::Tz;
 use std::process::exit;
+use std::thread::sleep;
+use std::time::Duration;
+use std::sync::Arc;
+use serenity::CacheAndHttp;
+use std::thread;
 
 mod hypebot_config;
 mod database;
 
 use database::*;
 use hypebot_config::HypeBotConfig;
-use crate::database::models::NewEvent;
+use crate::database::models::{NewEvent};
+use serenity::http::Http;
+use serenity::model::prelude::Ready;
+
+const INTERESTED_EMOJI: &str = "\u{2705}";
+const UNINTERESTED_EMOJI: &str = "\u{274C}";
 
 /// Event commands group
 #[group]
@@ -37,11 +47,40 @@ struct EventCommands;
 /// Handler for Discord events
 struct Handler;
 
+
+
 impl EventHandler for Handler {
     /// On bot ready
     fn ready(&self, _: Context, ready: Ready) {
         println!("Connected as {}", ready.user.name);
     }
+
+    /// On reaction
+    fn reaction_add(&self, ctx: Context, reaction: Reaction) {
+        if reaction.emoji.as_data() == INTERESTED_EMOJI {
+            let data = ctx.data.read();
+            let config = data.get::<HypeBotConfig>().unwrap();
+            let db_link = config.db_url.clone();
+            let message_id = reaction.message_id.0.to_string();
+
+            let event = match get_event_by_msg_id(db_link, message_id) {
+                Ok(event) => event,
+                Err(_) => {
+                    return;
+                }
+            };
+
+            let user = ctx.http.get_user(reaction.user_id.0).unwrap();
+
+            let dm_channel = user.create_dm_channel(&ctx.http).unwrap();
+
+            dm_channel.send_message(&ctx.http, |m| {
+                m.content(format!("You have signed up to receive reminders for **{}**!", &event.event_name))
+            }).ok();
+        }
+
+
+    }
 }
 
 /// Struct for storing drafted events
@@ -103,10 +142,16 @@ fn main() {
                     event_name: String::new(),
                     event_desc: String::new(),
                     thumbnail_link: String::new(),
+                    reminder_sent: 0 as i32,
                 },
                 creator_id: 0
             });
         }
+        let data = client.data.clone();
+        let cache_and_http = client.cache_and_http.clone();
+        thread::spawn(move || {
+            send_reminders(&cache_and_http, &data)
+        });
 
         // Start bot
         println!("Starting Hypebot!");
@@ -120,17 +165,49 @@ fn main() {
     }
 }
 
-fn send_event_msg(ctx: &Context, channel_id: u64, event: &NewEvent) -> CommandResult {
+fn send_reminders(cache_and_http: &Arc<CacheAndHttp>, data: &Arc<RwLock<ShareMap>>) {
-    let data = ctx.data.read();
+    let sleep_duration = Duration::from_secs(60);
-    let config = data.get::<HypeBotConfig>().unwrap();
+    loop {
-    let channel = ctx.http.get_channel(channel_id)?;
+        sleep(sleep_duration);
+        if let Some(config) = data.read().get::<HypeBotConfig>() {
+            let http = &cache_and_http.http;
+            let event_channel_id = config.event_channel;
 
-    let tz: Tz = config.event_timezone.parse()?;
+            if let Ok(events)= get_all_events(config.db_url.clone()) {
+                for event in events {
+                    let utc_time = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
+                    let time_to_event = utc_time - chrono::offset::Utc::now();
+
+                    if time_to_event.num_minutes() < 10 && event.reminder_sent != 1{
+                        if let Ok(message_id) = event.message_id.parse::<u64>() {
+                            let message = http.get_message(event_channel_id, message_id).unwrap();
+                            for user in message.reaction_users(&http,INTERESTED_EMOJI, None, None).unwrap() {
+                                if let Ok(dm_channel) = user.create_dm_channel(&http) {
+                                    dm_channel.send_message(&http, |m| {
+                                        m.content(format!("Hello! **{}** begins in **{} minutes**!", &event.event_name, time_to_event.num_minutes()))
+                                    }).ok();
+                                }
+                            }
+
+                            set_reminder(config.db_url.clone(), event.id).ok();
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}
+
+fn send_event_msg(http: &Http, config: &HypeBotConfig, channel_id: u64, event: &NewEvent) -> Result<Message> {
+    let channel = http.get_channel(channel_id).unwrap();
+
+    let tz: Tz = config.event_timezone.parse().unwrap();
     let utc_time = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
     let native_time = utc_time.with_timezone(&tz);
 
     // Send message
-    let msg = channel.id().send_message(&ctx, |m| {
+    let msg = channel.id().send_message(&http, |m| {
         m.embed(|e| {
             e.title(event.event_name.clone())
                 .color(Colour::PURPLE)
@@ -142,10 +219,10 @@ fn send_event_msg(ctx: &Context, channel_id: u64, event: &NewEvent) -> CommandRe
     })?;
 
     // Add reacts
-    msg.react(ctx, "\u{2705}")?;
+    msg.react(http, INTERESTED_EMOJI).unwrap();
-    msg.react(ctx, "\u{274C}")?;
+    msg.react(http, UNINTERESTED_EMOJI).unwrap();
 
-    Ok(())
+    Ok(msg)
 }
 
 #[command]
@@ -159,12 +236,20 @@ fn confirm_event(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult
     let new_event = &draft_event.event;
 
     if draft_event.creator_id == msg.author.id.0 {
-        send_event_msg(ctx,  config.event_channel, new_event)?;
+        let event_msg = send_event_msg(&ctx.http, config,  config.event_channel, new_event)?;
-
-        // Insert event into the database
-        insert_event(config.db_url.clone(), new_event);
-
         msg.reply(&ctx, "Event posted!")?;
+
+        let new_event = NewEvent {
+            message_id: event_msg.id.0.to_string(),
+            event_time: new_event.event_time.clone(),
+            event_desc: new_event.event_desc.clone(),
+            event_name: new_event.event_name.clone(),
+            thumbnail_link: new_event.event_name.clone(),
+            reminder_sent: 0,
+        };
+
+        insert_event(config.db_url.clone(), &new_event);
+
     }
     else {
         msg.reply(&ctx, format!("You do not have a pending event!"))?;
@@ -234,8 +319,9 @@ fn create_event (ctx: &mut Context, msg: &Message, mut args: Args) -> CommandRes
 
     {
         let data = ctx.data.read();
-        msg.reply(&ctx, format!("Draft message, use the `confirm_event` command to confirm it."))?;
+        let config = data.get::<HypeBotConfig>().unwrap();
-        send_event_msg(ctx, msg.channel_id.0, &data.get::<DraftEvent>().unwrap().event)?;
+        msg.reply(&ctx, format!("Draft message, use the `confirm_event` command to post it."))?;
+        send_event_msg(&ctx.http, config, msg.channel_id.0, &data.get::<DraftEvent>().unwrap().event)?;
     }
 
     Ok(())