soundboard and some tools

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "src/spotify-parser"]
+	path = src/spotify-parser
+	url = https://github.com/eRgo35/spotify-parser

Cargo.lock

@@ -336,7 +336,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
- "rand_core",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -682,6 +682,17 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.12"
@@ -691,7 +702,7 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "wasm-bindgen",
 ]
 
@@ -902,6 +913,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "json"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078e285eafdfb6c4b434e0d31e8cfcb5115b651496faca5749b88fafd4f23bfd"
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -959,15 +976,19 @@ dependencies = [
 
 [[package]]
 name = "lyra"
-version = "0.6.0"
+version = "0.8.0"
 dependencies = [
  "dotenv",
  "fancy-regex",
+ "json",
  "openssl",
+ "owoify",
  "poise",
- "rand",
+ "rand 0.8.5",
  "regex",
  "reqwest",
+ "serde",
+ "serde_json",
  "serenity",
  "songbird",
  "symphonia",
@@ -975,6 +996,7 @@ dependencies = [
  "tracing",
  "tracing-futures",
  "tracing-subscriber",
+ "url",
 ]
 
 [[package]]
@@ -1039,7 +1061,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
 dependencies = [
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
  "windows-sys 0.48.0",
 ]
 
@@ -1049,7 +1071,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.12",
 ]
 
 [[package]]
@@ -1220,6 +1242,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
+[[package]]
+name = "owoify"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d5373685d13f2b6080231760ae4e1ca37161f129e1eb2393ea9028ffa49339"
+dependencies = [
+ "rand 0.7.3",
+ "regex",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.1"
@@ -1407,6 +1439,19 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+]
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -1414,8 +1459,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
+ "rand_chacha 0.3.1",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
 ]
 
 [[package]]
@@ -1425,7 +1480,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
 ]
 
 [[package]]
@@ -1434,7 +1498,16 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.12",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
 ]
 
 [[package]]
