feat: disable the answer meme old workflow only use the /meme answer

src/botv2/handler.rs

@@ -1,121 +1,18 @@
 use super::init::{Data, Error};
-use crate::{db::user_image::User, img::config_file::KeyWordItem};
 use poise::serenity_prelude as serenity;
-use rand::Rng;
-use serenity::all::{CreateAttachment, CreateMessage};
-use tokio::fs::File;
 use tracing::{info, instrument};
 
-#[instrument(skip(ctx, _framework, data), err, level = "trace")]
+#[instrument(skip(_ctx, _framework, _data), err, level = "trace")]
 pub async fn event_handler(
-    ctx: &serenity::Context,
+    _ctx: &serenity::Context,
     event: &serenity::FullEvent,
     _framework: poise::FrameworkContext<'_, Data, Error>,
-    data: &Data,
+    _data: &Data,
 ) -> Result<(), Error> {
     match event {
         serenity::FullEvent::Ready { data_about_bot, .. } => {
             info!("{} 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.is_empty()
-            {
-                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 {
-                return Ok(());
-            }
-            if config_img.keyword.is_empty() || 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(())