eRgo35/lyra
1
0
Fork 0
mirror of https://github.com/eRgo35/lyra.git synced 2026-02-04 20:36:10 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

0.5.1 refractor

Browse Source
This commit is contained in:
Michał Czyż
2024-02-16 12:42:38 +01:00
parent 639fd7775f
commit 8a947926f7
37 changed files with 694 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/commands/music/deafen.rs
View File

@@ -1,4 +1,7 @@
use crate::{commands::embeds::{error_embed, embed, fail}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed, fail},
Context, Error,
};
use poise::CreateReply;
/// Deafens itself while in a voice channel; \
@@ -9,9 +12,7 @@ use poise::CreateReply;
aliases("shuush", "undeafen"),
category = "Music"
)]
pub async fn deafen(
ctx: Context<'_>
) -> Result<(), Error> {
pub async fn deafen(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -23,10 +24,9 @@ pub async fn deafen(
Some(handler) => handler,
None => {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
return Ok(());
}
};
@@ -38,17 +38,15 @@ pub async fn deafen(
fail(ctx, err.to_string()).await.unwrap();
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Undeafened!", "", "").await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, "Undeafened!", "", "").await.unwrap()))
.await?;
} else {
if let Err(err) = handler.deafen(true).await {
if let Err(err) = handler.deafen(true).await {
fail(ctx, err.to_string()).await.unwrap();
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Deafened!", "", "").await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, "Deafened!", "", "").await.unwrap()))
.await?;
}
Ok(())

34
src/commands/music/join.rs
View File

@@ -1,29 +1,28 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::commands::music::notifier::TrackErrorNotifier;
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
use songbird::TrackEvent;
use crate::commands::music::notifier::TrackErrorNotifier;
/// Joins your voice channel
#[poise::command(
prefix_command,
slash_command,
category = "Music"
)]
pub async fn join(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, category = "Music")]
pub async fn join(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let channel_id = ctx.guild().unwrap()
.voice_states.get(&ctx.author().id)
let channel_id = ctx
.guild()
.unwrap()
.voice_states
.get(&ctx.author().id)
.and_then(|voice_state| voice_state.channel_id);
let connect_to = match channel_id {
Some(channel) => channel,
None => {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
return Ok(());
}
};
@@ -38,9 +37,8 @@ pub async fn join(
handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Joined!", "Hi there!", "").await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, "Joined!", "Hi there!", "").await.unwrap()))
.await?;
Ok(())
}

27
src/commands/music/leave.rs
View File

@@ -1,5 +1,8 @@
use crate::{
commands::embeds::{embed, error_embed, fail},
Context, Error,
};
use poise::CreateReply;
use crate::{commands::embeds::{error_embed, fail, embed}, Context, Error};
/// Leaves the voice channel; \
/// aliases: leave, qa!
@@ -9,9 +12,7 @@ use crate::{commands::embeds::{error_embed, fail, embed}, Context, Error};
aliases("leave", "qa!"),
category = "Music"
)]
pub async fn leave(
ctx: Context<'_>
) -> Result<(), Error> {
pub async fn leave(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -21,20 +22,24 @@ pub async fn leave(
if !manager.get(guild_id).is_some() {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
return Ok(())
return Ok(());
}
if let Err(err) = manager.remove(guild_id).await {
if let Err(err) = manager.remove(guild_id).await {
fail(ctx, err.to_string()).await.unwrap();
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Left!", "I left the voice channel", "").await.unwrap())
).await?;
CreateReply::default().embed(
embed(ctx, "Left!", "I left the voice channel", "")
.await
.unwrap(),
),
)
.await?;
Ok(())
}

34
src/commands/music/mute.rs
View File

@@ -1,17 +1,18 @@
use crate::{commands::embeds::{error_embed, embed, fail}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed, fail},
Context, Error,
};
use poise::CreateReply;
/// Mutes itself while in a voice channel; \
/// aliases: mute, unmute, shhh
#[poise::command(
prefix_command,
prefix_command,
slash_command,
aliases("shhh", "unmute"),
category = "Music"
)]
pub async fn mute(
ctx: Context<'_>
) -> Result<(), Error> {
pub async fn mute(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -21,33 +22,30 @@ pub async fn mute(
let handler_lock = match manager.get(guild_id) {
Some(handler) => handler,
None => {
None => {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
return Ok(());
}
};
let mut handler = handler_lock.lock().await;
if handler.is_mute() {
if handler.is_mute() {
if let Err(err) = handler.mute(false).await {
fail(ctx, err.to_string()).await.unwrap();
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Unmuted!", "", "").await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, "Unmuted!", "", "").await.unwrap()))
.await?;
} else {
if let Err(err) = handler.mute(true).await {
fail(ctx, err.to_string()).await.unwrap();
}
ctx.send(
CreateReply::default().embed(embed(ctx, "Muted!", "", "").await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, "Muted!", "", "").await.unwrap()))
.await?;
}
Ok(())

33
src/commands/music/pause.rs
View File

@@ -1,15 +1,12 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
/// Pauses the currently playing song
#[poise::command(
prefix_command,
slash_command,
category = "Music"
)]
pub async fn pause(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, category = "Music")]
pub async fn pause(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -21,15 +18,19 @@ pub async fn pause(
let handler = handler_lock.lock().await;
let queue = handler.queue();
let _ = queue.pause();
ctx.send(
CreateReply::default().embed(embed(ctx, "Paused!", "Currently playing song is now paused!", "").await.unwrap())
).await?;
} else {
CreateReply::default().embed(
embed(ctx, "Paused!", "Currently playing song is now paused!", "")
.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?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())

167
src/commands/music/play.rs
View File

@@ -1,20 +1,20 @@
use crate::{commands::embeds::error_embed, Context, Error};
use crate::commands::music::metadata::Metadata;
use crate::{commands::embeds::error_embed, Context, Error};
use fancy_regex::Regex;
use poise::serenity_prelude::model::Timestamp;
use poise::serenity_prelude::Colour;
use poise::serenity_prelude::CreateEmbed;
use poise::CreateReply;
use regex::Regex as Regex_Classic;
use serenity::builder::CreateEmbedAuthor;
use serenity::builder::CreateEmbedFooter;
use songbird::events::TrackEvent;
use songbird::input::AuxMetadata;
use songbird::input::{Compose, YoutubeDl};
use songbird::tracks::{TrackHandle, TrackQueue};
use std::process::Command;
use std::time::Duration;
use poise::CreateReply;
use poise::serenity_prelude::CreateEmbed;
use poise::serenity_prelude::Colour;
use poise::serenity_prelude::model::Timestamp;
use serenity::builder::CreateEmbedAuthor;
use serenity::builder::CreateEmbedFooter;
use songbird::input::AuxMetadata;
use songbird::input::{Compose, YoutubeDl};
use songbird::events::TrackEvent;
use crate::commands::music::notifier::TrackErrorNotifier;
use crate::http::HttpKey;
@@ -23,33 +23,44 @@ use crate::http::HttpKey;
/// you can search by query or paste an url; \
/// aliases: play, p, enqueue
#[poise::command(
prefix_command,
slash_command,
prefix_command,
slash_command,
aliases("p", "enqueue"),
category = "Music"
)]
pub async fn play(
ctx: Context<'_>,
#[description = "Provide a query or an url"] #[rest] mut song: String,
ctx: Context<'_>,
#[description = "Provide a query or an url"]
#[rest]
mut song: String,
) -> Result<(), Error> {
let regex_spotify = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
let regex_youtube = Regex_Classic::new(r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#).unwrap();
let regex_youtube_playlist = Regex::new(r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*").unwrap();
let regex_youtube =
Regex_Classic::new(r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#)
.unwrap();
let regex_youtube_playlist = Regex::new(
r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*",
)
.unwrap();
let is_playlist = regex_youtube_playlist.is_match(&song).unwrap();
let is_spotify = regex_spotify.is_match(&song).unwrap();
let is_query = !song.starts_with("http");
let guild_id = ctx.guild_id().unwrap();
let channel_id = ctx.guild().unwrap().voice_states.get(&ctx.author().id).and_then(|voice_state| voice_state.channel_id);
let channel_id = ctx
.guild()
.unwrap()
.voice_states
.get(&ctx.author().id)
.and_then(|voice_state| voice_state.channel_id);
let connect_to = match channel_id {
Some(channel) => channel,
None => {
None => {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
return Ok(());
}
@@ -77,17 +88,24 @@ pub async fn play(
.args(["-j", "--flat-playlist", &song])
.output()
.expect("failed to execute process")
.stdout;
.stdout;
let list = String::from_utf8(raw_list.clone()).expect("Invalid UTF-8");
let urls: Vec<String> = regex_youtube.captures_iter(&list).map(|capture| capture[1].to_string()).collect();
for (index, url) in urls.clone().iter().enumerate() {
let urls: Vec<String> = regex_youtube
.captures_iter(&list)
.map(|capture| capture[1].to_string())
.collect();
for (index, url) in urls.clone().iter().enumerate() {
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;
let _ = track.typemap().write().await.insert::<Metadata>(aux_metadata);
let _ = track
.typemap()
.write()
.await
.insert::<Metadata>(aux_metadata);
if index == 0 {
let embed = generate_playlist_embed(ctx, track, urls.len()).await;
@@ -95,43 +113,61 @@ pub async fn play(
ctx.send(response).await?;
}
}
} else {
if is_spotify {
let exec = format!("node ./src/spotify --url {}", song);
let query = Command::new("sh").arg("-c").arg(exec).output().expect("failed to execute process").stdout;
let query = Command::new("sh")
.arg("-c")
.arg(exec)
.output()
.expect("failed to execute process")
.stdout;
let query_str = String::from_utf8(query.clone()).expect("Invalid UTF-8");
song = format!("ytsearch:{}", query_str.to_string());
}
if is_query {
song = format!("ytsearch:{}", song);
}
let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song);
let embed = generate_embed(ctx, src.clone(), handler.queue()).await;
let response = CreateReply::default().embed(embed.unwrap());
ctx.send(response).await?;
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);
let _ = track
.typemap()
.write()
.await
.insert::<Metadata>(aux_metadata);
}
}
Ok(())
}
async fn generate_embed(ctx: Context<'_>, src: YoutubeDl, queue: &TrackQueue) -> Result<CreateEmbed, Error> {
async fn generate_embed(
ctx: Context<'_>,
src: YoutubeDl,
queue: &TrackQueue,
) -> Result<CreateEmbed, Error> {
let metadata = src.clone().aux_metadata().await.unwrap();
let AuxMetadata {title, thumbnail, source_url, artist, duration, ..} = metadata;
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 mut description = format!("Song added to queue @ {}", queue.len());
if queue.len() == 0 {
description = format!("Playing now!");
}
@@ -142,24 +178,46 @@ async fn generate_embed(ctx: Context<'_>, src: YoutubeDl, queue: &TrackQueue) ->
.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(
"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()));
.footer(
CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
.icon_url(ctx.cache().current_user().face()),
);
Ok(embed)
}
async fn generate_playlist_embed(ctx: Context<'_>, track: TrackHandle, queue_length: usize) -> Result<CreateEmbed, Error> {
async fn generate_playlist_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 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!("Enqueued tracks: {}", queue_length - 1);
let embed = CreateEmbed::default()
@@ -167,13 +225,28 @@ async fn generate_playlist_embed(ctx: Context<'_>, track: TrackHandle, queue_len
.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)
.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()));
.footer(
CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
.icon_url(ctx.cache().current_user().face()),
);
Ok(embed)
}

47
src/commands/music/queue.rs
View File

@@ -1,23 +1,19 @@
use std::time::Duration;
use crate::{commands::embeds::error_embed, Context, Error};
use crate::commands::music::metadata::Metadata;
use poise::CreateReply;
use serenity::{builder::{CreateEmbedAuthor, CreateEmbedFooter}, model::{Colour, Timestamp}};
use crate::{commands::embeds::error_embed, Context, Error};
use poise::serenity_prelude::CreateEmbed;
use poise::CreateReply;
use serenity::{
builder::{CreateEmbedAuthor, CreateEmbedFooter},
model::{Colour, Timestamp},
};
use songbird::input::AuxMetadata;
/// Shows next tracks in queue; \
/// aliases: queue, q
#[poise::command(
prefix_command,
slash_command,
aliases("q"),
category = "Music"
)]
pub async fn queue(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, aliases("q"), category = "Music")]
pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -33,12 +29,17 @@ pub async fn queue(
for (index, song) in queue.current_queue().iter().enumerate() {
let meta_typemap = song.typemap().read().await;
let metadata = meta_typemap.get::<Metadata>().unwrap();
let AuxMetadata { title, artist, duration, ..} = metadata;
let AuxMetadata {
title,
artist,
duration,
..
} = metadata;
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());
// println!("{:?}", metadata.clone());
queue_res.push_str(&format!(
"{}. {} - {} [{:02}:{:02}] \n",
@@ -50,31 +51,31 @@ pub async fn queue(
));
}
ctx.send(
CreateReply::default().embed(embed(ctx, queue_res).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(embed(ctx, queue_res).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?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())
}
async fn embed(ctx: Context<'_>, queue: String) -> Result<CreateEmbed, Error> {
let title = "Now playing";
let timestamp = Timestamp::now();
let embed = CreateEmbed::default()
.author(CreateEmbedAuthor::new("Queue").icon_url(ctx.author().clone().face()))
.colour(Colour::from_rgb(255, 58, 97))
.title(title)
.description(queue)
.timestamp(timestamp)
.footer(CreateEmbedFooter::new(ctx.cache().current_user().name.to_string()).icon_url(ctx.cache().current_user().face()));
.footer(
CreateEmbedFooter::new(ctx.cache().current_user().name.to_string())
.icon_url(ctx.cache().current_user().face()),
);
Ok(embed)
}

64
src/commands/music/repeat.rs
View File

@@ -1,18 +1,23 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
use songbird::tracks::LoopState;
/// Loops currently playing song provided amount of times; \
/// aliases: repeat, loop, while, for
#[poise::command(
prefix_command,
prefix_command,
slash_command,
aliases("loop", "while", "for"),
category = "Music"
)]
pub async fn repeat(
ctx: Context<'_>,
#[description = "How many times"] #[rest] times: usize
ctx: Context<'_>,
#[description = "How many times"]
#[rest]
times: usize,
) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
@@ -21,7 +26,6 @@ pub async fn repeat(
.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();
@@ -34,36 +38,52 @@ pub async fn repeat(
let _ = queue.current().unwrap().disable_loop();
ctx.send(
CreateReply::default().embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap())
).await?;
CreateReply::default()
.embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap()),
)
.await?;
}
LoopState::Finite(_) => {
LoopState::Finite(_) => {
if times == 0 {
let _ = queue.current().unwrap().disable_loop();
ctx.send(
CreateReply::default().embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap())
).await?;
}
else if times < 100 {
CreateReply::default()
.embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap()),
)
.await?;
} else if times < 100 {
let _ = queue.current().unwrap().loop_for(times);
ctx.send(
CreateReply::default().embed(embed(ctx, &format!("Song looped {} times!", times), "You definitelly love this song!", "").await.unwrap())
).await?;
}
else {
CreateReply::default().embed(
embed(
ctx,
&format!("Song looped {} times!", times),
"You definitelly love this song!",
"",
)
.await
.unwrap(),
),
)
.await?;
} else {
let _ = queue.current().unwrap().enable_loop();
ctx.send(
CreateReply::default().embed(embed(ctx, "Song looped forever!", "A very long time!", "").await.unwrap())
).await?;
CreateReply::default().embed(
embed(ctx, "Song looped forever!", "A very long time!", "")
.await
.unwrap(),
),
)
.await?;
}
}
}
} else {
} else {
let msg = "I am not in a voice channel!";
ctx.send(
CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
).await?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())

