120 lines
3.8 KiB
Rust
120 lines
3.8 KiB
Rust
use log::{warn, info, error};
|
|
use serenity::all::Interaction;
|
|
use serenity::async_trait;
|
|
use serenity::model::gateway::Ready;
|
|
use serenity::model::channel::Message;
|
|
use serenity::prelude::*;
|
|
|
|
use crate::data::guilds::GuildCache;
|
|
use super::{commands, oai};
|
|
use super::commands::audio::create_response;
|
|
|
|
pub struct Handler {
|
|
// Open AI Config
|
|
pub oai: Option<oai::OAI>,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventHandler for Handler {
|
|
async fn message(&self, ctx: Context, msg: Message) {
|
|
// Ignore messages from bots
|
|
if msg.author.bot {
|
|
return;
|
|
}
|
|
match &self.oai {
|
|
Some(oai) => {
|
|
match msg.mentions_me(&ctx.http).await {
|
|
Ok(mentioned) => {
|
|
let bot_in_thread = match msg.channel_id.get_thread_members(&ctx.http).await {
|
|
Ok(t) => match t.iter().find(|t| t.user_id == ctx.cache.current_user().id) {
|
|
Some(_) => true,
|
|
None => false,
|
|
},
|
|
Err(_) => false,
|
|
};
|
|
if mentioned || bot_in_thread {
|
|
commands::chat::generate_response(&ctx, &msg, oai).await;
|
|
}
|
|
}
|
|
Err(why) => warn!("Could not check mentions: {:?}", why),
|
|
};
|
|
}
|
|
None => {}
|
|
}
|
|
}
|
|
|
|
async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
|
|
if let Interaction::Command(command) = interaction {
|
|
log::trace!("Received command interaction: {command:#?}");
|
|
match command.data.name.as_str() {
|
|
// Match commands without returns
|
|
"play" => commands::audio::play::run(&ctx, &command).await,
|
|
"stop" => commands::audio::stop::run(&ctx, &command).await,
|
|
"pause" => commands::audio::pause::run(&ctx, &command).await,
|
|
"resume" => commands::audio::resume::run(&ctx, &command).await,
|
|
"mute" => commands::audio::mute::run(&ctx, &command).await,
|
|
"skip" => commands::audio::skip::run(&ctx, &command).await,
|
|
"volume" => commands::audio::volume::run(&ctx, &command).await,
|
|
"schedule" => commands::event::schedule::run(&ctx, &command).await,
|
|
"roll" => commands::fun::roll::run(&ctx, &command).await,
|
|
_ => {
|
|
let content: String = match command.data.name.as_str() {
|
|
// Match commands with string returns
|
|
"ping" => commands::utility::ping::run(&command.data.options),
|
|
_ => "Unknown command".to_string(),
|
|
};
|
|
create_response(&ctx, &command, content).await;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn ready(&self, ctx: Context, ready: Ready) {
|
|
if ready.guilds.is_empty() {
|
|
warn!("No ready guilds found");
|
|
}
|
|
for guild in ready.guilds {
|
|
// Check if guild exists in database
|
|
let guild_id = guild.id.get() as i64;
|
|
if let None = GuildCache::get_by_id(guild_id).await.unwrap() {
|
|
let guild_cache = GuildCache {
|
|
id: guild_id,
|
|
bot_id: 1,
|
|
volume: 100,
|
|
};
|
|
guild_cache.insert().await.unwrap();
|
|
}
|
|
let commands = guild
|
|
.id
|
|
.set_commands(
|
|
&ctx.http,
|
|
vec![
|
|
commands::audio::play::register(),
|
|
commands::audio::stop::register(),
|
|
commands::audio::pause::register(),
|
|
commands::audio::resume::register(),
|
|
commands::audio::mute::register(),
|
|
commands::audio::skip::register(),
|
|
commands::audio::volume::register(),
|
|
commands::event::schedule::register(),
|
|
commands::fun::roll::register(),
|
|
commands::utility::ping::register(),
|
|
],
|
|
)
|
|
.await;
|
|
match commands {
|
|
Ok(c) => info!(
|
|
"Registered {} commands for guild {}",
|
|
c.len(),
|
|
guild.id.get()
|
|
),
|
|
Err(why) => error!(
|
|
"Could not register commands for guild {}: {:?}",
|
|
guild.id.get(),
|
|
why
|
|
),
|
|
};
|
|
}
|
|
}
|
|
}
|