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

music commands migrated

Browse Source
This commit is contained in:
Michał Czyż
2024-02-10 22:22:45 +01:00
parent 6946ddc9f1
commit a27e95a88d
23 changed files with 182 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/commands/misc.rs
View File

@@ -1,8 +0,0 @@
use serenity::model::channel::Message;
use serenity::Result as SerenityResult;
pub fn check_msg(result: SerenityResult<Message>) {
if let Err(why) = result {
println!("Error sending message: {:?}", why);
}
}

1
src/commands/mod.rs
View File

@@ -1,4 +1,3 @@
pub mod kashi;
pub mod misc;
pub mod music;
pub mod tools;

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

@@ -1,24 +1,18 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn deafen(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn deafen(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
let handler_lock = match manager.get(guild_id) {
Some(handler) => handler,
None => {
check_msg(msg.reply(ctx, "Not in a voice channel").await);
ctx.say("Not in a voice channel").await?;
return Ok(());
}
@@ -28,24 +22,16 @@ async fn deafen(ctx: &Context, msg: &Message) -> CommandResult {
if handler.is_deaf() {
if let Err(err) = handler.deafen(false).await {
check_msg(
msg.channel_id
.say(&ctx.http, format!("Failed: {:?}", err))
.await,
);
ctx.say(format!("Failed: {:?}", err)).await?;
}
check_msg(msg.channel_id.say(&ctx.http, "Undeafened").await);
ctx.say("Undeafened").await?;
} else {
if let Err(err) = handler.deafen(true).await {
check_msg(
msg.channel_id
.say(&ctx.http, format!("Failed: {:?}", err))
.await,
);
ctx.say(format!("Failed: {:?}", err)).await?;
}
check_msg(msg.channel_id.say(&ctx.http, "Deafened").await);
ctx.say("Deafened").await?;
}
Ok(())

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

@@ -1,29 +1,23 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use songbird::events::TrackEvent;
use crate::{Context, Error};
use songbird::TrackEvent;
use crate::commands::music::misc::TrackErrorNotifier;
use crate::commands::{misc::check_msg, music::misc::TrackErrorNotifier};
#[command]
#[only_in(guilds)]
async fn join(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let channel_id = msg.guild(&ctx.cache).unwrap().voice_states.get(&msg.author.id).and_then(|voice_state| voice_state.channel_id);
#[poise::command(prefix_command, slash_command)]
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).and_then(|voice_state| voice_state.channel_id);
let connect_to = match channel_id {
Some(channel) => channel,
None => {
check_msg(msg.reply(ctx, "Not in a voice channel").await);
ctx.say("Not in a voice channel").await?;
return Ok(());
}
};
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Songbird Voice placed at init")
.expect("Songbird client placed at init")
.clone();
if let Ok(handler_lock) = manager.join(guild_id, connect_to).await {
@@ -31,5 +25,7 @@ async fn join(ctx: &Context, msg: &Message) -> CommandResult {
handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
}
ctx.say("Joined the voice channel").await?;
Ok(())
}

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

@@ -1,36 +1,24 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn leave(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[aliases(q)]
#[only_in(guilds)]
async fn leave(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed in at init")
.expect("Songbird client placed at init")
.clone();
let has_handler = manager.get(guild_id).is_some();
if has_handler {
if let Err(err) = manager.remove(guild_id).await {
check_msg(
msg.channel_id
.say(&ctx.http, format!("Failed: {:?}", err))
.await,
);
}
check_msg(msg.channel_id.say(&ctx.http, "Left voice channel").await);
} else {
check_msg(msg.reply(ctx, "Not in a voice channel").await);
if !manager.get(guild_id).is_some() {
ctx.say("Not in a voice channel").await?;
return Ok(())
}
if let Err(err) = manager.remove(guild_id).await {
ctx.say(format!("Failed: {:?}", err)).await?;
}
ctx.say("Left voice channel").await?;
Ok(())
}

83
src/commands/music/loopcurrent.rs
View File

@@ -1,83 +0,0 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::{Args, CommandResult};
use serenity::model::prelude::*;
use serenity::prelude::*;
use songbird::tracks::LoopState;
use crate::commands::misc::check_msg;
#[command]
#[aliases(loop)]
#[only_in(guilds)]
async fn loopcurrent(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
.await
.expect("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().get_info().await;
let is_looped = track.unwrap().loops;
let count = match args.single::<usize>() {
Ok(count) => count,
Err(_) => 100,
};
match is_looped {
LoopState::Infinite => {
let _ = queue.current().unwrap().disable_loop();
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song unlooped."),
)
.await,
);
}
LoopState::Finite(_) => {
if count < 100 {
let _ = queue.current().unwrap().loop_for(count);
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song looped forever (a very long time)."),
)
.await,
)
}
else {
let _ = queue.current().unwrap().enable_loop();
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song looped {} times.", count),
)
.await,
)
}
}
}
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel to play in")
.await,
);
}
Ok(())
}