29
src/commands/music/resume.rs
View File

@@ -1,15 +1,12 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
/// Resumes currently paused song
#[poise::command(
prefix_command,
slash_command,
category = "Music"
)]
pub async fn resume(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, category = "Music")]
pub async fn resume(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -24,13 +21,17 @@ pub async fn resume(
ctx.say(format!("Song resumed.")).await?;
ctx.send(
CreateReply::default().embed(embed(ctx, "Resumed!", "Currently paused song is now resumed!", "").await.unwrap())
).await?;
CreateReply::default().embed(
embed(ctx, "Resumed!", "Currently paused song is now resumed!", "")
.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?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())

11
src/commands/music/seek.rs
View File

@@ -0,0 +1,11 @@
use crate::{commands::embeds::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> {
ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
.await?;
Ok(())
}

11
src/commands/music/shuffle.rs
View File

@@ -0,0 +1,11 @@
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(())
}

34
src/commands/music/skip.rs
View File

@@ -1,15 +1,12 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
/// Skips the currently playing song
#[poise::command(
prefix_command,
slash_command,
category = "Music"
)]
pub async fn skip(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, category = "Music")]
pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
@@ -23,13 +20,22 @@ pub async fn skip(
let _ = queue.skip();
ctx.send(
CreateReply::default().embed(embed(ctx, "Skipped!", "Next song: {song}", &format!("Songs left in queue: {}", queue.len())).await.unwrap())
).await?;
CreateReply::default().embed(
embed(
ctx,
"Skipped!",
"Next song: {song}",
&format!("Songs left in queue: {}", queue.len()),
)
.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?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())

11
src/commands/music/soundboard.rs
View File

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

41
src/commands/music/stop.rs
View File

@@ -1,19 +1,15 @@
use crate::{commands::embeds::{error_embed, embed}, Context, Error};
use crate::{
commands::embeds::{embed, error_embed},
Context, Error,
};
use poise::CreateReply;
/// Stops playback and destroys the queue; \
/// aliases: stop, end
#[poise::command(
prefix_command,
slash_command,
aliases("end"),
category = "Music"
)]
pub async fn stop(
ctx: Context<'_>
) -> Result<(), Error> {
#[poise::command(prefix_command, slash_command, aliases("end"), category = "Music")]
pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Songbird client placed at init")
@@ -25,14 +21,23 @@ pub async fn stop(
queue.stop();
ctx.send(
CreateReply::default().embed(embed(ctx, "Stopped!", "Playback stopped!", "Queue destroyed! Bot will stay and chill with you in a vc").await.unwrap())
).await?;
} else {
CreateReply::default().embed(
embed(
ctx,
"Stopped!",
"Playback stopped!",
"Queue destroyed! Bot will stay and chill with you in a vc",
)
.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?;
ctx.send(CreateReply::default().embed(error_embed(ctx, msg).await.unwrap()))
.await?;
}
Ok(())
}

11
src/commands/music/volume.rs
View File

@@ -0,0 +1,11 @@
use crate::{commands::embeds::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> {
ctx.send(CreateReply::default().embed(embed(ctx, "", "", "").await.unwrap()))
.await?;
Ok(())
}