chore: code cleanup

src/commands/moover/gif.rs

@@ -1,7 +1,7 @@
 use poise;
 use serenity::all::{Embed, User};
 
-use crate::types::{Error, Context};
+use crate::types::{Context, ContextExt, Error};
 
 #[poise::command(
     slash_command,
@@ -15,6 +15,6 @@ pub async fn gif(ctx: Context<'_>,
 ) -> Result<(), Error> {
     // let embed;
     // send_with_embed(ctx, "hug", &title, &desc).await?;
-    ctx.reply("Done!").await?;
+    ctx.reply_ephemeral("Done!").await?;
     Ok(())
 }

src/commands/user_interactions/headpat.rs

@@ -1,8 +1,7 @@
-use poise;
 use serenity::all::User;
 
 use super::interaction::send_with_embed;
-use crate::types::{Context, ContextExt, Error};
+use crate::types::{Context, Error};
 
 #[poise::command(
     slash_command,
@@ -16,6 +15,5 @@ pub async fn headpat(ctx: Context<'_>,
     let title = "HEADPATS!";
     let desc = format!("{} headpats {}", ctx.author(), user);
     send_with_embed(ctx, "headpat", &title, &desc).await?;
-    ctx.reply_ephemeral("Done!").await?;
     Ok(())
 }

src/commands/user_interactions/hug.rs

@@ -2,7 +2,7 @@ use poise;
 use serenity::all::User;
 
 use super::interaction::send_with_embed;
-use crate::types::{Context, ContextExt, Error};
+use crate::types::{Context, Error};
 
 #[poise::command(
     slash_command,
@@ -16,6 +16,5 @@ pub async fn hug(ctx: Context<'_>,
     let title = "HUGS!";
     let desc = format!("{} hugs {}", ctx.author(), user);
     send_with_embed(ctx, "hug", &title, &desc).await?;
-    ctx.reply_ephemeral("Done!").await?;
     Ok(())
 }

src/commands/user_interactions/interaction.rs

@@ -1,5 +1,5 @@
-use anyhow::anyhow;
+use poise::CreateReply;
-use serenity::all::{Colour, CreateEmbed, CreateMessage};
+use serenity::all::{Colour, CreateEmbed};
 use tenorv2::tenor_builder::Tenor;
 
 use crate::{types::Context, utils::gifs::get_random_tenor_gif};
@@ -20,15 +20,7 @@ pub(super) async fn send_with_embed(ctx: Context<'_>, query: &str, title: &str,
         .description(desc)
         .image(url.as_str());
 
-    if ctx.guild_id().is_none() {
+    ctx.send(CreateReply::default().embed(embed)).await?;
-        return Err(anyhow!("Guild id not available in context"));
-    }
-
-    ctx.channel_id()
-    .send_message(
-        ctx.http(),
-        CreateMessage::new().add_embed(embed)
-    ).await?;
 
     Ok(())
 }

src/commands/voice/general_player.rs

@@ -1,6 +1,7 @@
 use std::vec;
 
 use songbird::input::YoutubeDl;
+use songbird::TrackEvent;
 
 use crate::types::{Context, ContextExt, Error};
 use crate::commands::voice::voice_utils::autocomplete_channel;
@@ -11,7 +12,8 @@ use super::connect;
 #[poise::command(
     slash_command,
     description_localized("en-US", "Plays music from supported URL"),
