Move activity set out of Ready event

Might want to use this in the future. Remove the /random command as it's dumb.

.gitignore

@@ -1,2 +1,3 @@
 /target
 .env
+.idea

.idea/.gitignore

@@ -1,2 +0,0 @@
-# Default ignored files
-/workspace.xml

.idea/dataSources.local.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="dataSourceStorageLocal" created-in="CL-231.8109.174">
-    <data-source name="MySQL for 5.1 - soundfx@localhost" uuid="1067c1d0-1386-4a39-b3f5-6d48d6f279eb">
-      <database-info product="" version="" jdbc-version="" driver-name="" driver-version="" dbms="MYSQL" exact-version="0" />
-      <secret-storage>master_key</secret-storage>
-      <user-name>jude</user-name>
-      <schema-mapping />
-    </data-source>
-  </component>
-</project>

.idea/dataSources.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
-    <data-source source="LOCAL" name="MySQL for 5.1 - soundfx@localhost" uuid="1067c1d0-1386-4a39-b3f5-6d48d6f279eb">
-      <driver-ref>mysql</driver-ref>
-      <synchronize>true</synchronize>
-      <jdbc-driver>com.mysql.jdbc.Driver</jdbc-driver>
-      <jdbc-url>jdbc:mysql://localhost:3306/soundfx</jdbc-url>
-    </data-source>
-  </component>
-</project>

.idea/dictionaries/jude.xml

@@ -1,7 +0,0 @@
-<component name="ProjectDictionaryState">
-  <dictionary name="jude">
-    <words>
-      <w>reqwest</w>
-    </words>
-  </dictionary>
-</component>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="RsBorrowChecker" enabled="false" level="ERROR" enabled_by_default="false" />
-  </profile>
-</component>

.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/soundfx-rs.iml" filepath="$PROJECT_DIR$/.idea/soundfx-rs.iml" />
-    </modules>
-  </component>
-</project>

.idea/soundfx-rs.iml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="CPP_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/examples" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
-      <sourceFolder url="file://$MODULE_DIR$/benches" isTestSource="true" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.idea/sqldialects.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="SqlDialectMappings">
-    <file url="PROJECT" dialect="MySQL" />
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

Cargo.toml

@@ -2,35 +2,45 @@
 name = "soundfx-rs"
 description = "Discord bot for custom sound effects and soundboards"
 license = "AGPL-3.0-only"
-version = "1.5.9"
+version = "1.5.18"
 authors = ["jellywx <judesouthworth@pm.me>"]
 edition = "2018"
 
 [dependencies]
-songbird = { version = "0.3", features = ["builtin-queue"] }
-poise = "0.3"
-sqlx = { version = "0.5", default-features = false, features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "migrate"] }
-tokio = { version = "1", features = ["fs", "process", "io-util"] }
+songbird = { version = "0.4", features = ["builtin-queue"] }
+poise = "0.6.1-rc1"
+sqlx = { version = "0.7.3", default-features = false, features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "migrate"] }
+tokio = { version = "1", features = ["fs", "process", "io-util", "rt-multi-thread"] }
 lazy_static = "1.4"
-reqwest = "0.11"
-env_logger = "0.10"
-regex = "1.4"
+reqwest = "0.12"
+env_logger = "0.11"
+regex = "1.10"
 log = "0.4"
 serde_json = "1.0"
-dashmap = "5.3"
+dashmap = "6.0"
 serde = "1.0"
 dotenv = "0.15.0"
+prometheus = { version = "0.13.3", optional = true }
+axum = { version = "0.7.2", optional = true }
 
-[patch."https://github.com/serenity-rs/serenity"]
-serenity = { version = "0.11.5" }
+[dependencies.symphonia]
+version = "0.5"
+features = ["ogg"]
+
+[features]
+metrics = ["dep:prometheus", "dep:axum"]
 
 [package.metadata.deb]
+features = ["metrics"]
 depends = "$auto, ffmpeg"
 suggests = "mysql-server-8.0"
 maintainer-scripts = "debian"
 assets = [
     ["target/release/soundfx-rs", "usr/bin/soundfx-rs", "755"],
-    ["conf/default.env", "etc/soundfx-rs/default.env", "600"]
+    ["conf/default.env", "etc/soundfx-rs/config.env", "600"]
+]
+conf-files = [
+    "/etc/soundfx-rs/config.env",
 ]
 
 [package.metadata.deb.systemd-units]

debian/postinst

@@ -4,10 +4,6 @@ set -e
 
 id -u soundfx &>/dev/null || useradd -r -M soundfx
 
-if [ ! -f /etc/soundfx-rs/config.env ]; then
-  cp /etc/soundfx-rs/default.env /etc/soundfx-rs/config.env
-fi
-
 chown soundfx /etc/soundfx-rs/config.env
 
 #DEBHELPER#

debian/postrm

@@ -4,8 +4,4 @@ set -e
 
 id -u soundfx &>/dev/null || userdel soundfx
 
-if [ -f /etc/soundfx-rs/config.env ]; then
-  rm /etc/soundfx/config.env
-fi
-
 #DEBHELPER#

migrations/20230816145151_favorite_sounds.sql

