Kon/src/main.rs

107 lines
3.1 KiB
Rust
Raw Normal View History

2023-12-07 22:01:13 -05:00
mod commands;
2024-01-30 07:17:59 -05:00
mod controllers;
mod models;
2024-03-11 23:24:44 -04:00
mod utils;
2023-12-07 22:01:13 -05:00
use poise::serenity_prelude::{self as serenity};
2024-01-30 07:17:59 -05:00
use std::{
env::var,
error
};
2024-01-11 21:50:38 -05:00
use serenity::{
builder::{
CreateMessage,
CreateEmbed,
CreateEmbedAuthor
},
2024-01-30 07:17:59 -05:00
Context,
Ready,
2024-01-11 21:50:38 -05:00
ClientBuilder,
GatewayIntents
};
2023-12-07 22:01:13 -05:00
2024-01-30 07:17:59 -05:00
type Error = Box<dyn error::Error + Send + Sync>;
2023-12-07 22:01:13 -05:00
2024-01-07 10:40:54 -05:00
pub static EMBED_COLOR: i32 = 0x5a99c7;
static BOT_READY_NOTIFY: u64 = 865673694184996888;
2023-12-07 22:01:13 -05:00
async fn on_ready(
2024-01-30 07:17:59 -05:00
ctx: &Context,
ready: &Ready,
2023-12-07 22:01:13 -05:00
framework: &poise::Framework<(), Error>
) -> Result<(), Error> {
println!("Connected to API as {}", ready.user.name);
let message = CreateMessage::new();
let ready_embed = CreateEmbed::new()
.color(EMBED_COLOR)
.thumbnail(ready.user.avatar_url().unwrap_or_default())
.author(CreateEmbedAuthor::new(format!("{} ({}) is ready!", ready.user.name, &**utils::BOT_VERSION)).clone());
serenity::ChannelId::new(BOT_READY_NOTIFY).send_message(&ctx.http, message.add_embed(ready_embed)).await?;
2023-12-07 22:01:13 -05:00
let register_commands = var("REGISTER_CMDS").unwrap_or_else(|_| String::from("true")).parse::<bool>().unwrap_or(true);
2023-12-07 22:01:13 -05:00
if register_commands {
let builder = poise::builtins::create_application_commands(&framework.options().commands);
let commands = serenity::Command::set_global_commands(&ctx.http, builder).await;
2023-12-07 22:01:13 -05:00
match commands {
Ok(cmdmap) => for command in cmdmap.iter() {
println!("Registered command globally: {}", command.name);
},
2023-12-07 22:01:13 -05:00
Err(why) => println!("Error registering commands: {:?}", why)
}
}
Ok(())
}
#[tokio::main]
async fn main() {
let token = var("DISCORD_TOKEN").expect("Expected a \"DISCORD_TOKEN\" in the envvar but none was found");
2024-01-30 07:17:59 -05:00
let db = controllers::database::DatabaseController::new().await.expect("Failed to connect to database");
2023-12-07 22:01:13 -05:00
let framework = poise::Framework::builder()
2023-12-07 22:01:13 -05:00
.options(poise::FrameworkOptions {
commands: vec![
commands::ping::ping(),
2024-01-06 22:38:37 -05:00
commands::uptime::uptime(),
2024-01-30 13:22:08 -05:00
commands::status::status(),
commands::gameserver::gameserver()
2023-12-07 22:01:13 -05:00
],
pre_command: |ctx| Box::pin(async move {
2023-12-09 20:53:10 -05:00
let get_guild_name = match ctx.guild() {
Some(guild) => guild.name.clone(),
None => String::from("DM")
};
println!("[{}] {} ran /{}", get_guild_name, ctx.author().name, ctx.command().qualified_name)
2023-12-07 22:01:13 -05:00
}),
on_error: |error| Box::pin(async move {
match error {
poise::FrameworkError::Command { error, ctx, .. } => {
println!("PoiseCommandError({}): {}", ctx.command().qualified_name, error);
}
other => println!("PoiseOtherError: {:?}", other)
}
}),
2024-01-30 07:17:59 -05:00
initialize_owners: true,
2023-12-07 22:01:13 -05:00
..Default::default()
2023-12-10 04:56:25 -05:00
})
.setup(|ctx, ready, framework| Box::pin(on_ready(ctx, ready, framework)))
.build();
2024-01-30 07:17:59 -05:00
let mut client = ClientBuilder::new(token, GatewayIntents::GUILDS)
.framework(framework)
.await.expect("Error creating client");
{
let mut data = client.data.write().await;
data.insert::<controllers::database::DatabaseController>(db);
}
2023-12-07 22:01:13 -05:00
if let Err(why) = client.start().await {
println!("Client error: {:?}", why);
}
}