feat: bumped serenity to the latest version

Lots of changes to how it runs

src/commands/add_server.rs

@@ -1,68 +1,53 @@
-use serenity::{
-  builder::CreateApplicationCommand,
-  client::Context,
-  model::{
-    application::interaction::application_command::ApplicationCommandInteraction,
-    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
-  },
-};
+use serenity::all::{CommandDataOption, CommandDataOptionValue, CommandInteraction, CommandOptionType, CreateCommandOption};
+use serenity::{builder::CreateCommand, client::Context};
 use skynet_discord_bot::common::database::{get_server_config, DataBase, Servers};
 use skynet_discord_bot::common::set_roles::normal::update_server;
 use skynet_discord_bot::common::wolves::cns::get_wolves;
 use skynet_discord_bot::is_admin;
 use sqlx::{Error, Pool, Sqlite};
 
-pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
+pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
   // check if user has high enough permisssions
   if let Some(msg) = is_admin(command, ctx).await {
     return msg;
   }
 
-  let api_key = if let CommandDataOptionValue::String(key) = command
-    .data
-    .options
-    .first()
-    .expect("Expected user option")
-    .resolved
-    .as_ref()
-    .expect("Expected user object")
+  let wolves_api = if let Some(CommandDataOption {
+    value: CommandDataOptionValue::String(key),
+    ..
+  }) = command.data.options.first()
   {
-    key
+    key.to_string()
   } else {
     return "Please provide a wolves API key".to_string();
   };
 
-  let role_current = if let CommandDataOptionValue::Role(role) = command
-    .data
-    .options
-    .get(1)
-    .expect("Expected role option")
-    .resolved
-    .as_ref()
-    .expect("Expected role object")
+  let role_current = if let Some(CommandDataOption {
+    value: CommandDataOptionValue::Role(role),
+    ..
+  }) = command.data.options.get(1)
   {
-    role.id.to_owned()
+    role.to_owned()
   } else {
     return "Please provide a valid role for ``Role Current``".to_string();
   };
 
-  let mut role_past = None;
-  if let Some(x) = command.data.options.get(5) {
-    if let Some(CommandDataOptionValue::Role(role)) = &x.resolved {
-      role_past = Some(role.id.to_owned());
-    }
+  let role_past = if let Some(CommandDataOption {
+    value: CommandDataOptionValue::Role(role),
+    ..
+  }) = command.data.options.get(5)
+  {
+    Some(role.to_owned())
+  } else {
+    None
   };
 
-  let bot_channel_id = if let CommandDataOptionValue::Channel(channel) = command
-    .data
-    .options
-    .get(2)
-    .expect("Expected channel option")
-    .resolved
-    .as_ref()
-    .expect("Expected channel object")
+  let bot_channel_id = if let Some(CommandDataOption {
+    value: CommandDataOptionValue::Channel(channel),
+    ..
+  }) = command.data.options.get(2)
   {
-    channel.id.to_owned()
+    channel.to_owned()
   } else {
     return "Please provide a valid channel for ``Bot Channel``".to_string();
   };
@@ -75,7 +60,7 @@ pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> Stri
 
   let server_data = Servers {
     server: command.guild_id.unwrap_or_default(),
-    wolves_api: api_key.to_owned(),
+    wolves_api,
     role_past,
     role_current,
     member_past: 0,
@@ -95,43 +80,18 @@ pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> Stri
   "Added/Updated server info".to_string()
 }
 
-pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
-  command
-    .name("add")
+pub fn register() -> CreateCommand {
+  CreateCommand::new("add")
     .description("Enable the bot for this discord")
-    .create_option(|option| {
-      option
-        .name("api_key")
-        .description("UL Wolves API Key")
-        .kind(CommandOptionType::String)
-        .required(true)
-    })
-    .create_option(|option| {
-      option
-        .name("role_current")
-        .description("Role for Current members")
-        .kind(CommandOptionType::Role)
-        .required(true)
-    })
-    .create_option(|option| {
-      option
-        .name("bot_channel")
-        .description("Safe space for folks to use the bot commands.")
-        .kind(CommandOptionType::Channel)
-        .required(true)
-    })
-    .create_option(|option| {
-      option
-        .name("role_past")
-        .description("Role for Past members")
-        .kind(CommandOptionType::Role)
-        .required(false)
-    })
+    .add_option(CreateCommandOption::new(CommandOptionType::String, "api_key", "UL Wolves API Key").required(true))
+    .add_option(CreateCommandOption::new(CommandOptionType::Role, "role_current", "Role for Current members").required(true))
+    .add_option(CreateCommandOption::new(CommandOptionType::Channel, "bot_channel", "Safe space for folks to use the bot commands.").required(true))
+    .add_option(CreateCommandOption::new(CommandOptionType::Role, "role_past", "Role for Past members").required(false))
 }
 
 async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Result<Option<Servers>, Error> {
   let existing = get_server_config(db, &server.server).await;
-  let role_past = server.role_past.map(|x| *x.as_u64() as i64);
+  let role_past = server.role_past.map(|x| x.get() as i64);
 
   let insert = sqlx::query_as::<_, Servers>(
     "
@@ -139,11 +99,11 @@ async fn add_server(db: &Pool<Sqlite>, ctx: &Context, server: &Servers) -> Resul
       VALUES (?1, ?2, ?3, ?4, ?5)
     ",
   )
-  .bind(*server.server.as_u64() as i64)
+  .bind(server.server.get() as i64)
   .bind(&server.wolves_api)
   .bind(role_past)
-  .bind(*server.role_current.as_u64() as i64)
-  .bind(*server.bot_channel_id.as_u64() as i64)
+  .bind(server.role_current.get() as i64)
+  .bind(server.bot_channel_id.get() as i64)
   .fetch_optional(db)
   .await;