Remove top.gg

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-223.8836.42">
-    <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,13 +2,13 @@
 name = "soundfx-rs"
 description = "Discord bot for custom sound effects and soundboards"
 license = "AGPL-3.0-only"
-version = "1.5.7"
+version = "1.5.11"
 authors = ["jellywx <judesouthworth@pm.me>"]
 edition = "2018"
 
 [dependencies]
 songbird = { version = "0.3", features = ["builtin-queue"] }
-poise = "0.3"
+poise = "0.5.5"
 sqlx = { version = "0.5", default-features = false, features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "migrate"] }
 tokio = { version = "1", features = ["fs", "process", "io-util"] }
 lazy_static = "1.4"
@@ -20,9 +20,14 @@ serde_json = "1.0"
 dashmap = "5.3"
 serde = "1.0"
 dotenv = "0.15.0"
+prometheus = { version = "0.13.3", optional = true }
+axum = { version = "0.6.20", optional = true }
+
+[features]
+metrics = ["dep:prometheus", "dep:axum"]
 
 [patch."https://github.com/serenity-rs/serenity"]
-serenity = { version = "0.11.5" }
+serenity = { version = "0.11.6" }
 
 [package.metadata.deb]
 depends = "$auto, ffmpeg"
@@ -30,7 +35,10 @@ 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]

Containerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:20.04
+
+ENV RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH=/usr/local/cargo/bin:$PATH
+
+RUN apt update && DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt install -y gcc gcc-multilib cmake ffmpeg libopus-dev pkg-config libssl-dev curl mysql-client-8.0
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --profile minimal
+RUN cargo install cargo-deb

README.md

@@ -23,11 +23,26 @@ Options:
 
 ## Building from source
 
-1. Install build dependencies: `sudo apt install gcc gcc-multilib cmake ffmpeg libopus-dev`
+When running from source, the config options above can be configured simply as environment variables.
+
+Two options for building are offered. The first is easier.
+
+### Build for local platform
+
+1. Install build dependencies: `sudo apt install gcc gcc-multilib cmake ffmpeg libopus-dev pkg-config libssl-dev`
 2. Install database server: `sudo apt install mysql-server-8.0`. Create a database called `soundfx`
 3. Install Cargo and Rust from https://rustup.rs
 4. Install SQLx CLI: `cargo install sqlx-cli`
 5. From the source code directory, execute `sqlx migrate run`
 6. Build with cargo: `cargo build --release`
 
-When running from source, the config options above can be configured simply as environment variables.
+### Build for other platform
+
+By default, this builds targeting Ubuntu 20.04. Modify the Containerfile if you wish to target a different platform. These instructions are written using `podman`, but `docker` should work too.
+
+1. Install container software: `sudo apt install podman`.
+2. Install database server: `sudo apt install mysql-server-8.0`. Create a database called `soundfx`
+3. Install SQLx CLI: `cargo install sqlx-cli`
+4. From the source code directory, execute `sqlx migrate run`
+5. Build container image: `podman build -t soundfx .`
+6. Build with podman: `podman run --rm --network=host -v "$PWD":/mnt -w /mnt -e "DATABASE_URL=mysql://user@localhost/soundfx" soundfx cargo deb` 

debian/postinst

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+set -e
+
+id -u soundfx &>/dev/null || useradd -r -M soundfx
+
+chown soundfx /etc/soundfx-rs/config.env
+
+#DEBHELPER#

debian/postrm

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+id -u soundfx &>/dev/null || userdel soundfx
+
+#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