2
src/commands/music/misc.rs
View File

@@ -17,4 +17,4 @@ impl VoiceEventHandler for TrackErrorNotifier {
}
None
}
}
}

2
src/commands/music/mod.rs
View File

@@ -7,6 +7,6 @@ pub mod play;
pub mod queue;
pub mod skip;
pub mod stop;
pub mod loopcurrent;
pub mod repeat;
pub mod pause;
pub mod resume;

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

@@ -1,24 +1,18 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn mute(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn mute(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
let handler_lock = match manager.get(guild_id) {
Some(handler) => handler,
None => {
check_msg(msg.reply(ctx, "Not in a voice channel").await);
ctx.say("Not in a voice channel").await?;
return Ok(());
}
@@ -28,24 +22,16 @@ async fn mute(ctx: &Context, msg: &Message) -> CommandResult {
if handler.is_mute() {
if let Err(e) = handler.mute(false).await {
check_msg(
msg.channel_id
.say(&ctx.http, format!("failed: {:?}", e))
.await,
);
ctx.say(format!("failed: {:?}", e)).await?;
}
check_msg(msg.channel_id.say(&ctx.http, "Unmuted").await);
ctx.say("Unmuted").await?;
} else {
if let Err(err) = handler.mute(true).await {
check_msg(
msg.channel_id
.say(&ctx.http, format!("Failed: {:?}", err))
.await,
);
ctx.say(format!("Failed: {:?}", err)).await?;
}
check_msg(msg.channel_id.say(&ctx.http, "Muted").await);
ctx.say("Muted").await?;
}
Ok(())

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

@@ -1,18 +1,12 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn pause(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn pause(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
if let Some(handler_lock) = manager.get(guild_id) {
@@ -20,20 +14,9 @@ async fn pause(ctx: &Context, msg: &Message) -> CommandResult {
let queue = handler.queue();
let _ = queue.pause();
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song paused."),
)
.await,
);
ctx.say(format!("Song paused.")).await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel to play in")
.await,
);
ctx.say("Not in a voice channel to play in").await?;
}
Ok(())

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

@@ -1,58 +1,35 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::{Args, CommandResult};
use serenity::model::prelude::*;
use serenity::prelude::*;
use reqwest::Client as HttpClient;
use crate::{Context, Error};
use songbird::input::{Compose, YoutubeDl};
use songbird::events::TrackEvent;
use crate::commands::{misc::check_msg, music::misc::TrackErrorNotifier};
pub struct HttpKey;
impl TypeMapKey for HttpKey {
type Value = HttpClient;
}
#[command]
#[aliases(p)]
#[only_in(guilds)]
async fn play(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
let url = match args.single::<String>() {
Ok(url) => url,
Err(_) => {
check_msg(
msg.channel_id
.say(&ctx.http, "Must provide a URL to a video or audio")
.await,
);
return Ok(());
}
};
use crate::commands::music::misc::TrackErrorNotifier;
use crate::http::HttpKey;
#[poise::command(prefix_command, slash_command)]
pub async fn play(ctx: Context<'_>, url: String) -> Result<(), Error> {
let is_search = !url.starts_with("http");
let guild_id = msg.guild_id.unwrap();
let channel_id = msg.guild(&ctx.cache).unwrap().voice_states.get(&msg.author.id).and_then(|voice_state| voice_state.channel_id);
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 connect_to = match channel_id {
Some(channel) => channel,
None => {
check_msg(msg.reply(ctx, "Not in a voice channel").await);
ctx.say("Not in a voice channel").await?;
return Ok(());
}
};
let http_client = {
let data = ctx.data.read().await;
let data = ctx.serenity_context().data.read().await;
data.get::<HttpKey>()
.cloned()
.expect("Guaranteed to exist in the typemap.")
};
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Songbird Voice placed at init")
.clone();
@@ -65,22 +42,18 @@ async fn play(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
let mut src = if is_search {
println!("ytsearch:{}", url);
YoutubeDl::new_ytdl_like("yt-dlp", http_client, format!("ytsearch:{}", args.clone().message()))
YoutubeDl::new_ytdl_like("yt-dlp", http_client, format!("ytsearch:{}", url))
} else {
YoutubeDl::new_ytdl_like("yt-dlp", http_client, url)
};
let _ = handler.enqueue_input(src.clone().into()).await;
let metadata = src.aux_metadata().await.unwrap();
let _metadata = src.aux_metadata().await.unwrap();
check_msg(msg.channel_id.say(&ctx.http, format!("Playing song: {}", metadata.title.unwrap())).await);
// ctx.say(format!("Playing song: {}", metadata.title.unwrap())).await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel to play in")
.await,
);
ctx.say("Not in a voice channel to play in").await?;
}
Ok(())

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

@@ -1,18 +1,12 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[command]
#[only_in(guilds)]
async fn queue(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
#[poise::command(prefix_command, slash_command)]
pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
if let Some(handler_lock) = manager.get(guild_id) {
@@ -30,18 +24,10 @@ async fn queue(ctx: &Context, msg: &Message) -> CommandResult {
));
}
check_msg(
msg.channel_id
.say(&ctx.http, queue_res)
.await,
);
ctx.say(queue_res).await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel!")
.await,
);
ctx.say("Not in a voice channel!").await?;
}
Ok(())

43
src/commands/music/repeat.rs Normal file
View File

@@ -0,0 +1,43 @@
use crate::{Context, Error};
use songbird::tracks::LoopState;
#[poise::command(prefix_command, slash_command)]
pub async fn repeat(ctx: Context<'_>, times: usize) -> 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 track = queue.current().unwrap().get_info().await;
let is_looped = track.unwrap().loops;
match is_looped {
LoopState::Infinite => {
let _ = queue.current().unwrap().disable_loop();
ctx.say("Song unlooped.").await?;
}
LoopState::Finite(_) => {
if times < 100 {
let _ = queue.current().unwrap().loop_for(times);
ctx.say("Song looped forever (a very long time)").await?;
}
else {
let _ = queue.current().unwrap().enable_loop();
ctx.say(format!("Song looped {} times.", times)).await?;
}
}
}
} else {
ctx.say("Not in a voice channel to play in").await?;
}
Ok(())
}

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

@@ -1,18 +1,12 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn resume(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn resume(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
if let Some(handler_lock) = manager.get(guild_id) {
@@ -20,20 +14,9 @@ async fn resume(ctx: &Context, msg: &Message) -> CommandResult {
let queue = handler.queue();
let _ = queue.resume();
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song resumed."),
)
.await,
);
ctx.say(format!("Song resumed.")).await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel to play in")
.await,
);
ctx.say("Not in a voice channel to play in").await?;
}
Ok(())

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

@@ -1,18 +1,12 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[poise::command(prefix_command, slash_command)]
pub async fn skip(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn skip(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
if let Some(handler_lock) = manager.get(guild_id) {
@@ -20,20 +14,9 @@ async fn skip(ctx: &Context, msg: &Message) -> CommandResult {
let queue = handler.queue();
let _ = queue.skip();
check_msg(
msg.channel_id
.say(
&ctx.http,
format!("Song skipped: {} in queue.", queue.len()),
)
.await,
);
ctx.say(format!("Song skipped: {} in queue.", queue.len())).await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel to play in")
.await,
);
ctx.say("Not in a voice channel to play in").await?;
}
Ok(())

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

@@ -1,18 +1,12 @@
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::*;
use serenity::prelude::*;
use crate::{Context, Error};
use crate::commands::misc::check_msg;
#[command]
#[only_in(guilds)]
async fn stop(ctx: &Context, msg: &Message) -> CommandResult {
let guild_id = msg.guild_id.unwrap();
#[poise::command(prefix_command, slash_command)]
pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
let manager = songbird::get(ctx)
let manager = songbird::get(&ctx.serenity_context())
.await
.expect("Client placed at init")
.expect("Songbird client placed at init")
.clone();
if let Some(handler_lock) = manager.get(guild_id) {
@@ -20,13 +14,9 @@ async fn stop(ctx: &Context, msg: &Message) -> CommandResult {
let queue = handler.queue();
queue.stop();
check_msg(msg.channel_id.say(&ctx.http, "Playback stopped!").await);
ctx.say("Playback stopped!").await?;
} else {
check_msg(
msg.channel_id
.say(&ctx.http, "Not in a voice channel!")
.await,
);
ctx.say("Not in a voice channel!").await?;
}
Ok(())