feat: Mise en place de la commande ou on/off l'auto answer

src/bot/cmd/meme/enable.rs

@@ -1,14 +1,97 @@
 use serenity::{
     all::Message,
     client::Context,
-    framework::standard::{macros::command, CommandResult},
+    framework::standard::{macros::command, Args, CommandResult},
 };
 
+use crate::db::user_image::UserImage;
+
 #[command]
 #[description = "Enable/Disable the auto meme answer"]
-pub async fn enable(ctx: &Context, msg: &Message) -> CommandResult {
+pub async fn enable(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
-    if let Err(why) = msg.channel_id.say(&ctx.http, "Pong from framework!").await {
+    let guild = match msg.guild_id {
+        Some(guild) => guild,
+        None => return Ok(()),
+    };
+    let mut 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.create().await {
+                    Ok(_) => user_in_db,
+                    Err(e) => {
+                        if let Err(why) = msg
+                            .channel_id
+                            .say(&ctx.http, "Couldn't create user in db")
+                            .await
+                        {
                             println!("Error sending message: {:?}", why)
                         }
+                        println!("Error saving user image: {:?}", e);
+                        return Ok(());
+                    }
+                }
+            }
+            Err(e) => {
+                if let Err(why) = msg
+                    .channel_id
+                    .say(&ctx.http, "Error finding user image")
+                    .await
+                {
+                    println!("Error sending message: {:?}", why)
+                }
+                println!("Error finding user image: {:?}", e);
+                return Ok(());
+            }
+        };
+    if let Ok(new_status) = args.single::<bool>() {
+        if user_in_db.enable == new_status {
+            if let Err(why) = msg
+                .channel_id
+                .say(&ctx.http, format!("Auto answer the same : {}", new_status))
+                .await
+            {
+                println!("Error sending message: {:?}", why)
+            }
+            return Ok(());
+        }
+        user_in_db.enable = new_status;
+        match user_in_db.update().await {
+            Ok(_) => {
+                if let Err(why) = msg
+                    .channel_id
+                    .say(&ctx.http, format!("Auto answer : {}", new_status))
+                    .await
+                {
+                    println!("Error sending message: {:?}", why)
+                }
+            }
+            Err(e) => {
+                if let Err(why) = msg
+                    .channel_id
+                    .say(&ctx.http, "Couldn't update user in db")
+                    .await
+                {
+                    println!("Error sending message: {:?}", why)
+                }
+                println!("Error saving user image: {:?}", e);
+                return Ok(());
+            }
+        }
+        return Ok(());
+    } else {
+        if let Err(why) = msg
+            .channel_id
+            .say(
+                &ctx.http,
+                format!("Auto answer enabled : {}", user_in_db.enable),
+            )
+            .await
+        {
+            println!("Error sending message: {:?}", why)
+        }
+    }
+
     Ok(())
 }

src/bot/handler.rs

@@ -38,7 +38,7 @@ impl EventHandler for Handler {
                 Ok(None) => {
                     let user_in_db =
                         UserImage::new(guild.get(), msg.author.id.get(), false).unwrap();
-                    match user_in_db.save().await {
+                    match user_in_db.create().await {
                         Ok(_) => user_in_db,
                         Err(e) => {
                             println!("Error saving user image: {:?}", e);

src/db/user_image.rs

@@ -21,7 +21,7 @@ impl UserImage {
         })
     }
 
-    pub async fn save(&self) -> Result<(), surrealdb::Error> {
+    pub async fn create(&self) -> Result<(), surrealdb::Error> {
         match DB.create(Resource::from(USERIMAGE)).content(&self).await {
             Ok(_) => {}
             Err(e) => {
@@ -31,6 +31,22 @@ impl UserImage {
         Ok(())
     }
 
+    pub async fn update(&self) -> Result<(), surrealdb::Error> {
+        let sql = format!(
+            "UPDATE {} SET enable = {} WHERE server_id = {} AND user_id = {}",
+            USERIMAGE, self.enable, self.server_id, self.user_id
+        );
+        match DB.query(sql).await {
+            Ok(res) => {
+                println!("{:?}", res);
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        };
+        Ok(())
+    }
+
     pub async fn find_by_server_id_user_id(
         server_id: &u64,
         user_id: &u64,
@@ -45,7 +61,6 @@ impl UserImage {
                 return Err(e);
             }
         };
-        println!("{:?}", results);
         let user_image: UserImage = match results.take(0) {
             Ok(Some(user_image)) => user_image,
             Ok(None) => {