@@ -33,6 +33,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
@@ -57,7 +60,7 @@ __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();
 
     ctx.send(|m| m.ephemeral(true)
         .embed(|e| e

src/cmds/manage.rs

@@ -35,7 +35,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,11 +56,10 @@ 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)
-                        .await;
+                    let patreon_guild_member =
+                        GuildId(*PATREON_GUILD).member(ctx, ctx.author().id).await;
 
                     if let Ok(member) = patreon_guild_member {
                         permit_upload = member.roles.contains(&RoleId(*PATREON_ROLE));
@@ -89,9 +94,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?;
@@ -123,8 +125,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

src/cmds/mod.rs

@@ -1,5 +1,6 @@
 use crate::{models::sound::SoundCtx, Context};
 
+pub mod favorite;
 pub mod info;
 pub mod manage;
 pub mod play;
@@ -22,3 +23,19 @@ pub async fn autocomplete_sound(
         })
         .collect()
 }
+
+pub async fn autocomplete_favorite(
+    ctx: Context<'_>,
+    partial: &str,
+) -> Vec<poise::AutocompleteChoice<String>> {
+    ctx.data()
+        .autocomplete_favorite_sounds(&partial, ctx.author().id)
+        .await
+        .unwrap_or(vec![])
+        .iter()
+        .map(|s| poise::AutocompleteChoice {
+            name: s.name.clone(),
+            value: s.id.to_string(),
+        })
+        .collect()
+}

src/cmds/play.rs

@@ -1,11 +1,16 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
 use poise::serenity_prelude::{
     builder::CreateActionRow, model::application::component::ButtonStyle, GuildChannel,
+    ReactionType,
 };
 
+#[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,
 };
 
