129 lines
3.6 KiB
Rust
129 lines
3.6 KiB
Rust
use poise::samples::{register_globally, register_in_guild};
|
|
use serenity::async_trait;
|
|
use serenity::prelude::GatewayIntents;
|
|
use serenity::client::Context;
|
|
use serenity::model::gateway::Ready;
|
|
use serenity::all::{EventHandler, GuildId, Message};
|
|
use serenity::Client;
|
|
|
|
use tokio_cron_scheduler::{JobScheduler, Job};
|
|
use util::security::dotenv_var;
|
|
|
|
mod message_handler;
|
|
use message_handler::handle;
|
|
|
|
use std::future::Future;
|
|
use std::pin::Pin;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
mod commands;
|
|
mod util;
|
|
|
|
mod other;
|
|
use other::notice;
|
|
|
|
mod types;
|
|
|
|
struct Handler;
|
|
|
|
use commands::say::say;
|
|
use types::Error;
|
|
|
|
async fn on_error(error: poise::FrameworkError<'_, (), Error>) {
|
|
match error {
|
|
poise::FrameworkError::Setup { error, .. } => panic!("Failed to start bot: {:?}", error),
|
|
poise::FrameworkError::Command { error, ctx, .. } => {
|
|
println!("Error in command `{}`: {:?}", ctx.command().name, error,);
|
|
}
|
|
error => {
|
|
if let Err(e) = poise::builtins::on_error(error).await {
|
|
println!("Error while handling error: {}", e)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventHandler for Handler {
|
|
async fn message(&self, ctx: Context, msg: Message) {
|
|
handle(ctx, msg).await;
|
|
}
|
|
|
|
async fn ready(&self, ctx: Context, ready: Ready) {
|
|
println!("{} v0.3 is connected!", ready.user.name);
|
|
|
|
#[cfg(feature="RELEASE")] {
|
|
use util::debug::hello;
|
|
hello(ctx.http.clone()).await;
|
|
}
|
|
|
|
let sched = JobScheduler::new().await.unwrap();
|
|
|
|
let job_closure = move |_, _| -> Pin<Box<dyn Future<Output = ()> + Send>> {
|
|
let ctx_clone = ctx.clone();
|
|
Box::pin( async move {
|
|
notice::notice_wrapper(ctx_clone).await;
|
|
})
|
|
};
|
|
|
|
sched.add(Job::new_async("0 0 13 * * *", job_closure).expect("Cron job not set up correctly")).await.unwrap();
|
|
sched.start().await.unwrap();
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> anyhow::Result<()> {
|
|
use anyhow::Context;
|
|
|
|
// create poise framework for registering commands
|
|
let options = poise::FrameworkOptions {
|
|
commands: vec![say()],
|
|
prefix_options: poise::PrefixFrameworkOptions {
|
|
prefix: Some("/".into()),
|
|
edit_tracker: Some(Arc::new(poise::EditTracker::for_timespan(
|
|
Duration::from_secs(3600),
|
|
))),
|
|
..Default::default()
|
|
},
|
|
on_error: |err| Box::pin(on_error(err)),
|
|
command_check: Some(|ctx| {
|
|
Box::pin(async move {
|
|
return Ok(!ctx.author().bot)
|
|
})
|
|
}),
|
|
..Default::default()
|
|
};
|
|
|
|
let debug_guild_id = dotenv_var("DEBUG_GUILD_ID")
|
|
.context("DEBUG_GUILD_ID not found in env")?
|
|
.parse::<u64>().unwrap();
|
|
|
|
let framework = poise::Framework::builder()
|
|
.setup(move |ctx, _ready, framework| {
|
|
Box::pin(async move {
|
|
register_in_guild(ctx, &framework.options().commands, GuildId::new(debug_guild_id)).await?;
|
|
Ok(())
|
|
})
|
|
})
|
|
.options(options)
|
|
.build();
|
|
|
|
let token_str = "TOKEN";
|
|
|
|
#[cfg(feature="DEBUG")]
|
|
let token_str = "DEBUGTOKEN";
|
|
|
|
let token = dotenv_var(token_str).context("TOKEN not found in env")?;
|
|
|
|
let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
|
|
|
|
let mut client = Client::builder(&token, intents)
|
|
.event_handler(Handler)
|
|
.framework(framework)
|
|
.await
|
|
.context("Failed to build client")?;
|
|
|
|
client.start().await?;
|
|
Ok(())
|
|
}
|