110 lines
4.4 KiB
Rust
110 lines
4.4 KiB
Rust
use tokio::fs::File;
|
|
use poise::serenity_prelude as serenity;
|
|
use serenity::all::{CreateAttachment,CreateMessage};
|
|
use rand::Rng;
|
|
use crate::{db::user_image::User, img::config_file::KeyWordItem};
|
|
use super::init::{Data, Error};
|
|
|
|
pub async fn event_handler(
|
|
ctx: &serenity::Context,
|
|
event: &serenity::FullEvent,
|
|
_framework: poise::FrameworkContext<'_, Data, Error>,
|
|
data: &Data,
|
|
) -> Result<(), Error> {
|
|
match event {
|
|
serenity::FullEvent::Ready { data_about_bot, .. } => {
|
|
println!("{} is connected !", data_about_bot.user.name);
|
|
}
|
|
serenity::FullEvent::Message { new_message } => {
|
|
if new_message.author.bot || new_message.content.starts_with(&data.config.prefix.clone()) || new_message.content.len() == 0 {
|
|
return Ok(());
|
|
}
|
|
let config_img = data.config_img.clone();
|
|
let config = data.config.clone();
|
|
let guild = match new_message.guild_id {
|
|
Some(guild) => guild,
|
|
None => return Ok(()),
|
|
};
|
|
let user_in_db = match User::find_by_server_id_user_id(&guild.get(), &new_message.author.id.get()).await {
|
|
Ok(Some(user_in_db)) => user_in_db.clone(),
|
|
Ok(None) => {
|
|
let user_in_db = User::new(guild.get(), new_message.author.id.get(), false).unwrap();
|
|
match user_in_db.create().await {
|
|
Ok(_) => user_in_db,
|
|
Err(e) => {
|
|
println!("Error saving user image: {:?}", e);
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
println!("Error finding user image: {:?}", e);
|
|
return Ok(());
|
|
}
|
|
};
|
|
if !user_in_db.enable {
|
|
println!("User image is not enable");
|
|
return Ok(());
|
|
}
|
|
if config_img.keyword.len() == 0 || new_message.content.len() > 50 {
|
|
return Ok(());
|
|
}
|
|
|
|
let folder_container = match config_img
|
|
.keyword
|
|
.iter()
|
|
.find(|keyword| keyword.does_value_match(new_message.content.clone()))
|
|
{
|
|
Some(keyword_matching) => {
|
|
println!("{} match {:?}", new_message.content, keyword_matching);
|
|
let keyword_path = match keyword_matching.path.len() {
|
|
0 => keyword_matching.path[0].clone(),
|
|
_ => {
|
|
let id: usize = {
|
|
let mut rng = rand::thread_rng();
|
|
rng.gen_range(0..keyword_matching.path.len())
|
|
};
|
|
keyword_matching.path[id].clone()
|
|
}
|
|
};
|
|
|
|
keyword_path.clone()
|
|
}
|
|
None => return Ok(()),
|
|
};
|
|
|
|
let path = format!("{}/{}", config.image.path.clone(), folder_container);
|
|
let file_folder = KeyWordItem::output_folder_content(path.clone());
|
|
let id_rand: usize = {
|
|
let mut rng = rand::thread_rng();
|
|
rng.gen_range(0..file_folder.len())
|
|
};
|
|
let filename = match file_folder.get(id_rand) {
|
|
Some(file) => file.file_name().to_str().unwrap(),
|
|
None => return Ok(()),
|
|
};
|
|
let file_path = format!("{}/{}", path, filename);
|
|
let file = match File::open(file_path).await {
|
|
Ok(file) => file,
|
|
Err(why) => {
|
|
println!("Error opening file: {:?}", why);
|
|
return Ok(());
|
|
}
|
|
};
|
|
let attachment = match CreateAttachment::file(&file, filename).await {
|
|
Ok(attachment) => attachment,
|
|
Err(why) => {
|
|
println!("Error creating attachment: {:?}", why);
|
|
return Ok(());
|
|
}
|
|
};
|
|
let builder = CreateMessage::new().add_file(attachment);
|
|
|
|
if let Err(why) = new_message.channel_id.send_message(&ctx.http, builder).await {
|
|
println!("Error sending message: {:?}", why);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(())
|
|
} |