improve message format

Reviewed-on: #8

.gitea/workflows/deploy.yaml

@@ -5,6 +5,9 @@ on:
     branches:
       - main
 
+paths-ignore:
+- 'README.md'
+
 jobs:
   release-image:
     runs-on: ubuntu-latest
@@ -26,6 +29,5 @@ jobs:
         with:
           platforms: |
             linux/amd64
-            linux/arm64
           push: true
           tags: jheuel/ohrwurm:latest

Cargo.toml

@@ -23,7 +23,7 @@ twilight-util = { version = "0.15", features=["builder"] }
 dotenv = "0.15.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-url = "2.5.0"
+url = "2.5.1"
 anyhow = "1.0.86"
 dashmap = "5.5.3"
 async-trait = "0.1.80"

README.md

@@ -8,7 +8,7 @@
 Ohrwurm is a user-friendly bot designed to play music in Discord voice chats. Once added to your server, you can request a song using the command `/play {query}`, where query can be a URL to a YouTube video or playlist, or a simple search term. The bot will fetch the song and start playing it. You can pause the music with `/pause`, resume playback with `/resume`, and stop and clear the queue with `/stop`. If the bot is alone in a voice chat, it will automatically leave, but you can also manually make it leave with the `/leave` command.
 
 # Deployment
