private async Task Run()
{
UserCredential credential;
string clientSecretsPath = CredentialsManager.GetClientSecretsLocation();
using (FileStream stream = new FileStream(clientSecretsPath, FileMode.Open, FileAccess.Read))
{
// This OAuth 2.0 access scope allows for read-only access to the authenticated
// user's account, but not other types of account access.
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
new[] { YouTubeService.Scope.YoutubeReadonly },
"user",
CancellationToken.None,
new FileDataStore(GetType().ToString())
);
}
BaseClientService.Initializer baseClientServiceInitializer = new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = GetType().ToString()
};
YouTubeService youtubeService = new YouTubeService(baseClientServiceInitializer);
ChannelsResource.ListRequest channelsListRequest = youtubeService.Channels.List("contentDetails");
channelsListRequest.Mine = true;
// Retrieve the contentDetails part of the channel resource for the authenticated user's channel.
ChannelListResponse channelsListResponse = await channelsListRequest.ExecuteAsync();
foreach (Channel channel in channelsListResponse.Items)
{
// From the API response, extract the playlist ID that identifies the list
// of videos uploaded to the authenticated user's channel.
string uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads;
Console.WriteLine("Videos in list {0}", uploadsListId);
string nextPageToken = "";
while (nextPageToken != null)
{
PlaylistItemsResource.ListRequest playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet");
playlistItemsListRequest.PlaylistId = uploadsListId;
playlistItemsListRequest.MaxResults = 50;
playlistItemsListRequest.PageToken = nextPageToken;
// Retrieve the list of videos uploaded to the authenticated user's channel.
PlaylistItemListResponse playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync();
foreach (PlaylistItem playlistItem in playlistItemsListResponse.Items)
{
// Print information about each video.
Console.WriteLine("{0} ({1})", playlistItem.Snippet.Title, playlistItem.Snippet.ResourceId.VideoId);
}
nextPageToken = playlistItemsListResponse.NextPageToken;
}
}
}
public async Task Test_GetPlaylistItemsAsync_Async(string playlistId)
{
// Validate parameters.
if (string.IsNullOrWhiteSpace(playlistId))
{
throw new ArgumentNullException(nameof(playlistId));
}
// Create the youtube client.
var youTubeClient = CreateYouTubeClient();
// Create the request.
var request = new PlaylistItemListRequest(
playlistId
).AddParts(YouTube.V3.PlaylistItemResource.Part.Id);
// Make the call.
PlaylistItemListResponse response = await youTubeClient
.GetPlaylistItemsAsync(request, CancellationToken.None)
.ConfigureAwait(false);
// Validate
Assert.NotNull(response.Items);
Assert.NotEmpty(response.Items);
}
private async Task RunYoutubeService(int checkInterval)
{
_tempDateTime = DateTime.Now; // saving time of launch
_yts = new YouTubeService(new BaseClientService.Initializer
{
ApiKey = _ytApiKey,
ApplicationName = "leetbot"
});
PlaylistItemsResource.ListRequest playlistItemsListRequest = _yts.PlaylistItems.List("contentDetails");
playlistItemsListRequest.MaxResults = 5; // last 5 videos
playlistItemsListRequest.Fields = "items(contentDetails(videoId,videoPublishedAt))";
_discordClient.Logger.LogInformation("[YoutubeService] Service started.");
_isRunning = true;
while (true)
{
foreach (string uploadsId in _youtubeChannelList)
{
playlistItemsListRequest.PlaylistId = uploadsId;
PlaylistItemListResponse playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync();
foreach (PlaylistItem playlistItem in playlistItemsListResponse.Items)
{
if (playlistItem.ContentDetails.VideoPublishedAt == null ||
playlistItem.ContentDetails.VideoPublishedAt.GetValueOrDefault().CompareTo(_tempDateTime) <= 0)
{
continue;
}
_discordClient.Logger.LogInformation("[YoutubeService] " +
"New video uploaded: https://www.youtube.com/watch?v=" +
$"{playlistItem.ContentDetails.VideoId}");
foreach (DiscordChannel logChannel in _logChannelsList)
{
try
{
await _discordClient.SendMessageAsync(logChannel,
"@everyone NEW VIDEO\nhttps://www.youtube.com/watch?v=" +
$"{playlistItem.ContentDetails.VideoId}");
}
catch (Exception e)
{
_discordClient.Logger.LogError($"[YoutubeVideoMonitor] Discord message error: {e.Message}");
}
}
_tempDateTime = DateTime.Now;
}
}
await Task.Delay(checkInterval * 60 * 1000); // once in checkInterval minutes
_discordClient.Logger.LogDebug("[YoutubeVideoMonitor] Service tick.");
}
}
/// <summary>
/// Refreshes the cached data in Cassandra for a given YouTube playlist.
/// </summary>
internal async Task RefreshPlaylist(YouTubeVideoSource.VideosFromPlaylist playlistSource)
{
// Statement for inserting the video into the sample table
PreparedStatement preparedInsert = await _statementCache.NoContext.GetOrAddAsync(
"INSERT INTO sample_data_youtube_videos (sourceid, published_at, youtube_video_id, name, description) VALUES (?, ?, ?, ?, ?)");
bool getMoreVideos = true;
string nextPageToken = null;
var insertTasks = new List <Task>();
do
{
// Create playlist items request
PlaylistItemsResource.ListRequest playlistRequest = _youTubeService.PlaylistItems.List("snippet");
playlistRequest.MaxResults = MaxVideosPerRequest;
playlistRequest.PlaylistId = playlistSource.PlaylistId;
if (string.IsNullOrEmpty(nextPageToken) == false)
{
playlistRequest.PageToken = nextPageToken;
}
// Get the results and insert as rows in Cassandra
PlaylistItemListResponse playlistItems = await playlistRequest.ExecuteAsync().ConfigureAwait(false);
foreach (var playlistItem in playlistItems.Items)
{
// If we've reached the max, no need to continue
if (insertTasks.Count >= MaxVideosPerSource)
{
getMoreVideos = false;
break;
}
DateTimeOffset publishedAt = playlistItem.Snippet.PublishedAt.HasValue
? playlistItem.Snippet.PublishedAt.Value.ToUniversalTime()
: Epoch;
Task <RowSet> insertTask =
_session.ExecuteAsync(preparedInsert.Bind(playlistSource.UniqueId, publishedAt, playlistItem.Snippet.ResourceId.VideoId,
playlistItem.Snippet.Title, playlistItem.Snippet.Description));
insertTasks.Add(insertTask);
}
// If we don't have a next page, we can bail
nextPageToken = playlistItems.NextPageToken;
if (string.IsNullOrEmpty(nextPageToken))
{
getMoreVideos = false;
}
} while (getMoreVideos);
// Wait for any insert tasks to finish
if (insertTasks.Count > 0)
{
await Task.WhenAll(insertTasks).ConfigureAwait(false);
}
}
/// <summary>
/// Returns a list of video results for a channel, the latest 10 videos
/// </summary>
/// <param name="uploadsPlaylistId"></param>
/// <returns></returns>
public async Task <IReadOnlyCollection <VideoResult> > GetLatestVideos(string uploadsPlaylistId)
{
// construct a request for video snippets
var request = _ytService.PlaylistItems.List("snippet");
request.MaxResults = 50;
request.PlaylistId = uploadsPlaylistId;
PlaylistItemListResponse results = await request.ExecuteAsync();
// filter videos and take the snippet
return(_mapper.Map <List <VideoResult> >(results.Items));
}
public async Task <ActionResult <PlaylistItemListResponse> > List([Required, FromQuery] AppPlaylistItemListRequest request)
{
YouTubeService service = await serviceAccessor.InitializeServiceAsync();
PlaylistItemsResource.ListRequest requestActual = request.ToActualRequest(service);
try {
PlaylistItemListResponse response = await requestActual.ExecuteAsync();
return(new ActionResult <PlaylistItemListResponse>(response));
} catch (GoogleApiException ex) {
return(StatusCode((int)ex.HttpStatusCode, ex.ToString()));
}
}
public PlaylistContainerCards(PlaylistItemListResponse playlistItemListResponse, string playlistName,
TextBlock songLabel, Rectangle backgroundRectangle, ChromiumWebBrowser youtubePlayer, PlaylistCards parentCard, ScrollViewer playlistScrollViewer, Button playButton)
{
InitializeComponent();
PlaylistItemListResponse = playlistItemListResponse;
PlaylistName = playlistName;
YoutubePlayer = youtubePlayer;
SongLabel = songLabel;
BackgroundRectangle = backgroundRectangle;
PlaylistTitle.Text = playlistName;
ChannelTitle.Text = playlistItemListResponse.Items[0].Snippet.ChannelTitle;
_parentCard = parentCard;
_playlistScrollViewer = playlistScrollViewer;
_playButton = playButton;
}
public MPlaylistItemList(PlaylistItemListResponse response)
{
if (response == null)
{
return;
}
NextPageToken = response.NextPageToken;
PageInfo = new MPageInfo(response.PageInfo);
PrevPageToken = response.PrevPageToken;
VisitorId = response.VisitorId;
var items = response.Items.Where(i => i.Snippet.Title != "Deleted video");
Items = items.Select(i => new MPlayListItem(i)).ToList <IPlayListItem>();
}
internal List <Show> PlaylistItemsToShows(PlaylistItemListResponse response)
{
return(response.Items
.Where(item =>
item.Status?.PrivacyStatus == "public" &&
item.Snippet != null)
.Select(item => new Show
{
Id = item.Snippet.ResourceId.VideoId,
Title = item.Snippet.Title,
Description = item.Snippet.Description,
ThumbnailUrl = item.Snippet.Thumbnails?.Medium?.Url ?? item.Snippet.Thumbnails?.Standard?.Url ?? DefaultThumbnail,
Url = GetVideoUrl(item.Snippet.ResourceId.VideoId,
YouTubePlaylistId, item.Snippet.Position.GetValueOrDefault())
}).ToList());
}
public async Task ExecuteChannelListCommand()
{
if (string.IsNullOrEmpty(channel.Id))
{
return;
}
Items.RemoveAll(n => true);
var channelListRequest = YouTubeService.PlaylistItems.List("snippet");
channelListRequest.PlaylistId = Channel.ContentDetails.RelatedPlaylists.Uploads;
channelListRequest.MaxResults = 25;
listResponse = await channelListRequest.ExecuteAsync();
Items.AddRange(listResponse.Items);
}
public async Task <IPlaylistItemList> GetPlaylistItems(string playlistId, int maxResult, string nextPageToken)
{
if (string.IsNullOrEmpty(playlistId))
{
return(MPlaylistItemList.Empty);
}
var listRequest = _youTubeService.PlaylistItems.List("snippet,contentDetails");
listRequest.Key = _youTubeServiceControl.ApiKey;
listRequest.MaxResults = maxResult;
listRequest.PlaylistId = playlistId;
listRequest.PageToken = nextPageToken;
PlaylistItemListResponse playlistResponse = await listRequest.ExecuteAsync();
return(new MPlaylistItemList(playlistResponse));
}
private async Task <ShowList> GetShowsList()
{
using (var client = new YouTubeService(new BaseClientService.Initializer
{
ApplicationName = _appSettings.YouTubeApplicationName,
ApiKey = _appSettings.YouTubeApiKey
}))
{
var listRequest = client.PlaylistItems.List("snippet");
listRequest.PlaylistId = _appSettings.YouTubePlaylistId;
listRequest.MaxResults = 5 * 3; // 5 rows of 3 episodes
PlaylistItemListResponse playlistItems = null;
var started = Timing.GetTimestamp();
try
{
playlistItems = await listRequest.ExecuteAsync();
}
finally
{
TrackDependency(client.BaseUri, listRequest, playlistItems, started);
}
var result = new ShowList();
result.PreviousShows = playlistItems.Items.Select(item => new Show
{
Provider = "YouTube",
ProviderId = item.Snippet.ResourceId.VideoId,
Title = item.Snippet.Title,//GetUsefulBitsFromTitle(item.Snippet.Title),
Description = item.Snippet.Description,
ShowDate = DateTimeOffset.Parse(item.Snippet.PublishedAtRaw, null, DateTimeStyles.RoundtripKind),
ThumbnailUrl = item.Snippet.Thumbnails.High.Url,
Url = GetVideoUrl(item.Snippet.ResourceId.VideoId, item.Snippet.PlaylistId, item.Snippet.Position ?? 0)
}).ToList();
if (!string.IsNullOrEmpty(playlistItems.NextPageToken))
{
result.MoreShowsUrl = GetPlaylistUrl(_appSettings.YouTubePlaylistId);
}
return(result);
}
}
internal async Task <IEnumerable <PlaylistItem> > GetPlaylistItems(string playlistID, int maxResults = 1)
{
return(await this.YouTubeServiceWrapper(async() =>
{
List <PlaylistItem> results = new List <PlaylistItem>();
string pageToken = null;
do
{
PlaylistItemsResource.ListRequest request = this.connection.GoogleYouTubeService.PlaylistItems.List("snippet,contentDetails");
request.PlaylistId = playlistID;
request.MaxResults = Math.Min(maxResults, 50);
request.PageToken = pageToken;
PlaylistItemListResponse 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 <IEnumerable <YouTubeVideo> > GetVideos(string playlistId)
{
List <YouTubeVideo> videos = new List <YouTubeVideo>();
string pageToken = null;
do
{
PlaylistItemsResource.ListRequest listPlaylistRequest = _youTubeApiService.PlaylistItems.List("snippet");
listPlaylistRequest.PlaylistId = playlistId;
listPlaylistRequest.MaxResults = 50;
listPlaylistRequest.PageToken = pageToken;
PlaylistItemListResponse response = await listPlaylistRequest.ExecuteAsync();
pageToken = response.NextPageToken;
videos.AddRange(response.Items.Select(video => new YouTubeVideo(video.Id, video.Snippet.Title)));
} while (pageToken != null);
return(videos);
}
private async Task <IEnumerable <YouTubeVideo> > GetPlaylistVideos(string playlistId)
{
List <YouTubeVideo> videos = new List <YouTubeVideo>();
string pageToken = null;
do
{
PlaylistItemsResource.ListRequest playlistRequest = _youTubeApiService.PlaylistItems.List("snippet");
playlistRequest.PlaylistId = playlistId;
playlistRequest.MaxResults = MaxQueryResults;
playlistRequest.PageToken = pageToken;
PlaylistItemListResponse playlistResponse = await playlistRequest.ExecuteAsync();
pageToken = playlistResponse.NextPageToken;
videos.AddRange(await GetVideos(playlistResponse.Items.Select(playlistItem => playlistItem.Snippet.ResourceId.VideoId)));
} while (pageToken != null);
return(videos);
}
internal List <Show> PlaylistItemsToShows(PlaylistItemListResponse response)
{
var items = response.Items
.Where(item =>
item.Status?.PrivacyStatus == "public" &&
item.Snippet != null)
.Select(item => new Show
{
Id = item.Snippet.ResourceId.VideoId,
Title = item.Snippet.Title,
Description = item.Snippet.Description,
ThumbnailUrl = item.Snippet.Thumbnails?.Medium?.Url ?? item.Snippet.Thumbnails?.Standard?.Url ?? DefaultThumbnail,
Url = GetVideoUrl(item.Snippet.ResourceId.VideoId,
YouTubePlaylistId, item.Snippet.Position.GetValueOrDefault()),
ScheduledStartTime = item.Snippet.PublishedAt.HasValue ? item.Snippet.PublishedAt : null
}).ToList();
foreach (var item in items)
{
item.SetCalculateShowFields();
}
return(items);
}
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());
}
public PlaylistVideoModel GetVideosByPlaylistId(string playlistId, string apiKey)
{
var youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
ApiKey = apiKey,
ApplicationName = this.GetType().ToString()
});
List <PlaylistItemListResponse> lstPlaylistItemListResponse = new List <PlaylistItemListResponse>();
var playListResponse = new PlaylistItemListResponse();
var nextPageToken = "";
while (nextPageToken != null)
{
var searchPlaylistRequest = youtubeService.PlaylistItems.List("snippet,contentDetails,id");
searchPlaylistRequest.PlaylistId = playlistId;
searchPlaylistRequest.PageToken = nextPageToken;
searchPlaylistRequest.MaxResults = 50;
playListResponse = searchPlaylistRequest.Execute();
lstPlaylistItemListResponse.Add(playListResponse);
nextPageToken = playListResponse.NextPageToken;
}
var playlistVideoModel = new PlaylistVideoModel();
playlistVideoModel.playlistDetail = new PlayList();
playlistVideoModel.playlistVideos = new List <Models.Video>();
var firstplaylist = 0;
foreach (var playlist in lstPlaylistItemListResponse)
{
if (playlist.Items.Count > 0)
{
if (firstplaylist == 0)
{
var firstPlaylist = playlist.Items.First();
playlistVideoModel.playlistDetail.channelId = firstPlaylist.Snippet.ChannelId;
playlistVideoModel.playlistDetail.playlistId = firstPlaylist.Snippet.PlaylistId;
playlistVideoModel.playlistDetail.groupName = firstPlaylist.Snippet.Title;
playlistVideoModel.playlistDetail.groupDescription = firstPlaylist.Snippet.Description;
playlistVideoModel.playlistDetail.groupImageUrl = firstPlaylist.Snippet.Thumbnails?.Medium?.Url;
playlistVideoModel.totalResults = playlist.PageInfo.TotalResults;
playlistVideoModel.playlistDetail.languageId = -1;
playlistVideoModel.playlistDetail.genreId = -1;
}
foreach (var item in playlist.Items)
{
Models.Video video = new Models.Video();
video.videoId = item.Snippet.ResourceId.VideoId;
video.videoName = item.Snippet.Title;
firstplaylist = firstplaylist + 1;
video.sequenceNumber = firstplaylist;
video.imageUrl60 = item.Snippet.Thumbnails?.Standard?.Url;
video.imageUrl90 = item.Snippet.Thumbnails?.Medium?.Url;
video.imageUrl120 = item.Snippet.Thumbnails?.High?.Url;
playlistVideoModel.playlistVideos.Add(video);
}
}
}
return(playlistVideoModel);
}
private void TrackDependency(string url, PlaylistItemsResource.ListRequest listRequest, PlaylistItemListResponse playlistItems, long started)
{
if (_telemetry.IsEnabled())
{
Uri.TryCreate(url, UriKind.Absolute, out Uri uri);
var duration = Timing.GetDuration(started);
var dependency = new DependencyTelemetry
{
Type = "HTTP",
Target = uri?.Host ?? url,
Name = listRequest.RestPath,
Data = listRequest.CreateRequest().RequestUri.ToString(),
Timestamp = DateTimeOffset.UtcNow,
Duration = duration,
Success = playlistItems != null
};
dependency.Properties.Add("HTTP Method", listRequest.HttpMethod);
dependency.Properties.Add("Event Id", playlistItems.EventId);
dependency.Properties.Add("Total Results", (playlistItems.PageInfo.TotalResults ?? 0).ToString());
_telemetry.TrackDependency(dependency);
}
}
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 async Task <ShowList> GetShowsList()
{
using (var client = new YouTubeService(new BaseClientService.Initializer
{
ApplicationName = _appSettings.YouTubeApplicationName,
ApiKey = _appSettings.YouTubeApiKey
}))
{
var listRequest = client.PlaylistItems.List("snippet");
listRequest.PlaylistId = _appSettings.YouTubePlaylistId;
listRequest.MaxResults = 10 * 3; // 10 rows of 3 episodes
PlaylistItemListResponse playlistItems = null;
var started = Timing.GetTimestamp();
try
{
playlistItems = await listRequest.ExecuteAsync();
}
finally
{
TrackDependency(client.BaseUri, listRequest, playlistItems, started);
}
var result = new ShowList();
result.Shows = playlistItems.Items.Select(item => new Show
{
Provider = "YouTube",
ProviderId = item.Snippet.ResourceId.VideoId,
Title = GetUsefulBitsFromTitle(item.Snippet.Title),
Description = item.Snippet.Description,
ShowDate = DateTimeOffset.Parse(item.Snippet.PublishedAtRaw, null, DateTimeStyles.RoundtripKind),
ThumbnailUrl = item.Snippet.Thumbnails.High.Url,
Url = GetVideoUrl(item.Snippet.ResourceId.VideoId, item.Snippet.PlaylistId, item.Snippet.Position ?? 0)
}).ToList();
// hacky: the dates here are "dates added to the playlist. Here we fudge the dates on some of the
// older videos which don't belong to our channel so that they don't appear first.
// monkey patch ReactiveUI with Xamarin - Michael Stonis & Geoffrey Huntley - Xamarin University Guest Lecture - https://www.youtube.com/watch?v=vydDJ9CaIug
foreach (var video in result.Shows.Where(x => x.Url.Contains("vydDJ9CaIug")))
{
video.ShowDate = DateTime.Parse("2017-03-17");
}
// monkey patch "FRP In Practice: Taking a look at Reactive[UI/Cocoa]" by Paul Betts - https://www.youtube.com/watch?v=1XNATGjqM6U
foreach (var video in result.Shows.Where(x => x.Url.Contains("1XNATGjqM6U")))
{
video.ShowDate = DateTime.Parse("2014-09-22");
}
// monkey patch "FRP In Practice: Taking a look at Reactive[UI/Cocoa]" by Paul Betts - https://www.youtube.com/watch?v=1XNATGjqM6U
foreach (var video in result.Shows.Where(x => x.Url.Contains("1XNATGjqM6U")))
{
video.ShowDate = DateTime.Parse("2014-09-22");
}
// monkey patch Xamarin Evolve 2014: Awaiting for Rx: A Play in Four Acts - Paul Betts, Github - https://www.youtube.com/watch?v=5DZ8nC0ENdg
foreach (var video in result.Shows.Where(x => x.Url.Contains("5DZ8nC0ENdg")))
{
video.ShowDate = DateTime.Parse("2014-10-24");
}
if (!string.IsNullOrEmpty(playlistItems.NextPageToken))
{
result.MoreShowsUrl = GetPlaylistUrl(_appSettings.YouTubePlaylistId);
}
return(result);
}
}
public PlaylistCards(bool userPlaylist, bool userPlaylistContainerParent, string playlistName, PlaylistListResponse userPlaylistResponse,
PlaylistItemListResponse playlistItemListResponse, TextBlock songLabel, Rectangle backgroundRectangle,
ChromiumWebBrowser youtubePlayer, Grid expandedPlaylistHolder, UserPlaylistsContainer userPlaylistsContainer, ScrollViewer
playlistScrollViewer, Button playButton)
{
InitializeComponent();
Overlay.Opacity = 0;
_playlistItemListResponse = playlistItemListResponse;
_isUserPlaylist = userPlaylist;
_playlistScrollViewer = playlistScrollViewer;
_playButton = playButton;
if (userPlaylistContainerParent)
{
UserPlaylistsContainer = userPlaylistsContainer;
}
if (userPlaylist)
{
_userPlaylists = userPlaylistResponse;
Console.WriteLine(_userPlaylists);
//create user image
ImageBrush userImageBrush;
if (!File.Exists(FilePaths.UserImageLocation + "\\Userimage.png"))
{
userImageBrush = new ImageBrush(new BitmapImage(new Uri(GoogleServices.GetUserPicture())));
}
else
{
userImageBrush =
new ImageBrush(new BitmapImage(new Uri(FilePaths.UserImageLocation + "\\Userimage.png")));
}
userImageBrush.TileMode = TileMode.None;
UserPlaylistCover.Fill = userImageBrush;
PlaylistName.Text = "Your Playlists";
Panel.SetZIndex(SearchedPlaylistImagesCover, -9999);
if (_userPlaylists.Items != null)
{
ChannelName.Content = _userPlaylists.Items[0].Snippet.ChannelTitle;
}
else
{
ChannelName.Content = GoogleServices.UserPerson.DisplayName;
}
UserPlaylistsContainer = new UserPlaylistsContainer(this, _playlistScrollViewer);
}
else
{
int thumbnailsAdded = 0, actualIndex = 0;
while (true)
{
Uri backgroundImageUri;
try
{
backgroundImageUri = new Uri(_playlistItemListResponse.Items[actualIndex].Snippet.Thumbnails.Medium.Url);
ImageSource tempSource = new BitmapImage(backgroundImageUri);
((Image)SearchedPlaylistImagesCover.Children[thumbnailsAdded]).Source = tempSource;
thumbnailsAdded++;
actualIndex++;
if (thumbnailsAdded == 4)
{
break;
}
}
catch (Exception e)
{
Console.WriteLine("Adding song failed " + e);
if (thumbnailsAdded != 0)
{
thumbnailsAdded--;
}
actualIndex++;
}
}
Panel.SetZIndex(UserPlaylistCover, -9999);
ChannelName.Content = playlistItemListResponse.Items[0].Snippet.ChannelTitle;
PlaylistName.Text = playlistName;
}
Panel.SetZIndex(this, 1);
_songLabel = songLabel;
_playlistName = playlistName;
_backgroundRectangle = backgroundRectangle;
_youtubePlayer = youtubePlayer;
_expandedPlaylistHolder = expandedPlaylistHolder;
_isUserPlaylist = userPlaylist;
}
public async static Task <List <PlaylistItem> > GetMostRecentUploadsAsync(Subscription sub, DateTime?sinceDate = null)
{
List <PlaylistItem> resultsByDate = new List <PlaylistItem>();
if (!string.IsNullOrWhiteSpace(sub.PlaylistIdToWatch))
{
try
{
PlaylistItemsResource.ListRequest listRequest = Service.PlaylistItems.List("snippet,status");
listRequest.PlaylistId = sub.PlaylistIdToWatch;
PlaylistItemListResponse response = null;
List <PlaylistItem> results = new List <PlaylistItem>();
List <PlaylistItem> privateToPublic = new List <PlaylistItem>();
if (sub.IsPlaylist && !sub.IsPlaylistUploadsPlaylist) //If this is the uploads playlist for the channel, it WILL be at least somewhat ordered by most recent
{
//A playlist isn't necessarily in date order (the owner of the playlist could put them in any order).
//Unfortunately, that means we have to get every video in the playlist and order them by date. This will be costly for large playlists
listRequest.MaxResults = 50; //50 is the maximum
try
{
response = await listRequest.ExecuteAsync();
}
catch (Google.GoogleApiException e)
{
if (e.HttpStatusCode == HttpStatusCode.NotFound)
{
MessageBox.Show($"There was a problem accessing the playlist for {sub.Title}.\n\nPerhaps it has been deleted?");
return(resultsByDate);
}
else
{
throw;
}
}
results.AddRange(response.Items);
while (response.NextPageToken != null)
{
listRequest.PageToken = response.NextPageToken;
response = await listRequest.ExecuteAsync();
results.AddRange(response.Items);
}
}
else
{
listRequest.MaxResults = 50;
response = await listRequest.ExecuteAsync();
results.AddRange(response.Items);
//If we still haven't gotten any items older than the "sinceDate", get more
if (sinceDate != null)
{
while (!results.Any(p => p.Snippet.PublishedAt < sinceDate) && response.NextPageToken != null)
{
listRequest.PageToken = response.NextPageToken;
response = await listRequest.ExecuteAsync();
results.AddRange(response.Items);
}
}
}
//Remove any that do not match the regex filter
if (!string.IsNullOrEmpty(sub.FilterRegex))
{
results.RemoveAll(p => !Regex.IsMatch(p.Snippet.Title, sub.FilterRegex));
}
//Check to see if any of the sub's private videos have change to public
foreach (string videoId in sub.PrivateVideosToWatch)
{
PlaylistItem matchingItem = results.Find(p => p.Snippet.ResourceId.VideoId == videoId);
if (matchingItem != null && matchingItem.Status.PrivacyStatus == "public")
{
privateToPublic.Add(matchingItem);
}
}
//Stop watching for private video status change if it is now in "privateToPublic"
sub.PrivateVideosToWatch.RemoveAll(p => privateToPublic.Find(o => o.Snippet.ResourceId.VideoId == p) != null);
List <PlaylistItem> recentPrivateVideos = results.Where(p => p.Status != null && p.Status.PrivacyStatus == "private").ToList();
foreach (PlaylistItem video in recentPrivateVideos)
{
string videoId = video.Snippet.ResourceId.VideoId;
if (!sub.PrivateVideosToWatch.Contains(videoId))
{
sub.PrivateVideosToWatch.Add(videoId);
}
results.Remove(video);
}
if (sinceDate != null)
{
results = results.Where(p => p.Snippet.PublishedAt > sinceDate).ToList();
}
results.AddRange(privateToPublic);
////------------------------------------
//// There is currently a bug with retrieving uploads playlists where the returned order does not match
//// the order shown on YouTube https://issuetracker.google.com/issues/65067744 . To combat this, we
//// will get the top 50 results and order them by upload date
resultsByDate = results.OrderByDescending(p => p.Snippet.PublishedAt).ToList();
////------------------------------------
}
catch (Exception ex)
{
Common.HandleException(ex);
}
}
//Sometimes we sense a new video twice in "newUploads". Not sure why (if it's a YouTube API bug or my code), but this will prevent
//notifying for that video twice (removes duplicate videoIds from the results list)
resultsByDate = (from v in resultsByDate
group v by v.Snippet.ResourceId.VideoId into g
select g.First()).ToList();
return(resultsByDate);
}
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);
}
public List <YouTubeVideo> LoadURLVideos(SYMMSettings settings, List <YouTubeVideo> videos = null, string nextPageToken = null)
{
if (settings.UrlSpecs.IsPlaylist && settings.DownloadMode == Mode.All)
{
string playlistID = Regex.Split(settings.DownloadURL, @"list=")[1];
if (playlistID.Contains("&"))
{
playlistID = playlistID.Split('&')[0];
}
// Load Uploaded Playlist
PlaylistItemsResource.ListRequest playlistVideosReq = YouTubeService.PlaylistItems.List("snippet,id");
playlistVideosReq.PlaylistId = playlistID;
playlistVideosReq.PageToken = nextPageToken;
playlistVideosReq.MaxResults = 50;
PlaylistItemListResponse playlistVideosRes = playlistVideosReq.Execute();
// Finnaly grab the video IDs
if (videos == null)
{
videos = new List <YouTubeVideo>();
}
// Populate video list
foreach (PlaylistItem videoItem in playlistVideosRes.Items)
{
try
{
YouTubeVideo loadedVideo = new YouTubeVideo(videoItem.Snippet.Title, videoItem.Snippet.ResourceId.VideoId, videoItem.Snippet.Description, videoItem.Snippet.PublishedAt, videoItem.Snippet.Thumbnails.Default__.Url, videoItem.Snippet.ChannelTitle, videoItem.Snippet.Position);
videos.Add(loadedVideo);
if (OnVideoInformationLoaded != null)
{
OnVideoInformationLoaded(this, new VideoInformationLoadedEventArgs(loadedVideo));
}
}
catch (NullReferenceException)
{
Console.WriteLine("Skipped one deleted video");
}
}
// Check if we have more to grab
if (!string.IsNullOrEmpty(playlistVideosRes.NextPageToken))
{
videos = LoadURLVideos(settings, videos, playlistVideosRes.NextPageToken);
}
if (OnAllVideoInformationLoaded != null)
{
OnAllVideoInformationLoaded(this, new AllVideoInformationLoadedEventArgs(videos));
}
return(videos);
}
else if (settings.UrlSpecs.ContainsVideo)
{
string watchID = Regex.Split(Regex.Split(settings.DownloadURL, @"v=")[1], "&")[0];
VideosResource.ListRequest videoListReq = YouTubeService.Videos.List("snippet, id");
videoListReq.Id = watchID;
VideoListResponse videoListResp = videoListReq.Execute();
if (videos == null)
{
videos = new List <YouTubeVideo>();
}
Video videoItem = videoListResp.Items[0];
YouTubeVideo loadedVideo = new YouTubeVideo(videoItem.Snippet.Title, videoItem.Id, videoItem.Snippet.Description, videoItem.Snippet.PublishedAt, videoItem.Snippet.Thumbnails.Default__.Url, videoItem.Snippet.ChannelTitle, 0);
videos.Add(loadedVideo);
if (OnVideoInformationLoaded != null)
{
OnVideoInformationLoaded(this, new VideoInformationLoadedEventArgs(loadedVideo));
}
if (OnAllVideoInformationLoaded != null)
{
OnAllVideoInformationLoaded(this, new AllVideoInformationLoadedEventArgs(videos));
}
return(videos);
}
else
{
throw new ArgumentException("The URL specified is not a valid youtube playlist or watch url");
}
}
