feat: setup basic user_image and only answer if user enable

src/bot/cmd/help.rs

@@ -5,6 +5,7 @@ use serenity::framework::standard::{
 };
 use serenity::model::prelude::{Message, UserId};
 use std::collections::HashSet;
+
 #[help]
 #[individual_command_tip = "Hello! Pour plus d'information sur une commande, passer la en argument."]
 #[command_not_found_text = "La commande `{}` n'a pas été trouver."]

src/bot/cmd/meme/answer.rs

@@ -0,0 +1,28 @@
+use serenity::{
+    all::Message,
+    client::Context,
+    framework::standard::{macros::command, Args, CommandResult},
+};
+
+#[command]
+#[description = "Answer your message with a meme"]
+pub async fn answer(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
+    if let Ok(keyword) = args.single::<String>() {
+        if let Err(why) = msg
+            .channel_id
+            .say(&ctx.http, format!("Slow mode rate: {} seconds", keyword))
+            .await
+        {
+            println!("Error sending message: {:?}", why)
+        }
+        return Ok(());
+    }
+    if let Err(why) = msg
+        .channel_id
+        .say(&ctx.http, "Answer from framework!")
+        .await
+    {
+        println!("Error sending message: {:?}", why)
+    }
+    Ok(())
+}

src/bot/cmd/meme/enable.rs

@@ -0,0 +1,14 @@
+use serenity::{
+    all::Message,
+    client::Context,
+    framework::standard::{macros::command, CommandResult},
+};
+
+#[command]
+#[description = "Enable/Disable the auto meme answer"]
+pub async fn enable(ctx: &Context, msg: &Message) -> CommandResult {
+    if let Err(why) = msg.channel_id.say(&ctx.http, "Pong from framework!").await {
+        println!("Error sending message: {:?}", why)
+    }
+    Ok(())
+}

src/bot/cmd/meme/init.rs

@@ -0,0 +1,15 @@
+use super::{answer::ANSWER_COMMAND, enable::ENABLE_COMMAND};
+use serenity::all::standard::macros::group;
+
+// Include the meme commands
+// - enable/disable the meme answer
+// - trigger a one time meme answer (default command)
+// - make a request to add a new meme
+// - list meme categories
+#[group]
+#[prefixes("meme", "m")]
+#[summary = "Meme related commands"]
+#[description = "Commands to handle the meme related stuffs, it allow you to enable/disable the meme answer or to trigger a one time meme answer."]
+#[commands(enable, answer)]
+#[default_command(answer)]
+pub struct Meme;

src/bot/cmd/meme/mod.rs

@@ -0,0 +1,3 @@
+pub mod answer;
+pub mod enable;
+pub mod init;

src/bot/cmd/mod.rs

@@ -1,2 +1,3 @@
 pub mod help;
+pub mod meme;
 pub mod ping;

src/bot/handler.rs

@@ -10,6 +10,7 @@ use tokio::fs::File;
 
 use crate::{
     config::ConfigGlobal,
+    db::user_image::UserImage,
     img::config_file::{ConfigImgGlobal, KeyWordItem},
 };
 