-To deploy Ohrwurm with Docker, you can use the [provided Docker](https://hub.docker.com/r/jheuel/ohrwurm) image:
+To deploy Ohrwurm with Docker, you can use the [provided Docker image](https://hub.docker.com/r/jheuel/ohrwurm):
 ```bash
 docker run -d \
   --name ohrwurm \

src/commands/join.rs

@@ -38,6 +38,9 @@ pub(crate) async fn join_channel(
         call.deafen(true).await?;
     }
 
+    // create guild config
+    state.guild_settings.entry(guild_id).or_default();
+
     Ok(())
 }
 

src/commands/leave.rs

@@ -1,6 +1,26 @@
-use crate::state::State;
+use crate::state::{State, StateRef};
-use std::error::Error;
+use std::{error::Error, sync::Arc};
-use twilight_model::gateway::payload::incoming::InteractionCreate;
+use twilight_model::{
+    gateway::payload::incoming::InteractionCreate,
+    id::{marker::GuildMarker, Id},
+};
+
+pub(crate) async fn leave_channel(
+    guild_id: Id<GuildMarker>,
+    state: Arc<StateRef>,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    // stop playing
+    if let Some(call_lock) = state.songbird.get(guild_id) {
+        let call = call_lock.lock().await;
+        call.queue().stop();
+    }
+    // leave the voice channel
+    state.songbird.leave(guild_id).await?;
+
+    // reset guild settings
+    state.guild_settings.remove(&guild_id);
+    Ok(())
+}
 
 pub(crate) async fn leave(
     interaction: Box<InteractionCreate>,
@@ -16,6 +36,8 @@ pub(crate) async fn leave(
     let Some(guild_id) = interaction.guild_id else {
         return Ok(());
     };
-    state.songbird.leave(guild_id).await?;
+
+    leave_channel(guild_id, Arc::clone(&state)).await?;
+
     Ok(())
 }

src/commands/loop_queue.rs

@@ -1,5 +1,5 @@
 use crate::metadata::MetadataMap;
-use crate::state::{Settings, State, StateRef};
+use crate::state::{State, StateRef};
 use async_trait::async_trait;
 use songbird::{Event, EventContext, EventHandler, TrackEvent};
 use std::ops::Sub;
@@ -29,14 +29,8 @@ pub(crate) async fn loop_queue(
         return Ok(());
     };
 
-    state
-        .guild_settings
-        .entry(guild_id)
-        .or_insert_with(|| Settings { loop_queue: false });
-
     state.guild_settings.entry(guild_id).and_modify(|settings| {
         settings.loop_queue = !settings.loop_queue;
-        println!("loop_queue: {}", settings.loop_queue);
     });
 
     let looping = state

src/commands/mod.rs

@@ -3,6 +3,7 @@ pub(crate) use join::join;
 
 mod leave;
 pub(crate) use leave::leave;
+pub(crate) use leave::leave_channel;
 
 mod pause;
 pub(crate) use pause::pause;

src/commands/play.rs

@@ -11,6 +11,9 @@ use std::ops::Sub;
 use std::{error::Error, time::Duration};
 use tokio::process::Command;
 use tracing::debug;
+use twilight_model::channel::message::embed::{
+    EmbedAuthor, EmbedField, EmbedFooter, EmbedThumbnail,
+};
 use twilight_model::channel::message::MessageFlags;
 use twilight_model::gateway::payload::incoming::InteractionCreate;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
@@ -56,6 +59,7 @@ async fn get_tracks(
             if stderr.contains("YouTube said: The playlist does not exist.") {
                 return Err("YouTube said: The playlist does not exist.".into());
             }
+            return Err(stderr.into());
         }
         return Err("No tracks found".into());
     }
@@ -161,17 +165,35 @@ pub(crate) async fn play(
         call.queue().resume()?;
     }
 
+    struct TrackType {
+        url: String,
+        title: Option<String>,
+        duration_string: String,
+        channel: String,
+        thumbnail: Option<String>,
+    }
+
     let mut tracks_added = vec![];
-    for track in &tracks {
+    for yttrack in &tracks {
-        tracing::debug!("track: {:?}", track);
+        tracing::debug!("track: {:?}", yttrack);
-        let url = track.url.clone().or(track.original_url.clone()).ok_or("")?;
+        let url = yttrack
+            .url
+            .clone()
+            .or(yttrack.original_url.clone())
+            .ok_or("")?;
         let mut src = YoutubeDl::new(reqwest::Client::new(), url.clone());
         let src_copy = src.clone();
         let track: Track = src_copy.into();
 
         if let Ok(metadata) = src.aux_metadata().await {
             debug!("metadata: {:?}", metadata);
-            tracks_added.push((url.clone(), metadata.title.clone()));
+            tracks_added.push(TrackType {
+                url: url.clone(),
+                title: metadata.title.clone(),
+                duration_string: yttrack.duration_string.clone(),
+                channel: yttrack.channel.clone(),
+                thumbnail: metadata.thumbnail.clone(),
+            });
 
             if let Some(call_lock) = state.songbird.get(guild_id) {
                 let mut call = call_lock.lock().await;
@@ -197,16 +219,58 @@ pub(crate) async fn play(
     }
     let mut content = String::new();
     let num_tracks_added = tracks_added.len();
-    match num_tracks_added {
+    let embeds = match num_tracks_added {
-        0 => {}
+        0 => {
+            vec![]
+        }
         1 => {
-            let (title, url) = if let Some(track) = tracks_added.first() {
+            let track = tracks_added.first().unwrap();
-                let track = track.clone();
+
-                (track.1.unwrap_or("Unknown".to_string()), track.0)
+            let host = Url::parse(&track.url)?;
-            } else {
+            let host = host
-                ("Unknown".to_string(), "".to_string())
+                .host_str()
-            };
+                .unwrap_or_default()
-            content = format!("Added [{}]({}) to the queue", title, url);
+                .trim_start_matches("www.");
+            let mut embed = EmbedBuilder::new()
+                .author(EmbedAuthor {
+                    name: "🔊 Added to queue".to_string(),
+                    icon_url: None,
+                    proxy_icon_url: None,
+                    url: None,
+                })
+                .title(track.title.clone().unwrap_or("Unknown".to_string()))
+                .url(track.url.clone())
+                .color(colors::BLURPLE)
+                .footer(EmbedFooter {
+                    text: format!("Streaming from {}", host),
+                    icon_url: Some(format!(
+                        "https://www.google.com/s2/favicons?domain={}",
+                        host
+                    )),
+                    proxy_icon_url: None,
+                })
+                .field(EmbedField {
+                    inline: true,
+                    name: "Duration".to_string(),
+                    value: track.duration_string.clone(),
+                })
+                .field(EmbedField {
+                    inline: true,
+                    name: "Channel".to_string(),
+                    value: track.channel.clone(),
+                })
+                .build();
+
+            if let Some(thumbnail) = &track.thumbnail {
+                embed.thumbnail = Some(EmbedThumbnail {
+                    height: None,
+                    proxy_url: None,
+                    url: thumbnail.to_string(),
+                    width: None,
+                });
+            }
+
+            vec![embed]
         }
         _ => {
             let first_track = tracks.first().unwrap();
@@ -227,13 +291,14 @@ pub(crate) async fn play(
                 "Added {} tracks to the queue:\n",
                 num_tracks_added
             ));
+            let embed = EmbedBuilder::new()
+                .description(content)
+                .color(colors::BLURPLE)
+                .build();
+            vec![embed]
         }
-    }
+    };
 
-    let embeds = vec![EmbedBuilder::new()
-        .description(content)
-        .color(colors::BLURPLE)
-        .build()];
     state
         .http
         .interaction(interaction.application_id)

src/commands/stop.rs

@@ -23,6 +23,10 @@ pub(crate) async fn stop(
         return Ok(());
     };
 
+    state.guild_settings.entry(guild_id).and_modify(|settings| {
+        settings.loop_queue = false;
+    });
+
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
         call.queue().stop();

src/handler.rs

@@ -1,5 +1,7 @@
 use crate::commands::queue::{build_action_row, build_queue_embeds, TRACKS_PER_PAGE};
-use crate::commands::{delete, join, leave, loop_queue, pause, play, queue, resume, skip, stop};
+use crate::commands::{
+    delete, join, leave, leave_channel, loop_queue, pause, play, queue, resume, skip, stop,
+};
 use crate::state::State;
 use futures::Future;
 use std::error::Error;
@@ -63,13 +65,7 @@ pub(crate) async fn leave_if_alone(
 
     // count is 1 if the bot is the only one in the channel
     if count == 1 {
-        // stop playing
+        leave_channel(guild_id, Arc::clone(&state)).await?;
-        if let Some(call_lock) = state.songbird.get(guild_id) {
-            let call = call_lock.lock().await;
-            call.queue().stop();
-        }
-        // leave the voice channel
-        state.songbird.leave(guild_id).await?;
     }
     Ok(())
 }

src/state.rs

@@ -13,6 +13,18 @@ pub(crate) struct Settings {
     pub(crate) loop_queue: bool,
 }
 
+impl Settings {
+    pub(crate) fn new() -> Self {
+        Self { loop_queue: false }
+    }
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct StateRef {
     pub(crate) http: HttpClient,