@@ -1567,7 +1640,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "688c63d65483050968b2a8937f7995f443e27041a0f7700aa59b0822aedebb74"
 dependencies = [
  "cc",
- "getrandom",
+ "getrandom 0.2.12",
  "libc",
  "spin 0.9.8",
  "untrusted 0.9.0",
@@ -1802,9 +1875,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.196"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
+checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
 dependencies = [
  "serde_derive",
 ]
@@ -1832,9 +1905,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.196"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
+checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1843,9 +1916,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.113"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
+checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
 dependencies = [
  "itoa",
  "ryu",
@@ -2012,7 +2085,7 @@ dependencies = [
  "once_cell",
  "parking_lot",
  "pin-project",
- "rand",
+ "rand 0.8.5",
  "reqwest",
  "ringbuf",
  "rubato",
@@ -2624,7 +2697,7 @@ dependencies = [
  "http",
  "httparse",
  "log",
- "rand",
+ "rand 0.8.5",
  "rustls 0.20.9",
  "sha1",
  "thiserror",
@@ -2645,7 +2718,7 @@ dependencies = [
  "http",
  "httparse",
  "log",
- "rand",
+ "rand 0.8.5",
  "rustls 0.21.10",
  "sha1",
  "thiserror",
@@ -2661,7 +2734,7 @@ checksum = "30be5c7e2b13b4a59e0f93344c070c23404279a318a324eece1f4384ead47d86"
 dependencies = [
  "bitflags 1.3.2",
  "futures-util",
- "rand",
+ "rand 0.8.5",
  "rustls 0.20.9",
  "rustls-native-certs",
  "serde",
@@ -2813,7 +2886,7 @@ version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f00cc9702ca12d3c81455259621e676d0f7251cec66a21e98fe2e9a37db93b2a"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.12",
 ]
 
 [[package]]
@@ -2859,6 +2932,12 @@ dependencies = [
  "try-lock",
 ]
 
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lyra"
-version = "0.6.0"
+version = "0.8.0"
 authors = ["Michał Czyż <mike@c2yz.com>"]
 edition = "2021"
 description = "A featureful Discord bot written in Rust."
@@ -14,11 +14,15 @@ keywords = ["discord", "bot", "rust", "music", "featureful"]
 [dependencies]
 dotenv = "0.15.0"
 fancy-regex = "0.13.0"
+json = "0.12.4"
 openssl = { version = "0.10.63", features = ["vendored"] }
+owoify = "0.1.5"
 poise = "0.6.1"
 rand = "0.8.5"
 regex = "1.10.3"
-reqwest = "0.11.23"
+reqwest = { version = "0.11.23", features = ["json"]}
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
 serenity = { version = "0.12.0", features = ["cache", "framework", "standard_framework", "voice"] }
 songbird = { version = "0.4.0", features = ["builtin-queue", "serenity"] }
 symphonia = { version = "0.5.3", features = ["aac", "adpcm", "alac", "flac", "mpa", "isomp4"] }
@@ -26,3 +30,4 @@ tokio = { version = "1.35.1", features = ["macros", "full", "signal"] }
 tracing = "0.1.40"
 tracing-futures = "0.2.5"
 tracing-subscriber = "0.3.18"
+url = "2.5.0"

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.71-alpine
+FROM rust:1.75.0-alpine
 
 RUN apk add --update \
     alpine-sdk \

docker-compose.yaml

@@ -1,6 +1,6 @@
 version: '2'
 
 services:
-  melvinjs:
+  lyra:
     container_name: lyra
     build: .

scripts/launch.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-nohup ../lyra > lyra.log 2> lyra.err < /dev/null &
+nohup ./lyra > lyra.log 2> lyra.err < /dev/null &

src/commands/music.rs

@@ -10,7 +10,6 @@ pub mod queue;
 pub mod repeat;
 pub mod resume;
 pub mod seek;
-pub mod shuffle;
 pub mod skip;
 pub mod soundboard;
 pub mod stop;
@@ -26,7 +25,6 @@ pub use queue::queue;
 pub use repeat::repeat;
 pub use resume::resume;
 pub use seek::seek;
-pub use shuffle::shuffle;
 pub use skip::skip;
 pub use stop::stop;
 pub use volume::volume;

src/commands/music/play.rs

@@ -42,9 +42,12 @@ pub async fn play(
         r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*",
     )
     .unwrap();
+    let regex_spotify_playlist = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:(album|playlist)\/|\?uri=spotify:playlist:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
 
-    let is_playlist = regex_youtube_playlist.is_match(&song).unwrap();
+    let is_playlist = regex_youtube_playlist.is_match(&song).unwrap()
-    let is_spotify = regex_spotify.is_match(&song).unwrap();
+        || regex_spotify_playlist.is_match(&song).unwrap();
+    let is_spotify =
+        regex_spotify.is_match(&song).unwrap() || regex_spotify_playlist.is_match(&song).unwrap();
     let is_query = !song.starts_with("http");
 
     let guild_id = ctx.guild_id().unwrap();
@@ -83,6 +86,43 @@ pub async fn play(
 
         handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
 
+        if is_playlist && is_spotify {
+            let raw_list = Command::new("node")
+                .args(["./src/spotify-parser", &song])
+                .output()
+                .expect("failed to execute process")
+                .stdout;
+            let list = String::from_utf8(raw_list.clone()).expect("Invalid UTF-8");
+
+            let tracks: Vec<String> = list.split("\n").map(str::to_string).collect();
+
+            for (index, url) in tracks.clone().iter().enumerate() {
+                if url.is_empty() {
+                    break;
+                }
+                let src = YoutubeDl::new_ytdl_like(
+                    "yt-dlp",
+                    http_client.clone(),
+                    format!("ytsearch:{}", url.to_string()),
+                );
+                let aux_metadata = src.clone().aux_metadata().await.unwrap();
+                let track = handler.enqueue_input(src.clone().into()).await;
+                let _ = track
+                    .typemap()
+                    .write()
+                    .await
+                    .insert::<Metadata>(aux_metadata);
+
+                if index == 0 {
+                    let embed = generate_playlist_embed(ctx, track, tracks.len()).await;
+                    let response = CreateReply::default().embed(embed.unwrap());
+                    ctx.send(response).await?;
+                }
+            }
+
+            return Ok(());
+        }
+
         if is_playlist {
             let raw_list = Command::new("yt-dlp")
                 .args(["-j", "--flat-playlist", &song])
@@ -98,6 +138,9 @@ pub async fn play(
                 .collect();
 
             for (index, url) in urls.clone().iter().enumerate() {
+                if url.is_empty() {
+                    break;
+                }
                 let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), url.to_string());
                 let aux_metadata = src.clone().aux_metadata().await.unwrap();
                 let track = handler.enqueue_input(src.clone().into()).await;
@@ -113,12 +156,13 @@ pub async fn play(
                     ctx.send(response).await?;
                 }
             }
-        } else {
+
+            return Ok(());
+        }
+
         if is_spotify {
-                let exec = format!("node ./src/spotify --url {}", song);
+            let query = Command::new("node")
-                let query = Command::new("sh")
+                .args(["./src/spotify-parser", &song])
-                    .arg("-c")
-                    .arg(exec)
                 .output()
                 .expect("failed to execute process")
                 .stdout;
@@ -144,7 +188,6 @@ pub async fn play(
             .await
             .insert::<Metadata>(aux_metadata);
     }
-    }
 
     Ok(())
 }
@@ -166,7 +209,7 @@ async fn generate_embed(
     let timestamp = Timestamp::now();
     let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
     let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
-    let mut description = format!("Song added to queue @ {}", queue.len());
+    let mut description = format!("Song added to queue @ {}", queue.len() + 1);
 
     if queue.len() == 0 {
         description = format!("Playing now!");

src/commands/music/queue.rs

@@ -10,6 +10,8 @@ use serenity::{
 };
 use songbird::input::AuxMetadata;
 
+const QUEUE_DISPLAY_LENGTH: usize = 10;
+
 /// Shows next tracks in queue; \
 /// aliases: queue, q
 #[poise::command(prefix_command, slash_command, aliases("q"), category = "Music")]
@@ -25,8 +27,9 @@ pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
         let handler = handler_lock.lock().await;
         let queue = handler.queue();
         let mut queue_res = String::from("");
+        let mut too_long = false;
 
-        for (index, song) in queue.current_queue().iter().enumerate() {
+        for (index, song) in queue.clone().current_queue().iter().enumerate() {
             let meta_typemap = song.typemap().read().await;
             let metadata = meta_typemap.get::<Metadata>().unwrap();
             let AuxMetadata {
@@ -39,8 +42,6 @@ pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
             let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
             let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
 
-            // println!("{:?}", metadata.clone());
-
             queue_res.push_str(&format!(
                 "{}. {} - {} [{:02}:{:02}] \n",
                 index,
@@ -49,6 +50,17 @@ pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
                 duration_minutes,
                 duration_seconds
             ));
+
+            if index + 1 == QUEUE_DISPLAY_LENGTH {
+                too_long = true;
+                break;
+            }
+        }
+        if too_long {
+            queue_res.push_str(&format!(
+                "and {} more...",
+                queue.len() - QUEUE_DISPLAY_LENGTH
+            ));
         }
 
         ctx.send(CreateReply::default().embed(embed(ctx, queue_res).await.unwrap()))

src/commands/music/resume.rs

@@ -19,7 +19,6 @@ pub async fn resume(ctx: Context<'_>) -> Result<(), Error> {
         let queue = handler.queue();
         let _ = queue.resume();
 
-        ctx.say(format!("Song resumed.")).await?;
         ctx.send(
             CreateReply::default().embed(
                 embed(ctx, "Resumed!", "Currently paused song is now resumed!", "")

src/commands/music/seek.rs

@@ -1,11 +1,51 @@
-use crate::{commands::embeds::embed, Context, Error};
+use std::time::Duration;
+
+use crate::{
+    commands::embeds::{embed, error_embed},
+    Context, Error,
+};
 use poise::CreateReply;
 
 /// Seeks a track by provided seconds
 #[poise::command(prefix_command, slash_command, category = "Music")]
-pub async fn seek(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn seek(
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx: Context<'_>,
+    #[description = "How many seconds shall I seek"] seek: u64,
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird client placed at init")
+        .clone();
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let handler = handler_lock.lock().await;
+        let queue = handler.queue();
+
+        let seek_duration = Duration::from_secs(seek);
+
+        let track = queue.current().unwrap();
+        let _ = track.seek(seek_duration);
+
+        ctx.send(
+            CreateReply::default().embed(
+                embed(
+                    ctx,
+                    "Track seeked!",
+                    &format!("Track seeked by: {} seconds", seek),
+                    "",
+                )
+                .await
+                .unwrap(),
+            ),
+        )
         .await?;
+    } else {
+        let msg = "I am not in a voice channel!";
+        ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
+            .await?;
+    }
 
     Ok(())
 }

src/commands/music/shuffle.rs

@@ -1,11 +0,0 @@
-use crate::{commands::embeds::embed, Context, Error};
-use poise::CreateReply;
-
-/// Shuffles the playlist
-#[poise::command(prefix_command, slash_command, category = "Music")]
-pub async fn shuffle(ctx: Context<'_>) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
-        .await?;
-
-    Ok(())
-}

src/commands/music/skip.rs

@@ -1,8 +1,16 @@
+use crate::commands::music::metadata::Metadata;
+use std::time::Duration;
+
 use crate::{
     commands::embeds::{embed, error_embed},
     Context, Error,
 };
 use poise::CreateReply;
+use serenity::{
+    builder::{CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter},
+    model::{Colour, Timestamp},
+};
+use songbird::{input::AuxMetadata, tracks::TrackHandle};
 
 /// Skips the currently playing song
 #[poise::command(prefix_command, slash_command, category = "Music")]
@@ -17,21 +25,31 @@ pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
     if let Some(handler_lock) = manager.get(guild_id) {
         let handler = handler_lock.lock().await;
         let queue = handler.queue();
-        let _ = queue.skip();
+        let _ = queue.clone().skip();
+        let track_raw = queue.clone().current_queue();
+        let track = track_raw.get(1);
+        let queue_length = queue.len() - 1;
 
-        ctx.send(
+        let response;
-            CreateReply::default().embed(
+
-                embed(
+        match track {
-                    ctx,
+            Some(track) => {
-                    "Skipped!",
+                response = CreateReply::default().embed(
-                    "Next song: {song}",
+                    generate_embed(ctx, track.clone(), queue_length)
-                    &format!("Songs left in queue: {}", queue.len()),
-                )
                         .await
                         .unwrap(),
-            ),
+                );
-        )
+            }
-        .await?;
+            None => {
+                response = CreateReply::default().embed(
+                    embed(ctx, "Skipped!", "The queue is empty!", "")
+                        .await
+                        .unwrap(),
+                );
+            }
+        };
+
+        ctx.send(response).await?;
     } else {
         let msg = "I am not in a voice channel!";
         ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
@@ -40,3 +58,55 @@ pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
 
     Ok(())
 }
+
+async fn generate_embed(
+    ctx: Context<'_>,
+    track: TrackHandle,
+    queue_length: usize,
+) -> Result<CreateEmbed, Error> {
+    let meta_typemap = track.typemap().read().await;
+    let metadata = meta_typemap.get::<Metadata>().unwrap();
+    let AuxMetadata {
+        title,
+        thumbnail,
+        source_url,
+        artist,
+        duration,
+        ..
+    } = metadata;
+    let timestamp = Timestamp::now();
+    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
+    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
+
+    let description = format!("Song skipped! Queue length is {}", queue_length);
+
+    let embed = CreateEmbed::default()
+        .author(CreateEmbedAuthor::new("Skipped!").icon_url(ctx.author().clone().face()))
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title(title.as_ref().unwrap())
+        .url(source_url.as_ref().unwrap())
+        .thumbnail(
+            thumbnail
+                .as_ref()
+                .unwrap_or(&ctx.cache().current_user().face()),
+        )
+        .field(
+            "Artist",
+            artist.as_ref().unwrap_or(&"Unknown Artist".to_string()),
+            true,
+        )
+        .field(
+            "Duration",
+            format!("{:02}:{:02}", duration_minutes, duration_seconds),
+            true,
+        )
+        .field("DJ", ctx.author().name.clone(), true)
+        .description(description)
+        .timestamp(timestamp)
+        .footer(
+            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
+                .icon_url(ctx.cache().current_user().face()),
+        );
+
+    Ok(embed)
+}

src/commands/music/soundboard/effect.rs

@@ -1,11 +1,117 @@
-use crate::{commands::embeds::embed, Context, Error};
+use crate::{commands::embeds::error_embed, Context, Error};
+
+use poise::serenity_prelude::model::Timestamp;
+use poise::serenity_prelude::Colour;
+use poise::serenity_prelude::CreateEmbed;
 use poise::CreateReply;
+use serenity::builder::CreateEmbedAuthor;
+use serenity::builder::CreateEmbedFooter;
+use songbird::events::TrackEvent;
+use songbird::input::AuxMetadata;
+use songbird::input::{Compose, YoutubeDl};
+use std::time::Duration;
+
+use crate::commands::music::notifier::TrackErrorNotifier;
+use crate::http::HttpKey;
 
 /// Plays one of available audio effects
 #[poise::command(prefix_command, slash_command, category = "Music")]
-pub async fn effect(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn effect(
-    ctx.send(CreateReply::default().embed(embed(ctx, "Playing an effect", "", "").await.unwrap()))
+    ctx: Context<'_>,
+    #[description = "Shall output pause?"]
+    #[flag]
+    pause: bool,
+    #[description = "Provide a query or an url"]
+    #[rest]
+    mut song: String,
+) -> Result<(), Error> {
+    let is_query = !song.starts_with("http");
+
+    let guild_id = ctx.guild_id().unwrap();
+
+    let http_client = {
+        let data = ctx.serenity_context().data.read().await;
+        data.get::<HttpKey>()
+            .cloned()
+            .expect("Guaranteed to exist in the typemap.")
+    };
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird Voice placed at init")
+        .clone();
+
+    if pause {
+        if let Some(handler_lock) = manager.get(guild_id) {
+            let handler = handler_lock.lock().await;
+            let queue = handler.queue();
+            let _ = queue.pause();
+        }
+    }
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let mut handler = handler_lock.lock().await;
+
+        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
+
+        if is_query {
+            song = format!("ytsearch:{}", song);
+        }
+
+        let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
+        let embed = generate_embed(ctx, src.clone()).await;
+        let response = CreateReply::default().embed(embed.unwrap());
+        ctx.send(response).await?;
+
+        let _ = handler.play_input(src.clone().into());
+    } else {
+        let msg = "I am not in a voice channel!";
+        ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
             .await?;
+    }
 
     Ok(())
 }
+
+async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed, Error> {
+    let metadata = src.clone().aux_metadata().await.unwrap();
+    let AuxMetadata {
+        title,
+        thumbnail,
+        source_url,
+        artist,
+        duration,
+        ..
+    } = metadata;
+    let timestamp = Timestamp::now();
+    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
+    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
+
+    let description = format!("Playing now!");
+
+    let embed = CreateEmbed::default()
+        .author(CreateEmbedAuthor::new("Playing an effect!").icon_url(ctx.author().clone().face()))
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title(title.unwrap())
+        .url(source_url.unwrap())
+        .thumbnail(thumbnail.unwrap_or(ctx.cache().current_user().face()))
+        .field(
+            "Artist",
+            artist.unwrap_or("Unknown Artist".to_string()),
+            true,
+        )
+        .field(
+            "Duration",
+            format!("{:02}:{:02}", duration_minutes, duration_seconds),
+            true,
+        )
+        .field("DJ", ctx.author().name.clone(), true)
+        .description(description)
+        .timestamp(timestamp)
+        .footer(
+            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
+                .icon_url(ctx.cache().current_user().face()),
+        );
+
+    Ok(embed)
+}

src/commands/music/soundboard/stream.rs

@@ -1,11 +1,126 @@
-use crate::{commands::embeds::embed, Context, Error};
+use crate::{commands::embeds::error_embed, Context, Error};
-use poise::CreateReply;
 
-/// Hijacks current audio output and plays selected audio
+use poise::serenity_prelude::model::Timestamp;
-#[poise::command(prefix_command, slash_command, aliases("override"), category = "Music")]
+use poise::serenity_prelude::Colour;
-pub async fn stream(ctx: Context<'_>) -> Result<(), Error> {
+use poise::serenity_prelude::CreateEmbed;
-    ctx.send(CreateReply::default().embed(embed(ctx, "Playing audio", "", "").await.unwrap()))
+use poise::CreateReply;
+use serenity::builder::CreateEmbedAuthor;
+use serenity::builder::CreateEmbedFooter;
+use songbird::events::TrackEvent;
+use songbird::input::AuxMetadata;
+use songbird::input::{Compose, YoutubeDl};
+use std::time::Duration;
+
+use crate::commands::music::notifier::TrackErrorNotifier;
+use crate::http::HttpKey;
+
+/// Hijacks output and plays audio; \
+/// search by query or paste an url; \
+/// aliases: stream, override, hijack
+#[poise::command(
+    prefix_command,
+    slash_command,
+    aliases("override", "hijack"),
+    category = "Music"
+)]
+pub async fn stream(
+    ctx: Context<'_>,
+    #[description = "Shall output pause?"]
+    #[flag]
+    pause: bool,
+    #[description = "Provide a query or an url"]
+    #[rest]
+    mut song: String,
+) -> Result<(), Error> {
+    let is_query = !song.starts_with("http");
+
+    let guild_id = ctx.guild_id().unwrap();
+
+    let http_client = {
+        let data = ctx.serenity_context().data.read().await;
+        data.get::<HttpKey>()
+            .cloned()
+            .expect("Guaranteed to exist in the typemap.")
+    };
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird Voice placed at init")
+        .clone();
+
+    if pause {
+        if let Some(handler_lock) = manager.get(guild_id) {
+            let handler = handler_lock.lock().await;
+            let queue = handler.queue();
+            let _ = queue.pause();
+        }
+    }
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let mut handler = handler_lock.lock().await;
+
+        handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
+
+        if is_query {
+            song = format!("ytsearch:{}", song);
+        }
+
+        let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
+        let embed = generate_embed(ctx, src.clone()).await;
+        let response = CreateReply::default().embed(embed.unwrap());
+        ctx.send(response).await?;
+
+        let _ = handler.play_input(src.clone().into());
+    } else {
+        let msg = "I am not in a voice channel!";
+        ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
             .await?;
+    }
 
     Ok(())
 }
+
+async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed, Error> {
+    let metadata = src.clone().aux_metadata().await.unwrap();
+    let AuxMetadata {
+        title,
+        thumbnail,
+        source_url,
+        artist,
+        duration,
+        ..
+    } = metadata;
+    let timestamp = Timestamp::now();
+    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
+    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
+
+    let description = format!("Playing now!");
+
+    let embed = CreateEmbed::default()
+        .author(
+            CreateEmbedAuthor::new("Audio output hijacked!").icon_url(ctx.author().clone().face()),
+        )
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title(title.unwrap())
+        .url(source_url.unwrap())
+        .thumbnail(thumbnail.unwrap_or(ctx.cache().current_user().face()))
+        .field(
+            "Artist",
+            artist.unwrap_or("Unknown Artist".to_string()),
+            true,
+        )
+        .field(
+            "Duration",
+            format!("{:02}:{:02}", duration_minutes, duration_seconds),
+            true,
+        )
+        .field("DJ", ctx.author().name.clone(), true)
+        .description(description)
+        .timestamp(timestamp)
+        .footer(
+            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
+                .icon_url(ctx.cache().current_user().face()),
+        );
+
+    Ok(embed)
+}

src/commands/music/volume.rs

@@ -1,11 +1,44 @@
-use crate::{commands::embeds::embed, Context, Error};
+use crate::{
+    commands::embeds::{embed, error_embed},
+    Context, Error,
+};
 use poise::CreateReply;
 
 /// Changes output volume
 #[poise::command(prefix_command, slash_command, category = "Music")]
-pub async fn volume(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn volume(ctx: Context<'_>, #[description = "Volume"] volume: f32) -> Result<(), Error> {
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    let guild_id = ctx.guild_id().unwrap();
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird client placed at init")
+        .clone();
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let handler = handler_lock.lock().await;
+        let queue = handler.queue();
+
+        let track = queue.current().unwrap();
+        let _ = track.set_volume(volume / 100.0);
+
+        ctx.send(
+            CreateReply::default().embed(
+                embed(
+                    ctx,
+                    "Volume changed",
+                    "",
+                    &format!("Set volume to {}%", volume),
+                )
+                .await
+                .unwrap(),
+            ),
+        )
         .await?;
+    } else {
+        let msg = "I am not in a voice channel!";
+        ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
+            .await?;
+    }
 
     Ok(())
 }

src/commands/tools/dictionary.rs

@@ -1,12 +1,72 @@
 use poise::CreateReply;
+use serde::{Deserialize, Serialize};
+use url::form_urlencoded;
 
 use crate::{commands::embeds::embed, Context, Error};
 
 /// Explains provided query
-#[poise::command(prefix_command, slash_command, category = "Tools")]
+#[poise::command(prefix_command, slash_command, aliases("dict"), category = "Tools")]
-pub async fn dictionary(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn dictionary(
+    ctx: Context<'_>,
+    #[description = "Word you're looking for"]
+    #[rest]
+    word: String,
+) -> Result<(), Error> {
+    let data: String = form_urlencoded::byte_serialize(word.as_bytes()).collect();
+
+    let client = reqwest::Client::new();
+    let response = client
+        .get(format!(
+            "https://api.dictionaryapi.dev/api/v2/entries/en/{}",
+            data
+        ))
+        .send()
+        .await
+        .unwrap();
+
+    match response.status() {
+        reqwest::StatusCode::OK => match response.json::<Vec<Word>>().await {
+            Ok(parsed) => {
+                println!("{:?}", parsed);
+
                 ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
                     .await?;
+            }
+            Err(err) => println!("Something is messed up! {:?}", err),
+        },
+        reqwest::StatusCode::UNAUTHORIZED => {
+            println!("Unauthorized.. Uoops!!");
+        }
+        error => {
+            println!("Something went wrong: {:?}", error);
+        }
+    }
 
     Ok(())
 }
+
+#[derive(Serialize, Deserialize, Debug)]
+struct Definition {
+    definition: String,
+}
+
+#[allow(non_snake_case)]
+#[derive(Serialize, Deserialize, Debug)]
+struct Meaning {
+    partOfSpeech: String,
+    definitions: Vec<Definition>,
+}
+
+#[allow(non_snake_case)]
+#[derive(Serialize, Deserialize, Debug)]
+struct Phonetic {
+    text: Option<String>,
+    audio: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct Word {
+    word: String,
+    phonetics: Vec<Phonetic>,
+    meanings: Vec<Meaning>,
+}

src/commands/tools/owoify.rs

@@ -1,11 +1,17 @@
+use owoify::OwOifiable;
 use poise::CreateReply;
 
 use crate::{commands::embeds::embed, Context, Error};
 
 /// Owoifies whatever you want uwu
 #[poise::command(prefix_command, slash_command, category = "Tools")]
-pub async fn owoify(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn owoify(
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx: Context<'_>,
+    #[description = "Text to owoify w-woify OwO"]
+    #[rest]
+    text: String,
+) -> Result<(), Error> {
+    ctx.send(CreateReply::default().embed(embed(ctx, "OwO", &text.owoify(), "").await.unwrap()))
         .await?;
 
     Ok(())

src/commands/tools/qr.rs

@@ -1,12 +1,48 @@
 use poise::CreateReply;
+use serenity::{
+    builder::{CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter},
+    model::{Colour, Timestamp},
+};
 
-use crate::{commands::embeds::embed, Context, Error};
+use crate::{Context, Error};
+use url::form_urlencoded;
 
 /// Creates a qr code from text
 #[poise::command(prefix_command, slash_command, category = "Tools")]
-pub async fn qr(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn qr(
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx: Context<'_>,
-        .await?;
+    #[description = "Message to encode"]
+    #[rest]
+    message: String,
+) -> Result<(), Error> {
+    let response = CreateReply::default().embed(generate_embed(ctx, message).await.unwrap());
+    ctx.send(response).await?;
 
     Ok(())
 }
+
+async fn generate_embed(ctx: Context<'_>, message: String) -> Result<CreateEmbed, Error> {
+    let timestamp = Timestamp::now();
+    let data: String = form_urlencoded::byte_serialize(message.as_bytes()).collect();
+    let url = format!(
+        "http://api.qrserver.com/v1/create-qr-code/?data={}&size=1000x1000&ecc=Q&margin=8",
+        data
+    );
+
+    let embed = CreateEmbed::default()
+        .author(
+            CreateEmbedAuthor::new("Your message as a QR Code!")
+                .icon_url(ctx.author().clone().face()),
+        )
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title("Your QR Code:")
+        .url(url.clone())
+        .image(url)
+        .timestamp(timestamp)
+        .footer(
+            CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
+                .icon_url(ctx.cache().current_user().face()),
+        );
+
+    Ok(embed)
+}

src/commands/tools/verse.rs

@@ -1,12 +1,78 @@
+use crate::{
+    commands::embeds::{embed, error_embed},
+    Context, Error,
+};
 use poise::CreateReply;
-
+use serde::{Deserialize, Serialize};
-use crate::{commands::embeds::embed, Context, Error};
+use url::form_urlencoded;
 
 /// Reference Bible by verse
 #[poise::command(prefix_command, slash_command, category = "Tools")]
-pub async fn verse(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn verse(
-    ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
+    ctx: Context<'_>,
+    #[description = "Latin?"]
+    #[flag]
+    latin: bool,
+    #[description = "BOOK+CHAPTER:VERSE"]
+    #[rest]
+    verse: String,
+) -> Result<(), Error> {
+    let data: String = form_urlencoded::byte_serialize(verse.as_bytes()).collect();
+    let translation = if latin { "clementine" } else { "web" };
+    let client = reqwest::Client::new();
+    let response = client
+        .get(format!(
+            "https://bible-api.com/{}?translation={}",
+            data, translation
+        ))
+        .send()
+        .await
+        .unwrap();
+
+    match response.status() {
+        reqwest::StatusCode::OK => {
+            match response.json::<APIResponse>().await {
+                Ok(parsed) => {
+                    if parsed.text.len() > 4000 {
+                        ctx.send(
+                            CreateReply::default()
+                                .embed(error_embed(ctx, "Quoted text is too long!").await.unwrap()),
+                        )
                         .await?;
+                        return Ok(());
+                    }
+                    ctx.send(
+                        CreateReply::default().embed(
+                            embed(
+                                ctx,
+                                &parsed.translation_name,
+                                &parsed.text,
+                                &parsed.reference,
+                            )
+                            .await
+                            .unwrap(),
+                        ),
+                    )
+                    .await?;
+                }
+                Err(err) => println!("Something is messed up! {:?}", err),
+            };
+        }
+        reqwest::StatusCode::UNAUTHORIZED => {
+            println!("Unauthorized.. Uoops!!");
+        }
+        error => {
+            println!("Something went wrong: {:?}", error);
+        }
+    }
 
     Ok(())
 }
+
+#[derive(Serialize, Deserialize, Debug)]
+struct APIResponse {
+    reference: String,
+    text: String,
+    translation_name: String,
+    translation_note: String,
+}

src/commands/tools/weather.rs

@@ -4,7 +4,12 @@ use crate::{commands::embeds::embed, Context, Error};
 
 /// Shows weather for provided location
 #[poise::command(prefix_command, slash_command, category = "Tools")]
-pub async fn weather(ctx: Context<'_>) -> Result<(), Error> {
+pub async fn weather(
+    ctx: Context<'_>,
+    #[description = "Provide a city name"]
+    #[rest]
+    _location: String,
+) -> Result<(), Error> {
     ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
         .await?;
 

src/main.rs

@@ -53,7 +53,6 @@ async fn main() {
         music::repeat(),
         music::resume(),
         music::seek(),
-        music::shuffle(),
         music::skip(),
         music::stop(),
         music::volume(),