@@ -18,12 +19,7 @@ pub struct Handler;
 #[async_trait]
 impl EventHandler for Handler {
     async fn message(&self, ctx: Context, msg: Message) {
-        let chan_id: u64 = 675046560219791378;
+        if msg.author.bot || msg.content.starts_with("!") || msg.content.len() == 0 {
-        if msg.author.bot
-            || msg.content.starts_with("!")
-            || !msg.channel_id.eq(&chan_id)
-            || msg.content.len() == 0
-        {
             return;
         }
         if msg.content == "&ping" {
@@ -32,6 +28,33 @@ impl EventHandler for Handler {
             }
             return;
         }
+        let guild = match msg.guild_id {
+            Some(guild) => guild,
+            None => return,
+        };
+        let user_in_db: UserImage =
+            match UserImage::find_by_server_id_user_id(&guild.get(), &msg.author.id.get()).await {
+                Ok(Some(user_in_db)) => user_in_db.clone(),
+                Ok(None) => {
+                    let user_in_db =
+                        UserImage::new(guild.get(), msg.author.id.get(), false).unwrap();
+                    match user_in_db.save().await {
+                        Ok(_) => user_in_db,
+                        Err(e) => {
+                            println!("Error saving user image: {:?}", e);
+                            return;
+                        }
+                    }
+                }
+                Err(e) => {
+                    println!("Error finding user image: {:?}", e);
+                    return;
+                }
+            };
+        if !user_in_db.enable {
+            println!("User image is not enable");
+            return;
+        }
         let (config_img, config) = {
             let data_read = ctx.data.read().await;
             let config_img = data_read

src/bot/init.rs

@@ -1,3 +1,4 @@
+use super::cmd::meme::init::MEME_GROUP;
 use super::cmd::{help::HELP, ping::PING_COMMAND};
 use super::handler::Handler;
 use crate::config::{Config, ConfigGlobal};
@@ -67,7 +68,10 @@ pub fn start_bot(config: Config) {
                             Err(why) => panic!("Could not access application info: {:?}", why),
                         };
 
-                        let framework = StandardFramework::new().help(&HELP).group(&GENERAL_GROUP);
+                        let framework = StandardFramework::new()
+                            .help(&HELP)
+                            .group(&GENERAL_GROUP)
+                            .group(&MEME_GROUP);
 
                         framework.configure(
                             Configuration::new()

src/db/user_image.rs

@@ -1,28 +1,62 @@
-use std::num::NonZeroU64;
-
 use serde::{Deserialize, Serialize};
-use surrealdb::engine::remote::ws::Ws;
+use surrealdb::opt::Resource;
-use surrealdb::opt::auth::Root;
-use surrealdb::sql::Thing;
-use surrealdb::Surreal;
 
-#[derive(Debug, Serialize)]
+use super::init::DB;
-pub struct UserImage<'a> {
+
-    server_id: &'a NonZeroU64,
+const USERIMAGE: &str = "userimage";
-    user_id: &'a NonZeroU64,
+
-    enable: &'a bool,
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct UserImage {
+    pub server_id: u64,
+    pub user_id: u64,
+    pub enable: bool,
 }
 
-impl<'a> UserImage<'a> {
+impl UserImage {
-    pub fn new(
+    pub fn new(server_id: u64, user_id: u64, enable: bool) -> Result<Self, surrealdb::Error> {
-        server_id: &'a NonZeroU64,
-        user_id: &'a NonZeroU64,
-        enable: &'a bool,
-    ) -> Result<Self, surrealdb::Error> {
         Ok(Self {
             server_id,
             user_id,
             enable,
         })
     }
+
+    pub async fn save(&self) -> Result<(), surrealdb::Error> {
+        match DB.create(Resource::from(USERIMAGE)).content(&self).await {
+            Ok(_) => {}
+            Err(e) => {
+                return Err(e);
+            }
+        };
+        Ok(())
+    }
+
+    pub async fn find_by_server_id_user_id(
+        server_id: &u64,
+        user_id: &u64,
+    ) -> Result<Option<UserImage>, surrealdb::Error> {
+        let sql = format!(
+            "SELECT * FROM {} WHERE server_id = {} AND user_id = {}",
+            USERIMAGE, server_id, user_id
+        );
+        let mut results = match DB.query(&sql).await {
+            Ok(results) => results,
+            Err(e) => {
+                return Err(e);
+            }
+        };
+        println!("{:?}", results);
+        let user_image: UserImage = match results.take(0) {
+            Ok(Some(user_image)) => user_image,
+            Ok(None) => {
+                return Ok(None);
+            }
+            Err(err) => {
+                return Err(err);
+            }
+        };
+        Ok(Some(user_image))
+    }
+
+    // find a user image by server_id and user_id
 }

src/lib.rs

@@ -1,3 +1,4 @@
 pub mod bot;
 pub mod config;
+pub mod db;
 pub mod img;