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 <SearchResponse> GetResults()
{
SearchResponse response = new SearchResponse();
List <SearchResult> result = await LoadItems();
List <string> videosId = new List <string>();
List <string> channelsId = new List <string>();
List <string> playlistsId = new List <string>();
result.ForEach(item =>
{
switch (item.Id.Kind)
{
case "youtube#video":
videosId.Add(item.Id.VideoId);
break;
case "youtube#channel":
channelsId.Add(item.Id.ChannelId);
break;
case "youtube#playlist":
playlistsId.Add(item.Id.PlaylistId);
break;
}
});
VideoQuery videoQuery = new VideoQuery
{
Part = "snippet,contentDetails",
Id = string.Join(",", videosId),
MaxResults = this.Query.MaxResults
};
VideoListResponse videoResponse = await service.GetVideoInfo(videoQuery);
response.Videos.AddRange(videoResponse.Items);
ChannelQuery channelQuery = new ChannelQuery
{
Part = "snippet,statistics",
Id = string.Join(",", channelsId),
MaxResults = this.Query.MaxResults
};
ChannelListResponse channelResponse = await service.GetChannelInfo(channelQuery);
response.Channels.AddRange(channelResponse.Items);
PlaylistQuery playlistQuery = new PlaylistQuery
{
Part = "snippet,status,contentDetails",
Id = string.Join(",", playlistsId),
MaxResults = this.Query.MaxResults
};
PlaylistListResponse playlistResponse = await service.GetPlaylistInfo(playlistQuery);
response.Playlists.AddRange(playlistResponse.Items);
return(response);
}
public MPlaylistList(PlaylistListResponse response)
{
NextPageToken = response.NextPageToken;
PrevPageToken = response.PrevPageToken;
PageInfo = new MPageInfo(response.PageInfo);
VisitorId = response.VisitorId;
var items = response.Items;
Items = items.Select(i => new MPlaylist(i)).ToList <IPlaylist>();
}
/// <summary>
/// Gets the user play lists asynchronous.
/// </summary>
/// <param name="userEmail">The user email.</param>
/// <param name="playLists">The play lists.</param>
/// <returns></returns>
private async Task GetUserPlayListsAsync(string userEmail, List <YouTubePlayList> playLists)
{
var youtubeService = await GetYouTubeService(userEmail);
var channelsListRequest = youtubeService.Channels.List("contentDetails");
channelsListRequest.Mine = true;
var playlists = youtubeService.Playlists.List("snippet");
playlists.PageToken = "";
playlists.MaxResults = 50;
playlists.Mine = true;
PlaylistListResponse presponse = await playlists.ExecuteAsync();
foreach (var currentPlayList in presponse.Items)
{
playLists.Add(new YouTubePlayList(currentPlayList.Snippet.Title, currentPlayList.Id));
}
}
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);
}
public static async Task <PlaylistListResponse> QueryUserPlaylistsAsync()
{
var service = GoogleServices.YoutubeService;
var userPlaylistRequest = service.Playlists.List("snippet");
userPlaylistRequest.Mine = true;
var userPlaylistResponse = new PlaylistListResponse();
try
{
userPlaylistResponse = await userPlaylistRequest.ExecuteAsync();
Console.WriteLine("First id response from getuserplaylist " + userPlaylistResponse.Items[0].Id);
}
catch
{
Console.WriteLine("No user playlists found ");
}
return(userPlaylistResponse);
}
private async Task <Playlist> getUserPlaylist(YouTubeService youtubeService, string playlistName)
{
var playlistListRequest = youtubeService.Playlists.List("contentDetails,snippet");
playlistListRequest.Mine = true;
var playlistListResponse = new PlaylistListResponse();
playlistListResponse = await playlistListRequest.ExecuteAsync();
foreach (var playlistItem in playlistListResponse.Items)
{
if (playlistItem.Snippet.Title.ToLower().Equals(playlistName.ToLower()))
{
Console.WriteLine("Found Playlist {0}", playlistItem.Snippet.Title);
return(playlistItem);
}
}
// No playlist was found. Create one.
return(await createPlaylist(youtubeService, playlistName));
}
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 Run()
{
UserCredential credential;
using (var 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 read-only access to the authenticated
// user's account, but not other types of account access.
new[] { YouTubeService.Scope.Youtube },
"user",
CancellationToken.None,
new FileDataStore(this.GetType().ToString())
);
}
var youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = this.GetType().ToString()
});
List <PlayList> PLDetail = new List <PlayList>();
List <Videos> Videos = new List <Videos>();
var channelsListRequest = youtubeService.Channels.List("contentDetails");
channelsListRequest.Mine = true;
var nextPageToken = "";
while (nextPageToken != null)
{
var playlists = youtubeService.Playlists.List("snippet");
playlists.PageToken = nextPageToken;
playlists.MaxResults = 50;
playlists.Mine = true;
PlaylistListResponse presponse = await playlists.ExecuteAsync();
int i = 0;
foreach (var currentPlayList in presponse.Items)
{
string temp = currentPlayList.Snippet.Title;
Console.WriteLine(i + " : " + temp);
PLDetail.Add(new PlayList()
{
name = temp.Trim().ToLower(),
ID = currentPlayList.Id
});
i++;
}
nextPageToken = presponse.NextPageToken;
}
// Retrieve the contentDetails part of the channel resource for the authenticated user's channel.
var channelsListResponse = await channelsListRequest.ExecuteAsync();
// get todays date
string Today = DateTime.Today.ToString().Substring(0, 10);
foreach (var 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.
var uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads;
Console.WriteLine("Videos in list {0}", uploadsListId);
nextPageToken = "";
while (nextPageToken != null)
{
var 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.
var playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync();
foreach (var playlistItem in playlistItemsListResponse.Items)
{
string ItemDate = playlistItem.Snippet.PublishedAt.ToString();
if (ItemDate.StartsWith(Today))
{
Videos.Add(new Videos()
{
name = playlistItem.Snippet.Title.Trim().ToLower(),
ID = playlistItem.Snippet.ResourceId.VideoId
});
}
}
nextPageToken = playlistItemsListResponse.NextPageToken;
}
}
foreach (var Video in Videos)
{
foreach (var PL in PLDetail)
{
if (Video.name.Contains(PL.name))
{
// Add video to the matching playlist.
var newPlaylistItem = new PlaylistItem();
newPlaylistItem.Snippet = new PlaylistItemSnippet();
newPlaylistItem.Snippet.PlaylistId = PL.ID;
newPlaylistItem.Snippet.ResourceId = new ResourceId();
newPlaylistItem.Snippet.ResourceId.Kind = "youtube#video";
newPlaylistItem.Snippet.ResourceId.VideoId = Video.ID;
newPlaylistItem = await youtubeService.PlaylistItems.Insert(newPlaylistItem, "snippet").ExecuteAsync();
break;
}
}
}
}
private async Task AccessPlaylist()
{
UserCredential credential;
using (var stream = new FileStream(@"C:\client_id.json", FileMode.Open, FileAccess.Read))
{
credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
// This OAuth 2.0 access scope allows for read-only access to the authenticated
// user's account, but not other types of account access.
new[] { YouTubeService.Scope.YoutubeReadonly },
"psangat",
CancellationToken.None,
new FileDataStore(this.GetType().ToString())
);
}
var youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = this.GetType().ToString()
});
var playlists = youtubeService.Playlists.List("snippet");
playlists.PageToken = "";
playlists.MaxResults = 50;
playlists.Mine = true;
PlaylistListResponse presponse = await playlists.ExecuteAsync();
foreach (var currentPlayList in presponse.Items)
{
if (currentPlayList.Snippet.Title.Equals("Songs"))
{
PlaylistItemsResource.ListRequest listRequest = youtubeService.PlaylistItems.List("contentDetails");
listRequest.MaxResults = 50;
listRequest.PlaylistId = currentPlayList.Id;
listRequest.PageToken = playlists.PageToken;
var response = await listRequest.ExecuteAsync();
var index = 1;
foreach (var playlistItem in response.Items)
{
VideosResource.ListRequest videoR = youtubeService.Videos.List("snippet, contentDetails, status");
videoR.Id = playlistItem.ContentDetails.VideoId;
var responseV = await videoR.ExecuteAsync();
if (responseV.Items.Count > 0)
{
string link = String.Format("https://www.youtube.com/watch?v={0}&list={1}&index={2}", videoR.Id, currentPlayList.Id, index);
IEnumerable <VideoInfo> videoInfos = DownloadUrlResolver.GetDownloadUrls(link);
try
{
VideoInfo video = videoInfos.First(info => info.VideoType == VideoType.Mp4 && info.Resolution == 0 && !String.IsNullOrEmpty(info.Title));
Console.WriteLine("Downloading {0}", video.Title);
if (video.RequiresDecryption)
{
DownloadUrlResolver.DecryptDownloadUrl(video);
}
using (var progress = new ProgressBar())
{
for (int i = 0; i <= 100; i++)
{
progress.Report((double)i / 100);
Thread.Sleep(20);
}
}
var audioDownloader = new VideoDownloader(video, Path.Combine(@"C:\Users\prsangat\Desktop\Songs", video.Title + ".mp3"));
using (var progress = new ProgressBar())
{
audioDownloader.DownloadProgressChanged += (sender, args) => progress.Report(args.ProgressPercentage);
}
//audioDownloader.DownloadProgressChanged += (sender, args) => progre//Console.Write( "\r{0}% ", Math.Round(args.ProgressPercentage));
audioDownloader.Execute();
Console.WriteLine("Download Complete.");
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine(ex.ToString());
Console.WriteLine();
// throw;
}
index++;
}
}
playlists.PageToken = response.NextPageToken;
}
}
}
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 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;
}
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);
}
