Merge pull request 'Async Update' (#1) from async_update into master

Reviewed-on: https://git.birbmc.com/ZeroHD/HypeBot/pulls/1

.drone.yml

@@ -0,0 +1,39 @@
+---
+kind: pipeline
+name: compliance
+type: docker
+trigger:
+  event:
+    - pull_request
+steps:
+  - name: build
+    pull: always
+    image: rust:1.50
+    commands:
+      - rustup component add clippy
+      - cargo build --verbose
+      - cargo clippy
+---
+kind: pipeline
+name: release
+type: docker
+trigger:
+  branch:
+    - master
+  event:
+    - push
+steps:
+  - name: build
+    pull: always
+    image: rust:1.50
+    commands:
+      - cargo build --verbose --release
+  - name: gitea-release
+    pull: always
+    image: jolheiser/drone-gitea-main:latest
+    settings:
+      token:
+        from_secret: gitea_token
+      base: https://git.etztech.xyz
+      files:
+        - "target/release/hype_bot"

.gitignore

@@ -1,4 +1,6 @@
 /target
 **/*.rs.bk
 .env
-log/*
+log/
+config.toml
+.idea

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hype_bot"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Joey Hines <joey@ahines.net>"]
 edition = "2018"
 
@@ -10,17 +10,18 @@ edition = "2018"
 clap = "2.33.0"
 serde = "1.0.106"
 serde_derive = "1.0.104"
+serde_json = "1.0.63"
 config = "0.9"
-chrono = "0.4.11"
+chrono = { version = "0.4.19", default-features = false, features = ["clock", "std"] }
 chrono-tz = "0.4"
-diesel = { version = "1.4.0", features = ["mysql", "chrono"] }
-diesel_migrations = "1.4.0"
 log = "0.4.8"
 log4rs = "0.11.0"
 strfmt = "0.1.6"
 url = "2.1.1"
-white_rabbit = "0.1.1"
+tokio = { version = "1.2", features = ["macros", "rt-multi-thread"] }
+percent-encoding = "2.1.0"
+sled = "0.34.6"
 
 [dependencies.serenity]
-version = "0.8.6"
+version = "0.10.4"
-features = ["framework", "standard_framework"]
+features = ["framework", "standard_framework", "utils", "builder"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 ZeroHD
+Copyright (c) 2020-2021 ZeroHD
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,6 +1,6 @@
 # HypeBot
 A Discord bot for managing events. Uses [Serenity](https://github.com/serenity-rs/serenity) for the bot framework
-and [Diesel](http://diesel.rs/) as an ORM.
+and [sled](https://github.com/spacejam/sled) for the database
 
 ## Usage
 Creating an event can be done using the `create` command.
@@ -24,7 +24,7 @@ Users who react with ✅ will then be sent reminders about the event as private
 ## Config
 ```toml
 # Database URL
-db_url = "mysql://[user]:[password]@localhost/hypebot_db"
+db_location = "path/to/db"
 # Default image to show on the thumbnail
 default_thumbnail_link = "https://i.imgur.com/wPdnvoE.png"
 # Discord bot key

diesel.toml

@@ -1,5 +0,0 @@
-# For documentation on how to configure this file,
-# see diesel.rs/guides/configuring-diesel-cli
-
-[print_schema]
-file = "src/database/schema.rs"

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

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

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

@@ -1,12 +0,0 @@
--- Your SQL goes here
-CREATE TABLE events (
-  id INTEGER AUTO_INCREMENT PRIMARY KEY,
-  event_name VARCHAR(255) NOT NULL,
-  event_desc VARCHAR(255) NOT NULL,
-  event_loc VARCHAR(255) NOT NULL,
-  organizer VARCHAR(255) NOT NULL,
-  event_time DATETIME NOT NULL,
-  message_id VARCHAR(255) NOT NULL,
-  thumbnail_link VARCHAR(255) NOT NULL,
-  reminder_sent INTEGER NOT NULL
-)

migrations/2020-07-10-032139_bigger_desc_field/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE events MODIFY event_desc VARCHAR(255) ;

migrations/2020-07-10-032139_bigger_desc_field/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-ALTER TABLE events MODIFY event_desc VARCHAR(2050);

src/database/mod.rs

@@ -1,78 +1,84 @@
 pub mod models;
-pub mod schema;
 
-use diesel::prelude::*;
+use crate::models::Event;
-use diesel::result::Error;
+use serenity::prelude::TypeMapKey;
-use diesel::update;
+use sled::{open, Db, IVec, Result};
-use models::{Event, NewEvent};
+use std::path::Path;
-use std::vec::Vec;
+use std::sync::Arc;
 
-/// Establish a connection to the database
+pub struct Database {
-pub fn establish_connection(database_url: String) -> MysqlConnection {
+    db: Db,
-    MysqlConnection::establish(&database_url)
-        .expect(&format!("Error connecting to {}", database_url))
-}
-/// Insert an event into the database
-pub fn insert_event(database_url: String, new_event: &NewEvent) -> Result<Event, Error> {
-    use schema::events::dsl::{events, id};
-
-    let connection = establish_connection(database_url);
-
-    diesel::insert_into(events)
-        .values(new_event)
-        .execute(&connection)
-        .expect("Error saving event");
-
-    events.order(id).first(&connection)
 }
 
-/// Remove event
+impl Database {
-pub fn remove_event(database_url: String, event_id: i32) -> Result<usize, Error> {
+    /// Open the database
-    use schema::events::dsl::{events, id};
+    pub fn new(db_path: &Path) -> Result<Database> {
+        let db = open(db_path)?;
 
-    let connection = establish_connection(database_url);
+        Ok(Self { db })
+    }
 
-    diesel::delete(events.filter(id.eq(event_id))).execute(&connection)
+    /// DB iterator
+    fn db_iter(&self) -> sled::Iter {
+        self.db.iter()
+    }
+
+    /// Get events by a filter
+    pub fn filter_events<F>(&self, filter: F) -> Vec<Event>
+    where
+        F: Fn(&String, &Event) -> bool,
+    {
+        self.db_iter()
+            .filter_map(|pair| {
+                if let Ok((message_id, event)) = pair {
+                    let event: Event = event.into();
+                    let message_id: String = String::from_utf8(message_id.to_vec()).unwrap();
+                    if filter(&message_id, &event) {
+                        Some(event)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    /// Insert an event into the database
+    pub fn insert_event(&self, event: &Event) -> Result<()> {
+        let msg_id = &event.message_id;
+        let event: IVec = event.into();
+        self.db.insert(msg_id, event)?;
+
+        Ok(())
+    }
+
+    /// Remove event from database
+    pub fn remove_event(&self, event: &Event) -> Result<()> {
+        self.db.remove(event.message_id.clone())?;
+
+        Ok(())
+    }
+
+    /// Get event by name
+    pub fn get_event_by_name(&self, event_name: &str) -> Option<Event> {
+        self.filter_events(|_, e| e.event_name.as_str() == event_name)
+            .pop()
+    }
+
+    /// Get all events
+    pub fn get_all_events(&self) -> Vec<Event> {
+        self.filter_events(|_, _| true)
+    }
+
+    /// Get event my discord msg id
+    pub fn get_event_by_msg_id(&self, target_msg_id: &str) -> Option<Event> {
+        self.filter_events(|msg_id, _| msg_id.as_str() == target_msg_id)
+            .pop()
+    }
 }
 
-/// Get an event by name
+impl TypeMapKey for Database {
-pub fn get_event_by_name(database_url: String, name: String) -> Result<Event, Error> {
+    type Value = Arc<Database>;
-    use schema::events::dsl::{event_name, events};
-
-    let connection = establish_connection(database_url);
-
-    events
-        .filter(event_name.eq(&name))
-        .get_result::<Event>(&connection)
-}
-
-/// Get event by its message id
-pub fn get_event_by_msg_id(database_url: String, msg_id: String) -> Result<Event, Error> {
-    use schema::events::dsl::{events, message_id};
-
-    let connection = establish_connection(database_url);
-
-    events
-        .filter(message_id.eq(&msg_id))
-        .get_result::<Event>(&connection)
-}
-
-/// Get all events
-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)
-}
-
-/// Set the reminder state of an event
-pub fn set_reminder(database_url: String, event_id: i32, state: 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(state))
-        .execute(&connection)
 }

src/database/models.rs

@@ -1,10 +1,9 @@
-use super::schema::events;
+use chrono::{NaiveDateTime, Utc};
-use chrono::NaiveDateTime;
+use serde::{Deserialize, Serialize};
+use sled::IVec;
 
-#[derive(Queryable, Clone, Debug)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Event {
-    /// Event ID
-    pub id: i32,
     /// Event name
     pub event_name: String,
     /// Event long description
@@ -19,42 +18,40 @@ pub struct Event {
     pub message_id: String,
     /// Event message thumbnail link
     pub thumbnail_link: String,
-    /// Reminder sent tracker
-    pub reminder_sent: i32,
 }
 
-impl Into<NewEvent> for Event {
+impl Default for Event {
-    fn into(self) -> NewEvent {
+    fn default() -> Self {
-        NewEvent {
+        Self {
-            event_name: self.event_name.clone(),
+            message_id: String::default(),
-            event_desc: self.event_desc.clone(),
+            event_time: Utc::now().naive_utc(),
-            organizer: self.organizer.clone(),
+            event_name: String::default(),
-            event_loc: self.event_loc.clone(),
+            organizer: String::default(),
-            event_time: self.event_time.clone(),
+            event_desc: String::default(),
-            message_id: self.message_id.clone(),
+            event_loc: String::default(),
-            thumbnail_link: self.message_id.clone(),
+            thumbnail_link: String::default(),
-            reminder_sent: self.reminder_sent,
         }
     }
 }
 
-#[derive(Insertable, Clone, Debug)]
+impl Into<IVec> for &Event {
-#[table_name = "events"]
+    fn into(self) -> IVec {
-pub struct NewEvent {
+        IVec::from(serde_json::to_string(self).unwrap().as_str())
-    /// Event name
+    }
-    pub event_name: String,
+}
-    /// Event long description
+
-    pub event_desc: String,
+impl From<&IVec> for Event {
-    /// Event location
+    fn from(v: &IVec) -> Self {
-    pub event_loc: String,
+        let s = String::from_utf8(v.to_vec()).unwrap();
-    /// Event organizer
+
-    pub organizer: String,
+        let e: Event = serde_json::from_str(s.as_str()).unwrap();
-    /// Event datetime
+
-    pub event_time: NaiveDateTime,
+        e
-    /// Event discord message id
+    }
-    pub message_id: String,
+}
-    /// Event message thumbnail link
+
-    pub thumbnail_link: String,
+impl From<IVec> for Event {
-    /// Reminder sent tracker
+    fn from(v: IVec) -> Self {
-    pub reminder_sent: i32,
+        Self::from(&v)
+    }
 }

src/database/schema.rs

@@ -1,13 +0,0 @@
-table! {
-    events (id) {
-        id -> Integer,
-        event_name -> Varchar,
-        event_desc -> Varchar,
-        event_loc -> Varchar,
-        organizer -> Varchar,
-        event_time -> Datetime,
-        message_id -> Varchar,
-        thumbnail_link -> Varchar,
-        reminder_sent -> Integer,
-    }
-}

src/discord/events.rs

@@ -1,18 +1,17 @@
-use super::{get_config, send_event_msg};
-use crate::database::{get_event_by_name, insert_event, remove_event};
-use crate::discord::{
-    get_draft_event, schedule_event, send_dm_message, send_draft_event, update_draft_event,
-};
-use crate::INTERESTED_EMOJI;
 use chrono::offset::TimeZone;
 use chrono::{Datelike, NaiveDateTime, Timelike, Utc};
 use chrono_tz::Tz;
 use serenity::framework::standard::{macros::command, Args, CommandResult};
-use serenity::model::prelude::{Mentionable, Message, User};
+use serenity::model::prelude::{Mentionable, Message};
 use serenity::prelude::Context;
 use serenity::utils::{content_safe, ContentSafeOptions};
 use url::Url;
 
+use crate::discord::utility::{
+    delete_event, get_config, schedule_event, send_draft_event, send_event_msg, update_draft_event,
+};
+use crate::discord::{get_db, get_draft_event};
+
 #[command]
 /// Posts a previewed event
 ///
@@ -20,25 +19,28 @@ use url::Url;
 ///
 /// **Note**
 /// You can only post events you have created. Only one preview event can exist at a time.
-fn confirm(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult {
+async fn confirm(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
-    let config = get_config(&ctx.data)?;
+    let config = get_config(&ctx.data.read().await).await?;
-    let draft_event = get_draft_event(&ctx.data)?;
+    let draft_event = get_draft_event(&ctx.data.read().await).await?;
+    let db = get_db(&ctx.data.read().await).await?;
 
     let mut new_event = draft_event.event.clone();
     // Check to to see if message author is the owner of the pending event
     if draft_event.creator_id == msg.author.id.0 {
         // Send event message
-        let event_msg = send_event_msg(&ctx.http, &config, config.event_channel, &new_event, true)?;
+        let event_msg =
+            send_event_msg(&ctx, &config, config.event_channel, &new_event, true).await?;
 
-        msg.reply(&ctx, "Event posted!")?;
+        msg.reply(&ctx, "Event posted!").await?;
 
         new_event.message_id = event_msg.id.0.to_string();
 
-        let event = insert_event(config.db_url.clone(), &new_event)?;
+        db.insert_event(&new_event)?;
 
-        schedule_event(&ctx.http, &ctx.data, &event);
+        schedule_event(&ctx, &new_event).await;
     } else {
-        msg.reply(&ctx, format!("You do not have a pending event!"))?;
+        msg.reply(&ctx, "You do not have a pending event!".to_string())
+            .await?;
     }
 
     Ok(())
@@ -57,29 +59,31 @@ fn confirm(ctx: &mut Context, msg: &Message, _args: Args) -> CommandResult {
 ///
 /// **Organizer**
 /// The user or group that is organizing the event, defaults to the user creating the event
-fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
+async fn create(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
     // Get config
-    let config = get_config(&ctx.data)?;
+    let config = get_config(&ctx.data.read().await).await?;
 
     // Parse args
     let event_name = match args.find::<String>() {
         Ok(event_name) => event_name.replace("\"", ""),
         Err(_) => {
-            msg.reply(&ctx, "No event name provided.".to_string())?;
+            msg.reply(&ctx, "No event name provided.".to_string())
+                .await?;
             return Ok(());
         }
     };
     let date_string = match args.find::<String>() {
         Ok(date_string) => date_string.replace("\"", ""),
         Err(_) => {
-            msg.reply(&ctx, "No date provided.".to_string())?;
+            msg.reply(&ctx, "No date provided.".to_string()).await?;
             return Ok(());
         }
     };
     let description = match args.find::<String>() {
         Ok(desc) => desc.replace("\"", ""),
         Err(_) => {
-            msg.reply(&ctx, "No description provided.".to_string())?;
+            msg.reply(&ctx, "No description provided.".to_string())
+                .await?;
             return Ok(());
         }
     };
@@ -87,7 +91,7 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
     let location = match args.find::<String>() {
         Ok(desc) => desc.replace("\"", ""),
         Err(_) => {
-            msg.reply(&ctx, "No location provided.".to_string())?;
+            msg.reply(&ctx, "No location provided.".to_string()).await?;
             return Ok(());
         }
     };
@@ -99,7 +103,7 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
 
     let organizer = match args.find::<String>() {
         Ok(link) => link.replace("\"", ""),
-        Err(_) => msg.author.mention(),
+        Err(_) => msg.author.mention().to_string(),
     };
 
     // Parse date
@@ -110,7 +114,8 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
             msg.reply(
                 &ctx,
                 "Invalid date format. Format is HH:MMam YYYY-MM-DD".to_string(),
-            )?;
+            )
+            .await?;
             return Ok(());
         }
     };
@@ -130,7 +135,8 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
     let event_time = input_date.with_timezone(&Utc).naive_utc();
 
     if Utc::now().naive_utc() > event_time {
-        msg.reply(&ctx, "The scheduled time has already passed!")?;
+        msg.reply(&ctx, "The scheduled time has already passed!")
+            .await?;
         return Ok(());
     }
 
@@ -141,10 +147,10 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
         .clean_user(false)
         .clean_everyone(true);
 
-    let description = content_safe(&ctx.cache, description, &settings);
+    let description = content_safe(&ctx.cache, description, &settings).await;
-    let event_name = content_safe(&ctx.cache, event_name, &settings);
+    let event_name = content_safe(&ctx.cache, event_name, &settings).await;
-    let location = content_safe(&ctx.cache, location, &settings);
+    let location = content_safe(&ctx.cache, location, &settings).await;
-    let organizer = content_safe(&ctx.cache, organizer, &settings);
+    let organizer = content_safe(&ctx.cache, organizer, &settings).await;
 
     update_draft_event(
         &ctx,
@@ -155,8 +161,9 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
         thumbnail_link,
         event_time,
         msg.author.id.0,
-    )?;
+    )
-    send_draft_event(&ctx, msg.channel_id)?;
+    .await?;
+    send_draft_event(&ctx, msg.channel_id).await?;
 
     Ok(())
 }
@@ -165,31 +172,19 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
 /// Cancels an already scheduled event
 ///
 /// `~cancel "event name"`
-fn cancel(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
+async fn cancel(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
-    let config = get_config(&ctx.data)?;
+    let db = get_db(&ctx.data.read().await).await?;
 
     // Parse args
     let event_name = args.single::<String>()?.replace("\"", "");
 
-    let event = get_event_by_name(config.db_url.clone(), event_name)?;
+    if let Some(event) = db.get_event_by_name(&event_name) {
-    let message_id = event.message_id.parse::<u64>()?;
+        delete_event(ctx, &event).await?;
-    let message = ctx.http.get_message(config.event_channel, message_id)?;
+        msg.reply(&ctx, format!("{} has been cancelled", event.event_name))
-
+            .await?;
-    let reaction_users = message
+    } else {
-        .reaction_users(&ctx.http, INTERESTED_EMOJI, None, None)
+        msg.reply(&ctx, format!("{} now found!", event_name))
-        .unwrap_or(Vec::<User>::new());
+            .await?;
-
-    let cancel_msg = format!("**{}** has been canceled!", event.event_name.clone());
-
-    for user in reaction_users {
-        send_dm_message(&ctx.http, user, &cancel_msg);
     }
-
-    remove_event(config.db_url.clone(), event.id)?;
-
-    message.delete(&ctx)?;
-
-    msg.reply(&ctx, &cancel_msg)?;
-
     Ok(())
 }

src/discord/handler.rs

@@ -0,0 +1,68 @@
+use serenity::async_trait;
+use serenity::model::channel::Reaction;
+use serenity::model::gateway::Ready;
+use serenity::prelude::{Context, EventHandler};
+
+use crate::discord::utility::schedule_all_events;
+use crate::discord::{tasks, utility};
+use crate::INTERESTED_EMOJI;
+
+/// Handler for Discord events
+pub struct Handler;
+
+#[async_trait]
+impl EventHandler for Handler {
+    /// On reaction add
+    async fn reaction_add(&self, ctx: Context, reaction: Reaction) {
+        let config = utility::get_config(&ctx.data.read().await)
+            .await
+            .expect("Unable to get config");
+        if reaction.channel_id.0 == config.event_channel
+            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
+        {
+            utility::send_message_to_reaction_users(
+                &ctx,
+                &reaction,
+                "Hello, you are now receiving reminders for **{event}**",
+            )
+            .await;
+        }
+    }
+
+    /// On reaction remove
+    async fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
+        let config = utility::get_config(&ctx.data.read().await)
+            .await
+            .expect("Unable to get config");
+
+        if reaction.channel_id.0 == config.event_channel
+            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
+        {
+            utility::send_message_to_reaction_users(
+                &ctx,
+                &reaction,
+                "Hello, you are no longer receiving reminders for **{event}**",
+            )
+            .await;
+        }
+    }
+
+    /// On bot ready
+    async fn ready(&self, ctx: Context, ready: Ready) {
+        info!("Connected to Discord as {}", ready.user.name);
+
+        schedule_all_events(&ctx).await;
+
+        let cleanup_ctx = ctx.clone();
+
+        tokio::spawn(async move {
+            tasks::send_reminders_task(&ctx).await;
+        });
+
+        tokio::spawn(async move {
+            tasks::cleanup_task(&cleanup_ctx).await;
+        });
+
+        info!("Setup complete.")
+    }
+}

src/discord/mod.rs

@@ -1,226 +1,62 @@
-use crate::database::models::{Event, NewEvent};
+use std::collections::HashSet;
-use crate::database::{get_event_by_msg_id, remove_event, set_reminder};
-use crate::hypebot_config::HypeBotConfig;
-use crate::{INTERESTED_EMOJI, UNINTERESTED_EMOJI};
-use chrono::{DateTime, NaiveDateTime, Utc};
-use serenity::framework::standard::{CommandError, CommandResult};
-use serenity::http::Http;
-use serenity::model::prelude::{ChannelId, Message, Reaction, User};
-use serenity::prelude::TypeMapKey;
-use serenity::prelude::{Context, RwLock, ShareMap};
-use serenity::utils::Colour;
-use serenity::Result;
-use std::collections::HashMap;
 use std::sync::Arc;
-use strfmt::strfmt;
+
-use white_rabbit::{DateResult, Scheduler};
+use serenity::framework::standard::macros::help;
+use serenity::framework::standard::macros::hook;
+use serenity::framework::standard::{
+    help_commands, Args, CommandError, CommandGroup, CommandResult, HelpOptions,
+};
+use serenity::model::id::UserId;
+use serenity::model::prelude::Message;
+use serenity::prelude::Context;
+use serenity::prelude::{TypeMap, TypeMapKey};
+use tokio::sync::RwLockReadGuard;
+
+use crate::database::models::Event;
+use crate::database::Database;
 
 pub mod events;
+pub mod handler;
+pub mod tasks;
+pub mod utility;
 
 /// Struct for storing drafted events
-#[derive(Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct DraftEvent {
-    pub event: NewEvent,
+    pub event: Event,
     pub creator_id: u64,
 }
 
 impl TypeMapKey for DraftEvent {
-    type Value = DraftEvent;
+    type Value = Arc<DraftEvent>;
-}
-
-pub struct SchedulerKey;
-
-impl TypeMapKey for SchedulerKey {
-    type Value = Arc<RwLock<Scheduler>>;
-}
-
-/// Send a message to a reaction user
-pub fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_text: &str) {
-    if let Ok(config) = get_config(&ctx.data) {
-        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(e) => {
-                error!("Error getting event from reaction {}", e);
-                return;
-            }
-        };
-
-        let event_utc_time = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
-        let current_utc_time = chrono::offset::Utc::now();
-
-        let msg;
-
-        if event_utc_time > current_utc_time {
-            // Format message
-            let mut fmt = HashMap::new();
-            fmt.insert("event".to_string(), event.event_name);
-            msg = strfmt(msg_text, &fmt).unwrap();
-        } else {
-            msg = format!("**{}** has already started!", &event.event_name)
-        }
-
-        if let Ok(user) = reaction.user(&ctx.http) {
-            send_dm_message(&ctx.http, user, &msg);
-        }
-    }
-}
-
-/// Send a DM message to a user
-pub fn send_dm_message(http: &Http, user: User, message: &String) {
-    if let Ok(dm_channel) = user.create_dm_channel(&http) {
-        dm_channel.send_message(&http, |m| m.content(message)).ok();
-    }
-}
-
-/// Create a countdown link for the event
-pub fn get_countdown_link(event_name: &String, utc: &DateTime<Utc>) -> String {
-    let msg = event_name.replace(" ", "+");
-    let time = utc.format("%G%m%dT%H%M").to_string();
-
-    format!(
-        "https://www.timeanddate.com/countdown/generic?iso={}&p0=&msg={}&font=sanserif&csz=1",
-        time, msg
-    )
-}
-
-/// Sends the event message to the event channel
-pub fn send_event_msg(
-    http: &Http,
-    config: &HypeBotConfig,
-    channel_id: u64,
-    event: &NewEvent,
-    react: bool,
-) -> Result<Message> {
-    let channel = http.get_channel(channel_id)?;
-
-    let utc_time = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
-
-    let native_time = utc_time.with_timezone(&config.event_timezone);
-
-    let ping_roles = config
-        .ping_roles
-        .clone()
-        .into_iter()
-        .map(|role| format!("<@&{}>", role))
-        .collect::<Vec<String>>()
-        .join(" ");
-
-    // Send message
-    let msg = channel.id().send_message(&http, |m| {
-        m.embed(|e| {
-            e.title(event.event_name.clone())
-                .color(Colour::PURPLE)
-                .description(format!(
-                    "**{}**\n{}\n\n[Click Here For A Countdown]({})\n\nReact with {} below to receive event reminders!",
-                    native_time.format("%A, %B %d @ %I:%M %P %t %Z"),
-                    event.event_desc,
-                    get_countdown_link(&event.event_name, &utc_time),
-                    INTERESTED_EMOJI
-                ))
-                .thumbnail(event.thumbnail_link.clone())
-                .footer(|f| f.text("Local Event Time"))
-                .timestamp(utc_time.to_rfc3339())
-                .field("Location", &event.event_loc, true)
-                .field("Organizer", &event.organizer, true)
-        }).content(ping_roles)
-    })?;
-
-    if react {
-        // Add reacts
-        msg.react(http, INTERESTED_EMOJI)?;
-        msg.react(http, UNINTERESTED_EMOJI)?;
-    }
-
-    Ok(msg)
-}
-
-/// Updates the draft event stored in the context data
-pub fn update_draft_event(
-    ctx: &Context,
-    event_name: String,
-    event_desc: String,
-    organizer: String,
-    location: String,
-    thumbnail: String,
-    event_time: NaiveDateTime,
-    creator_id: u64,
-) -> CommandResult {
-    let mut data = ctx.data.write();
-    let mut draft_event = data
-        .get_mut::<DraftEvent>()
-        .ok_or(CommandError("Unable get draft event!".to_string()))?;
-
-    draft_event.event.event_name = event_name;
-    draft_event.event.event_desc = event_desc;
-    draft_event.event.event_loc = location;
-    draft_event.event.organizer = organizer;
-    draft_event.event.thumbnail_link = thumbnail;
-    draft_event.event.message_id = String::new();
-    draft_event.event.event_time = event_time;
-    draft_event.creator_id = creator_id;
-    Ok(())
-}
-
-/// Sends the draft event stored in the context data
-pub fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
-    let data = ctx.data.read();
-    let config = data
-        .get::<HypeBotConfig>()
-        .ok_or(CommandError("Config not found!".to_string()))?;
-    let draft_event = data
-        .get::<DraftEvent>()
-        .ok_or(CommandError("Draft event not found!".to_string()))?;
-
-    channel.send_message(&ctx, |m| {
-        m.content(format!(
-            "Draft message, use the `confirm` command to post it."
-        ))
-    })?;
-    send_event_msg(&ctx.http, config, channel.0, &draft_event.event, false)?;
-    Ok(())
-}
-
-/// Gets the config from context data
-pub fn get_config(
-    data: &Arc<RwLock<ShareMap>>,
-) -> std::result::Result<HypeBotConfig, CommandError> {
-    let data_read = data.read();
-    let config = data_read
-        .get::<HypeBotConfig>()
-        .ok_or(CommandError("Unable to get config".to_string()))?;
-
-    Ok(config.clone())
 }
 
 /// Gets the draft event from context data
-pub fn get_draft_event(
+pub async fn get_draft_event(
-    data: &Arc<RwLock<ShareMap>>,
+    data: &RwLockReadGuard<'_, TypeMap>,
-) -> std::result::Result<DraftEvent, CommandError> {
+) -> std::result::Result<Arc<DraftEvent>, CommandError> {
-    let data_read = data.read();
+    let draft_event = data
-    let draft_event = data_read
         .get::<DraftEvent>()
-        .ok_or(CommandError("Unable to queued event".to_string()))?;
+        .ok_or_else(|| CommandError::from("Unable to get queued event".to_string()))?;
 
     Ok(draft_event.clone())
 }
 
-/// Get the scheduler
+/// Gets the database from context data
-pub fn get_scheduler(
+pub async fn get_db(
-    data: &Arc<RwLock<ShareMap>>,
+    data: &RwLockReadGuard<'_, TypeMap>,
-) -> std::result::Result<Arc<RwLock<Scheduler>>, CommandError> {
+) -> std::result::Result<Arc<Database>, CommandError> {
-    let mut context = data.write();
+    let db = data
-    Ok(context
+        .get::<Database>()
-        .get_mut::<SchedulerKey>()
+        .ok_or_else(|| CommandError::from("Unable to get db".to_string()))?;
-        .ok_or(CommandError("Unable to get scheduler".to_string()))?
+
-        .clone())
+    Ok(db.clone())
 }
 
 /// Logs command errors to the logger
-pub fn log_error(
+#[hook]
-    _ctx: &mut Context,
+pub async fn log_error(
+    _ctx: &Context,
     _msg: &Message,
     command_name: &str,
     result: std::result::Result<(), CommandError>,
@@ -232,19 +68,18 @@ pub fn log_error(
 }
 
 /// Checks if the user has permission to use this bot
-pub fn permission_check(ctx: &mut Context, msg: &Message, _command_name: &str) -> bool {
+#[hook]
+pub async fn permission_check(ctx: &Context, msg: &Message, _command_name: &str) -> bool {
     if let Some(guild_id) = msg.guild_id {
-        if let Ok(config) = get_config(&ctx.data) {
+        if let Ok(config) = utility::get_config(&ctx.data.read().await).await {
-            if let Ok(roles) = ctx.http.get_guild_roles(guild_id.0) {
+            if let Ok(roles) = ctx.http.get_guild_roles(guild_id.0).await {
                 for role in roles {
                     if config.event_roles.contains(&role.id.0) {
-                        let has_role = match msg.author.has_role(&ctx, guild_id, role) {
+                        return msg
-                            Ok(has_role) => has_role,
+                            .author
-                            Err(_) => false,
+                            .has_role(&ctx, guild_id, role)
-                        };
+                            .await
-                        if has_role {
+                            .unwrap_or(false)
-                            return true;
-                        }
                     }
                 }
             }
@@ -254,85 +89,17 @@ pub fn permission_check(ctx: &mut Context, msg: &Message, _command_name: &str) -
     false
 }
 
-/// Schedule event reminders
+#[help]
-pub fn schedule_event(http: &Arc<Http>, data: &Arc<RwLock<ShareMap>>, event: &Event) {
+#[command_not_found_text = "Could not find: `{}`."]
-    let scheduler = {
+#[strikethrough_commands_tip_in_guild("")]
-        let mut context = data.write();
+async fn bot_help(
-        context
+    context: &Context,
-            .get_mut::<SchedulerKey>()
+    msg: &Message,
-            .expect("Expected Scheduler.")
+    args: Args,
-            .clone()
+    help_options: &'static HelpOptions,
-    };
+    groups: &[&'static CommandGroup],
-
+    owners: HashSet<UserId>,
-    let config = get_config(&data).unwrap();
+) -> CommandResult {
-
+    help_commands::with_embeds(context, msg, args, help_options, groups, owners).await;
-    if let Some(reminders) = config.reminders {
+    Ok(())
-        let event_time: DateTime<Utc> = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
-        let delete_time = event_time + chrono::Duration::minutes(1);
-        let mut scheduler = scheduler.write();
-
-        for reminder in reminders {
-            let reminder_time =
-                event_time - chrono::Duration::minutes(reminder.reminder_time as i64);
-
-            if reminder_time > chrono::offset::Utc::now() {
-                let reminder_msg = reminder.msg.clone();
-                let http = http.clone();
-                let data = data.clone();
-                let event = event.clone();
-
-                scheduler.add_task_datetime(reminder_time, move |_| {
-                    send_reminders(&http, &data, &event, &reminder_msg)
-                });
-            }
-        }
-
-        let http = http.clone();
-        let data = data.clone();
-        let event = event.clone();
-        scheduler.add_task_datetime(delete_time, move |_| {
-            delete_event(&http, &data, &event);
-            DateResult::Done
-        });
-    }
-}
-
-/// Send reminders
-pub fn send_reminders(
-    http: &Arc<Http>,
-    data: &Arc<RwLock<ShareMap>>,
-    event: &Event,
-    reminder_msg: &String,
-) -> DateResult {
-    let config = get_config(&data).unwrap();
-    let event_channel_id = config.event_channel;
-
-    if let Ok(message_id) = event.message_id.parse::<u64>() {
-        // Get message id
-        if let Ok(message) = http.get_message(event_channel_id, message_id) {
-            let reaction_users = message
-                .reaction_users(&http, INTERESTED_EMOJI, None, None)
-                .unwrap_or(Vec::<User>::new());
-
-            // Build reminder message
-            let msg: String = reminder_msg.replace("{EVENT_NAME}", event.event_name.as_str());
-
-            // Send reminder to each reacted user
-            for user in reaction_users {
-                send_dm_message(&http, user, &msg);
-            }
-        }
-    }
-
-    DateResult::Done
-}
-
-/// Delete event
-pub fn delete_event(http: &Arc<Http>, data: &Arc<RwLock<ShareMap>>, event: &Event) {
-    let config = get_config(&data).unwrap();
-
-    remove_event(config.db_url.clone(), event.id).ok();
-    if let Ok(message_id) = event.message_id.parse::<u64>() {
-        http.delete_message(config.event_channel, message_id).ok();
-    }
 }

src/discord/tasks.rs

@@ -0,0 +1,71 @@
+use chrono::{Duration, Utc};
+use serenity::prelude::Context;
+
+use crate::discord::{get_db, utility};
+use crate::reminder::Reminders;
+use crate::INTERESTED_EMOJI;
+
+/// Send reminders
+pub async fn send_reminders_task(ctx: &Context) {
+    let duration = tokio::time::Duration::from_secs(1);
+    loop {
+        tokio::time::sleep(duration).await;
+        let config = utility::get_config(&ctx.data.read().await)
+            .await
+            .expect("Unable to get config");
+        let event_channel_id = config.event_channel;
+
+        let reminder_msg: Vec<&String> = match &config.reminders {
+            None => return,
+            Some(reminder_msg) => reminder_msg.iter().map(|r| &r.msg).collect(),
+        };
+
+        let db = get_db(&ctx.data.read().await)
+            .await
+            .expect("Unable to get DB");
+
+        let mut data = ctx.data.write().await;
+        let reminders = data
+            .get_mut::<Reminders>()
+            .expect("Unable to get reminders");
+
+        let current_reminders = reminders.get_reminders();
+
+        for reminder in current_reminders {
+            if let Some(event) = db.get_event_by_msg_id(&reminder.event_id) {
+                let message_id = event.message_id.parse::<u64>().unwrap_or_default();
+                // Get message id
+                if let Ok(message) = ctx.http.get_message(event_channel_id, message_id).await {
+                    if let Ok(reaction_users) = message
+                        .reaction_users(ctx, INTERESTED_EMOJI, None, None)
+                        .await
+                    {
+                        // Build reminder message
+                        let msg: String = reminder_msg[reminder.reminder_id]
+                            .replace("{EVENT_NAME}", event.event_name.as_str());
+
+                        // Send reminder to each reacted user
+                        for user in reaction_users {
+                            utility::send_dm_message(ctx, user, &msg).await;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Delete old events
+pub async fn cleanup_task(ctx: &Context) {
+    let duration = tokio::time::Duration::from_secs(60 * 60);
+    loop {
+        tokio::time::sleep(duration).await;
+        let db = get_db(&ctx.data.read().await).await.unwrap();
+        let one_week_ago = Utc::now()
+            - Duration::from_std(std::time::Duration::from_secs(60 * 60 * 24 * 7)).unwrap();
+
+        for event in db.filter_events(|_, event| event.event_time < one_week_ago.naive_utc()) {
+            utility::delete_event(ctx, &event).await.ok();
+        }
+    }
+}

src/discord/utility.rs

@@ -0,0 +1,247 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use chrono::{DateTime, NaiveDateTime, Utc};
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+use serenity::framework::standard::{CommandError, CommandResult};
+use serenity::model::channel::{Message, Reaction};
+use serenity::model::id::ChannelId;
+use serenity::model::user::User;
+use serenity::prelude::{Context, TypeMap};
+use serenity::utils::Colour;
+use tokio::sync::RwLockReadGuard;
+
+use crate::database::models::Event;
+use crate::discord::{get_db, DraftEvent};
+use crate::hypebot_config::HypeBotConfig;
+use crate::reminder::Reminders;
+use crate::{discord, INTERESTED_EMOJI, UNINTERESTED_EMOJI};
+
+/// Send a message to a reaction user
+pub async fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_text: &str) {
+    if let Ok(db) = get_db(&ctx.data.read().await).await {
+        let message_id = reaction.message_id.0.to_string();
+
+        let event = match db.get_event_by_msg_id(&message_id) {
+            Some(event) => event,
+            None => {
+                return;
+            }
+        };
+
+        let event_utc_time = DateTime::<Utc>::from_utc(event.event_time, Utc);
+        let current_utc_time = chrono::offset::Utc::now();
+
+        let msg;
+
+        if event_utc_time > current_utc_time {
+            // Format message
+            let mut fmt = HashMap::new();
+            fmt.insert("event".to_string(), event.event_name);
+            msg = strfmt::strfmt(msg_text, &fmt).unwrap();
+
+            if let Ok(user) = reaction.user(&ctx).await {
+                send_dm_message(&ctx, user, &msg).await;
+            }
+        }
+    }
+}
+
+/// Send a DM message to a user
+pub async fn send_dm_message(ctx: &Context, user: User, message: &str) {
+    if let Ok(dm_channel) = user.create_dm_channel(ctx).await {
+        dm_channel
+            .send_message(ctx, |m| m.content(message))
+            .await
+            .ok();
+    }
+}
+
+pub const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
+
+/// Sends the event message to the event channel
+pub async fn send_event_msg(
+    ctx: &Context,
+    config: &HypeBotConfig,
+    channel_id: u64,
+    event: &Event,
+    react: bool,
+) -> serenity::Result<Message> {
+    let channel = ctx.http.get_channel(channel_id).await?;
+
+    let utc_time = DateTime::<Utc>::from_utc(event.event_time, Utc);
+
+    let native_time = utc_time.with_timezone(&config.event_timezone);
+
+    let ping_roles = config
+        .ping_roles
+        .clone()
+        .into_iter()
+        .map(|role| format!("<@&{}>", role))
+        .collect::<Vec<String>>()
+        .join(" ");
+
+    // Send message
+    let msg = channel.id().send_message(&ctx, |m| {
+        m.embed(|e| {
+            e.title(event.event_name.clone())
+                .color(Colour::PURPLE)
+                .description(format!(
+                    "**{}**\n{}\n\n[Click Here For A Countdown]({})\n\nReact with {} below to receive event reminders!",
+                    native_time.format("%A, %B %d @ %I:%M %P %t %Z"),
+                    event.event_desc,
+                    get_countdown_link(&event.event_name, &utc_time),
+                    INTERESTED_EMOJI
+                ))
+                .thumbnail(event.thumbnail_link.clone())
+                .footer(|f| f.text("Local Event Time"))
+                .timestamp(utc_time.to_rfc3339())
+                .field("Location", &event.event_loc, true)
+                .field("Organizer", &event.organizer, true)
+        }).content(ping_roles)
+    }).await?;
+
+    if react {
+        // Add reacts
+        msg.react(ctx, INTERESTED_EMOJI).await?;
+        msg.react(ctx, UNINTERESTED_EMOJI).await?;
+    }
+
+    Ok(msg)
+}
+
+/// Updates the draft event stored in the context data
+#[allow(clippy::too_many_arguments)]
+pub async fn update_draft_event(
+    ctx: &Context,
+    event_name: String,
+    event_desc: String,
+    organizer: String,
+    location: String,
+    thumbnail: String,
+    event_time: NaiveDateTime,
+    creator_id: u64,
+) -> CommandResult {
+    let mut data = ctx.data.write().await;
+    let draft_event = data
+        .get_mut::<DraftEvent>()
+        .ok_or_else(|| CommandError::from("Unable get draft event!".to_string()))?;
+
+    let new_draft_event = DraftEvent {
+        event: Event {
+            event_name,
+            event_desc,
+            event_loc: location,
+            organizer,
+            event_time,
+            message_id: "".to_string(),
+            thumbnail_link: thumbnail,
+        },
+        creator_id,
+    };
+
+    *draft_event = Arc::new(new_draft_event);
+
+    Ok(())
+}
+
+/// Sends the draft event stored in the context data
+pub async fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
+    let data = ctx.data.read().await;
+    let config = get_config(&data).await?;
+    let draft_event = discord::get_draft_event(&data).await?;
+
+    channel
+        .send_message(&ctx, |m| {
+            m.content("Draft message, use the `confirm` command to post it.".to_string())
+        })
+        .await?;
+    send_event_msg(ctx, &config, channel.0, &draft_event.event, false).await?;
+    Ok(())
+}
+
+/// Gets the config from context data
+pub async fn get_config(
+    data: &RwLockReadGuard<'_, TypeMap>,
+) -> std::result::Result<Arc<HypeBotConfig>, CommandError> {
+    let config = data
+        .get::<HypeBotConfig>()
+        .ok_or_else(|| CommandError::from("Unable to get config".to_string()))?;
+
+    Ok(config.clone())
+}
+
+/// Schedule event reminders
+pub async fn schedule_event(ctx: &Context, event: &Event) {
+    let config = get_config(&ctx.data.read().await)
+        .await
+        .expect("Unable to get config");
+
+    let mut data = ctx.data.write().await;
+
+    let reminders = data.get_mut::<Reminders>().unwrap();
+
+    reminders.add_reminders(event, &*config);
+}
+
+/// Schedule all events
+pub async fn schedule_all_events(ctx: &Context) {
+    let db = get_db(&ctx.data.read().await)
+        .await
+        .expect("Could not get database");
+
+    for event in db.get_all_events() {
+        schedule_event(&ctx, &event).await;
+    }
+}
+
+/// Delete event
+pub async fn delete_event(ctx: &Context, event: &Event) -> CommandResult {
+    let config = get_config(&ctx.data.read().await)
+        .await
+        .expect("Unable to get config");
+
+    let db = get_db(&ctx.data.read().await)
+        .await
+        .expect("Unable to get db");
+
+    let message_id = event.message_id.parse::<u64>()?;
+    let message = ctx
+        .http
+        .get_message(config.event_channel, message_id)
+        .await?;
+    let cancel_msg = format!("**{}** has been canceled!", event.event_name.clone());
+
+    // Only send a cancel message if the even has not already happened
+    if event.event_time > Utc::now().naive_utc() {
+        if let Ok(reaction_users) = message
+            .reaction_users(&ctx.http, INTERESTED_EMOJI, None, None)
+            .await
+        {
+            for user in reaction_users {
+                send_dm_message(ctx, user, &cancel_msg).await;
+            }
+        }
+    }
+
+    db.remove_event(event)?;
+
+    message.delete(ctx).await?;
+
+    if let Some(reminders) = ctx.data.write().await.get_mut::<Reminders>() {
+        reminders.remove_reminders(&event);
+    }
+
+    Ok(())
+}
+
+/// Create a countdown link for the event
+pub fn get_countdown_link(event_name: &str, utc: &DateTime<Utc>) -> String {
+    let msg = utf8_percent_encode(event_name, FRAGMENT);
+    let time = utc.format("%G%m%dT%H%M").to_string();
+
+    format!(
+        "https://www.timeanddate.com/countdown/generic?iso={}&p0=&msg={}&font=sanserif&csz=1",
+        time, msg
+    )
+}

src/hypebot_config.rs

@@ -4,6 +4,8 @@ use serde::de::{self, Error, Visitor};
 use serde::{Deserialize, Deserializer};
 use serenity::prelude::TypeMapKey;
 use std::fmt;
+use std::path::PathBuf;
+use std::sync::Arc;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct EventReminder {
@@ -13,7 +15,7 @@ pub struct EventReminder {
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct HypeBotConfig {
-    pub db_url: String,
+    pub db_location: PathBuf,
     pub default_thumbnail_link: String,
     pub discord_key: String,
     pub prefix: String,
@@ -48,9 +50,9 @@ where
 {
     let string = deserializer.deserialize_struct("Value", &["into_str"], ConfigValueVisitor)?;
 
-    let tz: Tz = string.parse().ok().ok_or(D::Error::custom(
+    let tz: Tz = string.parse().ok().ok_or_else(|| {
-        "Unable to parse datetime, should be in format \"Country/City\"",
+        D::Error::custom("Unable to parse datetime, should be in format \"Country/City\"")
-    ))?;
+    })?;
 
     Ok(tz)
 }
@@ -65,5 +67,5 @@ impl HypeBotConfig {
 }
 
 impl TypeMapKey for HypeBotConfig {
-    type Value = HypeBotConfig;
+    type Value = Arc<HypeBotConfig>;
 }

src/main.rs

@@ -1,13 +1,12 @@
 #[macro_use]
-extern crate diesel;
-#[macro_use]
-extern crate diesel_migrations;
-extern crate serde;
-#[macro_use]
 extern crate log;
 extern crate log4rs;
+extern crate serde;
+
+use std::path::Path;
+use std::process::exit;
+use std::sync::Arc;
 
-use chrono::{DateTime, Utc};
 use clap::{App, Arg};
 use log::LevelFilter;
 use log4rs::append::console::ConsoleAppender;
@@ -20,34 +19,24 @@ use log4rs::encode::pattern::PatternEncoder;
 use log4rs::filter::threshold::ThresholdFilter;
 use log4rs::init_config;
 use serenity::client::Client;
-use serenity::framework::standard::macros::{group, help};
+use serenity::framework::standard::macros::group;
-use serenity::framework::standard::{help_commands, Args, CommandGroup, HelpOptions};
+use serenity::framework::standard::StandardFramework;
-use serenity::framework::standard::{CommandResult, StandardFramework};
+
-use serenity::model::channel::{Message, Reaction};
+use database::*;
-use serenity::model::id::UserId;
+use discord::events::{CANCEL_COMMAND, CONFIRM_COMMAND, CREATE_COMMAND};
-use serenity::model::prelude::Ready;
+use discord::handler::Handler;
-use serenity::prelude::{Context, EventHandler, RwLock};
+use discord::BOT_HELP;
-use std::collections::HashSet;
+use discord::{log_error, permission_check, DraftEvent};
-use std::path::Path;
+use hypebot_config::HypeBotConfig;
-use std::process::exit;
+use reminder::Reminders;
-use std::sync::Arc;
-use white_rabbit::{DateResult, Scheduler};
 
 mod database;
 mod discord;
 mod hypebot_config;
+mod reminder;
 
-use database::models::NewEvent;
+const INTERESTED_EMOJI: char = '\u{2705}';
-use database::*;
+const UNINTERESTED_EMOJI: char = '\u{274C}';
-use discord::events::{CANCEL_COMMAND, CONFIRM_COMMAND, CREATE_COMMAND};
-use discord::{
-    delete_event, get_config, get_scheduler, log_error, permission_check, schedule_event,
-    send_message_to_reaction_users, DraftEvent, SchedulerKey,
-};
-use hypebot_config::HypeBotConfig;
-
-const INTERESTED_EMOJI: &str = "\u{2705}";
-const UNINTERESTED_EMOJI: &str = "\u{274C}";
 
 type HypeBotResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
@@ -58,70 +47,6 @@ type HypeBotResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 #[commands(create, confirm, cancel)]
 struct EventCommands;
 
-/// Handler for Discord events
-struct Handler;
-
-impl EventHandler for Handler {
-    /// On reaction add
-    fn reaction_add(&self, ctx: Context, reaction: Reaction) {
-        let config = match get_config(&ctx.data) {
-            Ok(config) => config,
-            Err(e) => {
-                error!("Unable to get config: {}", e.0);
-                return;
-            }
-        };
-        if reaction.channel_id.0 == config.event_channel
-            && reaction.emoji.as_data() == INTERESTED_EMOJI
-        {
-            send_message_to_reaction_users(
-                &ctx,
-                &reaction,
-                "Hello, you are now receiving reminders for **{event}**",
-            );
-        }
-    }
-
-    /// On reaction remove
-    fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
-        let config = match get_config(&ctx.data) {
-            Ok(config) => config,
-            Err(e) => {
-                error!("Unable to get config: {}", e.0);
-                return;
-            }
-        };
-        if reaction.channel_id.0 == config.event_channel
-            && reaction.emoji.as_data() == INTERESTED_EMOJI
-        {
-            send_message_to_reaction_users(
-                &ctx,
-                &reaction,
-                "Hello, you are no longer receiving reminders for **{event}**",
-            );
-        }
-    }
-
-    /// On bot ready
-    fn ready(&self, _: Context, ready: Ready) {
-        info!("Connected to Discord as {}", ready.user.name);
-    }
-}
-
-#[help]
-#[command_not_found_text = "Could not find: `{}`."]
-#[strikethrough_commands_tip_in_guild("HypeBot")]
-fn bot_help(
-    context: &mut Context,
-    msg: &Message,
-    args: Args,
-    help_options: &'static HelpOptions,
-    groups: &[&'static CommandGroup],
-    owners: HashSet<UserId>,
-) -> CommandResult {
-    help_commands::with_embeds(context, msg, args, help_options, groups, owners)
-}
-
 /// Does the setup for logging
 fn setup_logging(config: &HypeBotConfig) -> HypeBotResult<()> {
     // Build log file path
@@ -146,7 +71,7 @@ fn setup_logging(config: &HypeBotConfig) -> HypeBotResult<()> {
     let config = Config::builder()
         .appender(
             Appender::builder()
-                .filter(Box::new(ThresholdFilter::new(LevelFilter::Info)))
+                .filter(Box::new(ThresholdFilter::new(LevelFilter::Warn)))
                 .build(
                     "logfile",
                     Box::new(
@@ -180,8 +105,8 @@ fn setup_logging(config: &HypeBotConfig) -> HypeBotResult<()> {
     Ok(())
 }
 
-embed_migrations!("migrations/");
+#[tokio::main]
-fn main() -> HypeBotResult<()> {
+async fn main() -> HypeBotResult<()> {
     // Initialize arg parser
     let mut app = App::new("Hype Bot")
         .about("Hype Bot: Hype Up Your Discord Events!")
@@ -211,81 +136,37 @@ fn main() -> HypeBotResult<()> {
         // Setup logging
         setup_logging(&cfg)?;
 
-        // Run migrations
-        let connection = establish_connection(cfg.db_url.clone());
-        embedded_migrations::run(&connection)?;
-
         // New client
-        let mut client =
+        let mut client = Client::builder(cfg.discord_key.clone())
-            Client::new(cfg.discord_key.clone(), Handler).expect("Error creating client");
+            .event_handler(Handler)
-
+            .framework(
-        // Configure client
+                StandardFramework::new()
-        client.with_framework(
+                    .configure(|c| {
-            StandardFramework::new()
+                        c.prefix(cfg.prefix.as_str())
-                .configure(|c| {
+                            .allow_dm(false)
-                    c.prefix(cfg.prefix.as_str().clone())
+                            .ignore_bots(true)
-                        .allow_dm(false)
+                            .ignore_webhooks(true)
-                        .ignore_bots(true)
+                    })
-                        .ignore_webhooks(true)
+                    .before(permission_check)
-                })
+                    .after(log_error)
-                .before(permission_check)
+                    .group(&EVENTCOMMANDS_GROUP)
-                .after(log_error)
+                    .help(&BOT_HELP),
-                .group(&EVENTCOMMANDS_GROUP)
+            )
-                .help(&BOT_HELP),
+            .await?;
-        );
 
         // Copy config data to client data and setup scheduler
         {
-            let mut data = client.data.write();
+            let db = database::Database::new(&cfg.db_location)?;
-            data.insert::<HypeBotConfig>(cfg);
+            let mut data = client.data.write().await;
-            data.insert::<DraftEvent>(DraftEvent {
+            data.insert::<HypeBotConfig>(Arc::new(cfg));
-                event: NewEvent {
+            data.insert::<DraftEvent>(Arc::new(DraftEvent::default()));
-                    message_id: String::new(),
+            data.insert::<Reminders>(Reminders::default());
-                    event_time: Utc::now().naive_utc(),
+            data.insert::<database::Database>(Arc::new(db));
-                    event_name: String::new(),
-                    organizer: String::new(),
-                    event_desc: String::new(),
-                    event_loc: String::new(),
-                    thumbnail_link: String::new(),
-                    reminder_sent: 0 as i32,
-                },
-                creator_id: 0,
-            });
-
-            // Create scheduler
-            let scheduler = Scheduler::new(2);
-            let scheduler = Arc::new(RwLock::new(scheduler));
-            data.insert::<SchedulerKey>(scheduler);
-        }
-
-        // Schedule current events
-        let config = get_config(&client.data).expect("Unable to find get config");
-        let duration = chrono::Duration::minutes(60);
-        for event in get_all_events(config.db_url.clone()).unwrap() {
-            let event_time: DateTime<Utc> =
-                DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
-
-            if Utc::now() > event_time + duration {
-                delete_event(&client.cache_and_http.http, &client.data, &event);
-            } else if Utc::now() > event_time {
-                let scheduler = get_scheduler(&client.data).unwrap();
-                let mut scheduler = scheduler.write();
-                let cancel_time = event_time + duration;
-                let http = client.cache_and_http.http.clone();
-                let data = client.data.clone();
-
-                scheduler.add_task_datetime(cancel_time, move |_| {
-                    delete_event(&http, &data, &event);
-                    DateResult::Done
-                });
-            } else if event.reminder_sent == 0 {
-                schedule_event(&client.cache_and_http.http, &client.data, &event);
-            }
         }
 
         // Start bot
         info!("Starting HypeBot!");
-        if let Err(why) = client.start() {
+        if let Err(why) = client.start().await {
             error!("An error occurred while running the client: {:?}", why);
         }
     } else {

src/reminder/mod.rs

@@ -0,0 +1,158 @@
+use crate::database::models::Event;
+use crate::hypebot_config::HypeBotConfig;
+use chrono::{Duration, NaiveDateTime, Utc};
+use serenity::prelude::TypeMapKey;
+
+/// Event Reminder
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct Reminder {
+    pub event_id: String,
+    pub time: NaiveDateTime,
+    pub reminder_id: usize,
+}
+
+/// Set of reminders for currently active events
+#[derive(Debug, Clone, Default)]
+pub struct Reminders {
+    reminders: Vec<Reminder>,
+}
+
+impl TypeMapKey for Reminders {
+    type Value = Reminders;
+}
+
+impl Reminders {
+    /// Add all the reminders for an event
+    pub fn add_reminders(&mut self, event: &Event, config: &HypeBotConfig) {
+        if let Some(event_reminders) = &config.reminders {
+            for (reminder_id, event_reminder) in event_reminders.iter().enumerate() {
+                let reminder_time = event.event_time
+                    - chrono::Duration::minutes(event_reminder.reminder_time as i64);
+
+                if reminder_time > Utc::now().naive_utc() {
+                    self.reminders.push(Reminder {
+                        event_id: event.message_id.clone(),
+                        time: reminder_time,
+                        reminder_id,
+                    });
+                }
+            }
+        }
+    }
+
+    /// Get reminders that need to be sent
+    pub fn get_reminders(&mut self) -> Vec<Reminder> {
+        let reminders: Vec<Reminder> = self
+            .reminders
+            .iter()
+            .filter(|r| {
+                let time_diff = r.time - Utc::now().naive_utc();
+                time_diff > Duration::seconds(-5) && time_diff < Duration::seconds(5)
+            })
+            .cloned()
+            .collect();
+
+        self.reminders.retain(|r| !reminders.contains(r));
+
+        reminders
+    }
+
+    /// Removes reminders for an event
+    pub fn remove_reminders(&mut self, event: &Event) {
+        self.reminders.retain(|e| e.event_id != event.message_id)
+    }
+
+    /// Update reminders for an event
+    #[allow(dead_code)]
+    pub fn update_reminders(&mut self, event: &Event, config: &HypeBotConfig) {
+        self.remove_reminders(event);
+        self.add_reminders(event, config);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::hypebot_config::{EventReminder, HypeBotConfig};
+    use crate::models::Event;
+    use crate::reminder::Reminders;
+    use chrono::{Duration, Utc};
+
+    fn setup() -> (Reminders, HypeBotConfig, Event) {
+        let r = Reminders::default();
+
+        let c = HypeBotConfig {
+            db_location: "".to_string(),
+            default_thumbnail_link: "".to_string(),
+            discord_key: "".to_string(),
+            prefix: "".to_string(),
+            event_channel: 0,
+            event_roles: vec![],
+            ping_roles: vec![],
+            event_timezone: chrono_tz::UTC,
+            log_path: "".to_string(),
+            reminders: Some(
+                [
+                    EventReminder {
+                        msg: "".to_string(),
+                        reminder_time: 5,
+                    },
+                    EventReminder {
+                        msg: "".to_string(),
+                        reminder_time: 1,
+                    },
+                ]
+                .to_vec(),
+            ),
+        };
+
+        let e = Event {
+            id: 0,
+            event_name: "".to_string(),
+            event_desc: "".to_string(),
+            event_loc: "".to_string(),
+            organizer: "".to_string(),
+            event_time: Utc::now().naive_utc() + Duration::minutes(5) + Duration::seconds(5),
+            message_id: "".to_string(),
+            thumbnail_link: "".to_string(),
+            reminder_sent: 0,
+        };
+
+        (r, c, e)
+    }
+
+    #[test]
+    fn test_add_reminders() {
+        let (mut r, c, e) = setup();
+        r.add_reminders(&e, &c);
+
+        assert_eq!(r.reminders.len(), c.reminders.unwrap().len());
+    }
+
+    #[test]
+    fn test_get_reminders() {
+        let (mut r, c, e) = setup();
+        r.add_reminders(&e, &c);
+
+        assert_eq!(r.get_reminders().len(), 1);
+        assert_eq!(r.reminders.len(), c.reminders.unwrap().len() - 1);
+    }
+
+    #[test]
+    fn test_remove_reminders() {
+        let (mut r, c, e) = setup();
+        r.add_reminders(&e, &c);
+
+        r.remove_reminders(&e);
+        assert_eq!(r.reminders.len(), 0);
+    }
+
+    #[test]
+    fn test_update_reminders() {
+        let (mut r, c, e) = setup();
+        r.add_reminders(&e, &c);
+
+        r.update_reminders(&e, &c);
+
+        assert_eq!(r.get_reminders().len(), 1);
+    }
+}