void treeView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (treeView.SelectedItems.Count == 0)
{
return;
}
YoutubeChannelNodeBase item = treeView.SelectedItems[0] as YoutubeChannelNodeBase;
YoutubeSearchQuery youtubeSearch = null;
if (item is YoutubeChannelVideosNode || item is YoutubeChannelNode)
{
SearchResource.ListRequest searchListRequest = searchListRequest = Youtube.Search.List("snippet");
searchListRequest.ChannelId = item.ChannelId;
searchListRequest.MaxResults = YoutubeSearchViewModel.maxResults;
searchListRequest.Order = Google.Apis.YouTube.v3.SearchResource.ListRequest.OrderEnum.Date;
youtubeSearch = new YoutubeSearchQuery(searchListRequest, item.Name);
}
else if (item is YoutubeChannelPlaylistsNode)
{
PlaylistsResource.ListRequest playlistRequest = Youtube.Playlists.List("snippet");
playlistRequest.ChannelId = item.ChannelId;
playlistRequest.MaxResults = YoutubeSearchViewModel.maxResults;
youtubeSearch = new YoutubeSearchQuery(playlistRequest, item.Name);
}
EventAggregator.GetEvent <SearchEvent>().Publish(youtubeSearch);
e.Handled = true;
}
internal async Task <IEnumerable <Playlist> > GetPlaylists(Channel channel = null, bool myPlaylists = false, string id = null, int maxResults = 1)
{
return(await this.YouTubeServiceWrapper(async() =>
{
List <Playlist> results = new List <Playlist>();
string pageToken = null;
do
{
PlaylistsResource.ListRequest request = this.connection.GoogleYouTubeService.Playlists.List("snippet,contentDetails");
if (channel != null)
{
request.ChannelId = channel.Id;
}
else if (myPlaylists)
{
request.Mine = true;
}
else if (!string.IsNullOrEmpty(id))
{
request.Id = id;
}
request.MaxResults = Math.Min(maxResults, 50);
request.PageToken = pageToken;
PlaylistListResponse response = await request.ExecuteAsync();
results.AddRange(response.Items);
maxResults -= response.Items.Count;
pageToken = response.NextPageToken;
} while (maxResults > 0 && !string.IsNullOrEmpty(pageToken));
return results;
}));
}
public async Task <PlaylistListResponse> GetPlaylistInfo(PlaylistQuery query)
{
PlaylistsResource.ListRequest listRequest = _youtubeService.Playlists.List(query.Part);
listRequest.Id = query.Id;
listRequest.MaxResults = query.MaxResults;
return(await listRequest.ExecuteAsync());
}
public static Subscription GetPlaylistAsSubscription(string playlistId)
{
PlaylistsResource.ListRequest listRequest = Service.Playlists.List("snippet");
listRequest.Id = playlistId;
PlaylistListResponse response = listRequest.Execute();
string channelId = response.Items.FirstOrDefault().Snippet.ChannelId;
string playlistTitle = response.Items.FirstOrDefault().Snippet.Title;
Subscription playlistSubscription = new Subscription();
playlistSubscription.LastVideoPublishDate = DateTime.Now; //Get all videos from this point onwards
playlistSubscription.ChannelId = channelId;
playlistSubscription.PlaylistIdToWatch = playlistId;
playlistSubscription.Title = playlistTitle;
playlistSubscription.IsPlaylist = true;
playlistSubscription.IsPlaylistUploadsPlaylist = playlistId == GetChannelUploadsPlaylistId(playlistSubscription);
return(playlistSubscription);
}
private void AddPlaylistToList(string playlistURL)
{
string playlistID = Regex.Match(playlistURL, @"(PL|UU)[\w-]*").ToString();
PlaylistsResource.ListRequest listRequest = service.Playlists.List("snippet");
listRequest.Id = playlistID;
PlaylistListResponse response = listRequest.Execute();
string channelId = response.Items.FirstOrDefault().Snippet.ChannelId;
string playlistTitle = response.Items.FirstOrDefault().Snippet.Title;
Subscription playlistSubscription = new Subscription();
playlistSubscription.LastVideoPublishDate = DateTime.Now;
playlistSubscription.ChannelId = channelId;
playlistSubscription.PlaylistIdToWatch = playlistID;
playlistSubscription.Title = playlistTitle;
playlistSubscription.IsPlaylist = true;
listBoxPlaylists.Items.Add(playlistSubscription);
}
private async Task search(IClientServiceRequest request, String searchInfo, bool isNextPage, CancellationToken token)
{
SearchListResponse searchResponse = null;
PlaylistItemListResponse playlistItemResponse = null;
PlaylistListResponse playlistResponse = null;
SearchResource.ListRequest searchRequest = request as SearchResource.ListRequest;
PlaylistItemsResource.ListRequest playlistItemsRequest = request as PlaylistItemsResource.ListRequest;
PlaylistsResource.ListRequest playlistRequest = request as PlaylistsResource.ListRequest;
List <YoutubeItem> items = new List <YoutubeItem>();
int relevance;
if (isNextPage)
{
if (NextPageToken == null)
{
// Final page
return;
}
if (searchRequest != null)
{
searchRequest.PageToken = NextPageToken;
}
else if (playlistItemsRequest != null)
{
playlistItemsRequest.PageToken = NextPageToken;
}
else if (playlistRequest != null)
{
playlistRequest.PageToken = NextPageToken;
}
relevance = MediaState.UIMediaCollection.Count;
}
else
{
MediaState.clearUIState(searchInfo, DateTime.Now, MediaStateType.SearchResult);
CurrentQuery = request;
relevance = 0;
}
// Call the search.list method to retrieve results matching the specified query term.
if (searchRequest != null)
{
searchResponse = await searchRequest.ExecuteAsync(token);
NextPageToken = searchResponse.NextPageToken;
foreach (SearchResult searchResult in searchResponse.Items)
{
YoutubeItem newItem = null;
switch (searchResult.Id.Kind)
{
case "youtube#video":
newItem = new YoutubeVideoItem(searchResult, relevance);
break;
case "youtube#channel":
newItem = new YoutubeChannelItem(searchResult, relevance);
break;
case "youtube#playlist":
newItem = new YoutubePlaylistItem(searchResult, relevance);
break;
default:
break;
}
if (newItem == null || MediaState.UIMediaCollection.Contains(newItem))
{
continue;
}
items.Add(newItem);
relevance++;
}
}
if (playlistItemsRequest != null)
{
playlistItemResponse = await playlistItemsRequest.ExecuteAsync(token);
NextPageToken = playlistItemResponse.NextPageToken;
foreach (PlaylistItem playlistItem in playlistItemResponse.Items)
{
YoutubeVideoItem newItem = new YoutubeVideoItem(playlistItem, relevance);
items.Add(newItem);
relevance++;
}
}
if (playlistRequest != null)
{
playlistResponse = await playlistRequest.ExecuteAsync(token);
NextPageToken = playlistResponse.NextPageToken;
foreach (Playlist playlist in playlistResponse.Items)
{
YoutubePlaylistItem newItem = new YoutubePlaylistItem(playlist, relevance);
if (!items.Contains(newItem))
{
items.Add(newItem);
}
relevance++;
}
}
// Add each result to the appropriate list, and then display the lists of
// matching videos, channels, and playlists.
MediaState.addUIState(items);
}
private static async Task <List <Playlist> > GetAnotherPlaylist(PlaylistsResource.ListRequest playlistRequest, string playlistName)
{
playlistRequest.Id = playlistName;
return(await HandlePagination <Playlist>(playlistRequest));
}
public async Task QueuePlaylist(CommandContext ctx, string playlistUrl, [Description("Shuffle the playlist when adding to queue. \"true\" to enable.")] bool shuffle = false)
{
if (ctx.Client.GetVoiceNext()?.GetConnection(ctx.Guild)?.Channel != null && ctx.Client.GetVoiceNext().GetConnection(ctx.Guild).Channel.Users.All(e => e.Id != ctx.User.Id))
{
throw new OutputException("You must join a voice channel to queue songs.");
}
Uri playlistUri;
try
{
playlistUri = new Uri(playlistUrl);
}
catch
{
throw new OutputException("Invalid url.");
}
NameValueCollection query = HttpUtility.ParseQueryString(playlistUri.Query);
if (!query.AllKeys.Contains("list"))
{
throw new OutputException("Url must point to a YouTube playlist, specifically with a \"list=\" query.");
}
YouTubeService youtubeService = new YouTubeService(new BaseClientService.Initializer
{
ApiKey = Globals.BotSettings.YoutubeApiKey,
ApplicationName = this.GetType().ToString()
});
PlaylistsResource.ListRequest playlistListRequest = youtubeService.Playlists.List("snippet");
playlistListRequest.Id = query["list"];
playlistListRequest.MaxResults = 1;
PlaylistListResponse playlistListResponse = playlistListRequest.Execute();
PlaylistItemsResource.ListRequest playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet");
playlistItemsListRequest.PlaylistId = query["list"];
playlistItemsListRequest.MaxResults = 50;
PlaylistItemListResponse playlistItemsListResponse = playlistItemsListRequest.Execute();
if (!playlistItemsListResponse.Items.Any())
{
throw new OutputException("Unable to retrieve playlist or playlist is empty.");
}
if (shuffle)
{
playlistItemsListResponse.Items.Shuffle();
}
int resultQueueCount = GuildQueues.ContainsKey(ctx.Guild.Id) ? GuildQueues[ctx.Guild.Id].Count + playlistItemsListResponse.Items.Count : playlistItemsListResponse.Items.Count;
await ctx.RespondAsync($"Queuing {playlistItemsListResponse.Items.Count} songs, please be patient if this is the first items to be added to queue. " +
"(If you try to play music and nothing happens most likely the first song is still pending)");
if (!GuildMusicStatuses.TryGetValue(ctx.Guild.Id, out MusicStatus musicStatus))
{
GuildMusicStatuses.Add(ctx.Guild.Id, new MusicStatus
{
Skip = false
});
}
while (GuildMusicStatuses[ctx.Guild.Id].Queuing)
{
}
GuildMusicStatuses[ctx.Guild.Id].Queuing = true;
foreach (PlaylistItem playlistItem in playlistItemsListResponse.Items)
{
string id = playlistItem.Snippet.ResourceId.VideoId;
VideosResource.ListRequest idSearch = youtubeService.Videos.List("id,snippet");
idSearch.Id = id;
idSearch.MaxResults = 1;
VideoListResponse videoListResponse = await idSearch.ExecuteAsync();
if (videoListResponse.Items.Count == 0)
{
await ctx.RespondAsync("Video link cannot be parsed.");
return;
}
if (!GuildQueues.ContainsKey(ctx.Guild.Id))
{
GuildQueues.Add(ctx.Guild.Id, new List <JigglySong>());
}
Video parsedVideo = videoListResponse.Items.First();
if (!string.IsNullOrWhiteSpace(parsedVideo.ContentDetails?.Duration) && XmlConvert.ToTimeSpan(parsedVideo.ContentDetails.Duration).Minutes > 15)
{
await ctx.RespondAsync("This video is too long, please try to find something shorter than 15 minutes.");
}
Guid guid = Guid.NewGuid();
AddSong(guid, parsedVideo.Snippet.Title, parsedVideo.Id, parsedVideo.Snippet.ChannelTitle, JigglySong.SongType.Youtube, ctx.Member);
if (!DownloadHelper.GuildMusicTasks.ContainsKey(ctx.Guild.Id))
{
DownloadHelper.GuildMusicTasks.Add(ctx.Guild.Id, new List <(Guid guid, Func <string> downloadTask)>());
}
DownloadHelper.GuildMusicTasks[ctx.Guild.Id].Add((guid, () => DownloadHelper.DownloadFromYouTube(ctx, $"https://www.youtube.com/watch?v={id}")));
if (!DownloadHelper.IsDownloadLoopRunning)
{
new Thread(() => DownloadHelper.DownloadQueue(ctx.Guild.Id)).Start();
}
}
GuildMusicStatuses[ctx.Guild.Id].Queuing = false;
DiscordEmbedBuilder confirmationBuilder = new DiscordEmbedBuilder
{
Description = $"**✅ Successfully added [{playlistListResponse.Items.First().Snippet.Title}](https://www.youtube.com/playlist?list={query["list"]}) " +
$"to queue positions {resultQueueCount + 1 - playlistItemsListResponse.Items.Count}-{resultQueueCount}**"
};
await ctx.RespondAsync(null, false, confirmationBuilder.Build());
}
private async Task <Chart> GetOrCreatePlaylist(Chart chart)
{
int chartNameWithPrefixLen = chart.NameWithPrefix.Length;
UserCredential credential;
try
{
using (FileStream stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
// This OAuth 2.0 access scope allows for full read/write access to the
// authenticated user's account.
new[] { YouTubeService.Scope.Youtube },
"user",
CancellationToken.None,
new FileDataStore(GetType().ToString())
);
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
return(null);
}
var youTubeService = new YouTubeService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = GetType().ToString()
});
// Find playlist by chart name
PlaylistsResource.ListRequest playlistReq = youTubeService.Playlists.List("snippet");
playlistReq.Mine = true;
playlistReq.MaxResults = 10;
PlaylistListResponse playlistResp = await playlistReq.ExecuteAsync();
Playlist playlist = null;
foreach (Playlist playlistCandidate in playlistResp.Items)
{
string playlistTitle = playlistCandidate.Snippet.Title;
if (playlistTitle.Length > chartNameWithPrefixLen && playlistTitle.Substring(0, chartNameWithPrefixLen) == chart.NameWithPrefix)
{
playlist = playlistCandidate;
Debug.WriteLine("Playlist for {0} already exists as {1}", chart.Name, playlist.Snippet.Title);
break;
}
}
if (playlist == null)
{
// Create a new, private playlist in the authorized user's channel
playlist = new Playlist
{
Snippet = new PlaylistSnippet
{
Title = chart.PlaylistName,
Description = $"Source: {chart.Url}\n\nPlaylist created with the YouTube Playlist Builder https://github.com/RDultsin/YouTubePlaylistBuilder"
},
Status = new PlaylistStatus
{
PrivacyStatus = "public"
}
};
playlist = await youTubeService.Playlists.Insert(playlist, "snippet,status").ExecuteAsync();
Debug.WriteLine("Created playlist {0}", (object)playlist.Snippet.Title);
}
else
{
// Update title of playlist
playlist.Snippet.Title = chart.PlaylistName;
playlist.Snippet.Description = $"Source: {chart.Url}\n\nPlaylist updated with the YouTube Playlist Builder https://github.com/RDultsin/YouTubePlaylistBuilder";
playlist = await youTubeService.Playlists.Update(playlist, "snippet").ExecuteAsync();
Debug.WriteLine("Updated playlist {0}", (object)playlist.Snippet.Title);
// Remove all videos from playlist
PlaylistItemsResource.ListRequest playlistItemReq = youTubeService.PlaylistItems.List("snippet");
playlistItemReq.PlaylistId = playlist.Id;
playlistItemReq.MaxResults = 50;
PlaylistItemListResponse playlistItemResp = await playlistItemReq.ExecuteAsync();
foreach (PlaylistItem playlistItem in playlistItemResp.Items)
{
await youTubeService.PlaylistItems.Delete(playlistItem.Id).ExecuteAsync();
Debug.WriteLine("Removed playlist item {0} from playlist {1}", playlistItem.Snippet.Title, playlist.Snippet.Title);
}
}
// Add a videos to the playlist
foreach (Song song in chart.Songs)
{
PlaylistItem playlistItem = new PlaylistItem
{
Snippet = new PlaylistItemSnippet
{
PlaylistId = playlist.Id,
ResourceId = new ResourceId
{
Kind = "youtube#video",
VideoId = song.VideoId
}
}
};
playlistItem = await youTubeService.PlaylistItems.Insert(playlistItem, "snippet").ExecuteAsync();
Debug.WriteLine("Added playlist item {0} to playlist {1}", playlistItem.Snippet.Title, playlist.Snippet.Title);
}
return(chart);
}
