feat: command config for setting it up

(lsit command can come later to see the active ones)

src/commands/mod.rs

@@ -2,3 +2,4 @@ pub mod add_server;
 pub mod committee;
 pub mod link_email;
 pub mod minecraft;
+pub mod role_adder;

src/commands/role_adder.rs

@@ -0,0 +1,172 @@
+use serenity::{
+  builder::CreateApplicationCommand,
+  client::Context,
+  model::{
+    application::interaction::application_command::ApplicationCommandInteraction,
+    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
+  },
+};
+
+use skynet_discord_bot::{is_admin, DataBase, RoleAdder};
+use sqlx::{Error, Pool, Sqlite};
+
+pub mod edit {
+  use super::*;
+
+  pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+    // check if user has high enough permisssions
+    if let Some(msg) = is_admin(command, ctx).await {
+      return msg;
+    }
+
+    let role_a = if let CommandDataOptionValue::Role(role) = command
+        .data
+        .options
+        .get(0)
+        .expect("Expected role option")
+        .resolved
+        .as_ref()
+        .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    let role_b = if let CommandDataOptionValue::Role(role) = command
+        .data
+        .options
+        .get(1)
+        .expect("Expected role option")
+        .resolved
+        .as_ref()
+        .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    let role_c = if let CommandDataOptionValue::Role(role) = command
+        .data
+        .options
+        .get(2)
+        .expect("Expected role option")
+        .resolved
+        .as_ref()
+        .expect("Expected role object")
+    {
+      role.id.to_owned()
+    } else {
+      return "Please provide a valid role for ``Role Current``".to_string();
+    };
+
+    let delete = if let CommandDataOptionValue::Boolean(delete) = command
+        .data
+        .options
+        .get(3)
+        .expect("Expected true/false option")
+        .resolved
+        .as_ref()
+        .expect("Expected true/False object")
+    {
+      delete.to_owned()
+    } else {
+      false
+    };
+
+    let db_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
+    };
+    let db = db_lock.read().await;
+
+    let server_data = RoleAdder {
+      server: command.guild_id.unwrap_or_default(),
+      role_a,
+      role_b,
+      role_c,
+    };
+
+    match add_server(&db, &server_data, delete).await {
+      Ok(_) => {}
+      Err(e) => {
+        println!("{:?}", e);
+        return format!("Failure to insert into Servers {:?}", server_data);
+      }
+    }
+
+    "Added/Updated server info".to_string()
+  }
+
+  pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+    command
+        .name("roles_adder")
+        .description("Combine roles together to an new one")
+        .create_option(|option| {
+          option
+              .name("role_a")
+              .description("A role you want to add to Role B")
+              .kind(CommandOptionType::Role)
+              .required(true)
+        })
+        .create_option(|option| {
+          option
+              .name("role_b")
+              .description("A role you want to add to Role A")
+              .kind(CommandOptionType::Role)
+              .required(true)
+        })
+        .create_option(|option| {
+          option
+              .name("role_c")
+              .description("Sum of A and B")
+              .kind(CommandOptionType::Role)
+              .required(true)
+        })
+        .create_option(|option| {
+          option
+              .name("delete")
+              .description("Delete this entry.")
+              .kind(CommandOptionType::Boolean)
+              .required(false)
+        })
+  }
+
+  async fn add_server(db: &Pool<Sqlite>, server: &RoleAdder, delete: bool) -> Result<Option<RoleAdder>, Error> {
+    let action;
+    if delete {
+      action = sqlx::query_as::<_, RoleAdder>(
+        "
+      DELETE FROM roles_adder
+      WHERE server = ?1 AND role_a = ?2 AND role_b = ?3 AND role_c = ?4
+    ",
+      )
+          .bind(*server.server.as_u64() as i64)
+          .bind(*server.role_a.as_u64() as i64)
+          .bind(*server.role_b.as_u64() as i64)
+          .bind(*server.role_c.as_u64() as i64)
+          .fetch_optional(db)
+          .await;
+    } else {
+      action = sqlx::query_as::<_, RoleAdder>(
+        "
+      INSERT OR REPLACE INTO roles_adder (server, role_a, role_b, role_c)
+      VALUES (?1, ?2, ?3, ?4)
+    ",
+      )
+          .bind(*server.server.as_u64() as i64)
+          .bind(*server.role_a.as_u64() as i64)
+          .bind(*server.role_b.as_u64() as i64)
+          .bind(*server.role_c.as_u64() as i64)
+          .fetch_optional(db)
+          .await;
+    }
+
+    action
+  }
+
+}
+
+// TODO
+pub mod list {}