public Task LogMusicToDB(LavaTrack track, SocketCommandContext context)
{
//Get collection from database
IMongoCollection <BsonDocument> collection = _db.GetCollection("MusicLogs");
MusicLog newMusicLog = new MusicLog()
{
guild = Convert.ToInt64(context.Guild.Id),
user = Convert.ToInt64(context.User.Id),
username = context.User.Username,
date = DateTime.Now,
songTitle = track.Title,
songArtist = track.Author,
songUrl = track.Url,
songDuration = track.Duration
};
BsonDocument musicLogBson = new BsonDocument();
musicLogBson = newMusicLog.ToBsonDocument();
collection.InsertOne(musicLogBson);
return(Task.CompletedTask);
}
private async Task OnTrackFinished(LavaPlayer player, LavaTrack track, TrackEndReason reason)
{
_player = player;
switch (reason)
{
case TrackEndReason.Finished:
await PlayNextTrack();
break;
case TrackEndReason.Replaced:
break;
case TrackEndReason.LoadFailed:
await PlayNextTrack();
break;
case TrackEndReason.Cleanup:
break;
case TrackEndReason.Stopped:
break;
}
}
private async Task <string> GetNextSong(LavaTrack track)
{
var uri = new Uri(track.Url);
const string related = "https://www.youtube.com/watch?v={0}";
if (uri.Host != "www.youtube.com")
{
string search = await _google.GetRelatedVideoByQuery(track.Title).ConfigureAwait(false);
return(search == null ? null : string.Format(related, search));
}
NameValueCollection query = HttpUtility.ParseQueryString(uri.Query);
string videoId;
if (query.AllKeys.Contains("v"))
{
videoId = query["v"];
}
else
{
videoId = uri.Segments.Last();
}
string relatedId = await _google.GetRelatedVideo(videoId).ConfigureAwait(false);
return(relatedId == null ? null : string.Format(related, relatedId));
}
public async Task QueueAsync()
{
string content = "";
LavaTrack[] tracks = Player.Queue;
List <string> pages = new();
for (int i = 0; i < tracks.Length;)
{
LavaTrack track = tracks[i];
content += $"**{++i}** {await Player.GetTitleAsUrlAsync(track)} **|** ``{track.Duration:m\\:ss}``\n";
if (i % 10 == 0)
{
pages.Add(content);
content = "";
}
}
if (!string.IsNullOrEmpty(content))
{
pages.Add(content);
}
await Context.Reply.PaginatedMessageAsync(Context, pages);
}
public async Task OnFinished(LavaPlayer player, LavaTrack track, TrackReason reason)
{
if (reason is TrackReason.LoadFailed || reason is TrackReason.Cleanup)
{
return;
}
if (Loop && !WasSkipped)
{
await player.PlayAsync(track);
await player.TextChannel.SendMessageAsync("", false,
await EmbedHandler.CreateEmbed("Audio", string.Format("{0} is on repeat.", track.Title)));
}
else
{
WasSkipped = false;
player.Queue.TryDequeue(out LavaTrack nextTrack);
if (nextTrack is null)
{
await player.StopAsync();
}
else
{
await player.PlayAsync(nextTrack);
await player.TextChannel.SendMessageAsync("", false,
await EmbedHandler.CreateEmbed("Audio", string.Format("Now playing: {0}", nextTrack.Title)));
}
}
}
public async Task SkipAsync(int amount = 1)
{
try
{
if (amount <= 1)
{
var skipped = await player.SkipAsync();
await ReplyAsync($"Skipped: {skipped.Title}\nNow Playing: {player.CurrentTrack.Title}");
}
else
{
LavaTrack track = null;
for (int i = 0; i < amount; i++)
{
if (player.Queue.TryDequeue(out var trk))
{
if (trk is LavaTrack lavaTrack)
{
track = lavaTrack;
}
}
}
if (track != null)
{
await player.PlayAsync(track);
await ReplyAsync($"Skipped {amount} tracks\nNow Playing: {player.CurrentTrack.Title}");
}
}
}
catch
{
await ReplyAsync("There are no more items left in queue.");
}
}
public PlayPayload(ulong guildId, LavaTrack track, bool noReplace) : base(guildId, "play")
{
Hash = track.Hash;
StartTime = 0;
EndTime = (int)track.Duration.TotalMilliseconds;
NoReplace = noReplace;
}
public string GetRequestor(LavaTrack track)
{
string hyperlink = AudioService.Hyperlink(track);
var requestorID = AudioService.Tracks[Context.Guild.Id].First(t => t.ID == track.Id).RequestorID;
return(Context.Guild.GetUser(requestorID).Mention);
}
/// <summary>
/// Searches OVH for lyrics and returns them as string.
/// </summary>
/// <param name="lavaTrack"><see cref="LavaTrack"/></param>
/// <returns><see cref="string"/></returns>
/// <exception cref="ArgumentNullException">Throws if LavaTrack is null.</exception>
public static async ValueTask <string> SearchOVHAsync(LavaTrack lavaTrack)
{
if (lavaTrack == null)
{
throw new ArgumentNullException(nameof(lavaTrack));
}
var(author, title) = lavaTrack.GetAuthorAndTitle();
var url = $"https://api.lyrics.ovh/v1/{author.Encode()}/{title.Encode()}";
var bytes = await GetBytesAsync(url)
.ConfigureAwait(false);
if (bytes.Length == 0)
{
throw new Exception($"No lyrics found for {lavaTrack.Title}");
}
var rawJson = Encoding.UTF8.GetString(bytes);
var parse = JObject.Parse(rawJson);
if (!parse.TryGetValue("lyrics", out var result))
{
return(parse.GetValue("error").ToObject <string>());
}
var regex = new Regex(@"[\r\n]{2,}");
return(regex.Replace($"{result}", "\n"));
}
public async Task <LavaTrack> GetTrack(string url, bool prioritiseSoundcloud = false)
{
try
{
LavaTrack track = null;
if (Uri.TryCreate(url, UriKind.Absolute, out Uri uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps))
{
track = (await LavaRestClient.SearchTracksAsync(url)).Tracks.FirstOrDefault();
}
else
{
if (prioritiseSoundcloud)
{
track = (await LavaRestClient.SearchSoundcloudAsync(url)).Tracks.FirstOrDefault();
}
else
{
track = (await LavaRestClient.SearchYouTubeAsync(url)).Tracks.FirstOrDefault();
}
}
return(track);
}
catch
{
return(null);
}
}
private async Task OnTrackEnded(TrackEndedEventArgs args)
{
if (!args.Reason.ShouldPlayNext())
{
return;
}
var player = args.Player;
if (_pulledTrack != null)
{
await player.PlayAsync(_pulledTrack);
_pulledTrack = null;
return;
}
if (!player.Queue.TryDequeue(out var queueable))
{
return;
}
if (!(queueable is LavaTrack track))
{
await player.TextChannel.SendMessageAsync("Something wrong with the next track");
return;
}
await player.PlayAsync(track);
}
public async Task <Embed> SkipCurrentlyPlayingTrack(SocketGuildUser user, IMessageChannel channel)
{
LavaPlayer player = lavalink.DefaultNode.GetPlayer(Config.Bot.ServerID);
player.TextChannel = channel;
if (player.CurrentTrack != null && player.IsPlaying)
{
WasSkipped = true;
LavaTrack track = player.CurrentTrack;
await player.StopAsync();
if (player.Queue.Count > 0)
{
await player.PlayAsync(player.Queue.Items.ElementAt(0));
return(await EmbedHandler.CreateEmbed("Audio", string.Format("{0} was skipped.\nNext song: {1}.", track.Title, player.CurrentTrack.Title)));
}
else
{
return(await EmbedHandler.CreateEmbed("Audio", string.Format("{0} was skipped.\nThere are no more tracks in the queue.", track.Title)));
}
}
else
{
return(await EmbedHandler.CreateErrorEmbed("Audio, Current Track", "There Are No Current Track."));
}
}
public static LavaTrack DecodeTrack(string trackString)
{
const int trackInfoVersioned = 1;
var raw = Convert.FromBase64String(trackString);
var decoded = new LavaTrack
{
Hash = trackString
};
using var ms = new MemoryStream(raw);
using var jb = new JavaBinaryHelper(ms);
var messageHeader = jb.ReadInt32();
var messageFlags = (int)((messageHeader & 0xC0000000L) >> 30);
var version = (messageFlags & trackInfoVersioned) != 0 ? jb.ReadSByte() & 0xFF : 1;
decoded.Title = jb.ReadJavaUtf8();
decoded.Author = jb.ReadJavaUtf8();
decoded.TrackLength = jb.ReadInt64();
decoded.Id = jb.ReadJavaUtf8();
decoded.IsStream = jb.ReadBoolean();
var uri = jb.ReadNullableString();
decoded.Uri = uri != null && version >= 2 ? new Uri(uri) : null;
return(decoded);
}
public async Task TrackFinished(LavaPlayer player, LavaTrack track, TrackEndReason reason)
{
if (reason == TrackEndReason.LoadFailed || reason == TrackEndReason.Cleanup || reason == TrackEndReason.Replaced)
{
return;
}
//To stop un-necessary use, disconnect if there are no users left listening.
var users = await player.VoiceChannel.GetUsersAsync().FlattenAsync();
if (!users.Any())
{
await Client.DisconnectAsync(player.VoiceChannel);
await player.TextChannel?.SendMessageAsync("Music playback has been stopped as there are no users listening.");
return;
}
if (player.Queue.TryDequeue(out var nextTrack))
{
if (nextTrack is LavaTrack newTrack)
{
await player.PlayAsync(newTrack);
await player.TextChannel?.SendMessageAsync($"Now playing: {newTrack.Title}");
}
}
else
{
await player.StopAsync();
await player.TextChannel?.SendMessageAsync("Playlist finished.");
}
}
// Fires up when track is finished.. Maybe set timer here for autokick feature
public async Task OnFinished(LavaPlayer player, LavaTrack track, TrackReason reason)
{
if (reason is TrackReason.LoadFailed || reason is TrackReason.Cleanup)
{
return;
}
player.Queue.TryDequeue(out LavaTrack nextTrack);
if (nextTrack == null)
{
await player.StopAsync();
await BotService.SetBotStatus(_client, "Paused");
await player.TextChannel.SendMessageAsync("", false, await EmbedHandler.CreateBasicEmbed("Music", $"Paused, no songs in queue", Color.Gold));
}
else
{
await player.PlayAsync(nextTrack);
await player.TextChannel.SendMessageAsync("", false, await EmbedHandler.CreateBasicEmbed("Now Playing", $"{nextTrack.Title}", Color.Gold));
}
}
public async Task NowPlayingAsync()
{
Language lang = Commands.GetLanguage(Context.Guild.Id);
if (!_lavaNode.TryGetPlayer(Context.Guild, out LavaPlayer player))
{
await ReplyAsync(lang.Not_connected);
return;
}
if (player.PlayerState != PlayerState.Playing)
{
await ReplyAsync(lang.Not_playing);
return;
}
LavaTrack track = player.Track;
string artwork = await track.FetchArtworkAsync();
EmbedBuilder embed = new EmbedBuilder
{
Title = $"{track.Author} - {track.Title}",
ThumbnailUrl = artwork,
Url = track.Url
}
.AddField("Id", track.Id, true)
.AddField("Duration", track.Duration, true)
.AddField("Position", track.Position, true);
await ReplyAsync(embed : embed.Build());
}
public async Task OnFinished(LavaPlayer player, LavaTrack track, TrackEndReason reason)
{
if (reason is TrackEndReason.Cleanup || reason is TrackEndReason.Replaced)
{
return;
}
else if (reason is TrackEndReason.Stopped)
{
// TODO(Adam): add auto disconnect
return;
}
else if (reason is TrackEndReason.LoadFailed)
{
if (player.TextChannel != null)
{
await player.TextChannel.SendMessageAsync(embed : await EmbedHandler.CreateErrorEmbed("Load Failed", $"Failed to load `{Hyperlink(track)}`."));
}
return;
}
player.Queue.TryDequeue(out var queueObject);
var nextTrack = queueObject as LavaTrack;
if (nextTrack != null)
{
await player.PlayAsync(nextTrack);
if (player.TextChannel != null)
{
await player.TextChannel.SendMessageAsync(embed : await EmbedHandler.CreateBasicEmbed("Now Playing", $"{Hyperlink(nextTrack)}", Color.Blue));
}
}
}
public async Task <string> PlayAsync(string query, ulong guildId)
{
Player = lavaSocketClient.GetPlayer(guildId);
SearchResult results = await lavaRestClient.SearchYouTubeAsync(query);
if (results.LoadType == LoadType.NoMatches || results.LoadType == LoadType.LoadFailed)
{
return("No matches found.");
}
LavaTrack track = results.Tracks.FirstOrDefault();
if (track is null)
{
return("The possibility of you seeing this is less than 0% but Jetbrains won't shut up about it.");
}
if (Player.IsPlaying)
{
Player.Queue.Enqueue(track);
return($"{track.Title} has been added to the queue.");
}
await Player.PlayAsync(track);
return($"Now player: {track.Title}");
}
/// <summary>
/// Decodes the hash for the specified track.
/// </summary>
/// <param name="hash">Track's hash.</param>
/// <returns>
/// <see cref="LavaTrack" />
/// </returns>
public static LavaTrack Decode(string hash)
{
Span <byte> hashBuffer = stackalloc byte[hash.Length];
Encoding.ASCII.GetBytes(hash, hashBuffer);
Base64.DecodeFromUtf8InPlace(hashBuffer, out var bytesWritten);
var javaReader = new JavaBinaryReader(hashBuffer.Slice(0, bytesWritten));
// Reading header
var header = javaReader.Read <int>();
var flags = (int)((header & 0xC0000000L) >> 30);
var hasVersion = (flags & 1) != 0;
var version = hasVersion ? javaReader.Read <sbyte>() : 1;
var track = new LavaTrack()
.WithHash(hash)
.WithTitle(javaReader.ReadString())
.WithAuthor(javaReader.ReadString())
.WithDuration(javaReader.Read <long>())
.WithId(javaReader.ReadString())
.WithStream(javaReader.Read <bool>())
.WithUrl(javaReader.Read <bool>()
? javaReader.ReadString()
: string.Empty);
return(track);
}
public MusicService(LavaNode lavaNode, IServiceScopeFactory serviceScope)
{
_serviceScope = serviceScope;
_lavaNode = lavaNode;
_lavaNode.OnTrackEnded += OnTrackEnded;
_pulledTrack = null;
}
//When player is updated, fires up every 5 seconds
public async Task OnUpdated(LavaPlayer player, LavaTrack track, TimeSpan timeSpan)
{
if (player.IsPlaying || player.IsPaused)
{
await BotService.SetBotStatus(_client, $"{track.Title}");
}
await LoggingService.LogInformationAsync("OnUpdated", $"We here + Last time updated: {player.LastUpdate}");
}
public Song(LavaTrack track, SocketCommandContext context, int volume)
{
Track = track;
Guild = context.Guild;
Requester = (SocketGuildUser)context.User;
TextChannel = context.Channel;
DurationString = track.Length.ToString();
Volume = volume;
}
/// <summary>
/// Fetches artwork for Youtube, Twitch, SoundCloud and Vimeo.
/// </summary>
/// <param name="track"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static async ValueTask <string> FetchAsync(LavaTrack track)
{
if (track == null)
{
throw new ArgumentNullException(nameof(track));
}
var(shouldSearch, requestUrl) = track.Url.ToLower() switch {
var yt when yt.Contains("youtube")
=> (true, $"https://img.youtube.com/vi/{track.Id}/maxresdefault.jpg"),
var twitch when twitch.Contains("twitch")
=> (true, $"https://api.twitch.tv/v4/oembed?url={track.Url}"),
var sc when sc.Contains("soundcloud")
=> (true, $"https://soundcloud.com/oembed?url={track.Url}&format=json"),
var vim when vim.Contains("vimeo")
=> (false, $"https://i.vimeocdn.com/video/{track.Id}.png"),
_ => (false, "https://raw.githubusercontent.com/Yucked/Victoria/v5/src/Logo.png")
};
if (!shouldSearch)
{
return(requestUrl);
}
var(httpMethod, httpCompletionOption, fallbackUrl) = track.Url.ToLower().Contains("youtube")
? (HttpMethod.Head, HttpCompletionOption.ResponseHeadersRead, $"https://img.youtube.com/vi/{track.Id}/hqdefault.jpg")
: (HttpMethod.Get, HttpCompletionOption.ResponseContentRead, "https://raw.githubusercontent.com/Yucked/Victoria/v5/src/Logo.png");
var responseMessage = await VictoriaExtensions.HttpClient.SendAsync(new HttpRequestMessage {
Method = httpMethod,
RequestUri = new Uri(requestUrl)
}, httpCompletionOption);
if (!responseMessage.IsSuccessStatusCode)
{
return(fallbackUrl);
}
if (track.Url.ToLower().Contains("youtube"))
{
return(requestUrl);
}
using var content = responseMessage.Content;
await using var stream = await content.ReadAsStreamAsync();
var document = await JsonDocument.ParseAsync(stream);
return(document.RootElement.TryGetProperty("thumbnail_url", out var url)
? $"{url}"
: requestUrl);
}
private XyloxTrack ConvertTrackToXyloxTrack(LavaTrack track, bool isQueued)
=> new XyloxTrack
{
Id = track.Id,
Title = track.Title,
Author = track.Author,
Duration = track.Duration,
Url = track.Url,
IsQueued = isQueued
};
/// <summary>
///
/// </summary>
/// <param name="lavaTrack"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static ValueTask <string> SearchGeniusAsync(LavaTrack lavaTrack)
{
if (lavaTrack == null)
{
throw new ArgumentNullException(nameof(lavaTrack));
}
var(artist, title) = GetArtistAndTitle(lavaTrack);
return(SearchGeniusAsync(artist, title));
}
public string Remove(int index)
{
if (_player is null || _player.Queue.Equals(null) || (_player.Queue.Items.Count() == 0 && _player.Track == null))
{
return(":x: Queue is empty.");
}
LavaTrack track = _player.Queue.Items.ElementAt(index - 1) as LavaTrack;
_player.Queue.RemoveAt(index - 1);
return($":hash: Removed track `{track.Title}`");
}
public async Task <String> SkipAsync(IGuild guild)
{
if (SetPlayer(guild) || _player.Queue.Count is 0)
{
return("Nothing in queue!");
}
LavaTrack oldTrack = _player.Track;
await _player.SkipAsync();
return($"**Skipped:** *{oldTrack.Title}*\n**Now playing:** *{_player.Track.Title}*");
}
private async Task ReplyMusicExtended(LavaTrack track, bool added = true)
{
var url = await track.FetchArtworkAsync();
await ReplyMusicEmbedExtended(
track.Title,
track.Author,
url,
track.Duration.ToString(@"mm\:ss"),
track.Url,
added);
}
private string Queuelist(List <Victoria.Interfaces.IQueueable> queue)
{
string result = "";
for (int i = 1; i <= queue.Count && i < 10; i++)
{
LavaTrack track = (LavaTrack)queue[i - 1];
result += $"**{i}.** " + track.Title + " **[" + track.Duration + "]**" + '\n';
totalLenght += track.Duration;
}
return(result);
}
public new async Task <(CustomLavaTrack Skipped, CustomLavaTrack Current)> SkipAsync(TimeSpan?delay = null)
{
LavaTrack skipped = (await base.SkipAsync(delay)).Skipped;
CustomQueue.TryDequeue(out CustomLavaTrack lavaTrack);
CustomLavaTrack customSkipped = new CustomLavaTrack(skipped, User);
User = lavaTrack.User;
return(customSkipped, lavaTrack);
}
