Minecraft
/
HypeBot
6
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

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
async_update
Joey Hines 2021-01-09 15:45:16 -06:00
parent 47a1bc9a2a
commit 30177474e1
No known key found for this signature in database
GPG Key ID: 80F567B5C968F91B
7 changed files with 550 additions and 1014 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

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

1173
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

8
Cargo.toml
View File

@ -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"
features = ["framework", "standard_framework"]
version = "0.10.2"
features = ["framework", "standard_framework", "utils", "builder"]

2
LICENSE
View File

@ -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

57
src/discord/events.rs
View File

@ -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 {
let config = get_config(&ctx.data)?;
let draft_event = get_draft_event(&ctx.data)?;
async fn confirm(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
let config = get_config(&ctx.data).await?;
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 event_name = content_safe(&ctx.cache, event_name, &settings);
let location = content_safe(&ctx.cache, location, &settings);
let organizer = content_safe(&ctx.cache, organizer, &settings);
let description = content_safe(&ctx.cache, description, &settings).await;
let event_name = content_safe(&ctx.cache, event_name, &settings).await;
let location = content_safe(&ctx.cache, location, &settings).await;
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,
)?;
send_draft_event(&ctx, msg.channel_id)?;
).await?;
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 {
let config = get_config(&ctx.data)?;
async fn cancel(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
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(())
}

168
src/discord/mod.rs
View File

@ -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::{Context, RwLock, ShareMap};
use serenity::prelude::{TypeMapKey, TypeMap};
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) {
if let Ok(config) = get_config(&ctx.data) {
pub async fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_text: &str) {
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) {
send_dm_message(&ctx.http, user, &msg);
if let Ok(user) = reaction.user(&ctx).await {
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) {
if let Ok(dm_channel) = user.create_dm_channel(&http) {
dm_channel.send_message(&http, |m| m.content(message)).ok();
pub async fn send_dm_message(ctx: &Context, user: User, message: &String) {
if let Ok(dm_channel) = user.create_dm_channel(ctx).await {
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(
http: &Http,
pub async fn send_event_msg(
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(http, UNINTERESTED_EMOJI)?;
msg.react(ctx, INTERESTED_EMOJI).await?;
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 {
let data = ctx.data.read();
pub async fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
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."
))
})?;
send_event_msg(&ctx.http, config, channel.0, &draft_event.event, false)?;
}).await?;
send_event_msg(ctx, config, channel.0, &draft_event.event, false).await?;
Ok(())
}
/// Gets the config from context data
pub fn get_config(
data: &Arc<RwLock<ShareMap>>,
pub async fn get_config(
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(
data: &Arc<RwLock<ShareMap>>,
pub async fn get_draft_event(
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(
_ctx: &mut Context,
#[hook]
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(roles) = ctx.http.get_guild_roles(guild_id.0) {
if let Ok(config) = get_config(&ctx.data).await {
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) {
let scheduler = {
let mut context = data.write();
context
.get_mut::<SchedulerKey>()
.expect("Expected Scheduler.")
.clone()
};
let config = get_config(&data).unwrap();
pub async fn schedule_event(ctx: &Context, event: &Event) {
let config = get_config(&ctx.data).await.expect("Unable to get config");
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 |_| {
send_reminders(&http, &data, &event, &reminder_msg)
});
tokio::task::spawn(async move {
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(
http: &Arc<Http>,
data: &Arc<RwLock<ShareMap>>,
pub async fn send_reminders_task(
ctx: &Context,
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) {
let config = get_config(&data).unwrap();
pub async fn delete_event(http: &Arc<Http>, data: &Arc<RwLock<TypeMap>>, event: &Event) {
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();
}
}

152
src/main.rs
View File

@ -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::framework::standard::{help_commands, Args, CommandGroup, HelpOptions};
use serenity::async_trait;
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 std::collections::HashSet;
use std::path::Path;
use std::process::exit;
use std::sync::Arc;
use white_rabbit::{DateResult, Scheduler};
use serenity::prelude::{Context, EventHandler};
use database::*;
use database::models::NewEvent;
use discord::{
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;
use database::*;
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}";
const INTERESTED_EMOJI: char = '\u{2705}';
const UNINTERESTED_EMOJI: char = '\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) {
let config = match get_config(&ctx.data) {
async fn reaction_add(&self, ctx: Context, reaction: Reaction) {
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) {
let config = match get_config(&ctx.data) {
async fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
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")]
fn bot_help(
context: &mut Context,
#[strikethrough_commands_tip_in_guild("")]
async fn bot_help(
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");
// Configure client
client.with_framework(
StandardFramework::new()
.configure(|c| {
c.prefix(cfg.prefix.as_str().clone())
.allow_dm(false)
.ignore_bots(true)
.ignore_webhooks(true)
})
.before(permission_check)
.after(log_error)
.group(&EVENTCOMMANDS_GROUP)
.help(&BOT_HELP),
);
Client::builder(cfg.discord_key.clone()).event_handler(Handler).framework(
StandardFramework::new()
.configure(|c| {
c.prefix(cfg.prefix.as_str().clone())
.allow_dm(false)
.ignore_bots(true)
.ignore_webhooks(true)
})
.before(permission_check)
.after(log_error)
.group(&EVENTCOMMANDS_GROUP)
.help(&BOT_HELP),
).await?;
// 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 {