122 lines
3.4 KiB
Rust
122 lines
3.4 KiB
Rust
use serenity::{
|
|
all::{CommandDataOption, CommandDataOptionValue, CommandInteraction},
|
|
client::Context,
|
|
};
|
|
use skynet_discord_bot::common::{
|
|
database::{get_server_config, DataBase, Servers},
|
|
set_roles::normal::update_server,
|
|
wolves::cns::get_wolves,
|
|
};
|
|
use sqlx::{Error, Pool, Sqlite};
|
|
|
|
pub async fn run(command: &CommandInteraction, ctx: &Context) -> String {
|
|
let Some(CommandDataOption {
|
|
value: CommandDataOptionValue::SubCommand(sub_options),
|
|
..
|
|
}) = command.data.options.first()
|
|
else {
|
|
return "Please provide sub options".to_string();
|
|
};
|
|
|
|
let Some(CommandDataOptionValue::String(wolves_api)) = sub_options.first().map(|opt| &opt.value) else {
|
|
return "Please provide a wolves API key".to_string();
|
|
};
|
|
|
|
let Some(&CommandDataOptionValue::Role(role_current)) = sub_options.get(1).map(|opt| &opt.value) else {
|
|
return "Please provide a valid role for ``Role Current``".to_string();
|
|
};
|
|
|
|
let role_past = if let Some(x) = sub_options.get(5) {
|
|
match &x.value {
|
|
CommandDataOptionValue::Role(role) => Some(role.to_owned()),
|
|
_ => None,
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let Some(&CommandDataOptionValue::Channel(bot_channel_id)) = sub_options.get(2).map(|opt| &opt.value) else {
|
|
return "Please provide a valid channel for ``Bot Channel``".to_string();
|
|
};
|
|
|
|
let db = {
|
|
let data_read = ctx.data.read().await;
|
|
data_read.get::<DataBase>().expect("Expected Databse in TypeMap.").clone()
|
|
};
|
|
|
|
let server_data = Servers {
|
|
server: command.guild_id.unwrap_or_default(),
|
|
wolves_api: wolves_api.to_string(),
|
|
wolves_id: 0,
|
|
role_past,
|
|
role_current,
|
|
member_past: 0,
|
|
member_current: 0,
|
|
bot_channel_id,
|
|
};
|
|
|
|
if let Err(e) = add_server(&db, ctx, &server_data).await {
|
|
println!("{e:?}");
|
|
return format!("Failure to insert into Servers {server_data:?}");
|
|
}
|
|
|
|
"Added/Updated server info".to_string()
|
|
}
|
|
|
|
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.get() as i64);
|
|
|
|
let insert = sqlx::query_as::<_, Servers>(
|
|
"
|
|
INSERT OR REPLACE INTO servers (server, wolves_api, role_past, role_current, bot_channel_id)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
",
|
|
)
|
|
.bind(server.server.get() as i64)
|
|
.bind(&server.wolves_api)
|
|
.bind(role_past)
|
|
.bind(server.role_current.get() as i64)
|
|
.bind(server.bot_channel_id.get() as i64)
|
|
.fetch_optional(db)
|
|
.await;
|
|
|
|
// if the entry does not exist already then do a user update
|
|
let (update, current_remove, current_role, past_remove, past_role) = match &existing {
|
|
None => (true, false, None, false, None),
|
|
Some(x) => {
|
|
let mut result = (false, false, None, false, None);
|
|
if x.wolves_api != server.wolves_api {
|
|
result.0 = true;
|
|
}
|
|
if x.role_current != server.role_current {
|
|
result.0 = true;
|
|
result.1 = true;
|
|
result.2 = Some(x.role_current);
|
|
}
|
|
if x.role_past != server.role_past {
|
|
result.0 = true;
|
|
result.3 = true;
|
|
result.4 = x.role_past;
|
|
}
|
|
result
|
|
}
|
|
};
|
|
|
|
// update all users
|
|
if update {
|
|
// handle wolves api here
|
|
get_wolves(ctx).await;
|
|
|
|
let mut roles_remove = vec![];
|
|
if current_remove {
|
|
roles_remove.push(current_role)
|
|
}
|
|
if past_remove {
|
|
roles_remove.push(past_role)
|
|
}
|
|
update_server(ctx, server, &roles_remove, &[]).await;
|
|
}
|
|
|
|
insert
|
|
}
|