338 lines
11 KiB
Rust
338 lines
11 KiB
Rust
#[macro_use]
|
|
extern crate lazy_static;
|
|
|
|
mod commands;
|
|
#[cfg(not(test))]
|
|
mod component_models;
|
|
mod consts;
|
|
#[cfg(not(test))]
|
|
mod event_handlers;
|
|
#[cfg(not(test))]
|
|
mod hooks;
|
|
mod interval_parser;
|
|
mod metrics;
|
|
#[cfg(not(test))]
|
|
mod models;
|
|
mod postman;
|
|
#[cfg(test)]
|
|
mod test;
|
|
mod time_parser;
|
|
mod utils;
|
|
mod web;
|
|
|
|
use std::{
|
|
collections::HashMap,
|
|
env,
|
|
error::Error as StdError,
|
|
fmt::{Debug, Display, Formatter},
|
|
path::Path,
|
|
};
|
|
|
|
use chrono_tz::Tz;
|
|
use log::warn;
|
|
use poise::serenity_prelude::{
|
|
model::{
|
|
gateway::GatewayIntents,
|
|
id::{GuildId, UserId},
|
|
},
|
|
ClientBuilder,
|
|
};
|
|
use serenity::all::ActivityData;
|
|
use sqlx::{MySql, Pool};
|
|
use tokio::sync::{broadcast, broadcast::Sender, RwLock};
|
|
|
|
use crate::metrics::init_metrics;
|
|
#[cfg(test)]
|
|
use crate::test::TestContext;
|
|
#[cfg(not(test))]
|
|
use crate::{
|
|
commands::{
|
|
allowed_dm, clock, clock_context_menu::clock_context_menu, command_macro, dashboard,
|
|
delete, donate, help, info, look, multiline, nudge, offset, pause, remind, settings, timer,
|
|
timezone, todo, webhook,
|
|
},
|
|
consts::THEME_COLOR,
|
|
event_handlers::listener,
|
|
hooks::all_checks,
|
|
models::command_macro::CommandMacro,
|
|
};
|
|
|
|
type Database = MySql;
|
|
|
|
type Error = Box<dyn std::error::Error + Send + Sync>;
|
|
|
|
#[cfg(test)]
|
|
type Context<'a> = TestContext<'a>;
|
|
|
|
#[cfg(not(test))]
|
|
type Context<'a> = poise::Context<'a, Data, Error>;
|
|
|
|
type ApplicationContext<'a> = poise::ApplicationContext<'a, Data, Error>;
|
|
|
|
pub struct Data {
|
|
database: Pool<Database>,
|
|
#[cfg(not(test))]
|
|
recording_macros: RwLock<HashMap<(GuildId, UserId), CommandMacro>>,
|
|
popular_timezones: Vec<Tz>,
|
|
_broadcast: Sender<()>,
|
|
}
|
|
|
|
struct Ended;
|
|
|
|
impl Debug for Ended {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
f.write_str("Process ended.")
|
|
}
|
|
}
|
|
|
|
impl Display for Ended {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
f.write_str("Process ended.")
|
|
}
|
|
}
|
|
|
|
impl StdError for Ended {}
|
|
|
|
#[tokio::main(flavor = "multi_thread")]
|
|
#[cfg(not(test))]
|
|
async fn main() -> Result<(), Box<dyn StdError + Send + Sync>> {
|
|
let (tx, mut rx) = broadcast::channel(16);
|
|
|
|
tokio::select! {
|
|
output = _main(tx) => output,
|
|
_ = rx.recv() => Err(Box::new(Ended) as Box<dyn StdError + Send + Sync>)
|
|
}
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
|
|
env_logger::init();
|
|
|
|
if Path::new("/etc/reminder-rs/config.env").exists() {
|
|
dotenv::from_path("/etc/reminder-rs/config.env")?;
|
|
} else {
|
|
let _ = dotenv::dotenv();
|
|
}
|
|
|
|
let args = env::args().collect::<Vec<_>>();
|
|
let cmd_word = args.last().map(|w| w.as_str());
|
|
|
|
let database =
|
|
Pool::connect(&env::var("DATABASE_URL").expect("No database URL provided")).await.unwrap();
|
|
|
|
match cmd_word {
|
|
Some("clean") => {
|
|
let sent_clean_age = env::var("SENT_CLEAN_AGE").expect("No SENT_CLEAN_AGE provided");
|
|
if sent_clean_age.is_empty() {
|
|
panic!("SENT_CLEAN_AGE empty")
|
|
}
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM reminders
|
|
WHERE `utc_time` < NOW() - INTERVAL ? DAY
|
|
AND status != 'pending'
|
|
ORDER BY `utc_time`
|
|
LIMIT 1000
|
|
",
|
|
sent_clean_age
|
|
)
|
|
.execute(&database)
|
|
.await?;
|
|
|
|
let total_clean_age = env::var("TOTAL_CLEAN_AGE");
|
|
if let Ok(total_clean_age) = total_clean_age {
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM reminders
|
|
WHERE `utc_time` < NOW() - INTERVAL ? DAY
|
|
ORDER BY `utc_time`
|
|
LIMIT 1000
|
|
",
|
|
total_clean_age
|
|
)
|
|
.execute(&database)
|
|
.await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
_ => {
|
|
let discord_token =
|
|
env::var("DISCORD_TOKEN").expect("Missing DISCORD_TOKEN from environment");
|
|
|
|
let options = poise::FrameworkOptions {
|
|
commands: vec![
|
|
help::command(),
|
|
info::command(),
|
|
clock::command(),
|
|
donate::command(),
|
|
clock_context_menu(),
|
|
dashboard::command(),
|
|
timezone::command(),
|
|
poise::Command {
|
|
subcommands: vec![allowed_dm::set::set(), allowed_dm::unset::unset()],
|
|
..allowed_dm::allowed_dm()
|
|
},
|
|
poise::Command {
|
|
subcommands: vec![poise::Command {
|
|
subcommands: vec![
|
|
settings::ephemeral_confirmations::set::set(),
|
|
settings::ephemeral_confirmations::unset::unset(),
|
|
],
|
|
..settings::ephemeral_confirmations::ephemeral_confirmations()
|
|
}],
|
|
..settings::settings()
|
|
},
|
|
webhook::command(),
|
|
poise::Command {
|
|
subcommands: vec![
|
|
command_macro::delete_macro::delete_macro(),
|
|
command_macro::finish_macro::finish_macro(),
|
|
command_macro::list_macro::list_macro(),
|
|
command_macro::record_macro::record_macro(),
|
|
command_macro::run_macro::run_macro(),
|
|
],
|
|
..command_macro::command_macro()
|
|
},
|
|
pause::command(),
|
|
offset::command(),
|
|
nudge::command(),
|
|
look::command(),
|
|
delete::command(),
|
|
poise::Command {
|
|
subcommands: vec![
|
|
timer::list::list(),
|
|
timer::start::start(),
|
|
timer::delete::delete(),
|
|
],
|
|
..timer::timer()
|
|
},
|
|
multiline::command(),
|
|
remind::command(),
|
|
poise::Command {
|
|
subcommands: vec![
|
|
poise::Command {
|
|
subcommands: vec![
|
|
todo::guild::add::add(),
|
|
todo::guild::view::view(),
|
|
],
|
|
..todo::guild::guild()
|
|
},
|
|
poise::Command {
|
|
subcommands: vec![
|
|
todo::channel::add::add(),
|
|
todo::channel::view::view(),
|
|
],
|
|
..todo::channel::channel()
|
|
},
|
|
poise::Command {
|
|
subcommands: vec![todo::user::add::add(), todo::user::view::view()],
|
|
..todo::user::user()
|
|
},
|
|
],
|
|
..todo::todo()
|
|
},
|
|
],
|
|
allowed_mentions: None,
|
|
command_check: Some(|ctx| Box::pin(all_checks(ctx))),
|
|
event_handler: |ctx, event, _framework, data| Box::pin(listener(ctx, event, data)),
|
|
on_error: |error| {
|
|
Box::pin(async move {
|
|
match error {
|
|
poise::FrameworkError::CommandCheckFailed { .. } => {
|
|
// suppress error
|
|
}
|
|
error => {
|
|
if let Err(e) = poise::builtins::on_error(error).await {
|
|
log::error!("Error while handling error: {}", e);
|
|
}
|
|
}
|
|
}
|
|
})
|
|
},
|
|
..Default::default()
|
|
};
|
|
|
|
// Start metrics
|
|
init_metrics();
|
|
|
|
sqlx::migrate!().run(&database).await?;
|
|
|
|
let popular_timezones = sqlx::query!(
|
|
"
|
|
SELECT IFNULL(timezone, 'UTC') AS timezone
|
|
FROM users
|
|
WHERE timezone IS NOT NULL
|
|
GROUP BY timezone
|
|
ORDER BY COUNT(timezone) DESC
|
|
LIMIT 21
|
|
"
|
|
)
|
|
.fetch_all(&database)
|
|
.await
|
|
.unwrap()
|
|
.iter()
|
|
.map(|t| t.timezone.parse::<Tz>().unwrap())
|
|
.collect::<Vec<Tz>>();
|
|
|
|
let framework = poise::Framework::builder()
|
|
.setup(move |ctx, _bot, framework| {
|
|
Box::pin(async move {
|
|
poise::builtins::register_globally(ctx, &framework.options().commands)
|
|
.await?;
|
|
|
|
let kill_tx = tx.clone();
|
|
let kill_recv = tx.subscribe();
|
|
|
|
let ctx1 = ctx.clone();
|
|
let ctx2 = ctx.clone();
|
|
|
|
let pool1 = database.clone();
|
|
let pool2 = database.clone();
|
|
|
|
let run_settings = env::var("DONTRUN").unwrap_or_else(|_| "".to_string());
|
|
|
|
if !run_settings.contains("postman") {
|
|
tokio::spawn(async move {
|
|
match postman::initialize(kill_recv, ctx1, &pool1).await {
|
|
Ok(_) => {}
|
|
Err(e) => {
|
|
panic!("postman exiting: {}", e);
|
|
}
|
|
};
|
|
});
|
|
} else {
|
|
warn!("Not running postman");
|
|
}
|
|
|
|
if !run_settings.contains("web") {
|
|
tokio::spawn(async move {
|
|
web::initialize(kill_tx, ctx2, pool2).await.unwrap();
|
|
});
|
|
} else {
|
|
warn!("Not running web");
|
|
}
|
|
|
|
Ok(Data {
|
|
database,
|
|
popular_timezones,
|
|
recording_macros: Default::default(),
|
|
_broadcast: tx,
|
|
})
|
|
})
|
|
})
|
|
.options(options)
|
|
.build();
|
|
|
|
let mut client = ClientBuilder::new(&discord_token, GatewayIntents::GUILDS)
|
|
.framework(framework)
|
|
.activity(ActivityData::watching("for /remind"))
|
|
.await?;
|
|
|
|
client.start_autosharded().await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|