1156 lines
35 KiB
Rust
1156 lines
35 KiB
Rust
#[macro_use]
|
|
extern crate lazy_static;
|
|
|
|
extern crate reqwest;
|
|
|
|
mod guilddata;
|
|
mod sound;
|
|
mod error;
|
|
|
|
use sound::Sound;
|
|
use guilddata::GuildData;
|
|
|
|
use serenity::{
|
|
client::{
|
|
bridge::{
|
|
gateway::GatewayIntents,
|
|
voice::ClientVoiceManager,
|
|
},
|
|
Client, Context,
|
|
},
|
|
framework::standard::{
|
|
Args, CommandError, CommandResult, CheckResult, DispatchError, StandardFramework, Reason,
|
|
macros::{
|
|
command, group, check, hook,
|
|
}
|
|
},
|
|
model::{
|
|
channel::{
|
|
Channel,
|
|
Message,
|
|
},
|
|
guild::Guild,
|
|
id::{
|
|
GuildId,
|
|
RoleId,
|
|
UserId,
|
|
},
|
|
voice::VoiceState,
|
|
},
|
|
prelude::{
|
|
Mutex as SerenityMutex,
|
|
*
|
|
},
|
|
voice::Handler as VoiceHandler,
|
|
};
|
|
|
|
use sqlx::{
|
|
Pool,
|
|
mysql::{
|
|
MySqlPool,
|
|
MySqlConnection,
|
|
}
|
|
};
|
|
|
|
use dotenv::dotenv;
|
|
|
|
use tokio::{
|
|
sync::{
|
|
RwLock,
|
|
RwLockWriteGuard,
|
|
},
|
|
time,
|
|
};
|
|
|
|
use std::{
|
|
collections::HashMap,
|
|
env,
|
|
sync::Arc,
|
|
time::{
|
|
Duration,
|
|
SystemTime,
|
|
UNIX_EPOCH,
|
|
},
|
|
};
|
|
|
|
|
|
struct SQLPool;
|
|
|
|
impl TypeMapKey for SQLPool {
|
|
type Value = Pool<MySqlConnection>;
|
|
}
|
|
|
|
struct VoiceManager;
|
|
|
|
impl TypeMapKey for VoiceManager {
|
|
type Value = Arc<SerenityMutex<ClientVoiceManager>>;
|
|
}
|
|
|
|
struct VoiceGuilds;
|
|
|
|
impl TypeMapKey for VoiceGuilds {
|
|
type Value = Arc<RwLock<HashMap<GuildId, u64>>>;
|
|
}
|
|
|
|
struct ReqwestClient;
|
|
|
|
impl TypeMapKey for ReqwestClient {
|
|
type Value = Arc<reqwest::Client>;
|
|
}
|
|
|
|
static THEME_COLOR: u32 = 0x00e0f3;
|
|
|
|
lazy_static! {
|
|
static ref MAX_SOUNDS: u32 = {
|
|
dotenv().unwrap();
|
|
env::var("MAX_SOUNDS").unwrap().parse::<u32>().unwrap()
|
|
};
|
|
|
|
static ref PATREON_GUILD: u64 = {
|
|
dotenv().unwrap();
|
|
env::var("PATREON_GUILD").unwrap().parse::<u64>().unwrap()
|
|
};
|
|
|
|
static ref PATREON_ROLE: u64 = {
|
|
dotenv().unwrap();
|
|
env::var("PATREON_ROLE").unwrap().parse::<u64>().unwrap()
|
|
};
|
|
}
|
|
|
|
#[group]
|
|
#[commands(info, help, list_sounds, change_public, search_sounds, show_popular_sounds, show_random_sounds, set_greet_sound)]
|
|
#[checks(self_perm_check)]
|
|
struct AllUsers;
|
|
|
|
#[group]
|
|
#[commands(play, upload_new_sound, change_volume, delete_sound, stop_playing)]
|
|
#[checks(self_perm_check, role_check)]
|
|
struct RoleManagedUsers;
|
|
|
|
#[group]
|
|
#[commands(change_prefix, set_allowed_roles, allow_greet_sounds)]
|
|
#[checks(self_perm_check, permission_check)]
|
|
struct PermissionManagedUsers;
|
|
|
|
#[check]
|
|
#[name("self_perm_check")]
|
|
async fn self_perm_check(ctx: &Context, msg: &Message, _args: &mut Args) -> CheckResult {
|
|
let channel_o = msg.channel(&ctx).await;
|
|
|
|
if let Some(channel_e) = channel_o {
|
|
if let Channel::Guild(channel) = channel_e {
|
|
let permissions_r = channel.permissions_for_user(&ctx, &ctx.cache.current_user_id().await).await;
|
|
|
|
if let Ok(permissions) = permissions_r {
|
|
if permissions.send_messages() && permissions.embed_links() {
|
|
CheckResult::Success
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::Log("Bot does not have enough permissions".to_string()))
|
|
}
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::Log("No perms found".to_string()))
|
|
}
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::Log("No DM commands".to_string()))
|
|
}
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::Log("Channel not available".to_string()))
|
|
}
|
|
}
|
|
|
|
#[check]
|
|
#[name("role_check")]
|
|
async fn role_check(ctx: &Context, msg: &Message, _args: &mut Args) -> CheckResult {
|
|
|
|
async fn check_for_roles(ctx: &&Context, msg: &&Message) -> CheckResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let guild_opt = msg.guild(&ctx).await;
|
|
|
|
match guild_opt {
|
|
Some(guild) => {
|
|
let member_res = guild.member(*ctx, msg.author.id).await;
|
|
|
|
match member_res {
|
|
Ok(member) => {
|
|
let user_roles: String = member.roles
|
|
.iter()
|
|
.map(|r| (*r.as_u64()).to_string())
|
|
.collect::<Vec<String>>()
|
|
.join(", ");
|
|
|
|
let guild_id = *msg.guild_id.unwrap().as_u64();
|
|
|
|
let role_res = sqlx::query!(
|
|
"
|
|
SELECT COUNT(1) as count
|
|
FROM roles
|
|
WHERE
|
|
(guild_id = ? AND role IN (?)) OR
|
|
(role = ?)
|
|
",
|
|
guild_id, user_roles, guild_id
|
|
)
|
|
.fetch_one(&pool).await;
|
|
|
|
match role_res {
|
|
Ok(role_count) => {
|
|
if role_count.count > 0 {
|
|
CheckResult::Success
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::User("User has not got a sufficient role. Use `?roles` to set up role restrictions".to_string()))
|
|
}
|
|
}
|
|
|
|
Err(_) => {
|
|
CheckResult::Failure(Reason::User("User has not got a sufficient role. Use `?roles` to set up role restrictions".to_string()))
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(_) => {
|
|
CheckResult::Failure(Reason::User("Unexpected error looking up user roles".to_string()))
|
|
}
|
|
}
|
|
}
|
|
|
|
None => {
|
|
CheckResult::Failure(Reason::User("Unexpected error looking up guild".to_string()))
|
|
}
|
|
}
|
|
}
|
|
|
|
if perform_permission_check(ctx, &msg).await.is_success() {
|
|
CheckResult::Success
|
|
}
|
|
else {
|
|
check_for_roles(&ctx, &msg).await
|
|
}
|
|
}
|
|
|
|
#[check]
|
|
#[name("permission_check")]
|
|
async fn permission_check(ctx: &Context, msg: &Message, _args: &mut Args) -> CheckResult {
|
|
perform_permission_check(ctx, &msg).await
|
|
}
|
|
|
|
async fn perform_permission_check(ctx: &Context, msg: &&Message) -> CheckResult {
|
|
if let Some(guild) = msg.guild(&ctx).await {
|
|
if guild.member_permissions(&msg.author).manage_guild() {
|
|
CheckResult::Success
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::User(String::from("User needs `Manage Guild` permission")))
|
|
}
|
|
}
|
|
else {
|
|
CheckResult::Failure(Reason::User(String::from("Guild not cached")))
|
|
}
|
|
}
|
|
|
|
// create event handler for bot
|
|
struct Handler;
|
|
|
|
#[serenity::async_trait]
|
|
impl EventHandler for Handler {
|
|
async fn guild_create(&self, ctx: Context, _guild: Guild, is_new: bool) {
|
|
if is_new {
|
|
if let Ok(token) = env::var("DISCORDBOTS_TOKEN") {
|
|
let guild_count = ctx.cache.guild_count().await;
|
|
|
|
let mut hm = HashMap::new();
|
|
hm.insert("server_count", guild_count);
|
|
|
|
let client = ctx.data.read().await
|
|
.get::<ReqwestClient>().cloned().expect("Could not get ReqwestClient from data");
|
|
|
|
let response = client.post(format!("https://top.gg/api/bots/{}/stats", ctx.cache.current_user_id().await.as_u64()).as_str())
|
|
.header("Authorization", token)
|
|
.json(&hm)
|
|
.send()
|
|
.await;
|
|
|
|
if let Err(res) = response {
|
|
println!("DiscordBots Response: {:?}", res);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn voice_state_update(&self, ctx: Context, guild_id_opt: Option<GuildId>, old: Option<VoiceState>, new: VoiceState) {
|
|
if let (Some(guild_id), Some(user_channel)) = (guild_id_opt, new.channel_id) {
|
|
|
|
if old.is_none() {
|
|
|
|
if let Some(guild) = ctx.cache.guild(guild_id).await {
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let guild_data_opt = GuildData::get_from_id(guild, pool.clone()).await;
|
|
|
|
if let Some(guild_data) = guild_data_opt {
|
|
if guild_data.allow_greets {
|
|
let join_id_res = sqlx::query!(
|
|
"
|
|
SELECT join_sound_id
|
|
FROM users
|
|
WHERE user = ? AND join_sound_id IS NOT NULL
|
|
",
|
|
new.user_id.as_u64()
|
|
)
|
|
.fetch_one(&pool)
|
|
.await;
|
|
|
|
if let Ok(join_id_record) = join_id_res {
|
|
|
|
let join_id = join_id_record.join_sound_id;
|
|
|
|
let mut sound = sqlx::query_as_unchecked!(
|
|
Sound,
|
|
"
|
|
SELECT name, id, plays, public, server_id, uploader_id
|
|
FROM sounds
|
|
WHERE id = ?
|
|
",
|
|
join_id
|
|
)
|
|
.fetch_one(&pool)
|
|
.await.unwrap();
|
|
|
|
let voice_manager_lock = ctx.data.read().await
|
|
.get::<VoiceManager>().cloned().expect("Could not get VoiceManager from data");
|
|
|
|
let voice_guilds_lock = ctx.data.read().await
|
|
.get::<VoiceGuilds>().cloned().expect("Could not get VoiceGuilds from data");
|
|
|
|
let voice_guilds = voice_guilds_lock.write().await;
|
|
|
|
let mut voice_manager = voice_manager_lock.lock().await;
|
|
|
|
if let Some(handler) = voice_manager.join(guild_id, user_channel) {
|
|
let _audio = play_audio(&mut sound, guild_data, handler, voice_guilds, pool).await;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn play_audio(sound: &mut Sound, guild: GuildData, handler: &mut VoiceHandler, mut voice_guilds: RwLockWriteGuard<'_, HashMap<GuildId, u64>>, pool: MySqlPool)
|
|
-> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
|
|
let audio = handler.play_only(sound.store_sound_source(pool.clone()).await?);
|
|
|
|
{
|
|
let mut locked = audio.lock().await;
|
|
|
|
locked.volume(guild.volume as f32 / 100.0);
|
|
}
|
|
|
|
sound.plays += 1;
|
|
sound.commit(pool).await?;
|
|
|
|
let start = SystemTime::now();
|
|
let since_epoch = start.duration_since(UNIX_EPOCH).unwrap();
|
|
|
|
voice_guilds.insert(GuildId(guild.id), since_epoch.as_secs());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[hook]
|
|
async fn log_errors(_: &Context, m: &Message, cmd_name: &str, error: Result<(), CommandError>) {
|
|
if let Err(e) = error {
|
|
println!("Error in command {} ({}): {:?}", cmd_name, m.content, e);
|
|
}
|
|
}
|
|
|
|
#[hook]
|
|
async fn dispatch_error_hook(ctx: &Context, msg: &Message, error: DispatchError) {
|
|
match error {
|
|
DispatchError::CheckFailed(_f, reason) => {
|
|
if let Reason::User(description) = reason {
|
|
let _ = msg.reply(ctx, format!("You cannot do this command: {}", description)).await;
|
|
}
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
// entry point
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
|
|
dotenv()?;
|
|
|
|
let voice_guilds = Arc::new(RwLock::new(HashMap::new()));
|
|
|
|
let framework = StandardFramework::new()
|
|
.configure(|c| c
|
|
.dynamic_prefix(|ctx, msg| Box::pin(async move {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let guild = match msg.guild(&ctx.cache).await {
|
|
Some(guild) => guild,
|
|
|
|
None => {
|
|
return Some(String::from("?"));
|
|
}
|
|
};
|
|
|
|
match GuildData::get_from_id(guild.clone(), pool.clone()).await {
|
|
Some(mut guild_data) => {
|
|
let name = Some(guild.name);
|
|
|
|
if guild_data.name != name {
|
|
guild_data.name = name;
|
|
guild_data.commit(pool).await.unwrap();
|
|
}
|
|
Some(guild_data.prefix)
|
|
},
|
|
|
|
None => {
|
|
GuildData::create_from_guild(guild, pool).await.unwrap();
|
|
Some(String::from("?"))
|
|
}
|
|
}
|
|
}))
|
|
.allow_dm(false)
|
|
.ignore_bots(true)
|
|
.ignore_webhooks(true)
|
|
.on_mention(env::var("CLIENT_ID")
|
|
.and_then(|val| Ok(UserId(val.parse::<u64>().expect("CLIENT_ID not valid")))).ok())
|
|
)
|
|
.group(&ALLUSERS_GROUP)
|
|
.group(&ROLEMANAGEDUSERS_GROUP)
|
|
.group(&PERMISSIONMANAGEDUSERS_GROUP)
|
|
.after(log_errors)
|
|
.on_dispatch_error(dispatch_error_hook);
|
|
|
|
let mut client = Client::new(&env::var("DISCORD_TOKEN").expect("Missing token from environment"))
|
|
.intents(GatewayIntents::GUILD_VOICE_STATES | GatewayIntents::GUILD_MESSAGES | GatewayIntents::GUILDS)
|
|
.framework(framework)
|
|
.event_handler(Handler)
|
|
.await.expect("Error occurred creating client");
|
|
|
|
{
|
|
let pool = MySqlPool::new(&env::var("DATABASE_URL").expect("No database URL provided")).await.unwrap();
|
|
|
|
let mut data = client.data.write().await;
|
|
data.insert::<SQLPool>(pool);
|
|
|
|
data.insert::<VoiceManager>(Arc::clone(&client.voice_manager));
|
|
|
|
data.insert::<VoiceGuilds>(voice_guilds.clone());
|
|
|
|
data.insert::<ReqwestClient>(Arc::new(reqwest::Client::new()));
|
|
}
|
|
|
|
let cvm = Arc::clone(&client.voice_manager);
|
|
|
|
tokio::spawn(async {
|
|
let disconnect_cycle_delay = env::var("DISCONNECT_CYCLE_DELAY")
|
|
.unwrap_or("300".to_string())
|
|
.parse::<u64>().expect("DISCONNECT_CYCLE_DELAY invalid");
|
|
|
|
disconnect_from_inactive(cvm, voice_guilds, disconnect_cycle_delay).await
|
|
});
|
|
|
|
client.start_autosharded().await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn disconnect_from_inactive(voice_manager_mutex: Arc<SerenityMutex<ClientVoiceManager>>, voice_guilds: Arc<RwLock<HashMap<GuildId, u64>>>, wait_time: u64) {
|
|
loop {
|
|
time::delay_for(Duration::from_secs(wait_time)).await;
|
|
|
|
let voice_guilds_acquired = voice_guilds.read().await;
|
|
|
|
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
|
|
|
|
for (guild, last_active) in voice_guilds_acquired.iter() {
|
|
|
|
if (now - last_active) > wait_time {
|
|
|
|
let mut voice_manager = voice_manager_mutex.lock().await;
|
|
|
|
let manager_opt = voice_manager.get_mut(guild);
|
|
|
|
if let Some(manager) = manager_opt {
|
|
manager.leave();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[command("play")]
|
|
#[aliases("p")]
|
|
async fn play(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
|
|
let guild = match msg.guild(&ctx.cache).await {
|
|
Some(guild) => guild,
|
|
|
|
None => {
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let guild_id = guild.id;
|
|
|
|
let channel_to_join = guild
|
|
.voice_states.get(&msg.author.id)
|
|
.and_then(|voice_state| voice_state.channel_id);
|
|
|
|
match channel_to_join {
|
|
Some(user_channel) => {
|
|
let search_term = args.rest();
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let mut sound_vec = Sound::search_for_sound(
|
|
search_term,
|
|
*guild_id.as_u64(),
|
|
*msg.author.id.as_u64(),
|
|
pool.clone(),
|
|
true).await?;
|
|
|
|
let sound_res = sound_vec.first_mut();
|
|
|
|
match sound_res {
|
|
Some(sound) => {
|
|
let voice_manager_lock = ctx.data.read().await
|
|
.get::<VoiceManager>().cloned().expect("Could not get VoiceManager from data");
|
|
|
|
let mut voice_manager = voice_manager_lock.lock().await;
|
|
|
|
match voice_manager.join(guild_id, user_channel) {
|
|
Some(handler) => {
|
|
let guild_data = GuildData::get_from_id(guild, pool.clone()).await.unwrap();
|
|
|
|
let voice_guilds_lock = ctx.data.read().await
|
|
.get::<VoiceGuilds>().cloned().expect("Could not get VoiceGuilds from data");
|
|
|
|
let voice_guilds = voice_guilds_lock.write().await;
|
|
|
|
play_audio(sound, guild_data, handler, voice_guilds, pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, format!("Playing sound {} with ID {}", sound.name, sound.id)).await?;
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Failed to join channel").await?;
|
|
}
|
|
};
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Couldn't find sound by term provided").await?;
|
|
}
|
|
}
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "You are not in a voice chat!").await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command]
|
|
async fn help(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
msg.channel_id.send_message(&ctx, |m| m
|
|
.embed(|e| e
|
|
.title("Help")
|
|
.color(THEME_COLOR)
|
|
.description("Please visit our website at https://soundfx.jellywx.com/help"))).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command]
|
|
async fn info(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
|
|
msg.channel_id.send_message(&ctx, |m| m
|
|
.embed(|e| e
|
|
.title("Info")
|
|
.color(THEME_COLOR)
|
|
.description(format!("Default prefix: `?`
|
|
|
|
Reset prefix: `<@{0}> prefix ?`
|
|
|
|
Invite me: https://discordapp.com/oauth2/authorize?client_id={0}&scope=bot&permissions=36703232
|
|
|
|
**Welcome to SoundFX!**
|
|
Developer: <@203532103185465344>
|
|
Find me on https://discord.jellywx.com/ and on https://github.com/JellyWX :)
|
|
|
|
**An online dashboard is available!** Visit https://soundfx.jellywx.com/dashboard
|
|
There is a maximum sound limit per user. This can be removed by donating at https://patreon.com/jellywx", env::var("CLIENT_ID").unwrap())))).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("volume")]
|
|
async fn change_volume(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
|
|
let guild = match msg.guild(&ctx.cache).await {
|
|
Some(guild) => guild,
|
|
|
|
None => {
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let guild_data_opt = GuildData::get_from_id(guild, pool.clone()).await;
|
|
let mut guild_data = guild_data_opt.unwrap();
|
|
|
|
if args.len() == 1 {
|
|
match args.single::<u8>() {
|
|
Ok(volume) => {
|
|
guild_data.volume = volume;
|
|
|
|
guild_data.commit(pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, format!("Volume changed to {}%", volume)).await?;
|
|
}
|
|
|
|
Err(_) => {
|
|
msg.channel_id.say(&ctx,
|
|
format!("Current server volume: {vol}%. Change the volume with ```{prefix}volume <new volume>```",
|
|
vol = guild_data.volume, prefix = guild_data.prefix)).await?;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
msg.channel_id.say(&ctx,
|
|
format!("Current server volume: {vol}%. Change the volume with ```{prefix}volume <new volume>```",
|
|
vol = guild_data.volume, prefix = guild_data.prefix)).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("prefix")]
|
|
async fn change_prefix(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
|
|
let guild = match msg.guild(&ctx.cache).await {
|
|
Some(guild) => guild,
|
|
|
|
None => {
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let mut guild_data;
|
|
|
|
{
|
|
let guild_data_opt = GuildData::get_from_id(guild, pool.clone()).await;
|
|
|
|
guild_data = guild_data_opt.unwrap();
|
|
}
|
|
|
|
if args.len() == 1 {
|
|
match args.single::<String>() {
|
|
Ok(prefix) => {
|
|
if prefix.len() <= 5 {
|
|
guild_data.prefix = prefix;
|
|
|
|
guild_data.commit(pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, format!("Prefix changed to `{}`", guild_data.prefix)).await?;
|
|
}
|
|
else {
|
|
msg.channel_id.say(&ctx, "Prefix must be less than 5 characters long").await?;
|
|
}
|
|
}
|
|
|
|
Err(_) => {
|
|
msg.channel_id.say(&ctx, format!("Usage: `{prefix}prefix <new prefix>`", prefix = guild_data.prefix)).await?;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
msg.channel_id.say(&ctx, format!("Usage: `{prefix}prefix <new prefix>`", prefix = guild_data.prefix)).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("upload")]
|
|
async fn upload_new_sound(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
|
|
fn is_numeric(s: &String) -> bool {
|
|
for char in s.chars() {
|
|
if char.is_digit(10) {
|
|
continue;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
let new_name = args.rest().to_string();
|
|
|
|
if !new_name.is_empty() && new_name.len() <= 20 {
|
|
|
|
if !is_numeric(&new_name) {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
// need to check the name is not currently in use by the user
|
|
let count_name = Sound::count_named_user_sounds(*msg.author.id.as_u64(), &new_name, pool.clone()).await?;
|
|
if count_name > 0 {
|
|
msg.channel_id.say(&ctx, "You are already using that name. Please choose a unique name for your upload.").await?;
|
|
} else {
|
|
// need to check how many sounds user currently has
|
|
let count = Sound::count_user_sounds(*msg.author.id.as_u64(), pool.clone()).await?;
|
|
let mut permit_upload = true;
|
|
|
|
// need to check if user is patreon or nah
|
|
if count >= *MAX_SOUNDS {
|
|
let patreon_guild_member = GuildId(*PATREON_GUILD).member(ctx, msg.author.id).await;
|
|
|
|
if let Ok(member) = patreon_guild_member {
|
|
permit_upload = member.roles.contains(&RoleId(*PATREON_ROLE));
|
|
} else {
|
|
permit_upload = false;
|
|
}
|
|
}
|
|
|
|
if permit_upload {
|
|
msg.channel_id.say(&ctx, "Please now upload an audio file under 1MB in size (larger files will be automatically trimmed):").await?;
|
|
|
|
let reply = msg.channel_id.await_reply(&ctx)
|
|
.author_id(msg.author.id)
|
|
.timeout(Duration::from_secs(30))
|
|
.await;
|
|
|
|
match reply {
|
|
Some(reply_msg) => {
|
|
if reply_msg.attachments.len() == 1 {
|
|
match Sound::create_anon(
|
|
&new_name,
|
|
&reply_msg.attachments[0].url,
|
|
*msg.guild_id.unwrap().as_u64(),
|
|
*msg.author.id.as_u64(),
|
|
pool).await {
|
|
Ok(_) => {
|
|
msg.channel_id.say(&ctx, "Sound has been uploaded").await?;
|
|
}
|
|
|
|
Err(e) => {
|
|
println!("Error occured during upload: {:?}", e);
|
|
msg.channel_id.say(&ctx, "Sound failed to upload.").await?;
|
|
}
|
|
}
|
|
} else {
|
|
msg.channel_id.say(&ctx, "Please upload 1 attachment following your upload command. Aborted").await?;
|
|
}
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Upload timed out. Please redo the command").await?;
|
|
}
|
|
}
|
|
} else {
|
|
msg.channel_id.say(
|
|
&ctx,
|
|
format!(
|
|
"You have reached the maximum number of sounds ({}). Either delete some with `?delete` or join our Patreon for unlimited uploads at **https://patreon.com/jellywx**",
|
|
*MAX_SOUNDS,
|
|
)).await?;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
msg.channel_id.say(&ctx, "Please ensure the sound name contains a non-numerical character").await?;
|
|
}
|
|
}
|
|
else {
|
|
msg.channel_id.say(&ctx, "Usage: `?upload <name>`. Please ensure the name provided is less than 20 characters in length").await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("roles")]
|
|
async fn set_allowed_roles(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let guild_id = *msg.guild_id.unwrap().as_u64();
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
if args.len() == 0 {
|
|
let roles = sqlx::query!(
|
|
"
|
|
SELECT role
|
|
FROM roles
|
|
WHERE guild_id = ?
|
|
",
|
|
guild_id
|
|
)
|
|
.fetch_all(&pool)
|
|
.await?;
|
|
|
|
let all_roles = roles.iter().map(|i| format!("<@&{}>", i.role.to_string())).collect::<Vec<String>>().join(", ");
|
|
|
|
msg.channel_id.say(&ctx, format!("Usage: `?roles <role mentions or anything else to disable>`. Current roles: {}", all_roles)).await?;
|
|
}
|
|
else {
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM roles
|
|
WHERE guild_id = ?
|
|
",
|
|
guild_id
|
|
).execute(&pool).await?;
|
|
|
|
if msg.mention_roles.len() > 0 {
|
|
for role in msg.mention_roles.iter().map(|r| *r.as_u64()) {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO roles (guild_id, role)
|
|
VALUES
|
|
(?, ?)
|
|
",
|
|
guild_id, role
|
|
)
|
|
.execute(&pool)
|
|
.await?;
|
|
}
|
|
|
|
msg.channel_id.say(&ctx, "Specified roles whitelisted").await?;
|
|
}
|
|
else {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO roles (guild_id, role)
|
|
VALUES
|
|
(?, ?)
|
|
",
|
|
guild_id, guild_id
|
|
)
|
|
.execute(&pool)
|
|
.await?;
|
|
|
|
msg.channel_id.say(&ctx, "Role whitelisting disabled").await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("list")]
|
|
async fn list_sounds(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let sounds;
|
|
let mut message_buffer;
|
|
|
|
if args.rest() == "me" {
|
|
sounds = Sound::get_user_sounds(*msg.author.id.as_u64(), pool).await?;
|
|
|
|
message_buffer = "All your sounds: ".to_string();
|
|
}
|
|
else {
|
|
sounds = Sound::get_guild_sounds(*msg.guild_id.unwrap().as_u64(), pool).await?;
|
|
|
|
message_buffer = "All sounds on this server: ".to_string();
|
|
}
|
|
|
|
for sound in sounds {
|
|
message_buffer.push_str(format!("**{}** ({}), ", sound.name, if sound.public { "🔓" } else { "🔒" }).as_str());
|
|
|
|
if message_buffer.len() > 2000 {
|
|
msg.channel_id.say(&ctx, message_buffer).await?;
|
|
|
|
message_buffer = "".to_string();
|
|
}
|
|
}
|
|
|
|
if message_buffer.len() > 0 {
|
|
msg.channel_id.say(&ctx, message_buffer).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("public")]
|
|
async fn change_public(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
let uid = msg.author.id.as_u64();
|
|
|
|
let name = args.rest();
|
|
let gid = *msg.guild_id.unwrap().as_u64();
|
|
|
|
let mut sound_vec = Sound::search_for_sound(name, gid, *uid, pool.clone(), true).await?;
|
|
let sound_result = sound_vec.first_mut();
|
|
|
|
match sound_result {
|
|
Some(sound) => {
|
|
if sound.uploader_id != Some(*uid) {
|
|
msg.channel_id.say(&ctx, "You can only change the availability of sounds you have uploaded. Use `?list me` to view your sounds").await?;
|
|
}
|
|
|
|
else {
|
|
if sound.public {
|
|
sound.public = false;
|
|
|
|
msg.channel_id.say(&ctx, "Sound has been set to private 🔒").await?;
|
|
} else {
|
|
sound.public = true;
|
|
|
|
msg.channel_id.say(&ctx, "Sound has been set to public 🔓").await?;
|
|
}
|
|
|
|
sound.commit(pool).await?
|
|
}
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Sound could not be found by that name.").await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("delete")]
|
|
async fn delete_sound(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let uid = *msg.author.id.as_u64();
|
|
let gid = *msg.guild_id.unwrap().as_u64();
|
|
|
|
let name = args.rest();
|
|
|
|
let sound_vec = Sound::search_for_sound(name, gid, uid, pool.clone(), true).await?;
|
|
let sound_result = sound_vec.first();
|
|
|
|
match sound_result {
|
|
Some(sound) => {
|
|
if sound.uploader_id != Some(uid) && sound.server_id != gid {
|
|
msg.channel_id.say(&ctx, "You can only delete sounds from this guild or that you have uploaded.").await?;
|
|
}
|
|
|
|
else {
|
|
sound.delete(pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, "Sound has been deleted").await?;
|
|
}
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Sound could not be found by that name.").await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn format_search_results(search_results: Vec<Sound>, msg: &Message, ctx: &Context) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
let mut current_character_count = 0;
|
|
let title = "Public sounds matching filter:";
|
|
|
|
let field_iter = search_results.iter().take(25).map(|item| {
|
|
|
|
(&item.name, format!("ID: {}\nPlays: {}", item.id, item.plays), true)
|
|
|
|
}).filter(|item| {
|
|
|
|
current_character_count += item.0.len() + item.1.len();
|
|
|
|
current_character_count <= 2048 - title.len()
|
|
|
|
});
|
|
|
|
msg.channel_id.send_message(&ctx, |m| {
|
|
m.embed(|e| { e
|
|
.title(title)
|
|
.fields(field_iter)
|
|
})
|
|
}).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("search")]
|
|
async fn search_sounds(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let query = args.rest();
|
|
|
|
let search_results = Sound::search_for_sound(query, *msg.guild_id.unwrap().as_u64(), *msg.author.id.as_u64(), pool, false).await?;
|
|
|
|
format_search_results(search_results, msg, ctx).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("popular")]
|
|
async fn show_popular_sounds(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let search_results = sqlx::query_as_unchecked!(
|
|
Sound,
|
|
"
|
|
SELECT name, id, plays, public, server_id, uploader_id
|
|
FROM sounds
|
|
ORDER BY plays DESC
|
|
LIMIT 25
|
|
"
|
|
)
|
|
.fetch_all(&pool)
|
|
.await?;
|
|
|
|
format_search_results(search_results, msg, ctx).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("random")]
|
|
async fn show_random_sounds(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let search_results = sqlx::query_as_unchecked!(
|
|
Sound,
|
|
"
|
|
SELECT name, id, plays, public, server_id, uploader_id
|
|
FROM sounds
|
|
ORDER BY rand()
|
|
LIMIT 25
|
|
"
|
|
)
|
|
.fetch_all(&pool)
|
|
.await.unwrap();
|
|
|
|
format_search_results(search_results, msg, ctx).await.unwrap();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("greet")]
|
|
async fn set_greet_sound(ctx: &Context, msg: &Message, args: Args) -> CommandResult {
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not get SQLPool from data");
|
|
|
|
let query = args.rest();
|
|
let user_id = *msg.author.id.as_u64();
|
|
|
|
let _ = sqlx::query!(
|
|
"
|
|
INSERT IGNORE INTO users (user)
|
|
VALUES (?)
|
|
",
|
|
user_id
|
|
)
|
|
.execute(&pool)
|
|
.await;
|
|
|
|
if query.len() == 0 {
|
|
sqlx::query!(
|
|
"
|
|
UPDATE users
|
|
SET
|
|
join_sound_id = NULL
|
|
WHERE
|
|
user = ?
|
|
",
|
|
user_id
|
|
)
|
|
.execute(&pool)
|
|
.await?;
|
|
|
|
msg.channel_id.say(&ctx, "Your greet sound has been unset.").await?;
|
|
}
|
|
else {
|
|
|
|
let sound_vec = Sound::search_for_sound(query, *msg.guild_id.unwrap().as_u64(), user_id, pool.clone(), true).await?;
|
|
|
|
match sound_vec.first() {
|
|
Some(sound) => {
|
|
sound.set_as_greet(user_id, pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, format!("Greet sound has been set to {} (ID {})", sound.name, sound.id)).await?;
|
|
}
|
|
|
|
None => {
|
|
msg.channel_id.say(&ctx, "Could not find a sound by that name.").await?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("stop")]
|
|
async fn stop_playing(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
let voice_manager_lock = ctx.data.read().await
|
|
.get::<VoiceManager>().cloned().expect("Could not get VoiceManager from data");
|
|
|
|
let mut voice_manager = voice_manager_lock.lock().await;
|
|
|
|
let manager_opt = voice_manager.get_mut(msg.guild_id.unwrap());
|
|
|
|
if let Some(manager) = manager_opt {
|
|
manager.leave();
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[command("allow_greet")]
|
|
async fn allow_greet_sounds(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
|
|
let guild = match msg.guild(&ctx.cache).await {
|
|
Some(guild) => guild,
|
|
|
|
None => {
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let pool = ctx.data.read().await
|
|
.get::<SQLPool>().cloned().expect("Could not acquire SQL pool from data");
|
|
|
|
let guild_data_opt = GuildData::get_from_id(guild, pool.clone()).await;
|
|
|
|
if let Some(mut guild_data) = guild_data_opt {
|
|
guild_data.allow_greets = !guild_data.allow_greets;
|
|
|
|
guild_data.commit(pool).await?;
|
|
|
|
msg.channel_id.say(&ctx, format!("Greet sounds have been {}abled in this server", if guild_data.allow_greets { "en" } else { "dis" })).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|