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

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

Reviewed-on: https://git.birbmc.com/ZeroHD/HypeBot/pulls/1
master
Joey Hines 2021-06-24 01:07:25 +00:00
parent 47a1bc9a2a 6866602bca
commit 3942413e76
23 changed files with 1719 additions and 1901 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
.drone.yml 100644
View File

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

4
.gitignore vendored
View File

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

2094
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

15
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"
@ -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"
features = ["framework", "standard_framework"]
version = "0.10.4"
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

4
README.md
View File

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

5
diesel.toml
View File

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

0
migrations/.gitkeep
View File

2
migrations/2020-04-22-222856_create_events/down.sql
View File

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

12
migrations/2020-04-22-222856_create_events/up.sql
View File

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

2
migrations/2020-07-10-032139_bigger_desc_field/down.sql
View File

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

2
migrations/2020-07-10-032139_bigger_desc_field/up.sql
View File

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

142
src/database/mod.rs
View File

@ -1,78 +1,84 @@
pub mod models;
pub mod schema;
use diesel::prelude::*;
use diesel::result::Error;
use diesel::update;
use models::{Event, NewEvent};
use std::vec::Vec;
use crate::models::Event;
use serenity::prelude::TypeMapKey;
use sled::{open, Db, IVec, Result};
use std::path::Path;
use std::sync::Arc;
/// Establish a connection to the database
pub fn establish_connection(database_url: String) -> MysqlConnection {
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)
pub struct Database {
db: Db,
}
/// Remove event
pub fn remove_event(database_url: String, event_id: i32) -> Result<usize, Error> {
use schema::events::dsl::{events, id};
impl Database {
/// Open the database
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
pub fn get_event_by_name(database_url: String, name: String) -> Result<Event, Error> {
use schema::events::dsl::{event_name, events};
let connection = establish_connection(database_url);
events
.filter(event_name.eq(&name))
.get_result::<Event>(&connection)
}
/// 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)
impl TypeMapKey for Database {
type Value = Arc<Database>;
}

71
src/database/models.rs
View File

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

13
src/database/schema.rs
View File

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

97
src/discord/events.rs
View File

@ -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 {
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.read().await).await?;
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 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 +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 {
let config = get_config(&ctx.data)?;
async fn cancel(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
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)?;
let message_id = event.message_id.parse::<u64>()?;
let message = ctx.http.get_message(config.event_channel, message_id)?;
let reaction_users = message
.reaction_users(&ctx.http, INTERESTED_EMOJI, None, None)
.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);
if let Some(event) = db.get_event_by_name(&event_name) {
delete_event(ctx, &event).await?;
msg.reply(&ctx, format!("{} has been cancelled", event.event_name))
.await?;
} else {
msg.reply(&ctx, format!("{} now found!", event_name))
.await?;
}
remove_event(config.db_url.clone(), event.id)?;
message.delete(&ctx)?;
msg.reply(&ctx, &cancel_msg)?;
Ok(())
}

68
src/discord/handler.rs 100644
View File

@ -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.")
}
}

353
src/discord/mod.rs
View File

@ -1,226 +1,62 @@
use crate::database::models::{Event, NewEvent};
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::collections::HashSet;
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;
}
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())
type Value = Arc<DraftEvent>;
}
/// Gets the draft event from context data
pub fn get_draft_event(
data: &Arc<RwLock<ShareMap>>,
) -> std::result::Result<DraftEvent, CommandError> {
let data_read = data.read();
let draft_event = data_read
pub async fn get_draft_event(
data: &RwLockReadGuard<'_, TypeMap>,
) -> std::result::Result<Arc<DraftEvent>, CommandError> {
let draft_event = data
.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
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())
/// Gets the database from context data
pub async fn get_db(
data: &RwLockReadGuard<'_, TypeMap>,
) -> std::result::Result<Arc<Database>, CommandError> {
let db = data
.get::<Database>()
.ok_or_else(|| CommandError::from("Unable to get db".to_string()))?;
Ok(db.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 +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(roles) = ctx.http.get_guild_roles(guild_id.0) {
if let Ok(config) = utility::get_config(&ctx.data.read().await).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) {
Ok(has_role) => has_role,
Err(_) => false,
};
if has_role {
return true;
}
return msg
.author
.has_role(&ctx, guild_id, role)
.await
.unwrap_or(false)
}
}
}
@ -254,85 +89,17 @@ pub fn permission_check(ctx: &mut Context, msg: &Message, _command_name: &str) -
false
}
/// 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();
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 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();
}
#[help]
#[command_not_found_text = "Could not find: `{}`."]
#[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).await;
Ok(())
}

71
src/discord/tasks.rs 100644
View File

@ -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();
}
}
}

247
src/discord/utility.rs 100644
View File

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

12
src/hypebot_config.rs
View File

@ -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(
"Unable to parse datetime, should be in format \"Country/City\"",
))?;
let tz: Tz = string.parse().ok().ok_or_else(|| {
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>;
}

207
src/main.rs
View File

@ -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::{help_commands, Args, CommandGroup, HelpOptions};
use serenity::framework::standard::{CommandResult, StandardFramework};
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::framework::standard::macros::group;
use serenity::framework::standard::StandardFramework;
use database::*;
use discord::events::{CANCEL_COMMAND, CONFIRM_COMMAND, CREATE_COMMAND};
use discord::handler::Handler;
use discord::BOT_HELP;
use discord::{log_error, permission_check, DraftEvent};
use hypebot_config::HypeBotConfig;
use reminder::Reminders;
mod database;
mod discord;
mod hypebot_config;
mod reminder;
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>>;
@ -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/");
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!")
@ -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 =
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),
);
let mut client = Client::builder(cfg.discord_key.clone())
.event_handler(Handler)
.framework(
StandardFramework::new()
.configure(|c| {
c.prefix(cfg.prefix.as_str())
.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();
data.insert::<HypeBotConfig>(cfg);
data.insert::<DraftEvent>(DraftEvent {
event: NewEvent {
message_id: String::new(),
event_time: Utc::now().naive_utc(),
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);
}
let db = database::Database::new(&cfg.db_location)?;
let mut data = client.data.write().await;
data.insert::<HypeBotConfig>(Arc::new(cfg));
data.insert::<DraftEvent>(Arc::new(DraftEvent::default()));
data.insert::<Reminders>(Reminders::default());
data.insert::<database::Database>(Arc::new(db));
}
// 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 {

158
src/reminder/mod.rs 100644
View File

@ -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);
}
}