discord-bot/src/commands/add_server.rs

use serenity::{
  builder::CreateApplicationCommand,
  client::Context,
  model::{
    application::interaction::application_command::ApplicationCommandInteraction,
    prelude::{command::CommandOptionType, interaction::application_command::CommandDataOptionValue},
  },
};
use skynet_discord_bot::{DataBase, Servers, Wolves};
use sqlx::{Error, Pool, Sqlite};

pub async fn run(command: &ApplicationCommandInteraction, ctx: &Context) -> String {
  // check if user has high enough permisssions
  let mut admin = false;

  let g_id = match command.guild_id {
    None => return "Not in a server".to_string(),
    Some(x) => x,
  };

  let roles_server = g_id.roles(&ctx.http).await.unwrap_or_default();

  if let Ok(member) = g_id.member(&ctx.http, command.user.id).await {
    if let Some(permissions) = member.permissions {
      if permissions.administrator() {
        admin = true;
      }
    }

    for role_id in member.roles {
      if admin {
        break;
      }
      if let Some(role) = roles_server.get(&role_id) {
        if role.permissions.administrator() {
          admin = true;
        }
      }
    }
  }
  if !admin {
    return "Administrator permission required".to_string();
  }

  let api_key = if let CommandDataOptionValue::String(key) = command
    .data
    .options
    .get(0)
    .expect("Expected user option")
    .resolved
    .as_ref()
    .expect("Expected user object")
  {
    key
  } 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")
  {
    Some(role.id.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(2) {
    if let Some(CommandDataOptionValue::Role(role)) = &x.resolved {
      role_past = Some(role.id.to_owned());
    }
  };

  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 = Servers {
    server: command.guild_id.unwrap_or_default(),
    wolves_api: api_key.to_owned(),
    role_past,
    role_current,
    member_past: 0,
    member_current: 0,
  };

  match add_server(&db, &server_data).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("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("role_past")
        .description("Role for Past members")
        .kind(CommandOptionType::Role)
        .required(false)
    })
}

async fn add_server(db: &Pool<Sqlite>, server: &Servers) -> Result<Option<Wolves>, Error> {
  let role_past = server.role_past.map(|x| *x.as_u64() as i64);
  let role_current = server.role_current.map(|x| *x.as_u64() as i64);

  sqlx::query_as::<_, Wolves>(
    "
      INSERT OR REPLACE INTO servers (server, wolves_api, role_past, role_current)
      VALUES (?1, ?2, ?3, ?4)
    ",
  )
  .bind(*server.server.as_u64() as i64)
  .bind(&server.wolves_api)
  .bind(role_past)
  .bind(role_current)
  .fetch_optional(db)
  .await
}