discord-bot/src/main.rs

pub mod commands;

use crate::commands::role_adder::tools::on_role_change;
use serenity::model::guild::Member;
use serenity::model::id::GuildId;
use serenity::{
  async_trait,
  client::{Context, EventHandler},
  model::{
    application::{command::Command, interaction::Interaction},
    gateway::{GatewayIntents, Ready},
    prelude::Activity,
    user::OnlineStatus,
  },
  Client,
};
use skynet_discord_bot::common::database::{db_init, get_server_config, get_server_member, DataBase};
use skynet_discord_bot::common::set_roles::committee::update_committees;
use skynet_discord_bot::{get_config, Config};
use std::sync::Arc;
use tokio::sync::RwLock;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
  // handles previously linked accounts joining the server
  async fn guild_member_addition(&self, ctx: Context, mut new_member: Member) {
    let db_lock = {
      let data_read = ctx.data.read().await;
      data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
    };

    let db = db_lock.read().await;
    let config = match get_server_config(&db, &new_member.guild_id).await {
      None => return,
      Some(x) => x,
    };

    // committee server takes priority
    if new_member.guild_id.eq(&GuildId(1220150752656363520)) {
      let mut member = vec![new_member.clone()];
      update_committees(&db, &ctx, &mut member).await;
      return;
    }

    if get_server_member(&db, &new_member.guild_id, &new_member).await.is_ok() {
      let mut roles = vec![];

      if let Some(role) = &config.role_past {
        if !new_member.roles.contains(role) {
          roles.push(role.to_owned());
        }
      }

      if !new_member.roles.contains(&config.role_current) {
        roles.push(config.role_current.to_owned());
      }

      if let Err(e) = new_member.add_roles(&ctx, &roles).await {
        println!("{:?}", e);
      }
    } else {
      let msg = format!(
        r#"
Welcome {} to the {} server!
Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use ``/link_wolves`` to get full access.
        "#,
        new_member.display_name(),
        &config.server_name,
        &config.wolves_link,
        &config.server,
        &config.bot_channel_id
      );

      if let Err(err) = new_member.user.direct_message(&ctx, |m| m.content(&msg)).await {
        dbg!(err);
      }
    }
  }

  async fn ready(&self, ctx: Context, ready: Ready) {
    println!("[Main] {} is connected!", ready.user.name);
    ctx.set_presence(Some(Activity::playing("with humanity's fate")), OnlineStatus::Online).await;

    match Command::set_global_application_commands(&ctx.http, |commands| {
      commands
        .create_application_command(|command| commands::add_server::register(command))
        .create_application_command(|command| commands::role_adder::edit::register(command))
        .create_application_command(|command| commands::link_email::link::register(command))
        .create_application_command(|command| commands::link_email::verify::register(command))
        .create_application_command(|command| commands::minecraft::server::add::register(command))
        .create_application_command(|command| commands::minecraft::server::list::register(command))
        .create_application_command(|command| commands::minecraft::server::delete::register(command))
        .create_application_command(|command| commands::minecraft::user::add::register(command))
    })
    .await
    {
      Ok(_) => {}
      Err(e) => {
        println!("{:?}", e)
      }
    }
  }

  async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
    if let Interaction::ApplicationCommand(command) = interaction {
      let _ = command.defer_ephemeral(&ctx.http).await;
      //println!("Received command interaction: {:#?}", command);

      let content = match command.data.name.as_str() {
        // user commands
        "link_wolves" => commands::link_email::link::run(&command, &ctx).await,
        "verify" => commands::link_email::verify::run(&command, &ctx).await,
        "link_minecraft" => commands::minecraft::user::add::run(&command, &ctx).await,
        // admin commands
        "add" => commands::add_server::run(&command, &ctx).await,
        "roles_adder" => commands::role_adder::edit::run(&command, &ctx).await,
        "minecraft_add" => commands::minecraft::server::add::run(&command, &ctx).await,
        "minecraft_list" => commands::minecraft::server::list::run(&command, &ctx).await,
        "minecraft_delete" => commands::minecraft::server::delete::run(&command, &ctx).await,
        _ => "not implemented :(".to_string(),
      };

      if let Err(why) = command.edit_original_interaction_response(&ctx.http, |response| response.content(content)).await {
        println!("Cannot respond to slash command: {}", why);
      }
    }
  }

  // handles role updates
  async fn guild_member_update(&self, ctx: Context, _old_data: Option<Member>, new_data: Member) {
    // get config/db
    let db_lock = {
      let data_read = ctx.data.read().await;
      data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
    };

    let db = db_lock.read().await;

    // check if the role changed is part of the oens for this server
    on_role_change(&db, &ctx, new_data).await;
  }
}

#[tokio::main]
async fn main() {
  let config = get_config();
  let db = match db_init(&config).await {
    Ok(x) => x,
    Err(err) => {
      dbg!(err);
      return;
    }
  };

  // Intents are a bitflag, bitwise operations can be used to dictate which intents to use
  let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
  // Build our client.
  let mut client = Client::builder(&config.discord_token, intents)
    .event_handler(Handler {})
    .await
    .expect("Error creating client");

  {
    let mut data = client.data.write().await;

    data.insert::<Config>(Arc::new(RwLock::new(config)));
    data.insert::<DataBase>(Arc::new(RwLock::new(db)));
  }

  // Finally, start a single shard, and start listening to events.
  //
  // Shards will automatically attempt to reconnect, and will perform
  // exponential backoff until it reconnects.
  if let Err(why) = client.start().await {
    println!("Client error: {:?}", why);
  }
}