Skynet/discord-bot
6
0
Fork 2
Code Issues 3 Pull requests Projects 1 Releases Packages Wiki Activity Actions

Compare commits

base: Skynet:d1af8a7c1faa7bfd597d9948f71f1bcb3293148b
Branches Tags
Skynet:main
Skynet:#17-automate-onboarding-mk-ii
Skynet:#22_Role-Joiner
Skynet:#21_Normalise-email-inputs
Skynet:#6-incrimental-updating
..
compare: Skynet:42f301455a18a8d3a023374b3d7b21a067c286c0
Branches Tags
Skynet:main
Skynet:#17-automate-onboarding-mk-ii
Skynet:#22_Role-Joiner
Skynet:#21_Normalise-email-inputs
Skynet:#6-incrimental-updating

No commits in common. "d1af8a7c1faa7bfd597d9948f71f1bcb3293148b" and "42f301455a18a8d3a023374b3d7b21a067c286c0" have entirely different histories.
d1af8a7c1f ... 42f301455a

5 changed files with 4 additions and 311 deletions
Show stats Expand all files Collapse all files

11
db/migrations/6_role-adder.sql
View file

@ -1,11 +0,0 @@
CREATE TABLE IF NOT EXISTS roles_adder (
server integer not null,
role_a integer not null,
role_b integer not null,
role_c integer not null,
PRIMARY KEY(server,role_a,role_b,role_c)
);
CREATE INDEX IF NOT EXISTS index_roles_adder_server ON roles_adder (server);
CREATE INDEX IF NOT EXISTS index_roles_adder_from ON roles_adder (role_a,role_b);
CREATE INDEX IF NOT EXISTS index_roles_adder_to ON roles_adder (role_c);
CREATE INDEX IF NOT EXISTS index_roles_adder_search ON roles_adder (server,role_a,role_b);

1
src/commands/mod.rs
View file

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

247
src/commands/role_adder.rs
View file

@ -1,247 +0,0 @@
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();
};
if role_a == role_b {
return "Roles A and B must be different".to_string();
}
if (role_c == role_a) || (role_c == role_b) {
return "Role C cannot be same as A or B".to_string();
}
let mut delete = false;
if let Some(x) = command.data.options.get(3) {
let tmp = x.to_owned();
if let Some(y) = tmp.resolved {
match y {
CommandDataOptionValue::Boolean(z) => {
delete = z;
}
_ => {}
}
}
}
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 = command.guild_id.unwrap_or_default();
let server_data = RoleAdder {
server,
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);
}
}
let mut role_a_name = String::new();
let mut role_b_name = String::new();
let mut role_c_name = String::new();
if let Ok(x) = server.roles(&ctx).await {
if let Some(y) = x.get(&role_a) {
role_a_name = y.to_owned().name;
}
if let Some(y) = x.get(&role_b) {
role_b_name = y.to_owned().name;
}
if let Some(y) = x.get(&role_b) {
role_c_name = y.to_owned().name;
}
}
if delete {
format!("Removed {} + {} = {}", role_a_name, role_b_name, role_c_name)
} else {
format!("Added {} + {} = {}", role_a_name, role_b_name, role_c_name)
}
}
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 {}
pub mod tools {
use serenity::client::Context;
use serenity::model::guild::Member;
use skynet_discord_bot::RoleAdder;
use sqlx::{Pool, Sqlite};
pub async fn on_role_change(db: &Pool<Sqlite>, ctx: &Context, mut new_data: Member) {
// check if the role changed is part of the oens for this server
if let Some(role_adders) = sqlx::query_as::<_, RoleAdder>(
r#"
SELECT *
FROM roles_adder
WHERE server = ?
"#,
)
.bind(*new_data.guild_id.as_u64() as i64)
.fetch_all(db)
.await
.ok()
{
let mut roles_add = vec![];
let mut roles_remove = vec![];
for role_adder in role_adders {
// if the user has both A dnd B give them C
if new_data.roles.contains(&role_adder.role_a) && new_data.roles.contains(&role_adder.role_b) && !new_data.roles.contains(&role_adder.role_c)
{
roles_add.push(role_adder.role_c);
}
// If the suer has C but not A or B remove C
if new_data.roles.contains(&role_adder.role_c)
&& (!new_data.roles.contains(&role_adder.role_a) || !new_data.roles.contains(&role_adder.role_b))
{
roles_remove.push(role_adder.role_c);
}
}
if !roles_add.is_empty() {
if let Err(e) = new_data.add_roles(&ctx, &roles_add).await {
println!("{:?}", e);
}
}
if !roles_remove.is_empty() {
if let Err(e) = new_data.remove_roles(&ctx, &roles_remove).await {
println!("{:?}", e);
}
}
}
}
}