@@ -0,0 +1,6 @@
+CREATE TABLE favorite_sounds (
+    user_id BIGINT UNSIGNED NOT NULL,
+    sound_id INT UNSIGNED NOT NULL,
+    FOREIGN KEY (sound_id) REFERENCES `sounds`(`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+    PRIMARY KEY (user_id, sound_id)
+);

scripts/dump-query.sh

@@ -0,0 +1,8 @@
+mysql -D soundfx -N -e "SELECT name, hex(src) FROM sounds" > out
+split --additional-suffix=.row -l 1 out
+for filename in *.row; do
+    name=`grep -oP '^(.+)(?=\t)' $filename`
+    col=`awk -F '\t' '{print $2}' "$filename"`
+    echo $col > "$filename.hex"
+    xxd -r -p "$filename.hex" "$name.opus"
+done

src/cmds/favorite.rs

@@ -0,0 +1,94 @@
+use log::warn;
+
+use crate::{cmds::autocomplete_favorite, models::sound::SoundCtx, Context, Error};
+
+#[poise::command(slash_command, rename = "favorites", guild_only = true)]
+pub async fn favorites(_ctx: Context<'_>) -> Result<(), Error> {
+    Ok(())
+}
+
+/// Add a sound as a favorite
+#[poise::command(
+    slash_command,
+    rename = "add",
+    category = "Favorites",
+    guild_only = true
+)]
+pub async fn add_favorite(
+    ctx: Context<'_>,
+    #[description = "Name or ID of sound to favorite"] name: String,
+) -> Result<(), Error> {
+    let sounds = ctx
+        .data()
+        .search_for_sound(&name, ctx.guild_id().unwrap(), ctx.author().id, true)
+        .await;
+
+    match sounds {
+        Ok(sounds) => {
+            let sound = &sounds[0];
+
+            sound
+                .add_favorite(ctx.author().id, &ctx.data().database)
+                .await?;
+            ctx.say(format!(
+                "Sound {} (ID {}) added to favorites.",
+                sound.name, sound.id
+            ))
+            .await?;
+
+            Ok(())
+        }
+
+        Err(e) => {
+            warn!("Couldn't fetch sounds: {:?}", e);
+
+            ctx.say("Failed to find sound.").await?;
+
+            Ok(())
+        }
+    }
+}
+
+/// Remove a sound from your favorites
+#[poise::command(
+    slash_command,
+    rename = "remove",
+    category = "Favorites",
+    guild_only = true
+)]
+pub async fn remove_favorite(
+    ctx: Context<'_>,
+    #[description = "Name or ID of sound to favorite"]
+    #[autocomplete = "autocomplete_favorite"]
+    name: String,
+) -> Result<(), Error> {
+    let sounds = ctx
+        .data()
+        .search_for_sound(&name, ctx.guild_id().unwrap(), ctx.author().id, true)
+        .await;
+
+    match sounds {
+        Ok(sounds) => {
+            let sound = &sounds[0];
+
+            sound
+                .remove_favorite(ctx.author().id, &ctx.data().database)
+                .await?;
+            ctx.say(format!(
+                "Sound {} (ID {}) removed from favorites.",
+                sound.name, sound.id
+            ))
+            .await?;
+
+            Ok(())
+        }
+
+        Err(e) => {
+            warn!("Couldn't fetch sounds: {:?}", e);
+
+            ctx.say("Failed to find sound.").await?;
+
+            Ok(())
+        }
+    }
+}

src/cmds/info.rs

@@ -1,19 +1,23 @@
+use poise::{
+    serenity_prelude::{CreateEmbed, CreateEmbedFooter},
+    CreateReply,
+};
+
 use crate::{consts::THEME_COLOR, Context, Error};
 
 /// View bot commands
 #[poise::command(slash_command)]
 pub async fn help(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(|m| {
-        m.ephemeral(true).embed(|e| {
-            e.title("Help")
+    ctx.send(
+        CreateReply::default().ephemeral(true).embed(
+            CreateEmbed::new()
+                .title("Help")
                 .color(THEME_COLOR)
-                .footer(|f| {
-                    f.text(concat!(
-                        env!("CARGO_PKG_NAME"),
-                        " ver ",
-                        env!("CARGO_PKG_VERSION")
-                    ))
-                })
+                .footer(CreateEmbedFooter::new(concat!(
+                    env!("CARGO_PKG_NAME"),
+                    " ver ",
+                    env!("CARGO_PKG_VERSION")
+                )))
                 .description(
                     "__Info Commands__
 `/help` `/info`
@@ -33,6 +37,9 @@ __Library Commands__
 `/public` - Set a sound as public/private
 `/list server` - List sounds on this server
 `/list user` - List your sounds
+`/favorites add` - Add a favorite
+`/favorites remove` - Remove a favorite
+`/list favorites` - List favorites
 
 __Search Commands__
 `/search` - Search for public sounds by name
@@ -46,9 +53,9 @@ __Setting Commands__
 
 __Advanced Commands__
 `/soundboard` - Create a soundboard",
-                )
-        })
-    })
+                ),
+        ),
+    )
     .await?;
 
     Ok(())
@@ -57,15 +64,19 @@ __Advanced Commands__
 /// Get additional information about the bot
 #[poise::command(slash_command)]
 pub async fn info(ctx: Context<'_>) -> Result<(), Error> {
-    let current_user = ctx.discord().cache.current_user();
+    let current_user = ctx.serenity_context().cache.current_user().id.get();
 
-    ctx.send(|m| m.ephemeral(true)
-        .embed(|e| e
-            .title("Info")
-            .color(THEME_COLOR)
-            .footer(|f| f
-                .text(concat!(env!("CARGO_PKG_NAME"), " ver ", env!("CARGO_PKG_VERSION"))))
-            .description(format!("Invite me: https://discord.com/api/oauth2/authorize?client_id={}&permissions=3165184&scope=applications.commands%20bot
+    ctx.send(
+        CreateReply::default().ephemeral(true).embed(
+            CreateEmbed::new()
+                .title("Info")
+                .color(THEME_COLOR)
+                .footer(CreateEmbedFooter::new(concat!(
+                    env!("CARGO_PKG_NAME"),
+                    " ver ",
+                    env!("CARGO_PKG_VERSION")
+                )))
+                .description(format!("Invite me: https://discord.com/api/oauth2/authorize?client_id={}&permissions=3165184&scope=applications.commands%20bot
 
 **Welcome to SoundFX!**
 Developer: <@203532103185465344>
@@ -73,7 +84,9 @@ 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 subscribing at **https://patreon.com/jellywx**",
-                                 current_user.id.as_u64())))).await?;
+             current_user)))
+    )
+    .await?;
 
     Ok(())
 }

src/cmds/manage.rs

@@ -1,6 +1,10 @@
-use poise::serenity_prelude::{Attachment, GuildId, RoleId};
-use tokio::fs::File;
+use poise::{
+    serenity_prelude::{Attachment, CreateAttachment, GuildId, RoleId},
+    CreateReply,
+};
 
+#[cfg(feature = "metrics")]
+use crate::metrics::{DELETE_COUNTER, UPLOAD_COUNTER};
 use crate::{
     cmds::autocomplete_sound,
     consts::{MAX_SOUNDS, PATREON_GUILD, PATREON_ROLE},
@@ -21,6 +25,9 @@ pub async fn upload_new_sound(
     #[description = "Name to upload sound to"] name: String,
     #[description = "Sound file (max. 2MB)"] file: Attachment,
 ) -> Result<(), Error> {
+    #[cfg(feature = "metrics")]
+    UPLOAD_COUNTER.inc();
+
     ctx.defer().await?;
 
     fn is_numeric(s: &String) -> bool {
@@ -35,7 +42,13 @@ pub async fn upload_new_sound(
     }
 
     if !name.is_empty() && name.len() <= 20 {
-        if !is_numeric(&name) {
+        if name.starts_with("@") {
+            ctx.say("Sound names cannot start with an @ symbol. Please choose another name")
+                .await?;
+        } else if is_numeric(&name) {
+            ctx.say("Please ensure the sound name contains a non-numerical character")
+                .await?;
+        } else {
             // need to check the name is not currently in use by the user
             let count_name =
                 Sound::count_named_user_sounds(ctx.author().id, &name, &ctx.data().database)
@@ -50,14 +63,14 @@ pub async fn upload_new_sound(
                 let count = Sound::count_user_sounds(ctx.author().id, &ctx.data().database).await?;
                 let mut permit_upload = true;
 
-                // need to check if user is patreon or nah
+                // need to check if user is Patreon or not
                 if count >= *MAX_SOUNDS {
-                    let patreon_guild_member = GuildId(*PATREON_GUILD)
-                        .member(ctx.discord(), ctx.author().id)
+                    let patreon_guild_member = GuildId::from(*PATREON_GUILD)
+                        .member(ctx, ctx.author().id)
                         .await;
 
                     if let Ok(member) = patreon_guild_member {
-                        permit_upload = member.roles.contains(&RoleId(*PATREON_ROLE));
+                        permit_upload = member.roles.contains(&RoleId::from(*PATREON_ROLE));
                     } else {
                         permit_upload = false;
                     }
@@ -89,9 +102,6 @@ pub async fn upload_new_sound(
                         )).await?;
                 }
             }
-        } else {
-            ctx.say("Please ensure the sound name contains a non-numerical character")
-                .await?;
         }
     } else {
         ctx.say("Usage: `/upload <name>`. Please ensure the name provided is less than 20 characters in length").await?;
@@ -108,10 +118,13 @@ pub async fn delete_sound(
     #[autocomplete = "autocomplete_sound"]
     name: String,
 ) -> Result<(), Error> {
+    #[cfg(feature = "metrics")]
+    DELETE_COUNTER.inc();
+
     let pool = ctx.data().database.clone();
 
-    let uid = ctx.author().id.0;
-    let gid = ctx.guild_id().unwrap().0;
+    let uid = ctx.author().id.get();
+    let gid = ctx.guild_id().unwrap().get();
 
     let sound_vec = ctx.data().search_for_sound(&name, gid, uid, true).await?;
     let sound_result = sound_vec.first();
@@ -123,8 +136,8 @@ pub async fn delete_sound(
                     .await?;
             } else {
                 let has_perms = {
-                    if let Ok(member) = ctx.guild_id().unwrap().member(&ctx.discord(), uid).await {
-                        if let Ok(perms) = member.permissions(&ctx.discord()) {
+                    if let Ok(member) = ctx.guild_id().unwrap().member(&ctx, uid).await {
+                        if let Ok(perms) = member.permissions(&ctx) {
                             perms.manage_guild()
                         } else {
                             false
@@ -163,8 +176,8 @@ pub async fn change_public(
 ) -> Result<(), Error> {
     let pool = ctx.data().database.clone();
 
-    let uid = ctx.author().id.0;
-    let gid = ctx.guild_id().unwrap().0;
+    let uid = ctx.author().id.get();
+    let gid = ctx.guild_id().unwrap().get();
 
     let mut sound_vec = ctx.data().search_for_sound(&name, gid, uid, true).await?;
     let sound_result = sound_vec.first_mut();
@@ -213,13 +226,13 @@ pub async fn download_file(
 
     match sound.first() {
         Some(sound) => {
-            let source = sound.store_sound_source(&ctx.data().database).await?;
-
-            let file = File::open(&source).await?;
             let name = format!("{}-{}.opus", sound.id, sound.name);
 
-            ctx.send(|m| m.attachment((&file, name.as_str()).into()))
-                .await?;
+            ctx.send(CreateReply::default().attachment(CreateAttachment::bytes(
+                sound.src(&ctx.data().database).await,
+                name.as_str(),
+            )))
+            .await?;
         }
 
         None => {

src/cmds/mod.rs

@@ -1,5 +1,8 @@
+use poise::serenity_prelude::AutocompleteChoice;
+
 use crate::{models::sound::SoundCtx, Context};
 
+pub mod favorite;
 pub mod info;
 pub mod manage;
 pub mod play;
@@ -7,18 +10,22 @@ pub mod search;
 pub mod settings;
 pub mod stop;
 
-pub async fn autocomplete_sound(
-    ctx: Context<'_>,
-    partial: &str,
-) -> Vec<poise::AutocompleteChoice<String>> {
+pub async fn autocomplete_sound(ctx: Context<'_>, partial: &str) -> Vec<AutocompleteChoice> {
     ctx.data()
         .autocomplete_user_sounds(&partial, ctx.author().id, ctx.guild_id().unwrap())
         .await
         .unwrap_or(vec![])
         .iter()
-        .map(|s| poise::AutocompleteChoice {
-            name: s.name.clone(),
-            value: s.id.to_string(),
-        })
+        .map(|s| AutocompleteChoice::new(s.name.clone(), s.id.to_string()))
+        .collect()
+}
+
+pub async fn autocomplete_favorite(ctx: Context<'_>, partial: &str) -> Vec<AutocompleteChoice> {
+    ctx.data()
+        .autocomplete_favorite_sounds(&partial, ctx.author().id)
+        .await
+        .unwrap_or(vec![])
+        .iter()
+        .map(|s| AutocompleteChoice::new(s.name.clone(), s.id.to_string()))
         .collect()
 }

src/cmds/play.rs

@@ -1,11 +1,18 @@
-use poise::serenity_prelude::{
-    builder::CreateActionRow, model::application::component::ButtonStyle, GuildChannel,
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use poise::{
+    serenity_prelude::{
+        builder::CreateActionRow, ButtonStyle, CreateButton, GuildChannel, ReactionType,
+    },
+    CreateReply,
 };
 
+#[cfg(feature = "metrics")]
+use crate::metrics::PLAY_COUNTER;
 use crate::{
     cmds::autocomplete_sound,
     models::{guild_data::CtxGuildData, sound::SoundCtx},
-    utils::{join_channel, play_from_query, queue_audio},
+    utils::{join_channel, play_audio, play_from_query, queue_audio},
     Context, Error,
 };
 
@@ -20,27 +27,103 @@ pub async fn play(
     #[channel_types("Voice")]
     channel: Option<GuildChannel>,
 ) -> Result<(), Error> {
+    #[cfg(feature = "metrics")]
+    PLAY_COUNTER.inc();
+
     ctx.defer().await?;
 
-    let guild = ctx.guild().unwrap();
+    let guild = ctx.guild().map(|g| g.clone()).unwrap();
 
-    if channel.as_ref().map_or(false, |c| c.is_text_based()) {
-        ctx.say("The channel specified is not a voice channel.")
-            .await?;
-    } else {
-        ctx.say(
-            play_from_query(
-                &ctx.discord(),
-                &ctx.data(),
-                guild,
-                ctx.author().id,
-                channel.map(|c| c.id),
-                &name,
-                false,
-            )
-            .await,
+    ctx.say(
+        play_from_query(
+            &ctx.serenity_context(),
+            &ctx.data(),
+            &guild,
+            ctx.author().id,
+            channel.map(|c| c.id),
+            &name,
+            false,
         )
-        .await?;
+        .await,
+    )
+    .await?;
+
+    Ok(())
+}
+
+/// Play a random sound from this server
+#[poise::command(
+    slash_command,
+    rename = "random",
+    default_member_permissions = "SPEAK",
+    guild_only = true
+)]
+pub async fn play_random(
+    ctx: Context<'_>,
+    #[description = "Channel to play in (default: your current voice channel)"]
+    #[channel_types("Voice")]
+    channel: Option<GuildChannel>,
+) -> Result<(), Error> {
+    ctx.defer().await?;
+
+    let (channel_to_join, guild_id) = {
+        let guild = ctx.guild().unwrap();
+
+        (
+            channel.map(|c| c.id).or_else(|| {
+                guild
+                    .voice_states
+                    .get(&ctx.author().id)
+                    .and_then(|voice_state| voice_state.channel_id)
+            }),
+            guild.id,
+        )
+    };
+
+    match channel_to_join {
+        Some(channel) => {
+            let call = join_channel(ctx.serenity_context(), guild_id, channel).await?;
+
+            let sounds = ctx.data().guild_sounds(guild_id, None).await?;
+            if sounds.len() == 0 {
+                ctx.say("No sounds in this server!").await?;
+                return Ok(());
+            }
+
+            let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+
+            println!("{}", ts.subsec_micros());
+
+            // This is far cheaper and easier than using an RNG. No reason to use a full RNG here
+            // anyway.
+            match sounds.get(ts.subsec_micros() as usize % sounds.len()) {
+                Some(sound) => {
+                    let guild_data = ctx.data().guild_data(guild_id).await.unwrap();
+                    let mut lock = call.lock().await;
+
+                    play_audio(
+                        sound,
+                        guild_data.read().await.volume,
+                        &mut lock,
+                        &ctx.data().database,
+                        false,
+                    )
+                    .await
+                    .unwrap();
+
+                    ctx.say(format!("Playing {} (ID {})", sound.name, sound.id))
+                        .await?;
+                }
+
+                None => {
+                    ctx.say("No sounds in this server!").await?;
+                }
+            }
+        }
+
+        None => {
+            ctx.say("You are not in a voice chat!").await?;
+        }
     }
 
     Ok(())
@@ -133,24 +216,23 @@ pub async fn queue_play(
 ) -> Result<(), Error> {
     ctx.defer().await?;
 
-    let guild = ctx.guild().unwrap();
+    let (channel_to_join, guild_id) = {
+        let guild = ctx.guild().unwrap();
 
-    let channel_to_join = guild
-        .voice_states
-        .get(&ctx.author().id)
-        .and_then(|voice_state| voice_state.channel_id);
+        (
+            guild
+                .voice_states
+                .get(&ctx.author().id)
+                .and_then(|voice_state| voice_state.channel_id),
+            guild.id,
+        )
+    };
 
     match channel_to_join {
         Some(user_channel) => {
-            let (call_handler, _) = join_channel(ctx.discord(), guild.clone(), user_channel).await;
+            let call = join_channel(ctx.serenity_context(), guild_id, user_channel).await?;
 
-            let guild_data = ctx
-                .data()
-                .guild_data(ctx.guild_id().unwrap())
-                .await
-                .unwrap();
-
-            let mut lock = call_handler.lock().await;
+            let guild_data = ctx.data().guild_data(guild_id).await.unwrap();
 
             let query_terms = [
                 Some(sound_1),
@@ -193,14 +275,18 @@ pub async fn queue_play(
                 }
             }
 
-            queue_audio(
-                &sounds,
-                guild_data.read().await.volume,
-                &mut lock,
-                &ctx.data().database,
-            )
-            .await
-            .unwrap();
+            {
+                let mut lock = call.lock().await;
+
+                queue_audio(
+                    &sounds,
+                    guild_data.read().await.volume,
+                    &mut lock,
+                    &ctx.data().database,
+                )
+                .await
+                .unwrap();
+            }
 
             ctx.say(format!("Queued {} sounds!", sounds.len())).await?;
         }
@@ -227,13 +313,13 @@ pub async fn loop_play(
 ) -> Result<(), Error> {
     ctx.defer().await?;
 
-    let guild = ctx.guild().unwrap();
+    let guild = ctx.guild().map(|g| g.clone()).unwrap();
 
     ctx.say(
         play_from_query(
-            &ctx.discord(),
+            &ctx.serenity_context(),
             &ctx.data(),
-            guild,
+            &guild,
             ctx.author().id,
             None,
             &name,
@@ -316,21 +402,6 @@ pub async fn soundboard(
     #[description = "Name or ID of sound for button 20"]
     #[autocomplete = "autocomplete_sound"]
     sound_20: Option<String>,
-    #[description = "Name or ID of sound for button 21"]
-    #[autocomplete = "autocomplete_sound"]
-    sound_21: Option<String>,
-    #[description = "Name or ID of sound for button 22"]
-    #[autocomplete = "autocomplete_sound"]
-    sound_22: Option<String>,
-    #[description = "Name or ID of sound for button 23"]
-    #[autocomplete = "autocomplete_sound"]
-    sound_23: Option<String>,
-    #[description = "Name or ID of sound for button 24"]
-    #[autocomplete = "autocomplete_sound"]
-    sound_24: Option<String>,
-    #[description = "Name or ID of sound for button 25"]
-    #[autocomplete = "autocomplete_sound"]
-    sound_25: Option<String>,
 ) -> Result<(), Error> {
     ctx.defer().await?;
 
@@ -355,11 +426,6 @@ pub async fn soundboard(
         sound_18,
         sound_19,
         sound_20,
-        sound_21,
-        sound_22,
-        sound_23,
-        sound_24,
-        sound_25,
     ];
 
     let mut sounds = vec![];
@@ -377,24 +443,49 @@ pub async fn soundboard(
         }
     }
 
-    ctx.send(|m| {
-        m.content("**Play a sound:**").components(|c| {
-            for row in sounds.as_slice().chunks(5) {
-                let mut action_row: CreateActionRow = Default::default();
-                for sound in row {
-                    action_row.create_button(|b| {
-                        b.style(ButtonStyle::Primary)
-                            .label(&sound.name)
-                            .custom_id(sound.id)
-                    });
-                }
-
-                c.add_action_row(action_row);
+    let components = {
+        let mut c = vec![];
+        for row in sounds.as_slice().chunks(5) {
+            let mut action_row = vec![];
+            for sound in row {
+                action_row.push(
+                    CreateButton::new(sound.id.to_string())
+                        .style(ButtonStyle::Primary)
+                        .label(&sound.name),
+                );
             }
 
-            c
-        })
-    })
+            c.push(CreateActionRow::Buttons(action_row));
+        }
+
+        c.push(CreateActionRow::Buttons(vec![
+            CreateButton::new("#stop")
+                .label("Stop")
+                .emoji(ReactionType::Unicode("⏹".to_string()))
+                .style(ButtonStyle::Danger),
+            CreateButton::new("#mode")
+                .label("Mode:")
+                .style(ButtonStyle::Secondary)
+                .disabled(true),
+            CreateButton::new("#instant")
+                .label("Instant")
+                .emoji(ReactionType::Unicode("▶".to_string()))
+                .style(ButtonStyle::Secondary)
+                .disabled(true),
+            CreateButton::new("#loop")
+                .label("Loop")
+                .emoji(ReactionType::Unicode("🔁".to_string()))
+                .style(ButtonStyle::Secondary),
+        ]));
+
+        c
+    };
+
+    ctx.send(
+        CreateReply::default()
+            .content("**Play a sound:**")
+            .components(components),
+    )
     .await?;
 
     Ok(())

src/cmds/search.rs

@@ -1,10 +1,8 @@
 use poise::{
     serenity_prelude,
     serenity_prelude::{
-        application::component::ButtonStyle,
-        constants::MESSAGE_CODE_LIMIT,
-        interaction::{message_component::MessageComponentInteraction, InteractionResponseType},
-        CreateActionRow, CreateEmbed, GuildId, UserId,
+        constants::MESSAGE_CODE_LIMIT, ButtonStyle, ComponentInteraction, CreateActionRow,
+        CreateButton, CreateEmbed, EditInteractionResponse, GuildId, UserId,
     },
     CreateReply,
 };
@@ -16,8 +14,8 @@ use crate::{
     Context, Data, Error,
 };
 
-fn format_search_results<'a>(search_results: Vec<Sound>) -> CreateReply<'a> {
-    let mut builder = CreateReply::default();
+fn format_search_results(search_results: Vec<Sound>) -> CreateReply {
+    let builder = CreateReply::default();
 
     let mut current_character_count = 0;
     let title = "Public sounds matching filter:";
@@ -32,9 +30,7 @@ fn format_search_results<'a>(search_results: Vec<Sound>) -> CreateReply<'a> {
             current_character_count <= MESSAGE_CODE_LIMIT - title.len()
         });
 
-    builder.embed(|e| e.title(title).fields(field_iter));
-
-    builder
+    builder.embed(CreateEmbed::default().title(title).fields(field_iter))
 }
 
 /// Show uploaded sounds
@@ -47,12 +43,14 @@ pub async fn list_sounds(_ctx: Context<'_>) -> Result<(), Error> {
 enum ListContext {
     User = 0,
     Guild = 1,
+    Favorite = 2,
 }
 
 impl ListContext {
     pub fn title(&self) -> &'static str {
         match self {
             ListContext::User => "Your sounds",
+            ListContext::Favorite => "Your favorite sounds",
             ListContext::Guild => "Server sounds",
         }
     }
@@ -86,6 +84,20 @@ pub async fn list_user_sounds(ctx: Context<'_>) -> Result<(), Error> {
     Ok(())
 }
 
+/// Show sounds you have favorited
+#[poise::command(slash_command, rename = "favorite", guild_only = true)]
+pub async fn list_favorite_sounds(ctx: Context<'_>) -> Result<(), Error> {
+    let pager = SoundPager {
+        nonce: 0,
+        page: 0,
+        context: ListContext::Favorite,
+    };
+
+    pager.reply(ctx).await?;
+
+    Ok(())
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct SoundPager {
     nonce: u64,
@@ -102,15 +114,14 @@ impl SoundPager {
     ) -> Result<Vec<Sound>, sqlx::Error> {
         match self.context {
             ListContext::User => data.user_sounds(user_id, Some(self.page)).await,
+            ListContext::Favorite => data.favorite_sounds(user_id, Some(self.page)).await,
             ListContext::Guild => data.guild_sounds(guild_id, Some(self.page)).await,
         }
     }
 
     fn create_action_row(&self, max_page: u64) -> CreateActionRow {
-        let mut row = CreateActionRow::default();
-
-        row.create_button(|b| {
-            b.custom_id(
+        let row = CreateActionRow::Buttons(vec![
+            CreateButton::new(
                 serde_json::to_string(&SoundPager {
                     nonce: 0,
                     page: 0,
@@ -120,10 +131,8 @@ impl SoundPager {
             )
             .style(ButtonStyle::Primary)
             .label("⏪")
-            .disabled(self.page == 0)
-        })
-        .create_button(|b| {
-            b.custom_id(
+            .disabled(self.page == 0),
+            CreateButton::new(
                 serde_json::to_string(&SoundPager {
                     nonce: 1,
                     page: self.page.saturating_sub(1),
@@ -133,16 +142,12 @@ impl SoundPager {
             )
             .style(ButtonStyle::Secondary)
             .label("◀️")
-            .disabled(self.page == 0)
-        })
-        .create_button(|b| {
-            b.custom_id("pid")
+            .disabled(self.page == 0),
+            CreateButton::new("pid")
                 .style(ButtonStyle::Success)
                 .label(format!("Page {}", self.page + 1))
-                .disabled(true)
-        })
-        .create_button(|b| {
-            b.custom_id(
+                .disabled(true),
+            CreateButton::new(
                 serde_json::to_string(&SoundPager {
                     nonce: 2,
                     page: self.page.saturating_add(1),
@@ -152,10 +157,8 @@ impl SoundPager {
             )
             .style(ButtonStyle::Secondary)
             .label("▶️")
-            .disabled(self.page == max_page)
-        })
-        .create_button(|b| {
-            b.custom_id(
+            .disabled(self.page == max_page),
+            CreateButton::new(
                 serde_json::to_string(&SoundPager {
                     nonce: 3,
                     page: max_page,
@@ -165,16 +168,14 @@ impl SoundPager {
             )
             .style(ButtonStyle::Primary)
             .label("⏩")
-            .disabled(self.page == max_page)
-        });
+            .disabled(self.page == max_page),
+        ]);
 
         row
     }
 
     fn embed(&self, sounds: &[Sound], count: u64) -> CreateEmbed {
-        let mut embed = CreateEmbed::default();
-
-        embed
+        CreateEmbed::default()
             .color(THEME_COLOR)
             .title(self.context.title())
             .description(format!("**{}** sounds:", count))
@@ -188,15 +189,13 @@ impl SoundPager {
                     ),
                     true,
                 )
-            }));
-
-        embed
+            }))
     }
 
     pub async fn handle_interaction(
         ctx: &serenity_prelude::Context,
         data: &Data,
-        interaction: &MessageComponentInteraction,
+        interaction: &ComponentInteraction,
     ) -> Result<(), Error> {
         let user_id = interaction.user.id;
         let guild_id = interaction.guild_id.unwrap();
@@ -205,18 +204,17 @@ impl SoundPager {
         let sounds = pager.get_page(data, user_id, guild_id).await?;
         let count = match pager.context {
             ListContext::User => data.count_user_sounds(user_id).await?,
+            ListContext::Favorite => data.count_favorite_sounds(user_id).await?,
             ListContext::Guild => data.count_guild_sounds(guild_id).await?,
         };
 
         interaction
-            .create_interaction_response(&ctx, |r| {
-                r.kind(InteractionResponseType::UpdateMessage)
-                    .interaction_response_data(|d| {
-                        d.ephemeral(true)
-                            .add_embed(pager.embed(&sounds, count))
-                            .components(|c| c.add_action_row(pager.create_action_row(count / 25)))
-                    })
-            })
+            .edit_response(
+                &ctx,
+                EditInteractionResponse::default()
+                    .add_embed(pager.embed(&sounds, count))
+                    .components(vec![pager.create_action_row(count / 25)]),
+            )
             .await?;
 
         Ok(())
@@ -228,6 +226,7 @@ impl SoundPager {
             .await?;
         let count = match self.context {
             ListContext::User => ctx.data().count_user_sounds(ctx.author().id).await?,
+            ListContext::Favorite => ctx.data().count_favorite_sounds(ctx.author().id).await?,
             ListContext::Guild => {
                 ctx.data()
                     .count_guild_sounds(ctx.guild_id().unwrap())
@@ -235,14 +234,12 @@ impl SoundPager {
             }
         };
 
-        ctx.send(|r| {
-            r.ephemeral(true)
-                .embed(|e| {
-                    *e = self.embed(&sounds, count);
-                    e
-                })
-                .components(|c| c.add_action_row(self.create_action_row(count / 25)))
-        })
+        ctx.send(
+            CreateReply::default()
+                .ephemeral(true)
+                .embed(self.embed(&sounds, count))
+                .components(vec![self.create_action_row(count / 25)]),
+        )
         .await?;
 
         Ok(())
@@ -265,36 +262,7 @@ pub async fn search_sounds(
         .search_for_sound(&query, ctx.guild_id().unwrap(), ctx.author().id, false)
         .await?;
 
-    ctx.send(|m| {
-        *m = format_search_results(search_results);
-        m
-    })
-    .await?;
-
-    Ok(())
-}
-
-/// Show a page of random sounds
-#[poise::command(slash_command, rename = "random", guild_only = true)]
-pub async fn show_random_sounds(ctx: Context<'_>) -> Result<(), Error> {
-    let search_results = sqlx::query_as_unchecked!(
-        Sound,
-        "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE public = 1
-    ORDER BY rand()
-    LIMIT 25
-        "
-    )
-    .fetch_all(&ctx.data().database)
-    .await?;
-
-    ctx.send(|m| {
-        *m = format_search_results(search_results);
-        m
-    })
-    .await?;
+    ctx.send(format_search_results(search_results)).await?;
 
     Ok(())
 }

src/cmds/settings.rs

@@ -1,4 +1,7 @@
-use poise::serenity_prelude::{GuildId, User};
+use poise::{
+    serenity_prelude::{GuildId, User},
+    CreateReply,
+};
 
 use crate::{
     cmds::autocomplete_sound,
@@ -60,16 +63,14 @@ pub async fn set_guild_greet_sound(
     #[description = "User to set join sound for"] user: User,
 ) -> Result<(), Error> {
     if user.id != ctx.author().id {
-        let guild = ctx.guild().unwrap();
-        let permissions = guild
-            .member_permissions(&ctx.discord(), ctx.author().id)
-            .await;
+        let permissions = ctx.author_member().await.unwrap().permissions(&ctx.cache());
 
         if permissions.map_or(true, |p| !p.manage_guild()) {
-            ctx.send(|b| {
-                b.ephemeral(true)
-                    .content("Only admins can change other user's greet sounds.")
-            })
+            ctx.send(
+                CreateReply::default()
+                    .ephemeral(true)
+                    .content("Only admins can change other user's greet sounds."),
+            )
             .await?;
 
             return Ok(());
@@ -109,16 +110,14 @@ pub async fn unset_guild_greet_sound(
     #[description = "User to set join sound for"] user: User,
 ) -> Result<(), Error> {
     if user.id != ctx.author().id {
-        let guild = ctx.guild().unwrap();
-        let permissions = guild
-            .member_permissions(&ctx.discord(), ctx.author().id)
-            .await;
+        let permissions = ctx.author_member().await.unwrap().permissions(&ctx.cache());
 
         if permissions.map_or(true, |p| !p.manage_guild()) {
-            ctx.send(|b| {
-                b.ephemeral(true)
-                    .content("Only admins can change other user's greet sounds.")
-            })
+            ctx.send(
+                CreateReply::default()
+                    .ephemeral(true)
+                    .content("Only admins can change other user's greet sounds."),
+            )
             .await?;
 
             return Ok(());
@@ -159,20 +158,19 @@ pub async fn set_user_greet_sound(
                 .update_join_sound(ctx.author().id, None::<GuildId>, Some(sound.id))
                 .await?;
 
-            ctx.send(|b| {
-                b.ephemeral(true).content(format!(
-                    "Greet sound has been set to {} (ID {})",
-                    sound.name, sound.id
-                ))
-            })
+            ctx.send(CreateReply::default().ephemeral(true).content(format!(
+                "Greet sound has been set to {} (ID {})",
+                sound.name, sound.id
+            )))
             .await?;
         }
 
         None => {
-            ctx.send(|b| {
-                b.ephemeral(true)
-                    .content("Could not find a sound by that name.")
-            })
+            ctx.send(
+                CreateReply::default()
+                    .ephemeral(true)
+                    .content("Could not find a sound by that name."),
+            )
             .await?;
         }
     }
@@ -187,8 +185,12 @@ pub async fn unset_user_greet_sound(ctx: Context<'_>) -> Result<(), Error> {
         .update_join_sound(ctx.author().id, None::<GuildId>, None)
         .await?;
 
-    ctx.send(|b| b.ephemeral(true).content("Greet sound has been unset"))
-        .await?;
+    ctx.send(
+        CreateReply::default()
+            .ephemeral(true)
+            .content("Greet sound has been unset"),
+    )
+    .await?;
 
     Ok(())
 }

src/cmds/stop.rs

@@ -10,7 +10,7 @@ use crate::{Context, Error};
     guild_only = true
 )]
 pub async fn stop_playing(ctx: Context<'_>) -> Result<(), Error> {
-    let songbird = songbird::get(ctx.discord()).await.unwrap();
+    let songbird = songbird::get(ctx.serenity_context()).await.unwrap();
     let call_opt = songbird.get(ctx.guild_id().unwrap());
 
     if let Some(call) = call_opt {
@@ -27,7 +27,7 @@ pub async fn stop_playing(ctx: Context<'_>) -> Result<(), Error> {
 /// Disconnect the bot
 #[poise::command(slash_command, default_member_permissions = "SPEAK", guild_only = true)]
 pub async fn disconnect(ctx: Context<'_>) -> Result<(), Error> {
-    let songbird = songbird::get(ctx.discord()).await.unwrap();
+    let songbird = songbird::get(ctx.serenity_context()).await.unwrap();
     let _ = songbird.leave(ctx.guild_id().unwrap()).await;
 
     ctx.say("👍").await?;

src/event_handlers.rs

@@ -1,14 +1,10 @@
-use std::{collections::HashMap, env};
-
 use poise::serenity_prelude::{
-    model::{
-        application::interaction::{Interaction, InteractionResponseType},
-        channel::Channel,
-    },
-    utils::shard_id,
-    Activity, Context,
+    ActionRowComponent, ButtonKind, Context, CreateActionRow, CreateButton,
+    EditInteractionResponse, FullEvent, Interaction,
 };
 
+#[cfg(feature = "metrics")]
+use crate::metrics::GREET_COUNTER;
 use crate::{
     cmds::search::SoundPager,
     models::{
@@ -20,140 +16,176 @@ use crate::{
     Data, Error,
 };
 
-pub async fn listener(ctx: &Context, event: &poise::Event<'_>, data: &Data) -> Result<(), Error> {
+pub async fn listener(ctx: &Context, event: &FullEvent, data: &Data) -> Result<(), Error> {
     match event {
-        poise::Event::Ready { .. } => {
-            ctx.set_activity(Activity::watching("for /play")).await;
-        }
-        poise::Event::GuildCreate { guild, is_new, .. } => {
-            if *is_new {
-                if let Ok(token) = env::var("DISCORDBOTS_TOKEN") {
-                    let shard_count = ctx.cache.shard_count();
-                    let current_shard_id = shard_id(guild.id.as_u64().to_owned(), shard_count);
-
-                    let guild_count = ctx
-                        .cache
-                        .guilds()
-                        .iter()
-                        .filter(|g| {
-                            shard_id(g.as_u64().to_owned(), shard_count) == current_shard_id
-                        })
-                        .count() as u64;
-
-                    let mut hm = HashMap::new();
-                    hm.insert("server_count", guild_count);
-                    hm.insert("shard_id", current_shard_id);
-                    hm.insert("shard_count", shard_count);
-
-                    let response = data
-                        .http
-                        .post(
-                            format!(
-                                "https://top.gg/api/bots/{}/stats",
-                                ctx.cache.current_user_id().as_u64()
-                            )
-                            .as_str(),
-                        )
-                        .header("Authorization", token)
-                        .json(&hm)
-                        .send()
-                        .await;
-
-                    if let Err(res) = response {
-                        println!("DiscordBots Response: {:?}", res);
-                    }
-                }
-            }
-        }
-        poise::Event::VoiceStateUpdate { old, new, .. } => {
+        FullEvent::VoiceStateUpdate { old, new, .. } => {
             if let Some(past_state) = old {
                 if let (Some(guild_id), None) = (past_state.guild_id, new.channel_id) {
                     if let Some(channel_id) = past_state.channel_id {
-                        if let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx) {
-                            if channel.members(&ctx).await.map(|m| m.len()).unwrap_or(0) <= 1 {
-                                let songbird = songbird::get(ctx).await.unwrap();
+                        let is_okay = ctx
+                            .cache
+                            .channel(channel_id)
+                            .map(|c| c.members(&ctx).ok().map(|m| m.len()))
+                            .flatten()
+                            .unwrap_or(0)
+                            <= 1;
 
-                                let _ = songbird.remove(guild_id).await;
-                            }
+                        if is_okay {
+                            let songbird = songbird::get(ctx).await.unwrap();
+
+                            songbird.remove(guild_id).await?;
                         }
                     }
                 }
             } else if let (Some(guild_id), Some(user_channel)) = (new.guild_id, new.channel_id) {
-                if let Some(guild) = ctx.cache.guild(guild_id) {
-                    let guild_data_opt = data.guild_data(guild.id).await;
+                let guild_data_opt = data.guild_data(guild_id).await;
 
-                    if let Ok(guild_data) = guild_data_opt {
-                        let volume;
-                        let allowed_greets;
+                if let Ok(guild_data) = guild_data_opt {
+                    let volume;
+                    let allowed_greets;
 
+                    {
+                        let read = guild_data.read().await;
+
+                        volume = read.volume;
+                        allowed_greets = read.allow_greets;
+                    }
+
+                    if allowed_greets != AllowGreet::Disabled {
+                        if let Some(join_id) = data
+                            .join_sound(
+                                new.user_id,
+                                new.guild_id,
+                                allowed_greets == AllowGreet::GuildOnly,
+                            )
+                            .await
                         {
-                            let read = guild_data.read().await;
+                            let mut sound = sqlx::query_as_unchecked!(
+                                Sound,
+                                "
+                                    SELECT name, id, public, server_id, uploader_id
+                                        FROM sounds
+                                        WHERE id = ?",
+                                join_id
+                            )
+                            .fetch_one(&data.database)
+                            .await
+                            .unwrap();
 
-                            volume = read.volume;
-                            allowed_greets = read.allow_greets;
-                        }
+                            let call = join_channel(&ctx, guild_id, user_channel).await?;
 
-                        if allowed_greets != AllowGreet::Disabled {
-                            if let Some(join_id) = data
-                                .join_sound(
-                                    new.user_id,
-                                    new.guild_id,
-                                    allowed_greets == AllowGreet::GuildOnly,
-                                )
-                                .await
-                            {
-                                let mut sound = sqlx::query_as_unchecked!(
-                                    Sound,
-                                    "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE id = ?
-                                        ",
-                                    join_id
-                                )
-                                .fetch_one(&data.database)
-                                .await
-                                .unwrap();
+                            #[cfg(feature = "metrics")]
+                            GREET_COUNTER.inc();
 
-                                let (handler, _) = join_channel(&ctx, guild, user_channel).await;
-
-                                play_audio(
-                                    &mut sound,
-                                    volume,
-                                    &mut handler.lock().await,
-                                    &data.database,
-                                    false,
-                                )
-                                .await
-                                .unwrap();
-                            }
+                            play_audio(
+                                &mut sound,
+                                volume,
+                                &mut call.lock().await,
+                                &data.database,
+                                false,
+                            )
+                            .await
+                            .unwrap();
                         }
                     }
                 }
             }
         }
-        poise::Event::InteractionCreate { interaction } => match interaction {
-            Interaction::MessageComponent(component) => {
+        FullEvent::InteractionCreate { interaction } => match interaction {
+            Interaction::Component(component) => {
                 if let Some(guild_id) = component.guild_id {
                     if let Ok(()) = SoundPager::handle_interaction(ctx, &data, component).await {
                     } else {
-                        component
-                            .create_interaction_response(ctx, |r| {
-                                r.kind(InteractionResponseType::DeferredUpdateMessage)
-                            })
-                            .await
-                            .unwrap();
+                        let mode = component.data.custom_id.as_str();
+                        match mode {
+                            "#stop" => {
+                                component.defer(&ctx).await.unwrap();
 
-                        play_from_query(
-                            &ctx,
-                            &data,
-                            guild_id.to_guild_cached(&ctx).unwrap(),
-                            component.user.id,
-                            None,
-                            &component.data.custom_id,
-                            false,
-                        )
-                        .await;
+                                let songbird = songbird::get(ctx).await.unwrap();
+                                let call_opt = songbird.get(guild_id);
+
+                                if let Some(call) = call_opt {
+                                    let mut lock = call.lock().await;
+
+                                    lock.stop();
+                                }
+                            }
+
+                            "#loop" | "#queue" | "#instant" => {
+                                let components = {
+                                    let mut c = vec![];
+
+                                    for action_row in &component.message.components {
+                                        let mut row = vec![];
+                                        // These are always buttons
+                                        for component in &action_row.components {
+                                            match component {
+                                                ActionRowComponent::Button(button) => match &button
+                                                    .data
+                                                {
+                                                    ButtonKind::Link { .. } => {}
+                                                    ButtonKind::NonLink { custom_id, style } => row
+                                                        .push(
+                                                            CreateButton::new(
+                                                                if custom_id.starts_with('#') {
+                                                                    custom_id.to_string()
+                                                                } else {
+                                                                    format!(
+                                                                        "{}{}",
+                                                                        custom_id
+                                                                            .split('#')
+                                                                            .next()
+                                                                            .unwrap(),
+                                                                        mode
+                                                                    )
+                                                                },
+                                                            )
+                                                            .label(button.label.clone().unwrap())
+                                                            .emoji(button.emoji.clone().unwrap())
+                                                            .disabled(
+                                                                custom_id == "#mode"
+                                                                    || custom_id == mode,
+                                                            )
+                                                            .style(*style),
+                                                        ),
+                                                },
+                                                _ => {}
+                                            }
+                                        }
+
+                                        c.push(CreateActionRow::Buttons(row));
+                                    }
+                                    c
+                                };
+
+                                let response =
+                                    EditInteractionResponse::default().components(components);
+
+                                component.edit_response(&ctx, response).await.unwrap();
+                            }
+
+                            id_mode => {
+                                component.defer(&ctx).await.unwrap();
+
+                                let mut it = id_mode.split('#');
+                                let id = it.next().unwrap();
+                                let mode = it.next().unwrap_or("instant");
+
+                                let guild =
+                                    guild_id.to_guild_cached(&ctx).map(|g| g.clone()).unwrap();
+
+                                play_from_query(
+                                    &ctx,
+                                    &data,
+                                    &guild,
+                                    component.user.id,
+                                    None,
+                                    id.split('#').next().unwrap(),
+                                    mode == "loop",
+                                )
+                                .await;
+                            }
+                        }
                     }
                 }
             }

src/main.rs

@@ -5,6 +5,8 @@ mod cmds;
 mod consts;
 mod error;
 mod event_handlers;
+#[cfg(feature = "metrics")]
+mod metrics;
 mod models;
 mod utils;
 
@@ -12,11 +14,11 @@ use std::{env, path::Path, sync::Arc};
 
 use dashmap::DashMap;
 use poise::serenity_prelude::{
-    builder::CreateApplicationCommands,
     model::{
         gateway::GatewayIntents,
         id::{GuildId, UserId},
     },
+    ActivityData, ClientBuilder,
 };
 use songbird::SerenityInit;
 use sqlx::{MySql, Pool};
@@ -28,7 +30,6 @@ type Database = MySql;
 
 pub struct Data {
     database: Pool<Database>,
-    http: reqwest::Client,
     guild_data_cache: DashMap<GuildId, Arc<RwLock<GuildData>>>,
     join_sound_cache: DashMap<UserId, DashMap<Option<GuildId>, Option<u32>>>,
 }
@@ -36,36 +37,6 @@ pub struct Data {
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Context<'a> = poise::Context<'a, Data, Error>;
 
-pub async fn register_application_commands(
-    ctx: &poise::serenity_prelude::Context,
-    framework: &poise::Framework<Data, Error>,
-    guild_id: Option<GuildId>,
-) -> Result<(), poise::serenity_prelude::Error> {
-    let mut commands_builder = CreateApplicationCommands::default();
-    let commands = &framework.options().commands;
-    for command in commands {
-        if let Some(slash_command) = command.create_as_slash_command() {
-            commands_builder.add_application_command(slash_command);
-        }
-        if let Some(context_menu_command) = command.create_as_context_menu_command() {
-            commands_builder.add_application_command(context_menu_command);
-        }
-    }
-    let commands_builder = poise::serenity_prelude::json::Value::Array(commands_builder.0);
-
-    if let Some(guild_id) = guild_id {
-        ctx.http
-            .create_guild_application_commands(guild_id.0, &commands_builder)
-            .await?;
-    } else {
-        ctx.http
-            .create_global_application_commands(&commands_builder)
-            .await?;
-    }
-
-    Ok(())
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     if Path::new("/etc/soundfx-rs/config.env").exists() {
@@ -85,6 +56,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             cmds::manage::download_file(),
             cmds::manage::delete_sound(),
             cmds::play::play(),
+            cmds::play::play_random(),
             cmds::play::queue_play(),
             cmds::play::loop_play(),
             cmds::play::soundboard(),
@@ -92,10 +64,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
                 subcommands: vec![
                     cmds::search::list_guild_sounds(),
                     cmds::search::list_user_sounds(),
+                    cmds::search::list_favorite_sounds(),
                 ],
                 ..cmds::search::list_sounds()
             },
-            cmds::search::show_random_sounds(),
+            poise::Command {
+                subcommands: vec![
+                    cmds::favorite::add_favorite(),
+                    cmds::favorite::remove_favorite(),
+                ],
+                ..cmds::favorite::favorites()
+            },
             cmds::search::search_sounds(),
             cmds::stop::stop_playing(),
             cmds::stop::disconnect(),
@@ -124,7 +103,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             },
         ],
         allowed_mentions: None,
-        listener: |ctx, event, _framework, data| Box::pin(listener(ctx, event, data)),
+        event_handler: |ctx, event, _framework, data| Box::pin(listener(ctx, event, data)),
         ..Default::default()
     };
 
@@ -134,16 +113,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
     sqlx::migrate!().run(&database).await?;
 
-    poise::Framework::builder()
-        .token(discord_token)
-        .user_data_setup(move |ctx, _bot, framework| {
+    #[cfg(feature = "metrics")]
+    {
+        metrics::init_metrics();
+        tokio::spawn(async { metrics::serve().await });
+    }
+
+    let framework = poise::Framework::builder()
+        .setup(move |ctx, _bot, framework| {
             Box::pin(async move {
-                register_application_commands(ctx, framework, None)
-                    .await
-                    .unwrap();
+                poise::builtins::register_globally(ctx, &framework.options().commands).await?;
 
                 Ok(Data {
-                    http: reqwest::Client::new(),
                     database,
                     guild_data_cache: Default::default(),
                     join_sound_cache: Default::default(),
@@ -151,10 +132,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             })
         })
         .options(options)
-        .client_settings(move |client_builder| client_builder.register_songbird())
-        .intents(GatewayIntents::GUILD_VOICE_STATES | GatewayIntents::GUILDS)
-        .run_autosharded()
-        .await?;
+        .build();
+
+    let mut client = ClientBuilder::new(
+        &discord_token,
+        GatewayIntents::GUILD_VOICE_STATES | GatewayIntents::GUILDS,
+    )
+    .activity(ActivityData::watching("for /play"))
+    .framework(framework)
+    .register_songbird()
+    .await?;
+
+    client.start_autosharded().await.unwrap();
 
     Ok(())
 }

src/metrics.rs

@@ -0,0 +1,46 @@
+use axum::{routing::get, Router};
+use lazy_static;
+use log::warn;
+use prometheus::{register_int_counter, IntCounter, Registry};
+
+lazy_static! {
+    static ref REGISTRY: Registry = Registry::new();
+    pub static ref PLAY_COUNTER: IntCounter =
+        register_int_counter!("play_cmd", "Number of calls to /play").unwrap();
+    pub static ref UPLOAD_COUNTER: IntCounter =
+        register_int_counter!("upload_cmd", "Number of calls to /upload").unwrap();
+    pub static ref DELETE_COUNTER: IntCounter =
+        register_int_counter!("delete_cmd", "Number of calls to /delete").unwrap();
+    pub static ref GREET_COUNTER: IntCounter =
+        register_int_counter!("greet_invoke", "Number of greet sounds played").unwrap();
+}
+
+pub fn init_metrics() {
+    REGISTRY.register(Box::new(PLAY_COUNTER.clone())).unwrap();
+    REGISTRY.register(Box::new(UPLOAD_COUNTER.clone())).unwrap();
+    REGISTRY.register(Box::new(DELETE_COUNTER.clone())).unwrap();
+    REGISTRY.register(Box::new(GREET_COUNTER.clone())).unwrap();
+}
+
+pub async fn serve() {
+    let app = Router::new().route("/metrics", get(metrics));
+
+    let listener = tokio::net::TcpListener::bind("localhost:31755")
+        .await
+        .unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn metrics() -> String {
+    let encoder = prometheus::TextEncoder::new();
+    let res_custom = encoder.encode_to_string(&REGISTRY.gather());
+
+    match res_custom {
+        Ok(s) => s,
+        Err(e) => {
+            warn!("Error encoding metrics: {:?}", e);
+
+            String::new()
+        }
+    }
+}

src/models/guild_data.rs

@@ -78,12 +78,10 @@ impl GuildData {
 
         let guild_data = sqlx::query_as_unchecked!(
             GuildData,
-            "
-SELECT id, prefix, volume, allow_greets, allowed_role
-    FROM servers
-    WHERE id = ?
-            ",
-            guild_id.as_u64()
+            "SELECT id, prefix, volume, allow_greets, allowed_role
+                FROM servers
+                WHERE id = ?",
+            guild_id.get()
         )
         .fetch_one(db_pool)
         .await;
@@ -104,17 +102,15 @@ SELECT id, prefix, volume, allow_greets, allowed_role
         let guild_id = guild_id.into();
 
         sqlx::query!(
-            "
-INSERT INTO servers (id)
-    VALUES (?)
-            ",
-            guild_id.as_u64()
+            "INSERT INTO servers (id)
+                VALUES (?)",
+            guild_id.get()
         )
         .execute(db_pool)
         .await?;
 
         Ok(GuildData {
-            id: guild_id.as_u64().to_owned(),
+            id: guild_id.get(),
             prefix: String::from("?"),
             volume: 100,
             allow_greets: AllowGreet::Enabled,

src/models/join_sound.rs

@@ -1,4 +1,5 @@
 use poise::serenity_prelude::{async_trait, model::id::UserId, GuildId};
+use sqlx::Acquire;
 
 use crate::Data;
 
@@ -47,14 +48,13 @@ impl JoinSoundCtx for Data {
                     sqlx::query_as!(
                         JoinSound,
                         "
-SELECT join_sound_id
-    FROM join_sounds
-    WHERE user = ?
-    AND guild = ?
-    ORDER BY guild IS NULL
-                    ",
-                        user_id.as_u64(),
-                        guild_id.map(|g| g.0)
+                        SELECT join_sound_id
+                            FROM join_sounds
+                            WHERE user = ?
+                            AND guild = ?
+                            ORDER BY guild IS NULL",
+                        user_id.get(),
+                        guild_id.map(|g| g.get())
                     )
                     .fetch_one(&self.database)
                     .await
@@ -62,14 +62,13 @@ SELECT join_sound_id
                     sqlx::query_as!(
                         JoinSound,
                         "
-SELECT join_sound_id
-    FROM join_sounds
-    WHERE user = ?
-    AND (guild IS NULL OR guild = ?)
-    ORDER BY guild IS NULL
-                    ",
-                        user_id.as_u64(),
-                        guild_id.map(|g| g.0)
+                        SELECT join_sound_id
+                            FROM join_sounds
+                            WHERE user = ?
+                            AND (guild IS NULL OR guild = ?)
+                            ORDER BY guild IS NULL",
+                        user_id.get(),
+                        guild_id.map(|g| g.get())
                     )
                     .fetch_one(&self.database)
                     .await
@@ -111,29 +110,29 @@ SELECT join_sound_id
             Some(join_id) => {
                 sqlx::query!(
                     "DELETE FROM join_sounds WHERE user = ? AND guild <=> ?",
-                    user_id.0,
-                    guild_id.map(|g| g.0)
+                    user_id.get(),
+                    guild_id.map(|g| g.get())
                 )
-                .execute(&mut transaction)
+                .execute(transaction.acquire().await?)
                 .await?;
 
                 sqlx::query!(
                     "INSERT INTO join_sounds (user, join_sound_id, guild) VALUES (?, ?, ?)",
-                    user_id.0,
+                    user_id.get(),
                     join_id,
-                    guild_id.map(|g| g.0)
+                    guild_id.map(|g| g.get())
                 )
-                .execute(&mut transaction)
+                .execute(transaction.acquire().await?)
                 .await?;
             }
 
             None => {
                 sqlx::query!(
                     "DELETE FROM join_sounds WHERE user = ? AND guild <=> ?",
-                    user_id.0,
-                    guild_id.map(|g| g.0)
+                    user_id.get(),
+                    guild_id.map(|g| g.get())
                 )
-                .execute(&mut transaction)
+                .execute(transaction.acquire().await?)
                 .await?;
             }
         }

src/models/sound.rs

@@ -1,9 +1,7 @@
-use std::{env, path::Path};
-
 use poise::serenity_prelude::async_trait;
-use songbird::input::restartable::Restartable;
+use songbird::input::Input;
 use sqlx::Executor;
-use tokio::{fs::File, io::AsyncWriteExt, process::Command};
+use tokio::process::Command;
 
 use crate::{consts::UPLOAD_MAX_SIZE, error::ErrorTypes, Data, Database};
 
@@ -37,17 +35,31 @@ pub trait SoundCtx {
         user_id: U,
         guild_id: G,
     ) -> Result<Vec<Sound>, sqlx::Error>;
+    async fn autocomplete_favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        query: &str,
+        user_id: U,
+    ) -> Result<Vec<Sound>, sqlx::Error>;
     async fn user_sounds<U: Into<u64> + Send>(
         &self,
         user_id: U,
         page: Option<u64>,
     ) -> Result<Vec<Sound>, sqlx::Error>;
+    async fn favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        user_id: U,
+        page: Option<u64>,
+    ) -> Result<Vec<Sound>, sqlx::Error>;
     async fn guild_sounds<G: Into<u64> + Send>(
         &self,
         guild_id: G,
         page: Option<u64>,
     ) -> Result<Vec<Sound>, sqlx::Error>;
     async fn count_user_sounds<U: Into<u64> + Send>(&self, user_id: U) -> Result<u64, sqlx::Error>;
+    async fn count_favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        user_id: U,
+    ) -> Result<u64, sqlx::Error>;
     async fn count_guild_sounds<G: Into<u64> + Send>(
         &self,
         guild_id: G,
@@ -85,14 +97,13 @@ impl SoundCtx for Data {
             let sound = sqlx::query_as_unchecked!(
                 Sound,
                 "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE id = ? AND (
-        public = 1 OR
-        uploader_id = ? OR
-        server_id = ?
-    )
-                ",
+                SELECT name, id, public, server_id, uploader_id
+                    FROM sounds
+                    WHERE id = ? AND (
+                        public = 1 OR
+                        uploader_id = ? OR
+                        server_id = ?
+                    )",
                 id,
                 user_id,
                 guild_id
@@ -109,19 +120,28 @@ SELECT name, id, public, server_id, uploader_id
                 sound = sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE name = ? AND (
-        public = 1 OR
-        uploader_id = ? OR
-        server_id = ?
-    )
-    ORDER BY uploader_id = ? DESC, server_id = ? DESC, public = 1 DESC, rand()
-                    ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE name = ? AND (
+                            public = 1 OR
+                            uploader_id = ? OR
+                            server_id = ?
+                        )
+                        ORDER BY
+                            uploader_id = ? DESC,
+                            EXISTS(
+                                SELECT 1
+                                FROM favorite_sounds
+                                WHERE sound_id = id AND user_id = ?
+                            ) DESC,
+                            server_id = ? DESC,
+                            public = 1 DESC,
+                            rand()",
                     name,
                     user_id,
                     guild_id,
                     user_id,
+                    user_id,
                     guild_id
                 )
                 .fetch_all(&db_pool)
@@ -130,19 +150,28 @@ SELECT name, id, public, server_id, uploader_id
                 sound = sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE name LIKE CONCAT('%', ?, '%') AND (
-        public = 1 OR
-        uploader_id = ? OR
-        server_id = ?
-    )
-    ORDER BY uploader_id = ? DESC, server_id = ? DESC, public = 1 DESC, rand()
-                    ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE name LIKE CONCAT('%', ?, '%') AND (
+                            public = 1 OR
+                            uploader_id = ? OR
+                            server_id = ?
+                        )
+                        ORDER BY
+                            uploader_id = ? DESC,
+                            EXISTS(
+                                SELECT 1
+                                FROM favorite_sounds
+                                WHERE sound_id = id AND user_id = ?
+                            ) DESC,
+                            server_id = ? DESC,
+                            public = 1 DESC,
+                            rand()",
                     name,
                     user_id,
                     guild_id,
                     user_id,
+                    user_id,
                     guild_id
                 )
                 .fetch_all(&db_pool)
@@ -160,18 +189,48 @@ SELECT name, id, public, server_id, uploader_id
         guild_id: G,
     ) -> Result<Vec<Sound>, sqlx::Error> {
         let db_pool = self.database.clone();
+        let user_id = user_id.into();
 
         sqlx::query_as_unchecked!(
             Sound,
             "
-SELECT name, id, public, server_id, uploader_id
-FROM sounds
-WHERE name LIKE CONCAT(?, '%') AND (uploader_id = ? OR server_id = ?)
-LIMIT 25
-            ",
+            SELECT name, id, public, server_id, uploader_id
+            FROM sounds
+            WHERE name LIKE CONCAT(?, '%') AND (uploader_id = ? OR server_id = ? OR EXISTS(
+                SELECT 1
+                FROM favorite_sounds
+                WHERE sound_id = id AND user_id = ?
+            ))
+            LIMIT 25",
+            query,
+            user_id,
+            guild_id.into(),
+            user_id,
+        )
+        .fetch_all(&db_pool)
+        .await
+    }
+
+    async fn autocomplete_favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        query: &str,
+        user_id: U,
+    ) -> Result<Vec<Sound>, sqlx::Error> {
+        let db_pool = self.database.clone();
+
+        sqlx::query_as_unchecked!(
+            Sound,
+            "
+            SELECT name, id, public, server_id, uploader_id
+            FROM sounds
+            WHERE name LIKE CONCAT(?, '%') AND EXISTS(
+                SELECT 1
+                FROM favorite_sounds
+                WHERE sound_id = id AND user_id = ?
+            )
+            LIMIT 25",
             query,
             user_id.into(),
-            guild_id.into(),
         )
         .fetch_all(&db_pool)
         .await
@@ -187,12 +246,11 @@ LIMIT 25
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE uploader_id = ?
-    ORDER BY id DESC
-    LIMIT ?, ?
-            ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE uploader_id = ?
+                        ORDER BY id DESC
+                        LIMIT ?, ?",
                     user_id.into(),
                     page * 25,
                     (page + 1) * 25
@@ -204,11 +262,52 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE uploader_id = ?
-    ORDER BY id DESC
-            ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE uploader_id = ?
+                        ORDER BY id DESC",
+                    user_id.into()
+                )
+                .fetch_all(&self.database)
+                .await?
+            }
+        };
+
+        Ok(sounds)
+    }
+
+    async fn favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        user_id: U,
+        page: Option<u64>,
+    ) -> Result<Vec<Sound>, sqlx::Error> {
+        let sounds = match page {
+            Some(page) => {
+                sqlx::query_as_unchecked!(
+                    Sound,
+                    "
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        INNER JOIN favorite_sounds f ON sounds.id = f.sound_id
+                        WHERE f.user_id = ?
+                        ORDER BY id DESC
+                        LIMIT ?, ?",
+                    user_id.into(),
+                    page * 25,
+                    (page + 1) * 25
+                )
+                .fetch_all(&self.database)
+                .await?
+            }
+            None => {
+                sqlx::query_as_unchecked!(
+                    Sound,
+                    "
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        INNER JOIN favorite_sounds f ON sounds.id = f.sound_id
+                        WHERE f.user_id = ?
+                        ORDER BY id DESC",
                     user_id.into()
                 )
                 .fetch_all(&self.database)
@@ -229,12 +328,11 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE server_id = ?
-    ORDER BY id DESC
-    LIMIT ?, ?
-            ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE server_id = ?
+                        ORDER BY id DESC
+                        LIMIT ?, ?",
                     guild_id.into(),
                     page * 25,
                     (page + 1) * 25
@@ -247,11 +345,10 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
-    FROM sounds
-    WHERE server_id = ?
-    ORDER BY id DESC
-            ",
+                    SELECT name, id, public, server_id, uploader_id
+                        FROM sounds
+                        WHERE server_id = ?
+                        ORDER BY id DESC",
                     guild_id.into()
                 )
                 .fetch_all(&self.database)
@@ -272,6 +369,19 @@ SELECT name, id, public, server_id, uploader_id
         .count as u64)
     }
 
+    async fn count_favorite_sounds<U: Into<u64> + Send>(
+        &self,
+        user_id: U,
+    ) -> Result<u64, sqlx::Error> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(1) as count FROM favorite_sounds WHERE user_id = ?",
+            user_id.into()
+        )
+        .fetch_one(&self.database)
+        .await?
+        .count as u64)
+    }
+
     async fn count_guild_sounds<G: Into<u64> + Send>(
         &self,
         guild_id: G,
@@ -287,7 +397,7 @@ SELECT name, id, public, server_id, uploader_id
 }
 
 impl Sound {
-    async fn src(&self, db_pool: impl Executor<'_, Database = Database>) -> Vec<u8> {
+    pub(crate) async fn src(&self, db_pool: impl Executor<'_, Database = Database>) -> Vec<u8> {
         struct Src {
             src: Vec<u8>,
         }
@@ -295,11 +405,10 @@ impl Sound {
         let record = sqlx::query_as_unchecked!(
             Src,
             "
-SELECT src
-    FROM sounds
-    WHERE id = ?
-    LIMIT 1
-            ",
+            SELECT src
+                FROM sounds
+                WHERE id = ?
+                LIMIT 1",
             self.id
         )
         .fetch_one(db_pool)
@@ -309,33 +418,11 @@ SELECT src
         record.src
     }
 
-    pub async fn store_sound_source(
-        &self,
-        db_pool: impl Executor<'_, Database = Database>,
-    ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
-        let caching_location = env::var("CACHING_LOCATION").unwrap_or(String::from("/tmp"));
-
-        let path_name = format!("{}/sound-{}", caching_location, self.id);
-        let path = Path::new(&path_name);
-
-        if !path.exists() {
-            let mut file = File::create(&path).await?;
-
-            file.write_all(&self.src(db_pool).await).await?;
-        }
-
-        Ok(path_name)
-    }
-
     pub async fn playable(
         &self,
         db_pool: impl Executor<'_, Database = Database>,
-    ) -> Result<Restartable, Box<dyn std::error::Error + Send + Sync>> {
-        let path_name = self.store_sound_source(db_pool).await?;
-
-        Ok(Restartable::ffmpeg(path_name, false)
-            .await
-            .expect("FFMPEG ERROR!"))
+    ) -> Result<Input, Box<dyn std::error::Error + Send + Sync>> {
+        Ok(Input::from(self.src(db_pool).await))
     }
 
     pub async fn count_user_sounds<U: Into<u64>>(
@@ -346,10 +433,9 @@ SELECT src
 
         let c = sqlx::query!(
             "
-SELECT COUNT(1) as count
-    FROM sounds
-    WHERE uploader_id = ?
-        ",
+            SELECT COUNT(1) as count
+                FROM sounds
+                WHERE uploader_id = ?",
             user_id
         )
         .fetch_one(db_pool)
@@ -368,12 +454,11 @@ SELECT COUNT(1) as count
 
         let c = sqlx::query!(
             "
-SELECT COUNT(1) as count
-    FROM sounds
-    WHERE
-        uploader_id = ? AND
-        name = ?
-        ",
+            SELECT COUNT(1) as count
+                FROM sounds
+                WHERE
+                    uploader_id = ? AND
+                    name = ?",
             user_id,
             name
         )
@@ -390,12 +475,11 @@ SELECT COUNT(1) as count
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         sqlx::query!(
             "
-UPDATE sounds
-SET
-    public = ?
-WHERE
-    id = ?
-            ",
+            UPDATE sounds
+            SET
+                public = ?
+            WHERE
+                id = ?",
             self.public,
             self.id
         )
@@ -416,6 +500,42 @@ WHERE
         Ok(())
     }
 
+    pub async fn add_favorite<U: Into<u64>>(
+        &self,
+        user_id: U,
+        db_pool: impl Executor<'_, Database = Database>,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync + Send>> {
+        let user_id = user_id.into();
+
+        sqlx::query!(
+            "INSERT INTO favorite_sounds (user_id, sound_id) VALUES (?, ?)",
+            user_id,
+            self.id
+        )
+        .execute(db_pool)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove_favorite<U: Into<u64>>(
+        &self,
+        user_id: U,
+        db_pool: impl Executor<'_, Database = Database>,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync + Send>> {
+        let user_id = user_id.into();
+
+        sqlx::query!(
+            "DELETE FROM favorite_sounds WHERE user_id = ? AND sound_id = ?",
+            user_id,
+            self.id
+        )
+        .execute(db_pool)
+        .await?;
+
+        Ok(())
+    }
+
     pub async fn create_anon<G: Into<u64>, U: Into<u64>>(
         name: &str,
         src_url: &str,
@@ -460,9 +580,8 @@ WHERE
             Some(data) => {
                 match sqlx::query!(
                     "
-INSERT INTO sounds (name, server_id, uploader_id, public, src)
-    VALUES (?, ?, ?, 1, ?)
-                ",
+                    INSERT INTO sounds (name, server_id, uploader_id, public, src)
+                        VALUES (?, ?, ?, 1, ?)",
                     name,
                     server_id,
                     user_id,

src/utils.rs

@@ -1,11 +1,13 @@
-use std::sync::Arc;
+use std::{ops::Deref, sync::Arc};
 
-use poise::serenity_prelude::model::{
-    channel::Channel,
-    guild::Guild,
-    id::{ChannelId, UserId},
+use poise::serenity_prelude::{
+    model::{
+        guild::Guild,
+        id::{ChannelId, UserId},
+    },
+    ChannelType, EditVoiceState, GuildId,
 };
-use songbird::{create_player, error::JoinResult, tracks::TrackHandle, Call};
+use songbird::{tracks::TrackHandle, Call};
 use sqlx::Executor;
 use tokio::sync::{Mutex, MutexGuard};
 
@@ -22,21 +24,20 @@ pub async fn play_audio(
     volume: u8,
     call_handler: &mut MutexGuard<'_, Call>,
     db_pool: impl Executor<'_, Database = Database>,
-    loop_: bool,
+    r#loop: bool,
 ) -> Result<TrackHandle, Box<dyn std::error::Error + Send + Sync>> {
-    let (track, track_handler) = create_player(sound.playable(db_pool).await?.into());
+    let track = sound.playable(db_pool).await?;
+    let handle = call_handler.play_input(track);
 
-    let _ = track_handler.set_volume(volume as f32 / 100.0);
+    handle.set_volume(volume as f32 / 100.0)?;
 
-    if loop_ {
-        let _ = track_handler.enable_loop();
+    if r#loop {
+        handle.enable_loop()?;
     } else {
-        let _ = track_handler.disable_loop();
+        handle.disable_loop()?;
     }
 
-    call_handler.play(track);
-
-    Ok(track_handler)
+    Ok(handle)
 }
 
 pub async fn queue_audio(
@@ -46,11 +47,10 @@ pub async fn queue_audio(
     db_pool: impl Executor<'_, Database = Database> + Copy,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     for sound in sounds {
-        let (a, b) = create_player(sound.playable(db_pool).await?.into());
+        let track = sound.playable(db_pool).await?;
+        let handle = call_handler.enqueue_input(track).await;
 
-        let _ = b.set_volume(volume as f32 / 100.0);
-
-        call_handler.enqueue(a);
+        handle.set_volume(volume as f32 / 100.0)?;
     }
 
     Ok(())
@@ -58,60 +58,65 @@ pub async fn queue_audio(
 
 pub async fn join_channel(
     ctx: &poise::serenity_prelude::Context,
-    guild: Guild,
+    guild_id: GuildId,
     channel_id: ChannelId,
-) -> (Arc<Mutex<Call>>, JoinResult<()>) {
+) -> Result<Arc<Mutex<Call>>, Box<dyn std::error::Error + Send + Sync>> {
     let songbird = songbird::get(ctx).await.unwrap();
-    let current_user = ctx.cache.current_user_id();
+    let current_user = ctx.cache.current_user().id;
 
-    let current_voice_state = guild
-        .voice_states
-        .get(&current_user)
-        .and_then(|voice_state| voice_state.channel_id);
+    let current_voice_state = ctx
+        .cache
+        .guild(guild_id)
+        .map(|g| {
+            g.voice_states
+                .get(&current_user)
+                .and_then(|voice_state| voice_state.channel_id)
+        })
+        .flatten();
 
-    let (call, res) = if current_voice_state == Some(channel_id) {
-        let call_opt = songbird.get(guild.id);
+    let call = if current_voice_state == Some(channel_id) {
+        let call_opt = songbird.get(guild_id);
 
         if let Some(call) = call_opt {
-            (call, Ok(()))
+            Ok(call)
         } else {
-            let (call, res) = songbird.join(guild.id, channel_id).await;
-
-            (call, res)
+            songbird.join(guild_id, channel_id).await
         }
     } else {
-        let (call, res) = songbird.join(guild.id, channel_id).await;
-
-        (call, res)
-    };
+        songbird.join(guild_id, channel_id).await
+    }?;
 
     {
-        // set call to deafen
-        let _ = call.lock().await.deafen(true).await;
+        call.lock().await.deafen(true).await?;
     }
 
-    if let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx) {
-        let _ = channel
-            .edit_voice_state(&ctx, ctx.cache.current_user(), |v| v.suppress(false))
-            .await;
+    if let Some(channel) = ctx.cache.channel(channel_id).map(|c| c.clone()) {
+        if channel.kind == ChannelType::Stage {
+            let user_id = ctx.cache.current_user().id.clone();
+
+            channel
+                .edit_voice_state(&ctx, user_id, EditVoiceState::new().suppress(true))
+                .await?;
+        }
     }
 
-    (call, res)
+    Ok(call)
 }
 
 pub async fn play_from_query(
     ctx: &poise::serenity_prelude::Context,
     data: &Data,
-    guild: Guild,
+    guild: impl Deref<Target = Guild> + Send + Sync,
     user_id: UserId,
     channel: Option<ChannelId>,
     query: &str,
-    loop_: bool,
+    r#loop: bool,
 ) -> String {
-    let guild_id = guild.id;
+    let guild_id = guild.deref().id;
 
     let channel_to_join = channel.or_else(|| {
         guild
+            .deref()
             .voice_states
             .get(&user_id)
             .and_then(|voice_state| voice_state.channel_id)
@@ -129,8 +134,7 @@ pub async fn play_from_query(
             match sound_res {
                 Some(sound) => {
                     {
-                        let (call_handler, _) =
-                            join_channel(ctx, guild.clone(), user_channel).await;
+                        let call_handler = join_channel(ctx, guild_id, user_channel).await.unwrap();
 
                         let guild_data = data.guild_data(guild_id).await.unwrap();
 
@@ -141,7 +145,7 @@ pub async fn play_from_query(
                             guild_data.read().await.volume,
                             &mut lock,
                             &data.database,
-                            loop_,
+                            r#loop,
                         )
                         .await
                         .unwrap();