public async Task Play(CommandContext ctx, [RemainingText] string search)
{
if (ctx.Member.VoiceState == null || ctx.Member.VoiceState.Channel == null)
{
await ctx.RespondAsync("You must be in a voice channel!");
return;
}
var node = Lavalink;
var conn = node.GetGuildConnection(ctx.Member.VoiceState.Guild);
if (conn == null)
{
await Join(ctx);
}
conn = node.GetGuildConnection(ctx.Guild);
var loadResult = new LavalinkLoadResult();
if (search.StartsWith("D:/"))
{
loadResult = await Lavalink.Rest.GetTracksAsync(new Uri(search, UriKind.Relative));
}
else if (search.StartsWith("https:"))
{
loadResult = await Lavalink.Rest.GetTracksAsync(new Uri(search, UriKind.Absolute));
}
else
{
loadResult = await Lavalink.Rest.GetTracksAsync(search);
}
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed ||
loadResult.LoadResultType == LavalinkLoadResultType.NoMatches)
{
await ctx.RespondAsync("Track search failed.");
if (conn.CurrentState.CurrentTrack == null)
{
await Leave(ctx);
}
return;
}
var result = loadResult.Tracks.First();
if (queues.ContainsKey(ctx.Guild.Id))
{
if (queues[ctx.Guild.Id].IsEmpty && conn.CurrentState.CurrentTrack == null)
{
await conn.PlayAsync(result);
}
else
{
queues[ctx.Guild.Id].Enqueue(result);
if (!result.Identifier.StartsWith("D:/"))
{
await ctx.RespondAsync(
$"A track was already playing, the requested track ({result.Title}, `{"https://youtu.be/" + result.Uri.ToString()[^11..]}`) has been added to the queue!");
public async Task PlayAsync(CommandContext ctx,
[Description("desc-audio-url")] Uri uri)
{
LavalinkLoadResult tlr = await this.Service.GetTracksAsync(uri);
await this.InternalPlayAsync(ctx, tlr);
}
/// <summary>
/// Adiciona novas músicas à playlist utilizando a API do YouTube para realizar a busca.
/// </summary>
/// <param name="numberOfTracksToGrab"> How many songs to search for. </param>
/// <returns></returns>
public static async Task AddSongs(short numberOfTracksToGrab)
{
LavalinkGuildConnection guildConnection = LavalinkNode.GetGuildConnection(await Lavalink.Client.GetGuildAsync(configJson.ServerId).ConfigureAwait(false));
for (int i = 0; i < numberOfTracksToGrab; i++)
{
WordsGenerator _wordsGenerator = new WordsGenerator(_randomNumber);
List <string> wordList = _wordsGenerator.GenerateWordList();
YoutubeSearchEngine _youtubeSearchEngine = new YoutubeSearchEngine(1);
Dictionary <string, string> searchResult = _youtubeSearchEngine.SearchVideos(wordList);
foreach (var result in searchResult)
{
Uri videoUri = new Uri(result.Value);
LavalinkLoadResult loadResult = await LavalinkNode.Rest.GetTracksAsync(videoUri).ConfigureAwait(false);
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed || loadResult.LoadResultType == LavalinkLoadResultType.NoMatches)
{
await guildConnection.Guild.GetChannel(configJson.ComandosBotCanalId).SendMessageAsync($"ERR0! Pesquisa por {searchResult} falhou! Tipo do resultado: {result.Key}").ConfigureAwait(false);
}
else
{
Playlist.Add(loadResult.Tracks.First());
await guildConnection.Guild.GetChannel(configJson.ComandosBotCanalId).SendMessageAsync($"A música: {loadResult.Tracks.First().Title} foi adicionada à playlist de músicas para tocar!").ConfigureAwait(false);
}
}
}
}
public async Task PlayFileAsync(CommandContext ctx,
[RemainingText, Description("desc-audio-url")] string path)
{
var fi = new FileInfo(path);
LavalinkLoadResult tlr = await this.Service.GetTracksAsync(fi);
await this.InternalPlayAsync(ctx, tlr);
}
public async Task Play(CommandContext ctx, [Description("URI to the audio to play.")] string song, [Description("Source to search from. {Youtube, SoundCloud}")] string source = "Youtube")
{
LavalinkNodeConnection lavalinkNodeConnection = await Connections.GetNodeConnection(ctx);
LavalinkTrack track = null;
if (Uri.TryCreate(song, UriKind.Absolute, out Uri uri))
{
LavalinkLoadResult results = await lavalinkNodeConnection.Rest.GetTracksAsync(uri);
if (results.Exception.Message != null)
{
throw new Exception(results.Exception.Message);
}
IEnumerable <LavalinkTrack> tracks = results.Tracks;
if (tracks.Count() == 0)
{
throw new InvalidOperationException($"Could not find `{uri.OriginalString}`.");
}
track = tracks.First();
}
else
{
if (Enum.TryParse(source, true, out LavalinkSearchType lavalinkSearchType))
{
IEnumerable <LavalinkTrack> tracks = lavalinkNodeConnection.Rest.GetTracksAsync(song, lavalinkSearchType).GetAwaiter().GetResult().Tracks;
if (tracks.Count() == 0)
{
throw new InvalidOperationException($"There were 0 results for `{song}`.");
}
track = tracks.First();
}
else
{
throw new InvalidOperationException($"`{source}` is not a valid source.");
}
}
LavalinkGuildConnection lavalinkGuildConnection = lavalinkNodeConnection.GetGuildConnection(ctx.Guild);
Messaging messaging = new Messaging(ctx);
if (lavalinkGuildConnection.CurrentState.CurrentTrack == null)
{
await lavalinkGuildConnection.PlayAsync(track);
if (loops[ctx.Guild.Id])
{
queues[ctx.Guild.Id].Enqueue(track);
}
await messaging.RespondContent(true, track.Length)($"🎤 {track.Author} - {track.Title}");
}
else
{
queues[ctx.Guild.Id].Enqueue(track);
await messaging.RespondContent()("Added to the queue.");
}
}
public async Task CreateFixed(CommandContext ctx, [RemainingText] string name)
{
var inter = ctx.Client.GetInteractivity();
var pls = await PlaylistDB.GetPlaylistsSimple(ctx.Member.Id);
if (pls.Any(x => x == name))
{
await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithTitle("Create Fixed Playlist").WithDescription("**Error** You already have a playlist with that name!").Build());
return;
}
var msg = await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithTitle("Create Fixed Playlist").WithDescription("Please send the playlist URL now!\n" +
"> Just the link, no bot prefix needed!").Build());
var gets = await inter.WaitForMessageAsync(x => x.Author == ctx.Member, TimeSpan.FromSeconds(30));
await msg.DeleteAsync();
LavalinkLoadResult s = null;
try
{
s = await Bot.LLEU[ctx.Client.ShardId].GetTracksAsync(new Uri(gets.Result.Content));
}
catch
{
await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithTitle("Create Fixed Playlist").WithDescription("**Error** Reasons could be:\n" +
"> The provided link was not a playlist\n" +
"> The playlist is unavailable (for example set to private)").Build());
return;
}
if (s.LoadResultType != DSharpPlus.Lavalink.LavalinkLoadResultType.PlaylistLoaded)
{
await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithTitle("Create Fixed Playlist").WithDescription("**Error** Reasons could be:\n" +
"> The provided link was not a playlist\n" +
"> The playlist is unavailable (for example set to private)").Build());
return;
}
if (gets.Result.Content.Contains("youtu") && !gets.Result.Content.Contains("soundcloud"))
{
await PlaylistDB.AddPlaylist(name, ctx.Member.Id, ExtService.Youtube, gets.Result.Content);
}
else
{
await PlaylistDB.AddPlaylist(name, ctx.Member.Id, ExtService.Soundcloud, gets.Result.Content);
}
await ctx.RespondAsync(embed : new DiscordEmbedBuilder().WithTitle("Create Fixed Playlist").WithDescription($"Fixed playlist created with name -> {name} and {s.Tracks.Count()} Songs!").Build());
}
private async Task InternalPlayAsync(CommandContext ctx, LavalinkLoadResult tlr)
{
IEnumerable <LavalinkTrack> tracks = tlr.Tracks;
if (tlr.LoadResultType == LavalinkLoadResultType.LoadFailed || !tracks.Any() || this.Player is null)
{
throw new CommandFailedException(ctx, "cmd-err-music-none");
}
if (this.Player.IsShuffled)
{
tracks = this.Service.Shuffle(tracks);
}
int trackCount = tracks.Count();
foreach (LavalinkTrack track in tracks)
{
this.Player.Enqueue(new Song(track, ctx.Member));
}
DiscordChannel?chn = ctx.Member.VoiceState?.Channel ?? ctx.Guild.CurrentMember.VoiceState?.Channel;
if (chn is null)
{
throw new CommandFailedException(ctx, "cmd-err-music-vc");
}
await this.Player.CreatePlayerAsync(chn);
await this.Player.PlayAsync();
if (trackCount > 1)
{
await ctx.ImpInfoAsync(this.ModuleColor, Emojis.Headphones, "fmt-music-add-many", trackCount);
}
else
{
LavalinkTrack track = tracks.First();
await ctx.RespondWithLocalizedEmbedAsync(emb => {
emb.WithColor(this.ModuleColor);
emb.WithLocalizedTitle("fmt-music-add", Emojis.Headphones);
emb.WithDescription(Formatter.Bold(Formatter.Sanitize(track.Title)));
emb.AddLocalizedTitleField("str-author", track.Author, inline: true);
emb.AddLocalizedTitleField("str-duration", track.Length.ToDurationString(), inline: true);
emb.WithUrl(track.Uri);
});
}
}
public async Task Play(CommandContext ctx, LavalinkLoadResult results)
{
var audio = results.Tracks.FirstOrDefault();
if (results.LoadResultType == LavalinkLoadResultType.LoadFailed || audio is null)
{
await ctx.RespondAsync(":mag: No tracks were found at specified link.").ConfigureAwait(false);
return;
}
Player.Enqueue(new MusicData(audio, ctx.Member));
await Player.CreatePlayerAsync(ctx.Member.VoiceState.Channel);
await Player.PlayAsync();
await ctx.RespondAsync(
$":play_pause: Now playing: {Formatter.Bold(Formatter.Sanitize(audio.Title))} by {Formatter.Bold(Formatter.Sanitize(audio.Author))}.")
.ConfigureAwait(false);
}
public async Task Tocar(CommandContext context, [Description("Pesquisa que o bot fará no site externo.")][RemainingText] string searchQuery)
{
if (context.Channel.Id == BotClient.configJson.ComandosBotCanalId)
{
guildConnection = BotClient.LavalinkNode.GetGuildConnection(await BotClient.Lavalink.Client.GetGuildAsync(BotClient.configJson.ServerId).ConfigureAwait(false));
if (context.Member.VoiceState == null || context.Member.VoiceState.Channel == null)
{
await context.RespondAsync($"{context.User.Username} você precisa estar conectado a um canal de voz!").ConfigureAwait(false);
return;
}
if (guildConnection == null)
{
await context.RespondAsync($"ERR0! Lavalink não está conectado!").ConfigureAwait(false);
return;
}
YoutubeSearchEngine youtubeSearchEngine = new YoutubeSearchEngine(1);
Dictionary <string, string> searchResult = youtubeSearchEngine.SearchVideos(searchQuery);
if (searchResult.Count == 0)
{
await context.RespondAsync($"ERR0! Pesquisa por {searchQuery} falhou! Não consegui encontrar nenhum vídeo no YouTube!").ConfigureAwait(false);
return;
}
string videoTitle = searchResult.ElementAt(0).Key.ToString();
LavalinkLoadResult loadResult = await BotClient.LavalinkNode.Rest.GetTracksAsync(videoTitle).ConfigureAwait(false);
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed || loadResult.LoadResultType == LavalinkLoadResultType.NoMatches)
{
await context.RespondAsync($"ERR0! Pesquisa por {searchQuery} falhou! Tipo do resultado: {loadResult.LoadResultType}").ConfigureAwait(false);
}
LavalinkTrack track = loadResult.Tracks.First();
if (track.Length >= new TimeSpan(0, BotClient.configJson.TrackMaxLengthInMinutes, 0))
{
await context.RespondAsync($"Duração da Música {track.Title} é maior que o maximo permitido(valor configurável)! Ignorando esta música...");
await context.RespondAsync($"Duração: {track.Length.Hours}:{track.Length.Minutes}:{track.Length.Seconds}.");
return;
}
if (BotClient.Playlist.Count == 0)
{
BotClient.Playlist.Add(track);
await guildConnection.SetVolumeAsync(50).ConfigureAwait(false);
await guildConnection.PlayAsync(BotClient.Playlist[0]).ConfigureAwait(false);
await context.RespondAsync($"Tocando: {track.Title}! Volume: {50}%").ConfigureAwait(false);
BotClient.IsSongPlaying = true;
}
else
{
BotClient.Playlist.Add(track);
await context.RespondAsync($"A música: {track.Title} foi adicionada à playlist de músicas para tocar!").ConfigureAwait(false);
}
}
}
public async Task PlayAsync(CommandContext ctx, string searchQuery)
{
if (this._isPaused && !this._isStopped)
{
await this.LavalinkGuildConnection.ResumeAsync();
return;
}
DiscordChannel commandChannel = ctx.Channel;
DiscordMember memberCommand = ctx.Member;
string memberCommandMention = memberCommand.Mention;
this.LavalinkGuildConnection = this._lavalinkNodeConnection.GetGuildConnection(ctx.Guild);
if (this.LavalinkGuildConnection?.IsConnected != true)
{
DiscordChannel memberVoiceChannel = ctx.Member.VoiceState?.Channel;
if (memberVoiceChannel is null)
{
await commandChannel.SendMessageAsync($"{memberCommandMention}, join a voice channel!!");
return;
}
this.LavalinkGuildConnection = await this._lavalinkNodeConnection.ConnectAsync(memberVoiceChannel);
await this.LavalinkGuildConnection.SetVolumeAsync(50);
this.LavalinkGuildConnection.PlaybackFinished += this.PlaybackFinished;
this.LavalinkGuildConnection.PlaybackStarted += this.PlaybackStarted;
this.LavalinkGuildConnection.TrackException += this.TrackError;
this.LavalinkGuildConnection.TrackStuck += this.TrackStuck;
}
LavalinkLoadResult resultTracks = !Uri.TryCreate(searchQuery, UriKind.Absolute, out Uri resultUri) ?
await this.LavalinkGuildConnection.GetTracksAsync(searchQuery) :
await this.LavalinkGuildConnection.GetTracksAsync(resultUri);
if (this.Playlist is null)
{
this.Playlist = new Dictionary <LavalinkTrack, CommandContext>();
}
switch (resultTracks.LoadResultType)
{
case LavalinkLoadResultType.TrackLoaded:
case LavalinkLoadResultType.SearchResult:
{
var trackResult = resultTracks.Tracks.FirstOrDefault();
this.Playlist.Add(trackResult, ctx);
if (this._isPlaying)
{
await commandChannel.SendMessageAsync($"{memberCommandMention}, `{trackResult.Author}'s` - `{trackResult.Title}` song was successfully added to the playlist.");
return;
}
break;
}
case LavalinkLoadResultType.PlaylistLoaded:
{
IEnumerable <LavalinkTrack> listOfTracks = resultTracks.Tracks;
foreach (LavalinkTrack trackForeach in listOfTracks)
{
this.Playlist.Add(trackForeach, ctx);
}
if (this._isPlaying)
{
await commandChannel.SendMessageAsync($"{memberCommandMention}, `{listOfTracks.Count()}` songs have been successfully added to the playlist.");
return;
}
break;
}
case LavalinkLoadResultType.NoMatches:
{
await commandChannel.SendMessageAsync($"{memberCommandMention}, no songs were found, please search again later.");
return;
}
case LavalinkLoadResultType.LoadFailed:
{
if (this._reconnections == 3)
{
await commandChannel.SendMessageAsync($"{memberCommandMention}, an error occurred while trying to load this song, please try again.");
return;
}
++this._reconnections;
await this.PlayAsync(ctx, searchQuery);
return;
}
}
LavalinkTrack track = this.Playlist.Keys.FirstOrDefault();
await this.LavalinkGuildConnection.PlayAsync(track);
this._isPlaying = true;
}
public async Task EnqueueTrack(CommandContext ctx, [RemainingText] string input)
{
_Cmdctx = ctx;
if (ctx.Member?.VoiceState?.Channel == null)
{
await ctx.RespondAsync("You must be connected to a voice channel to use this command.");
return;
}
var lavaconfig = new LavalinkConfiguration
{
Password = ""
};
if (_LavalinkNode == null || !_LavalinkNode.IsConnected)
{
_LavalinkNode = await _Lavalink.ConnectAsync(lavaconfig);
}
if ((_LavalinkGuild == null || !_LavalinkGuild.IsConnected))
{
_LavalinkGuild = await _LavalinkNode.ConnectAsync(ctx.Member.VoiceState.Channel);
_LavalinkGuild.PlaybackFinished += PlayTrack;
}
var tracks = new LavalinkLoadResult();
Uri uri;
if (Uri.TryCreate(input, UriKind.Absolute, out uri))
{
tracks = await _LavalinkNode.GetTracksAsync(uri);
}
else
{
tracks = await _LavalinkNode.GetTracksAsync(input);
}
switch (tracks.LoadResultType)
{
case LavalinkLoadResultType.SearchResult:
case LavalinkLoadResultType.TrackLoaded:
_Playlist.Enqueue(tracks.Tracks.First());
await ctx.RespondAsync($"**[Enqueued]** {tracks.Tracks.First().Title}");
break;
case LavalinkLoadResultType.PlaylistLoaded:
foreach (LavalinkTrack track in tracks.Tracks)
{
_Playlist.Enqueue(track);
}
await ctx.RespondAsync($"Playlist Loaded.");
break;
case LavalinkLoadResultType.LoadFailed:
await ctx.RespondAsync($"Track could not be loaded.");
break;
case LavalinkLoadResultType.NoMatches:
await ctx.RespondAsync($"Track Not Found.");
break;
default:
await ctx.RespondAsync($"Error.");
return;
}
if (string.IsNullOrEmpty(_LavalinkGuild.CurrentState.CurrentTrack.Title))
{
_LavalinkGuild.Play(_Playlist.Peek());
}
}
public async Task PlayAsync(CommandContext ctx,
[Description("Termo de pesquisa ou link para tocar.")]
[RemainingText] string pesquisa = null)
{
if (pesquisa == null)
{
await ctx.RespondAsync($"{ctx.User.Mention} **|** Você precisa fornecer uma url ou termo para eu pesquisar no Youtube e depois tocar a música desejada.");
return;
}
MusicPlayer player = await _music.GetOrCreatePlayerAsync(ctx.Guild, ctx.Channel);
LavalinkLoadResult result = null;
if (Uri.IsWellFormedUriString(pesquisa, UriKind.Absolute))
{
result = await _music.Node.GetTracksAsync(new Uri(pesquisa));
}
else
{
result = await _music.Node.GetTracksAsync(pesquisa);
}
switch (result.LoadResultType)
{
case LavalinkLoadResultType.LoadFailed:
await ctx.RespondAsync($"{ctx.User.Mention} **|** Houve um problema ao carregar a música selecionada!");
return;
case LavalinkLoadResultType.NoMatches:
await ctx.RespondAsync($"{ctx.User.Mention} **|** Nenhum resultado com a pesquisa ou link foi encontrado!");
return;
case LavalinkLoadResultType.PlaylistLoaded: {
int indice = 0;
lock (player.Queue)
indice = player.Queue.Count;
var str = "";
var pages = new List <Page>();
foreach (var track in result.Tracks)
{
if (str.Length >= 1500)
{
pages.Add(new Page {
Content = ctx.User.Mention,
Embed = new DiscordEmbedBuilder()
.WithTitle($"{ctx.User.Mention} **|** Músicas adicionadas na Playlist.")
.WithDescription(str)
.WithFooter($"Comando requisitado pelo: " + ctx.Member.Username, iconUrl: ctx.User.AvatarUrl)
.WithColor(DiscordColor.Orange)
});
str = "";
}
else
{
str += $"**`{string.Format("{0:00}", indice++)}`**: {Formatter.MaskedUrl(Formatter.Sanitize(track.Title), track.Uri)} (`{MusicPlayer.FormatTimespan(track.Length)}`)\n";
}
var qresult = player.Enqueue(new MusicItem(track, ctx.Member, ctx.Channel));
if (qresult == MusicOperationResult.QueueFull)
{
await ctx.RespondAsync($"{ctx.User.Mention} **|** A fila encheu e nem todas as músicas foram adicionadas! :/");
await PrepareAsync();
player.Play();
await ctx.Client.GetInteractivity()
.SendPaginatedMessage(ctx.Channel, ctx.User, pages);
return;
}
}
if (!string.IsNullOrEmpty(str))
{
pages.Add(new Page {
Content = ctx.User.Mention,
Embed = new DiscordEmbedBuilder()
.WithTitle($"{ctx.User.Mention} **|** Músicas adicionadas na Playlist.")
.WithDescription(str)
.WithFooter($"Comando requisitado pelo: " + ctx.Member.Username, iconUrl: ctx.User.AvatarUrl)
.WithColor(DiscordColor.Orange)
});
}
await PrepareAsync();
player.Play();
await ctx.Client.GetInteractivity()
.SendPaginatedMessage(ctx.Channel, ctx.User, pages);
}
return;
case LavalinkLoadResultType.SearchResult:
case LavalinkLoadResultType.TrackLoaded: {
var track = result.Tracks
.FirstOrDefault();
await ctx.RespondAsync($"{ctx.User.Mention} **|** A música: **{Formatter.Sanitize(track.Title)}** " +
$"por: **{Formatter.Sanitize(track.Author)}** foi adicionada a playlist.");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"[{DateTime.Now.Year}-{DateTime.Now.Month}-{DateTime.Now.Day} {DateTime.Now.Hour}:{DateTime.Now.Minute}:{DateTime.Now.Second} -03:00] [Lavalink] A música: \"{Formatter.Sanitize(track.Title)}\" " +
$"por: \"{Formatter.Sanitize(track.Author)}\" foi adicionada a playlist.");
Console.ResetColor();
await PrepareAsync();
player.Enqueue(new MusicItem(track, ctx.Member, ctx.Channel));
player.Play();
}
return;
}
async Task PrepareAsync()
{
var vs = ctx.Member.VoiceState;
var chn = vs.Channel;
await player.CreatePlayerAsync(chn);
}
}
public async Task Play(CommandContext ctx, [Description("The search request")][RemainingText] string search)
{
if (ctx.Member.VoiceState == null || ctx.Member.VoiceState.Channel == null)
{
await ctx.RespondAsync("You are not in a VC.");
return;
}
LavalinkNodeConnection node = ctx.Client.GetLavalink().ConnectedNodes.Values.First();
await node.ConnectAsync(ctx.Member.VoiceState.Channel);
LavalinkGuildConnection conn = node.GetGuildConnection(ctx.Member.VoiceState.Guild);
if (conn == null)
{
await ctx.RespondAsync("Lavalink not connected.");
return;
}
LavalinkLoadResult loadResult = await node.Rest.GetTracksAsync(search, LavalinkSearchType.Youtube);
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed ||
loadResult.LoadResultType == LavalinkLoadResultType.NoMatches)
{
await ctx.RespondAsync($"Track search failed for {search}");
return;
}
DiscordEmbedBuilder resultsEmbed = new DiscordEmbedBuilder
{
Title = "I found this for you on Youtube:",
Description = "Respond with the number you would like to play!",
Color = DiscordColor.Red
};
int index = 0;
foreach (LavalinkTrack result in loadResult.Tracks)
{
index++;
resultsEmbed.AddField($"{index}:", $"[{result.Title}]({result.Uri})");
if (index == 10)
{
break;
}
}
DiscordMessage selectOne = await ctx.RespondAsync(resultsEmbed.Build());
InteractivityExtension interactivity = ctx.Client.GetInteractivity();
var selection = await interactivity.WaitForMessageAsync(x => x.Channel == ctx.Channel && x.Author == ctx.User);
LavalinkTrack track = loadResult.Tracks.ElementAt(int.Parse(selection.Result.Content) - 1);
if (LavalinkService.Instance.Queues != null && LavalinkService.Instance.Queues.ContainsKey(ctx.Guild))
{
LavalinkService.Instance.Queues[ctx.Guild].Add(track);
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder
{
Title = "Added to playlist:",
Description = $"[{track.Title}]({track.Uri})",
Color = DiscordColor.Red
};
await ctx.RespondAsync(embedBuilder.Build());
}
else if (conn.CurrentState.CurrentTrack != null)
{
if (LavalinkService.Instance.Queues == null)
{
LavalinkService.Instance.Queues = new Dictionary <DiscordGuild, List <LavalinkTrack> >();
LavalinkService.Instance.Repeats = new Dictionary <DiscordGuild, Repeaters>
{
{ ctx.Guild, Repeaters.off }
};
}
LavalinkService.Instance.Queues.Add(ctx.Guild, new List <LavalinkTrack> {
track
});
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder
{
Title = "Added to playlist:",
Description = $"[{track.Title}]({track.Uri})",
Color = DiscordColor.Red
};
await ctx.RespondAsync(embedBuilder.Build());
}
else
{
await conn.PlayAsync(track);
LavalinkService.Instance.Repeats = new Dictionary <DiscordGuild, Repeaters>
{
{ ctx.Guild, Repeaters.off }
};
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder
{
Title = "Now playing:",
Description = $"[{track.Title}]({track.Uri})",
Color = DiscordColor.Red
};
await ctx.RespondAsync(embedBuilder.Build());
}
await selectOne.DeleteAsync();
await selection.Result.DeleteAsync();
}
public async Task Import(CommandContext ctx, [Description("Playlist URL")] Uri playlistURL)
{
if (ctx.Member.VoiceState == null || ctx.Member.VoiceState.Channel == null)
{
await ctx.RespondAsync("You are not in a vc.");
return;
}
LavalinkNodeConnection node = ctx.Client.GetLavalink().ConnectedNodes.Values.First();
await node.ConnectAsync(ctx.Member.VoiceState.Channel);
LavalinkGuildConnection conn = node.GetGuildConnection(ctx.Member.VoiceState.Guild);
if (conn == null)
{
await ctx.RespondAsync("Lavalink not connected.");
return;
}
LavalinkLoadResult loadResult = await conn.GetTracksAsync(playlistURL);
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed || loadResult.LoadResultType == LavalinkLoadResultType.NoMatches)
{
await ctx.RespondAsync($"Playlist search failed for {playlistURL}");
return;
}
foreach (LavalinkTrack track in loadResult.Tracks)
{
if (LavalinkService.Instance.Queues != null && LavalinkService.Instance.Queues.ContainsKey(ctx.Guild))
{
LavalinkService.Instance.Queues[ctx.Guild].Add(track);
}
else if (conn.CurrentState.CurrentTrack != null)
{
LavalinkService.Instance.Queues = new Dictionary <DiscordGuild, List <LavalinkTrack> >
{
{ ctx.Guild, new List <LavalinkTrack> {
track
} }
};
LavalinkService.Instance.Repeats = new Dictionary <DiscordGuild, Repeaters>
{
{ ctx.Guild, Repeaters.off }
};
}
else
{
await conn.PlayAsync(track);
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder
{
Title = "Now playing:",
Description = $"[{track.Title}]({track.Uri})",
Color = DiscordColor.Red
};
await ctx.RespondAsync(embedBuilder.Build());
await Task.Delay(1000);
}
}
await ctx.RespondAsync("Done (i think).");
}