@@ -24,13 +29,12 @@ pub async fn play(
 
     let guild = ctx.guild().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 {
+    #[cfg(feature = "metrics")]
+    PLAY_COUNTER.inc();
+
     ctx.say(
         play_from_query(
-                &ctx.discord(),
+            &ctx.serenity_context(),
             &ctx.data(),
             guild,
             ctx.author().id,
@@ -41,6 +45,69 @@ pub async fn play(
         .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 guild = ctx.guild().unwrap();
+    let channel_to_join = channel.map(|c| c.id).or_else(|| {
+        guild
+            .voice_states
+            .get(&ctx.author().id)
+            .and_then(|voice_state| voice_state.channel_id)
+    });
+
+    match channel_to_join {
+        Some(channel) => {
+            let (call_handler, _) =
+                join_channel(ctx.serenity_context(), guild.clone(), channel).await;
+
+            let sounds = ctx.data().guild_sounds(guild.id, None).await?;
+
+            let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+
+            // 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_handler.lock().await;
+
+                    play_audio(
+                        sound,
+                        guild_data.read().await.volume,
+                        &mut lock,
+                        &ctx.data().database,
+                        false,
+                    )
+                    .await
+                    .unwrap();
+                }
+
+                None => {
+                    ctx.say("No sounds in this server!").await?;
+                }
+            }
+        }
+
+        None => {
+            ctx.say("You are not in a voice chat!").await?;
+        }
     }
 
     Ok(())
@@ -142,7 +209,8 @@ pub async fn queue_play(
 
     match channel_to_join {
         Some(user_channel) => {
-            let (call_handler, _) = join_channel(ctx.discord(), guild.clone(), user_channel).await;
+            let (call_handler, _) =
+                join_channel(ctx.serenity_context(), guild.clone(), user_channel).await;
 
             let guild_data = ctx
                 .data()
@@ -231,7 +299,7 @@ pub async fn loop_play(
 
     ctx.say(
         play_from_query(
-            &ctx.discord(),
+            &ctx.serenity_context(),
             &ctx.data(),
             guild,
             ctx.author().id,
@@ -316,21 +384,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 +408,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![];
@@ -392,7 +440,33 @@ pub async fn soundboard(
                 c.add_action_row(action_row);
             }
 
-            c
+            c.create_action_row(|r| {
+                r.create_button(|b| {
+                    b.label("Stop")
+                        .emoji(ReactionType::Unicode("⏹".to_string()))
+                        .style(ButtonStyle::Danger)
+                        .custom_id("#stop")
+                })
+                .create_button(|b| {
+                    b.label("Mode:")
+                        .style(ButtonStyle::Secondary)
+                        .disabled(true)
+                        .custom_id("#mode")
+                })
+                .create_button(|b| {
+                    b.label("Instant")
+                        .emoji(ReactionType::Unicode("▶".to_string()))
+                        .style(ButtonStyle::Secondary)
+                        .disabled(true)
+                        .custom_id("#instant")
+                })
+                .create_button(|b| {
+                    b.label("Loop")
+                        .emoji(ReactionType::Unicode("🔁".to_string()))
+                        .style(ButtonStyle::Secondary)
+                        .custom_id("#loop")
+                })
+            })
         })
     })
     .await?;

src/cmds/search.rs

@@ -47,12 +47,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 +88,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,6 +118,7 @@ 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,
         }
     }
@@ -205,6 +222,7 @@ 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?,
         };
 
@@ -228,6 +246,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())
@@ -273,28 +292,3 @@ pub async fn search_sounds(
 
     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?;
-
-    Ok(())
-}

src/cmds/settings.rs

@@ -61,9 +61,7 @@ pub async fn set_guild_greet_sound(
 ) -> 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 = guild.member_permissions(&ctx, ctx.author().id).await;
 
         if permissions.map_or(true, |p| !p.manage_guild()) {
             ctx.send(|b| {
@@ -110,9 +108,7 @@ pub async fn unset_guild_greet_sound(
 ) -> 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 = guild.member_permissions(&ctx, ctx.author().id).await;
 
         if permissions.map_or(true, |p| !p.manage_guild()) {
             ctx.send(|b| {

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,12 +1,9 @@
-use std::{collections::HashMap, env};
-
 use poise::serenity_prelude::{
     model::{
         application::interaction::{Interaction, InteractionResponseType},
         channel::Channel,
     },
-    utils::shard_id,
-    Activity, Context,
+    ActionRowComponent, Activity, Context, CreateActionRow, CreateComponents,
 };
 
 use crate::{
@@ -25,46 +22,6 @@ pub async fn listener(ctx: &Context, event: &poise::Event<'_>, data: &Data) -> R
         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, .. } => {
             if let Some(past_state) = old {
                 if let (Some(guild_id), None) = (past_state.guild_id, new.channel_id) {
@@ -105,10 +62,9 @@ pub async fn listener(ctx: &Context, event: &poise::Event<'_>, data: &Data) -> R
                                 let mut sound = sqlx::query_as_unchecked!(
                                     Sound,
                                     "
-SELECT name, id, public, server_id, uploader_id
+                                    SELECT name, id, public, server_id, uploader_id
                                         FROM sounds
-    WHERE id = ?
-                                        ",
+                                        WHERE id = ?",
                                     join_id
                                 )
                                 .fetch_one(&data.database)
@@ -137,6 +93,9 @@ SELECT name, id, public, server_id, uploader_id
                 if let Some(guild_id) = component.guild_id {
                     if let Ok(()) = SoundPager::handle_interaction(ctx, &data, component).await {
                     } else {
+                        let mode = component.data.custom_id.as_str();
+                        match mode {
+                            "#stop" => {
                                 component
                                     .create_interaction_response(ctx, |r| {
                                         r.kind(InteractionResponseType::DeferredUpdateMessage)
@@ -144,19 +103,111 @@ SELECT name, id, public, server_id, uploader_id
                                     .await
                                     .unwrap();
 
+                                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" => {
+                                component
+                                    .create_interaction_response(ctx, |r| {
+                                        r.kind(InteractionResponseType::UpdateMessage)
+                                            .interaction_response_data(|d| {
+                                                let mut c: CreateComponents = Default::default();
+
+                                                for action_row in &component.message.components {
+                                                    let mut a: CreateActionRow = Default::default();
+                                                    // These are always buttons
+                                                    for component in &action_row.components {
+                                                        match component {
+                                                            ActionRowComponent::Button(button) => {
+                                                                a.create_button(|b| {
+                                                                    if let Some(label) =
+                                                                        &button.label
+                                                                    {
+                                                                        b.label(label);
+                                                                    }
+                                                                    if let Some(emoji) =
+                                                                        &button.emoji
+                                                                    {
+                                                                        b.emoji(emoji.clone());
+                                                                    }
+                                                                    if let Some(custom_id) =
+                                                                        &button.custom_id
+                                                                    {
+                                                                        if custom_id
+                                                                            .starts_with('#')
+                                                                        {
+                                                                            b.custom_id(custom_id)
+                                                                                .disabled(
+                                                                                    custom_id
+                                                                                        == "#mode"
+                                                                                        || custom_id
+                                                                                            == mode,
+                                                                                );
+                                                                        } else {
+                                                                            b.custom_id(format!(
+                                                                                "{}{}",
+                                                                                custom_id
+                                                                                    .split('#')
+                                                                                    .next()
+                                                                                    .unwrap(),
+                                                                                mode
+                                                                            ));
+                                                                        }
+                                                                    }
+
+                                                                    b.style(button.style);
+
+                                                                    b
+                                                                });
+                                                            }
+                                                            _ => {}
+                                                        }
+                                                    }
+
+                                                    c.add_action_row(a);
+                                                }
+
+                                                d.set_components(c)
+                                            })
+                                    })
+                                    .await
+                                    .unwrap();
+                            }
+
+                            id_mode => {
+                                component
+                                    .create_interaction_response(ctx, |r| {
+                                        r.kind(InteractionResponseType::DeferredUpdateMessage)
+                                    })
+                                    .await
+                                    .unwrap();
+
+                                let mut it = id_mode.split('#');
+                                let id = it.next().unwrap();
+                                let mode = it.next().unwrap_or("instant");
+
                                 play_from_query(
                                     &ctx,
                                     &data,
                                     guild_id.to_guild_cached(&ctx).unwrap(),
                                     component.user.id,
                                     None,
-                            &component.data.custom_id,
-                            false,
+                                    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;
 
@@ -68,8 +70,8 @@ pub async fn register_application_commands(
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    if Path::new("/etc/soundfx-rs/default.env").exists() {
-        dotenv::from_path("/etc/soundfx-rs/default.env").unwrap();
+    if Path::new("/etc/soundfx-rs/config.env").exists() {
+        dotenv::from_path("/etc/soundfx-rs/config.env").unwrap();
     }
 
     env_logger::init();
@@ -85,6 +87,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 +95,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 +134,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,9 +144,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
     sqlx::migrate!().run(&database).await?;
 
+    #[cfg(feature = "metrics")]
+    {
+        metrics::init_metrics();
+        tokio::spawn(async { metrics::serve().await });
+    }
+
     poise::Framework::builder()
         .token(discord_token)
-        .user_data_setup(move |ctx, _bot, framework| {
+        .setup(move |ctx, _bot, framework| {
             Box::pin(async move {
                 register_application_commands(ctx, framework, None)
                     .await

src/metrics.rs

@@ -0,0 +1,40 @@
+use std::net::SocketAddr;
+
+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", "Number of calls to /play").unwrap();
+}
+
+pub fn init_metrics() {
+    REGISTRY.register(Box::new(PLAY_COUNTER.clone())).unwrap();
+}
+
+pub async fn serve() {
+    let app = Router::new().route("/", get(metrics));
+    let addr = SocketAddr::from(([127, 0, 0, 1], 31755));
+
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .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/sound.rs

@@ -37,17 +37,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 +99,13 @@ impl SoundCtx for Data {
             let sound = sqlx::query_as_unchecked!(
                 Sound,
                 "
-SELECT name, id, public, server_id, uploader_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 +122,28 @@ SELECT name, id, public, server_id, uploader_id
                 sound = sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    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()
-                    ",
+                        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 +152,28 @@ SELECT name, id, public, server_id, uploader_id
                 sound = sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    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()
-                    ",
+                        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 +191,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 +248,11 @@ LIMIT 25
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    SELECT name, id, public, server_id, uploader_id
                         FROM sounds
                         WHERE uploader_id = ?
                         ORDER BY id DESC
-    LIMIT ?, ?
-            ",
+                        LIMIT ?, ?",
                     user_id.into(),
                     page * 25,
                     (page + 1) * 25
@@ -204,11 +264,52 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    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 +330,11 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    SELECT name, id, public, server_id, uploader_id
                         FROM sounds
                         WHERE server_id = ?
                         ORDER BY id DESC
-    LIMIT ?, ?
-            ",
+                        LIMIT ?, ?",
                     guild_id.into(),
                     page * 25,
                     (page + 1) * 25
@@ -247,11 +347,10 @@ SELECT name, id, public, server_id, uploader_id
                 sqlx::query_as_unchecked!(
                     Sound,
                     "
-SELECT name, id, public, server_id, uploader_id
+                    SELECT name, id, public, server_id, uploader_id
                         FROM sounds
                         WHERE server_id = ?
-    ORDER BY id DESC
-            ",
+                        ORDER BY id DESC",
                     guild_id.into()
                 )
                 .fetch_all(&self.database)
@@ -272,6 +371,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,
@@ -295,11 +407,10 @@ impl Sound {
         let record = sqlx::query_as_unchecked!(
             Src,
             "
-SELECT src
+            SELECT src
                 FROM sounds
                 WHERE id = ?
-    LIMIT 1
-            ",
+                LIMIT 1",
             self.id
         )
         .fetch_one(db_pool)
@@ -346,10 +457,9 @@ SELECT src
 
         let c = sqlx::query!(
             "
-SELECT COUNT(1) as count
+            SELECT COUNT(1) as count
                 FROM sounds
-    WHERE uploader_id = ?
-        ",
+                WHERE uploader_id = ?",
             user_id
         )
         .fetch_one(db_pool)
@@ -368,12 +478,11 @@ SELECT COUNT(1) as count
 
         let c = sqlx::query!(
             "
-SELECT COUNT(1) as count
+            SELECT COUNT(1) as count
                 FROM sounds
                 WHERE
                     uploader_id = ? AND
-        name = ?
-        ",
+                    name = ?",
             user_id,
             name
         )
@@ -390,12 +499,11 @@ SELECT COUNT(1) as count
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         sqlx::query!(
             "
-UPDATE sounds
-SET
+            UPDATE sounds
+            SET
                 public = ?
-WHERE
-    id = ?
-            ",
+            WHERE
+                id = ?",
             self.public,
             self.id
         )
@@ -409,12 +517,41 @@ WHERE
         &self,
         db_pool: impl Executor<'_, Database = Database>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        sqlx::query!("DELETE FROM sounds WHERE id = ?", self.id)
+            .execute(db_pool)
+            .await?;
+
+        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!(
-            "
-DELETE
-    FROM sounds
-    WHERE id = ?
-            ",
+            "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)
@@ -467,9 +604,8 @@ DELETE
             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

@@ -22,13 +22,13 @@ 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_handler.set_volume(volume as f32 / 100.0);
 
-    if loop_ {
+    if r#loop {
         let _ = track_handler.enable_loop();
     } else {
         let _ = track_handler.disable_loop();
@@ -106,7 +106,7 @@ pub async fn play_from_query(
     user_id: UserId,
     channel: Option<ChannelId>,
     query: &str,
-    loop_: bool,
+    r#loop: bool,
 ) -> String {
     let guild_id = guild.id;
 
@@ -141,7 +141,7 @@ pub async fn play_from_query(
                             guild_data.read().await.volume,
                             &mut lock,
                             &data.database,
-                            loop_,
+                            r#loop,
                         )
                         .await
                         .unwrap();

systemd/soundfx-rs.service

@@ -2,6 +2,7 @@
 Description=Discord bot for custom sound effects and soundboards
 
 [Service]
+User=soundfx
 Type=simple
 ExecStart=/usr/bin/soundfx-rs
 WorkingDirectory=/etc/soundfx-rs