-    category = "Voice"
+    category = "Voice",
+    guild_only
 )]
 pub async fn play(ctx: Context<'_>,
     #[autocomplete = "autocomplete_channel"]
@@ -20,34 +22,20 @@ pub async fn play(ctx: Context<'_>,
     #[description = "Source URL: "]
     url: String,
 ) -> Result<(), Error> {
-
+    let events = vec![TrackEvent::End, TrackEvent::Error];
-    if ctx.guild().is_none() {
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
+        Ok(result) => result,
-        return Ok(());
+        Err(e) => {
-    }
-
-    let manager = songbird::get(ctx.serenity_context())
-        .await
-        .expect("Songbird Voice client placed in at initialisation.")
-        .clone();
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    let http_client = &ctx.data().http_client;
-
-    if manager.get(guild_id).is_none() {
-        if let Err(e) = connect(&ctx, guild_id, channel).await {
             ctx.reply_ephemeral(&e.to_string()).await?;
+            println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
             return Ok(())
         }
-    }
+    };
     
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;
         
+        let http_client = &ctx.data().http_client;
         let src = YoutubeDl::new(http_client.clone(), url);
         handler.enqueue_input(src.into()).await;
     }

src/commands/voice/player_common.rs

@@ -2,6 +2,7 @@ use std::vec;
 
 use poise::CreateReply;
 use songbird::input::{File, Input};
+use songbird::TrackEvent;
 
 use crate::utils::debug::send_error;
 use crate::types::{Context, ContextExt, Error};
@@ -18,7 +19,8 @@ use super::voice_utils::{connect, autocomplete_channel};
 #[poise::command(
     slash_command,
     description_localized("en-US", "Disconnect from voice channel"),
-    category = "Voice"
+    category = "Voice",
+    guild_only
 )]
 pub async fn disconnect(
     ctx: Context<'_>
@@ -68,7 +70,8 @@ async fn autocomplete_song(
 #[poise::command(
     slash_command,
     description_localized("en-US", "Play song from server storage"),
-    category = "Voice"
+    category = "Voice",
+    guild_only
 )]
 pub async fn play_local(ctx: Context<'_>,
     #[autocomplete = "autocomplete_channel"]
@@ -78,31 +81,15 @@ pub async fn play_local(ctx: Context<'_>,
     #[description = "Filename of local song: "]
     file_name: String
 ) -> Result<(), Error> {
-
+    let events = vec![TrackEvent::End, TrackEvent::Error];
-    if ctx.guild().is_none() {
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
+        Ok(result) => result,
-        return Ok(());
+        Err(e) => {
-    }
+            ctx.reply_ephemeral(&e.to_string()).await?;
-
+            println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
-    let manager = songbird::get(ctx.serenity_context())
+            return Ok(())
-        .await
-        .expect("Songbird Voice client placed in at initialisation.")
-        .clone();
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    if manager.get(guild_id).is_none() {
-        match connect(&ctx, guild_id, channel).await {
-            Ok(_) => (),
-            Err(e) => {
-                ctx.reply_ephemeral(&e.to_string()).await?;
-                return Ok(())
-            }
         }
-    }
+    };
 
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;
@@ -124,7 +111,8 @@ pub async fn play_local(ctx: Context<'_>,
 #[poise::command(
     slash_command,
     description_localized("en-US", "Display currently playing info"),
-    category = "Voice"
+    category = "Voice",
+    guild_only
 )]
 pub async fn playing(ctx: Context<'_>) -> Result<(), Error> {
 

src/commands/voice/radio/radio_player.rs

@@ -5,6 +5,7 @@ use reqwest::Client;
 
 use songbird::input::Input;
 use songbird::input::HttpRequest;
+use songbird::TrackEvent;
 
 use super::super::connect;
 use super::link_or_string;
@@ -21,7 +22,8 @@ use crate::commands::voice::voice_utils::autocomplete_channel;
 #[poise::command(
     slash_command,
     description_localized("en-US", "Plays music from URL source"),
-    subcommands("search", "play")
+    subcommands("search", "play"),
+    guild_only
 )]
 pub async fn radio(_ctx: Context<'_>) -> Result<(), Error> {
     Ok(())
@@ -41,12 +43,6 @@ pub async fn play(ctx: Context<'_>,
     #[description = "Radio station: "]
     name: String,
 ) -> Result<(), Error> {
-
-    if ctx.guild().is_none() {
-        ctx.reply_ephemeral("Can't use this outside of guild").await?;
-        return Ok(());
-    }
-
     let api = &ctx.data().radio_browser;
     
     let stations_result = match link_or_string(&name) {
@@ -88,23 +84,15 @@ pub async fn play(ctx: Context<'_>,
         return Ok(())
     };
 
-    let manager = songbird::get(ctx.serenity_context())
+    let events = vec![TrackEvent::End, TrackEvent::Error];
-        .await
+    let (manager, guild_id) = match connect(&ctx, channel, events).await {
-        .expect("Songbird Voice client placed in at initialisation.")
+        Ok(result) => result,
-        .clone();
+        Err(e) => {
-
-    let Some(guild_id) = ctx.guild_id() else {
-        ctx.reply_ephemeral("Guild id not found").await?;
-        return Ok(())
-    };
-
-    if manager.get(guild_id).is_none() {
-        if let Err(e) = connect(&ctx, guild_id, channel).await {
             ctx.reply_ephemeral(&e.to_string()).await?;
             println!("SONGBIRD MANAGER ERROR: {}", e.to_string());
             return Ok(())
         }
-    }
+    };
 
     if let Some(handler_lock) = manager.get(guild_id) {
         let mut handler = handler_lock.lock().await;

src/commands/voice/voice_types.rs

@@ -35,7 +35,6 @@ pub struct GeneralInfo {
     pub duration: Option<String>
 }
 
-
 #[async_trait]
 impl GenerateEmbed for GeneralInfo {
     async fn generate_embed(&self) -> CreateEmbed {

src/commands/voice/voice_utils.rs

@@ -1,8 +1,11 @@
+use std::sync::Arc;
+
 use serenity::all::{ChannelId, GuildId};
 use serenity::async_trait;
 
+use serenity::model::voice;
 use songbird::events::{Event, EventContext, EventHandler as VoiceEventHandler};
-use songbird::TrackEvent;
+use songbird::{Songbird, TrackEvent};
 
 use crate::{types::{Context, Error}, utils::utilities::get_channel_by_name};
 
@@ -49,7 +52,15 @@ impl VoiceEventHandler for TrackErrorNotifier {
     }
 }
 
-pub async fn connect(ctx: &Context<'_>, guild_id: GuildId, channel: Option<String>) -> Result<(), Error> {
+pub async fn connect(ctx: &Context<'_>, channel: Option<String>, events: Vec<TrackEvent>) -> Result<(Arc<Songbird>, GuildId), String> {
+    if ctx.guild().is_none() {
+        return Err("dadsa".to_string())
+    }
+
+    let Some(guild_id) = ctx.guild_id() else {
+        return Err("dadsa".to_string())
+    };
+
     let voice_channel = get_voice_channel(&ctx, channel).await?;
 
     let manager = songbird::get(ctx.serenity_context())
@@ -59,10 +70,12 @@ pub async fn connect(ctx: &Context<'_>, guild_id: GuildId, channel: Option<Strin
 
     if let Ok(handler_lock) = manager.join(guild_id, voice_channel).await {
         let mut handler = handler_lock.lock().await;
-        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
+        for event in events {
+            handler.add_global_event(event.into(), TrackErrorNotifier);
+        }
     }
 
-    Ok(())
+    Ok((manager, guild_id))
 }
 
 pub async fn autocomplete_channel(

src/commands/voice/yt/yt_player.rs

@@ -6,7 +6,6 @@ use songbird::input::YoutubeDl;
 use crate::commands::util::connect;
 use crate::util::poise_context_extension::ContextExt;
 use crate::types::{Context, Error};
-use crate::commands::voice::util::autocomplete_channel;
 
 // TODO: search, queue
 #[poise::command(
@@ -14,9 +13,9 @@ use crate::commands::voice::util::autocomplete_channel;
     description_localized("en-US", "Plays music from YouTube URL")
 )]
 pub async fn play_yt(ctx: Context<'_>,
-    #[autocomplete = "autocomplete_channel"]
     #[description = "Voice channel name: "]
-    channel: Option<String>,
+    #[channel_types("Voice")]
+    channel: Option<GuildChannel>,
     #[description = "Source URL: "]
     url: String,
 ) -> Result<(), Error> {

src/handlers.rs

@@ -0,0 +1,2 @@
+pub mod message_handler;
+pub mod voice_state_handler;

src/handlers/voice_state_handler.rs

@@ -0,0 +1,75 @@
+use std::time::Duration;
+
+use serenity::all::{Context, CreateMessage, GuildChannel, VoiceState};
+use tokio::time::sleep;
+
+use crate::utils::{debug::send_error, voice_state_to_guild_channel};
+
+async fn get_channel_info(ctx: &Context, voice_state: &VoiceState) -> Option<GuildChannel> {
+    let voice_channel = voice_state_to_guild_channel(&ctx, &voice_state).await?;
+
+    let Ok(members) = voice_channel.members(&ctx.cache) else {
+        return None
+    };
+
+    let mut is_connected = false;
+    let mut users_connected: usize = 0;
+    for member in &members {
+        if member.user.id == ctx.cache.current_user().id {
+            is_connected = true
+        }
+        if ! member.user.bot {
+            users_connected += 1;
+        }
+    }
+
+    // Check if there is no real user in the voice channel
+    if ! is_connected || users_connected > 0 {
+        return None;
+    }
+
+    Some(voice_channel)
+}
+
+pub async fn handle_voice_update(ctx: Context, voice_state_old: VoiceState, voice_state: VoiceState) -> Option<()> {
+    // The user did not disconnect so we don't need to handle if the bot was left alone
+    // Logic is as follows:
+    // User connected -> voice_state_old is None (we handle this before this function)
+    // User moved to different VC or disconnected -> we only check old channel for number of users anyway 
+    if voice_state.channel_id.is_some() {
+        return None
+    }
+
+    let mut voice_channel = get_channel_info(&ctx, &voice_state_old).await?;
+
+    let manager = songbird::get(&ctx)
+        .await
+        .expect("Songbird Voice client placed in at initialisation.")
+        .clone();
+
+    // bot is not playing any music so we don't need to handle this
+    if manager.get(voice_channel.guild_id).is_none() {
+        return None;
+    }
+
+    // There is a problem with this implementation
+    // if bot is left alone and users joins and disconnects while this counts down
+    // this is not a big problem since we want to disconnect anyway
+    sleep(Duration::from_secs(5)).await;
+
+    voice_channel = get_channel_info(&ctx, &voice_state_old).await?;
+
+    match manager.remove(voice_channel.guild_id).await {
+        Ok(()) => {
+            let _ = voice_channel.send_message(ctx.http,
+                CreateMessage::new()
+                .content("Disconnected to save bandwidth")
+            ).await;
+        }
+        Err(e) => {
+            let _ = send_error(ctx.http, e.to_string()).await;
+        }
+    }
+
+    None
+}

src/main.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 use std::error;
 use std::env;
 
+use serenity::all::VoiceState;
 use serenity::async_trait;
 use serenity::futures::lock::Mutex;
 use serenity::prelude::GatewayIntents;
@@ -19,12 +20,14 @@ use reqwest::Client as HttpClient;
 use dotenv::dotenv;
 
 use songbird::SerenityInit;
+
 use tokio_cron_scheduler::{JobScheduler, Job};
 
 use radiobrowser::RadioBrowserAPI;
 
-mod message_handler;
+mod handlers;
-use message_handler::handle;
+use handlers::message_handler::handle;
+use handlers::voice_state_handler::handle_voice_update;
 
 mod commands;
 mod utils;
@@ -35,6 +38,7 @@ use other::notice;
 mod types;
 use types::{Data, Error};
 
+
 struct Handler;
 
 async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
@@ -53,6 +57,15 @@ async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
 
 #[async_trait]
 impl EventHandler for Handler {
+    async fn voice_state_update(&self, ctx: Context, old: Option<VoiceState>, new: VoiceState) {
+        // User was not connected to any channel and connected to VC
+        let Some(old_channel) = old else {
+            return
+        };
+
+        handle_voice_update(ctx, old_channel, new).await;
+    }
+
     async fn message(&self, ctx: Context, msg: Message) {
         handle(ctx, msg).await;
     }

src/utils/utilities.rs

@@ -1,6 +1,6 @@
 use std::{fs, hash::{DefaultHasher, Hash, Hasher}, io, path::Path, sync::Arc, vec};
 
-use serenity::{all::{ChannelId, ChannelType, CreateMessage, GuildId, GuildRef, Message}, http::Http};
+use serenity::{all::{ChannelId, ChannelType, Context, CreateMessage, GuildChannel, GuildId, GuildRef, Message, VoiceState}, http::Http};
 
 
 pub async fn get_system_channel(guild_id: GuildId, http: &Http) -> anyhow::Result<ChannelId> {
@@ -15,6 +15,16 @@ pub async fn replace_msg(http: Arc<Http>, msg: Message, content: String) -> Resu
     return ChannelId::new(msg.channel_id.get()).send_message(http.clone(), CreateMessage::new().content(content)).await;
 }
 
+pub async fn voice_state_to_guild_channel(ctx: &Context, voice_state: &VoiceState) -> Option<GuildChannel> {
+    let Ok(channel) = voice_state.channel_id?
+        .to_channel(&ctx.http)
+        .await else {
+            return None
+    };
+
+    Some(channel.guild()?)
+}
+
 pub fn get_vc_names(guild: GuildRef) -> Vec<String> {
 
     let mut result: Vec<String> = [].to_vec();