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

music commands migrated

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

3
Cargo.lock generated
View File

@@ -933,7 +933,7 @@ dependencies = [
[[package]]
name = "lyra"
version = "0.3.0"
version = "0.4.0"
dependencies = [
"dotenv",
"openssl",
@@ -2338,6 +2338,7 @@ dependencies = [
"libc",
"mio",
"num_cpus",
"parking_lot",
"pin-project-lite",
"signal-hook-registry",
"socket2",

12
Cargo.toml
View File

@@ -1,7 +1,15 @@
[package]
name = "lyra"
version = "0.3.0"
version = "0.4.0"
authors = ["Michał Czyż <mike@c2yz.com>"]
edition = "2021"
description = "A featureful Discord bot written in Rust."
documentation = "https://lyra.c2yz.com/docs"
readme = "README.md"
homepage = "https://lyra.c2yz.com"
license-file = "LICENSE.md"
keywords = ["discord", "bot", "rust", "music", "featureful"]
[dependencies]
dotenv = "0.15.0"
@@ -12,7 +20,7 @@ reqwest = "0.11.23"
serenity = { version = "0.12.0", features = ["cache", "framework", "standard_framework", "voice"] }
songbird = { version = "0.4.0", features = ["builtin-queue", "serenity"] }
symphonia = "0.5.3"
tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "signal"] }
tokio = { version = "1.35.1", features = ["macros", "full", "signal"] }
tracing = "0.1.40"
tracing-futures = "0.2.5"
tracing-subscriber = "0.3.18"

6
LICENSE.md
View File

@@ -1,5 +1,7 @@
# License
Copyright(c) Michał Czyż 2024
Copyright (C) 2024 Michał Czyż
[Currently] All Rights Reserved.
All Rights Reserved.
This build is private and shall not be distributed nor modified without permission.

0
scripts/cross-build.sh Normal file → Executable file
View File

2
scripts/launch.sh Normal file → Executable file
View File

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

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/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;
#[poise::command(prefix_command, slash_command)]
pub async fn queue(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn queue(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) {
@@ -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;
#[poise::command(prefix_command, slash_command)]
pub async fn stop(ctx: Context<'_>) -> Result<(), Error> {
let guild_id = ctx.guild_id().unwrap();
#[command]
#[only_in(guilds)]
async fn stop(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,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(())

8
src/http.rs Normal file
View File

@@ -0,0 +1,8 @@
use reqwest::Client as HttpClient;
use poise::serenity_prelude::prelude::TypeMapKey;
pub struct HttpKey;
impl TypeMapKey for HttpKey {
type Value = HttpClient;
}

10
src/main.rs
View File

@@ -4,9 +4,14 @@ use poise::serenity_prelude::{self as serenity, ActivityData};
use std::sync::Arc;
use std::time::Duration;
use tracing::{info, warn, error};
use reqwest::Client as HttpClient;
mod http;
mod commands;
// http typemap for handling requests
use crate::http::HttpKey;
// commands: music
use crate::commands::music::deafen::*;
use crate::commands::music::join::*;
@@ -16,7 +21,7 @@ use crate::commands::music::play::*;
use crate::commands::music::queue::*;
use crate::commands::music::skip::*;
use crate::commands::music::stop::*;
use crate::commands::music::loopcurrent::*;
use crate::commands::music::repeat::*;
use crate::commands::music::pause::*;
use crate::commands::music::resume::*;
@@ -66,7 +71,7 @@ async fn main() {
deafen(),
join(),
leave(),
loopcurrent(),
repeat(),
mute(),
pause(),
play(),
@@ -144,6 +149,7 @@ async fn main() {
let mut client = serenity::ClientBuilder::new(token, intents)
.framework(framework)
.register_songbird()
.type_map_insert::<HttpKey>(HttpClient::new())
.await
.expect("Error creating client");