Initial async update commit

+ Naive port of all code to async serenity
+ Limited testing has been done, but the bot seems to work
+ Removed WhiteRabbit dependency (does not work in async)
+ Further cleanup needed

.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"
 
@@ -19,8 +19,8 @@ log = "0.4.8"
 log4rs = "0.11.0"
 strfmt = "0.1.6"
 url = "2.1.1"
-white_rabbit = "0.1.1"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 
 [dependencies.serenity]
-version = "0.8.6"
+version = "0.10.2"
-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

src/discord/events.rs

@@ -20,25 +20,25 @@ 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).await?;
-    let draft_event = get_draft_event(&ctx.data)?;
+    let draft_event = get_draft_event(&ctx.data).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)?;
 
-        schedule_event(&ctx.http, &ctx.data, &event);
+        schedule_event(&ctx, &event).await;
     } else {
-        msg.reply(&ctx, format!("You do not have a pending event!"))?;
+        msg.reply(&ctx, format!("You do not have a pending event!")).await?;
     }
 
     Ok(())
@@ -57,29 +57,29 @@ 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).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 +87,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 +99,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 +110,7 @@ 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 +130,7 @@ 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 +141,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 +155,8 @@ fn create(ctx: &mut Context, msg: &Message, mut args: Args) -> CommandResult {
         thumbnail_link,
         event_time,
         msg.author.id.0,
-    )?;
+    ).await?;
-    send_draft_event(&ctx, msg.channel_id)?;
+    send_draft_event(&ctx, msg.channel_id).await?;
 
     Ok(())
 }
@@ -165,31 +165,32 @@ 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 config = get_config(&ctx.data).await?;
 
     // Parse args
     let event_name = args.single::<String>()?.replace("\"", "");
 
     let event = get_event_by_name(config.db_url.clone(), event_name)?;
     let message_id = event.message_id.parse::<u64>()?;
-    let message = ctx.http.get_message(config.event_channel, message_id)?;
+    let message = ctx.http.get_message(config.event_channel, message_id).await?;
 
     let reaction_users = message
         .reaction_users(&ctx.http, INTERESTED_EMOJI, None, None)
+        .await
         .unwrap_or(Vec::<User>::new());
 
     let cancel_msg = format!("**{}** has been canceled!", event.event_name.clone());
 
     for user in reaction_users {
-        send_dm_message(&ctx.http, user, &cancel_msg);
+        send_dm_message(ctx, user, &cancel_msg).await;
     }
 
     remove_event(config.db_url.clone(), event.id)?;
 
-    message.delete(&ctx)?;
+    message.delete(&ctx).await?;
 
-    msg.reply(&ctx, &cancel_msg)?;
+    msg.reply(&ctx, &cancel_msg).await?;
 
     Ok(())
 }

src/discord/mod.rs

@@ -1,19 +1,20 @@
 use crate::database::models::{Event, NewEvent};
-use crate::database::{get_event_by_msg_id, remove_event, set_reminder};
+use crate::database::{get_event_by_msg_id, remove_event};
 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::{TypeMapKey, TypeMap};
-use serenity::prelude::{Context, RwLock, ShareMap};
+use serenity::prelude::{Context, RwLock};
 use serenity::utils::Colour;
 use serenity::Result;
+use serenity::framework::standard::macros::hook;
 use std::collections::HashMap;
 use std::sync::Arc;
 use strfmt::strfmt;
-use white_rabbit::{DateResult, Scheduler};
+use diesel::result::Error;
 
 pub mod events;
 
@@ -28,22 +29,18 @@ impl TypeMapKey for DraftEvent {
     type Value = 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) {
+pub async fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_text: &str) {
-    if let Ok(config) = get_config(&ctx.data) {
+    if let Ok(config) = get_config(&ctx.data).await {
         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);
+                if !matches!(e, diesel::result::Error::NotFound) {
+                    error!("Error getting event from reaction {}", e);
+                }
                 return;
             }
         };