31
src/lib.rs
View file

@ -293,37 +293,6 @@ impl<'r> FromRow<'r, SqliteRow> for Minecraft {
} }
} }
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RoleAdder {
pub server: GuildId,
pub role_a: RoleId,
pub role_b: RoleId,
pub role_c: RoleId,
}
impl<'r> FromRow<'r, SqliteRow> for RoleAdder {
fn from_row(row: &'r SqliteRow) -> Result<Self, Error> {
let server_tmp: i64 = row.try_get("server")?;
let server = GuildId::from(server_tmp as u64);
Ok(Self {
server,
role_a: get_role_from_row(row, "role_a"),
role_b: get_role_from_row(row, "role_b"),
role_c: get_role_from_row(row, "role_c"),
})
}
}
fn get_role_from_row(row: &SqliteRow, col: &str) -> RoleId {
match row.try_get(col) {
Ok(x) => {
let tmp: i64 = x;
RoleId(tmp as u64)
}
_ => RoleId::from(0u64),
}
}
pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> { pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
let database = format!("{}/{}", &config.home, &config.database); let database = format!("{}/{}", &config.home, &config.database);

25
src/main.rs
View file

@ -1,28 +1,27 @@
pub mod commands; pub mod commands;
use crate::commands::role_adder::tools::on_role_change;
use serenity::model::guild::Member;
use serenity::{ use serenity::{
async_trait, async_trait,
client::{Context, EventHandler}, client::{Context, EventHandler},
model::{ model::{
application::{command::Command, interaction::Interaction}, application::{command::Command, interaction::Interaction},
gateway::{GatewayIntents, Ready}, gateway::{GatewayIntents, Ready},
guild,
prelude::Activity, prelude::Activity,
user::OnlineStatus, user::OnlineStatus,
}, },
Client, Client,
}; };
use skynet_discord_bot::{db_init, get_config, get_server_config, get_server_member, Config, DataBase};
use std::sync::Arc; use std::sync::Arc;
use skynet_discord_bot::{db_init, get_config, get_server_config, get_server_member, Config, DataBase};
use tokio::sync::RwLock; use tokio::sync::RwLock;
struct Handler; struct Handler;
#[async_trait] #[async_trait]
impl EventHandler for Handler { impl EventHandler for Handler {
// handles previously linked accounts joining the server async fn guild_member_addition(&self, ctx: Context, mut new_member: guild::Member) {
async fn guild_member_addition(&self, ctx: Context, mut new_member: Member) {
let db_lock = { let db_lock = {
let data_read = ctx.data.read().await; let data_read = ctx.data.read().await;
data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone() data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
@ -76,7 +75,6 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
match Command::set_global_application_commands(&ctx.http, |commands| { match Command::set_global_application_commands(&ctx.http, |commands| {
commands commands
.create_application_command(|command| commands::add_server::register(command)) .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::link::register(command))
.create_application_command(|command| commands::link_email::verify::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::add::register(command))
@ -108,7 +106,6 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
"link_minecraft" => commands::minecraft::user::add::run(&command, &ctx).await, "link_minecraft" => commands::minecraft::user::add::run(&command, &ctx).await,
// admin commands // admin commands
"add" => commands::add_server::run(&command, &ctx).await, "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_add" => commands::minecraft::server::add::run(&command, &ctx).await,
"minecraft_list" => commands::minecraft::server::list::run(&command, &ctx).await, "minecraft_list" => commands::minecraft::server::list::run(&command, &ctx).await,
"minecraft_delete" => commands::minecraft::server::delete::run(&command, &ctx).await, "minecraft_delete" => commands::minecraft::server::delete::run(&command, &ctx).await,
@ -123,20 +120,6 @@ Sign up on [UL Wolves]({}) and go to https://discord.com/channels/{}/{} and use
} }
} }
} }
// 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] #[tokio::main]