Recombined bot and service, fixed dockerfile

service/src/bot/commands/audio/play.rs

@@ -0,0 +1,134 @@
+use log::{debug, warn, error};
+
+use serenity::{prelude::*, async_trait};
+use serenity::builder::CreateApplicationCommand;
+use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
+use songbird::EventHandler;
+
+use crate::bot::commands::audio::{join, leave, add_song, get_songbird, AudioConfigs};
+
+use super::{create_response, edit_response};
+
+pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
+  // Get the track url
+  let track_url = match command.data.options.get(0) {
+    Some(t) => match &t.value {
+      Some(v) => match v.as_str() {
+        Some(s) => s.to_owned(),
+        None => {
+          warn!("Missing track option");
+          if let Err(why) = create_response(&ctx, &command, format!("Track option is missing")).await {
+            error!("Failed to create response message: {}", why);
+          }
+          return;
+        }
+      }
+      None => {
+        warn!("Missing track option");
+        if let Err(why) = create_response(&ctx, &command, format!("Track option is missing")).await {
+          error!("Failed to create response message: {}", why);
+        }
+        return;
+      }
+    }
+    None => {
+      warn!("Missing track option");
+      if let Err(why) = create_response(&ctx, &command, format!("Track option is missing")).await {
+        error!("Failed to create response message: {}", why);
+      }
+      return;
+    }
+  };
+
+  // Create the initial response
+  if let Err(why) = create_response(&ctx, &command, format!("Processing command...")).await {
+    error!("Failed to create response message: {}", why);
+    return;
+  }
+
+  match join(&ctx, &command.guild_id, &command.user).await {
+    Ok(_) => {
+      let guild_id = match command.guild_id {
+        Some(g) => g,
+        None => {
+          if let Err(why) = edit_response(&ctx, &command, "Unable to join voice channel".to_string()).await {
+            error!("Failed to edit response message: {}", why);
+          }
+          return;
+        }
+      };
+      debug!("Play command executed with track: {:?}", track_url);
+
+      let manager = get_songbird(ctx).await;
+      if let Some(handler_lock) = manager.get(guild_id) {
+        let is_queue_empty = {
+          let call_handler = handler_lock.lock().await;
+          call_handler.queue().is_empty()
+        };
+        let audio_config = {
+          let data_read = ctx.data.read().await;
+          data_read.get::<AudioConfigs>().expect("Expected AudioConfigs in TypeMap.").clone()
+        };
+        let ac = audio_config.read().await;
+        match add_song(handler_lock.clone(), &track_url, is_queue_empty, ac.get(&guild_id)).await {
+          Ok(added_song) => {
+            let track_title = added_song.title.unwrap();
+            debug!("Added track: {}", track_title);
+            if let Err(why) = edit_response(&ctx, &command, format!("Added track to queue: {}", track_title)).await {
+              error!("Failed to edit response message: {}", why);
+            }
+            let mut handler = handler_lock.lock().await;
+            handler.remove_all_global_events();
+            handler.add_global_event(songbird::Event::Track(songbird::TrackEvent::End), TrackEndNotifier { guild_id, call: manager })
+          }
+          Err(why) => {
+            warn!("Failed to add song: {}", why);
+            if let Err(why) = edit_response(&ctx, &command, format!("Failed to add song: {}", why)).await {
+              error!("Failed to edit response message: {}", why);
+            }
+            if let Err(why) = leave(&ctx, &command.guild_id).await {
+              error!("Failed to leave voice channel: {}", why);
+            }
+            return;
+          }
+        };
+      }
+    },
+    Err(err) => {
+      warn!("{}", err);
+      if let Err(why) = edit_response(&ctx, &command, format!("{}", err)).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    }
+  }
+}
+
+pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+  command.name("play").description("Plays the given track").create_option(|option| { option
+    .name("track")
+    .description("The track to be played")
+    .kind(serenity::model::prelude::command::CommandOptionType::String)
+    .required(true)
+  })
+}
+
+struct TrackEndNotifier {
+  pub call: std::sync::Arc<songbird::Songbird>,
+  pub guild_id: serenity::model::id::GuildId
+}
+
+#[async_trait]
+impl EventHandler for TrackEndNotifier {
+  async fn act(&self, ctx: &songbird::events::EventContext<'_>) -> Option<songbird::events::Event> {
+    if let songbird::EventContext::Track(_track_list) = ctx {
+      if let Some(call) = self.call.get(self.guild_id) {
+        let mut handler = call.lock().await;
+        if handler.queue().is_empty() {
+          debug!("Queue is empty, leaving voice channel");
+          handler.leave().await.unwrap();
+        }
+      }
+    }
+    None
+  }
+}