@@ -62,16 +59,16 @@ pub fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_te
             msg = format!("**{}** has already started!", &event.event_name)
         }
 
-        if let Ok(user) = reaction.user(&ctx.http) {
+        if let Ok(user) = reaction.user(&ctx).await {
-            send_dm_message(&ctx.http, user, &msg);
+            send_dm_message(&ctx, user, &msg).await;
         }
     }
 }
 
 /// Send a DM message to a user
-pub fn send_dm_message(http: &Http, user: User, message: &String) {
+pub async fn send_dm_message(ctx: &Context, user: User, message: &String) {
-    if let Ok(dm_channel) = user.create_dm_channel(&http) {
+    if let Ok(dm_channel) = user.create_dm_channel(ctx).await {
-        dm_channel.send_message(&http, |m| m.content(message)).ok();
+        dm_channel.send_message(ctx, |m| m.content(message)).await.ok();
     }
 }
 
@@ -87,14 +84,14 @@ pub fn get_countdown_link(event_name: &String, utc: &DateTime<Utc>) -> String {
 }
 
 /// Sends the event message to the event channel
-pub fn send_event_msg(
+pub async fn send_event_msg(
-    http: &Http,
+    ctx: &Context,
     config: &HypeBotConfig,
     channel_id: u64,
     event: &NewEvent,
     react: bool,
 ) -> Result<Message> {
-    let channel = http.get_channel(channel_id)?;
+    let channel = ctx.http.get_channel(channel_id).await?;
 
     let utc_time = DateTime::<Utc>::from_utc(event.event_time.clone(), Utc);
 
@@ -109,7 +106,7 @@ pub fn send_event_msg(
         .join(" ");
 
     // Send message
-    let msg = channel.id().send_message(&http, |m| {
+    let msg = channel.id().send_message(&ctx, |m| {
         m.embed(|e| {
             e.title(event.event_name.clone())
                 .color(Colour::PURPLE)
@@ -126,19 +123,19 @@ pub fn send_event_msg(
                 .field("Location", &event.event_loc, true)
                 .field("Organizer", &event.organizer, true)
         }).content(ping_roles)
-    })?;
+    }).await?;
 
     if react {
         // Add reacts
-        msg.react(http, INTERESTED_EMOJI)?;
+        msg.react(ctx, INTERESTED_EMOJI).await?;
-        msg.react(http, UNINTERESTED_EMOJI)?;
+        msg.react(ctx, UNINTERESTED_EMOJI).await?;
     }
 
     Ok(msg)
 }
 
 /// Updates the draft event stored in the context data
-pub fn update_draft_event(
+pub async fn update_draft_event(
     ctx: &Context,
     event_name: String,
     event_desc: String,
@@ -148,10 +145,10 @@ pub fn update_draft_event(
     event_time: NaiveDateTime,
     creator_id: u64,
 ) -> CommandResult {
-    let mut data = ctx.data.write();
+    let mut data = ctx.data.write().await;
     let mut draft_event = data
         .get_mut::<DraftEvent>()
-        .ok_or(CommandError("Unable get draft event!".to_string()))?;
+        .ok_or(CommandError::from("Unable get draft event!".to_string()))?;
 
     draft_event.event.event_name = event_name;
     draft_event.event.event_desc = event_desc;
@@ -165,62 +162,52 @@ pub fn update_draft_event(
 }
 
 /// Sends the draft event stored in the context data
-pub fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
+pub async fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
-    let data = ctx.data.read();
+    let data = ctx.data.read().await;
     let config = data
         .get::<HypeBotConfig>()
-        .ok_or(CommandError("Config not found!".to_string()))?;
+        .ok_or(CommandError::from("Config not found!".to_string()))?;
     let draft_event = data
         .get::<DraftEvent>()
-        .ok_or(CommandError("Draft event not found!".to_string()))?;
+        .ok_or(CommandError::from("Draft event not found!".to_string()))?;
 
     channel.send_message(&ctx, |m| {
         m.content(format!(
             "Draft message, use the `confirm` command to post it."
         ))
-    })?;
+    }).await?;
-    send_event_msg(&ctx.http, config, channel.0, &draft_event.event, false)?;
+    send_event_msg(ctx, config, channel.0, &draft_event.event, false).await?;
     Ok(())
 }
 
 /// Gets the config from context data
-pub fn get_config(
+pub async fn get_config(
-    data: &Arc<RwLock<ShareMap>>,
+    data: &Arc<RwLock<TypeMap>>,
 ) -> std::result::Result<HypeBotConfig, CommandError> {
-    let data_read = data.read();
+    let data_read = data.read().await;
     let config = data_read
         .get::<HypeBotConfig>()
-        .ok_or(CommandError("Unable to get config".to_string()))?;
+        .ok_or(CommandError::from("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: &Arc<RwLock<TypeMap>>,
 ) -> std::result::Result<DraftEvent, CommandError> {
-    let data_read = data.read();
+    let data_read = data.read().await;
     let draft_event = data_read
         .get::<DraftEvent>()
-        .ok_or(CommandError("Unable to queued event".to_string()))?;
+        .ok_or(CommandError::from("Unable to queued event".to_string()))?;
 
     Ok(draft_event.clone())
 }
 
-/// Get the scheduler
-pub fn get_scheduler(
-    data: &Arc<RwLock<ShareMap>>,
-) -> std::result::Result<Arc<RwLock<Scheduler>>, CommandError> {
-    let mut context = data.write();
-    Ok(context
-        .get_mut::<SchedulerKey>()
-        .ok_or(CommandError("Unable to get scheduler".to_string()))?
-        .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 +219,17 @@ 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) = get_config(&ctx.data).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 match msg.author.has_role(&ctx, guild_id, role).await {
                             Ok(has_role) => has_role,
                             Err(_) => false,
                         };
-                        if has_role {
-                            return true;
-                        }
                     }
                 }
             }
@@ -255,63 +240,48 @@ pub fn permission_check(ctx: &mut Context, msg: &Message, _command_name: &str) -
 }
 
 /// Schedule event reminders
-pub fn schedule_event(http: &Arc<Http>, data: &Arc<RwLock<ShareMap>>, event: &Event) {
+pub async fn schedule_event(ctx: &Context, event: &Event) {
-    let scheduler = {
+    let config = get_config(&ctx.data).await.expect("Unable to get config");
-        let mut context = data.write();
-        context
-            .get_mut::<SchedulerKey>()
-            .expect("Expected Scheduler.")
-            .clone()
-    };
-
-    let config = get_config(&data).unwrap();
 
     if let Some(reminders) = config.reminders {
         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 ctx = ctx.clone();
                 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 |_| {
+                tokio::task::spawn(async move {
-                    send_reminders(&http, &data, &event, &reminder_msg)
+                        send_reminders_task(&ctx, reminder_time, &event, &reminder_msg).await;
-                });
+                    }
+                );
             }
         }
-
-        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(
+pub async fn send_reminders_task(
-    http: &Arc<Http>,
+    ctx: &Context,
-    data: &Arc<RwLock<ShareMap>>,
+    datetime: DateTime<Utc>,
     event: &Event,
     reminder_msg: &String,
-) -> DateResult {
+) {
-    let config = get_config(&data).unwrap();
+    let duration = datetime - chrono::offset::Utc::now();
+    tokio::time::sleep(tokio::time::Duration::from_millis(duration.num_milliseconds() as u64)).await;
+    let config = get_config(&ctx.data).await.expect("Unable to get config");
     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) {
+        if let Ok(message) = ctx.http.get_message(event_channel_id, message_id).await {
             let reaction_users = message
-                .reaction_users(&http, INTERESTED_EMOJI, None, None)
+                .reaction_users(ctx, INTERESTED_EMOJI, None, None)
+                .await
                 .unwrap_or(Vec::<User>::new());
 
             // Build reminder message
@@ -319,20 +289,18 @@ pub fn send_reminders(
 
             // Send reminder to each reacted user
             for user in reaction_users {
-                send_dm_message(&http, user, &msg);
+                send_dm_message(ctx, user, &msg).await;
             }
         }
     }
-
-    DateResult::Done
 }
 
 /// Delete event
-pub fn delete_event(http: &Arc<Http>, data: &Arc<RwLock<ShareMap>>, event: &Event) {
+pub async fn delete_event(http: &Arc<Http>, data: &Arc<RwLock<TypeMap>>, event: &Event) {
-    let config = get_config(&data).unwrap();
+    let config = get_config(&data).await.expect("Unable to get config");
 
     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();
+        http.delete_message(config.event_channel, message_id).await.ok();
     }
 }

src/main.rs

@@ -2,52 +2,52 @@
 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::collections::HashSet;
+use std::path::Path;
+use std::process::exit;
 
 use chrono::{DateTime, Utc};
 use clap::{App, Arg};
-use log::LevelFilter;
 use log4rs::append::console::ConsoleAppender;
+use log4rs::append::rolling_file::policy::compound::CompoundPolicy;
 use log4rs::append::rolling_file::policy::compound::roll::fixed_window::FixedWindowRoller;
 use log4rs::append::rolling_file::policy::compound::trigger::size::SizeTrigger;
-use log4rs::append::rolling_file::policy::compound::CompoundPolicy;
 use log4rs::append::rolling_file::RollingFileAppender;
 use log4rs::config::{Appender, Config, Root};
 use log4rs::encode::pattern::PatternEncoder;
 use log4rs::filter::threshold::ThresholdFilter;
 use log4rs::init_config;
+use log::LevelFilter;
 use serenity::client::Client;
-use serenity::framework::standard::macros::{group, help};
+use serenity::async_trait;
-use serenity::framework::standard::{help_commands, Args, CommandGroup, HelpOptions};
+use serenity::framework::standard::{Args, CommandGroup, help_commands, HelpOptions};
 use serenity::framework::standard::{CommandResult, StandardFramework};
+use serenity::framework::standard::macros::{group, help};
 use serenity::model::channel::{Message, Reaction};
 use serenity::model::id::UserId;
 use serenity::model::prelude::Ready;
-use serenity::prelude::{Context, EventHandler, RwLock};
+use serenity::prelude::{Context, EventHandler};
-use std::collections::HashSet;
+
-use std::path::Path;
+use database::*;
-use std::process::exit;
+use database::models::NewEvent;
-use std::sync::Arc;
+use discord::{
-use white_rabbit::{DateResult, Scheduler};
+    delete_event, DraftEvent, get_config, log_error, permission_check,
+    schedule_event, send_message_to_reaction_users,
+};
+use discord::events::{CANCEL_COMMAND, CONFIRM_COMMAND, CREATE_COMMAND};
+use hypebot_config::HypeBotConfig;
 
 mod database;
 mod discord;
 mod hypebot_config;
 
-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>>;
 
@@ -61,65 +61,78 @@ struct EventCommands;
 /// Handler for Discord events
 struct Handler;
 
+#[async_trait]
 impl EventHandler for Handler {
     /// On reaction add
-    fn reaction_add(&self, ctx: Context, reaction: Reaction) {
+    async fn reaction_add(&self, ctx: Context, reaction: Reaction) {
-        let config = match get_config(&ctx.data) {
+        let config = match get_config(&ctx.data).await {
             Ok(config) => config,
             Err(e) => {
-                error!("Unable to get config: {}", e.0);
+                error!("Unable to get config: {}", e);
                 return;
             }
         };
         if reaction.channel_id.0 == config.event_channel
-            && reaction.emoji.as_data() == INTERESTED_EMOJI
+            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
         {
             send_message_to_reaction_users(
                 &ctx,
                 &reaction,
                 "Hello, you are now receiving reminders for **{event}**",
-            );
+            ).await;
         }
     }
 
     /// On reaction remove
-    fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
+    async fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
-        let config = match get_config(&ctx.data) {
+        let config = match get_config(&ctx.data).await {
             Ok(config) => config,
             Err(e) => {
-                error!("Unable to get config: {}", e.0);
+                error!("Unable to get config: {}", e);
                 return;
             }
         };
         if reaction.channel_id.0 == config.event_channel
-            && reaction.emoji.as_data() == INTERESTED_EMOJI
+            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
         {
             send_message_to_reaction_users(
                 &ctx,
                 &reaction,
                 "Hello, you are no longer receiving reminders for **{event}**",
-            );
+            ).await;
         }
     }
 
     /// On bot ready
-    fn ready(&self, _: Context, ready: Ready) {
+    async fn ready(&self, ctx: Context, ready: Ready) {
         info!("Connected to Discord as {}", ready.user.name);
+
+        // Schedule current events
+        let config = get_config(&ctx.data).await.expect("Unable to get config");
+        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 event.reminder_sent == 0 {
+                schedule_event(&ctx, &event).await;
+            }
+        }
     }
 }
 
 #[help]
 #[command_not_found_text = "Could not find: `{}`."]
-#[strikethrough_commands_tip_in_guild("HypeBot")]
+#[strikethrough_commands_tip_in_guild("")]
-fn bot_help(
+async fn bot_help(
-    context: &mut Context,
+    context: &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)
+    help_commands::with_embeds(context, msg, args, help_options, groups, owners).await;
+    Ok(())
 }
 
 /// Does the setup for logging
@@ -181,7 +194,8 @@ fn setup_logging(config: &HypeBotConfig) -> HypeBotResult<()> {
 }
 
 embed_migrations!("migrations/");
-fn main() -> HypeBotResult<()> {
+#[tokio::main]
+async fn main() -> HypeBotResult<()> {
     // Initialize arg parser
     let mut app = App::new("Hype Bot")
         .about("Hype Bot: Hype Up Your Discord Events!")
@@ -217,26 +231,23 @@ fn main() -> HypeBotResult<()> {
 
         // New client
         let mut client =
-            Client::new(cfg.discord_key.clone(), Handler).expect("Error creating client");
+            Client::builder(cfg.discord_key.clone()).event_handler(Handler).framework(
-
+                StandardFramework::new()
-        // Configure client
+                    .configure(|c| {
-        client.with_framework(
+                        c.prefix(cfg.prefix.as_str().clone())
-            StandardFramework::new()
+                            .allow_dm(false)
-                .configure(|c| {
+                            .ignore_bots(true)
-                    c.prefix(cfg.prefix.as_str().clone())
+                            .ignore_webhooks(true)
-                        .allow_dm(false)
+                    })
-                        .ignore_bots(true)
+                    .before(permission_check)
-                        .ignore_webhooks(true)
+                    .after(log_error)
-                })
+                    .group(&EVENTCOMMANDS_GROUP)
-                .before(permission_check)
+                    .help(&BOT_HELP),
-                .after(log_error)
+            ).await?;
-                .group(&EVENTCOMMANDS_GROUP)
-                .help(&BOT_HELP),
-        );
 
         // Copy config data to client data and setup scheduler
         {
-            let mut data = client.data.write();
+            let mut data = client.data.write().await;
             data.insert::<HypeBotConfig>(cfg);
             data.insert::<DraftEvent>(DraftEvent {
                 event: NewEvent {
@@ -251,41 +262,12 @@ fn main() -> HypeBotResult<()> {
                 },
                 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 {