public IList<Video> GetVideoFor(string videoName) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = API_KEY, ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = PREFIX+videoName; searchListRequest.MaxResults = MAX_RESULTS; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = searchListRequest.Execute(); IList<Video> videos = new List<Video>(); foreach (var searchResult in searchListResponse.Items) { if (searchResult.Id.Kind == "youtube#video") { videos.Add(new Video( EMBEBED_BASE_URL + searchResult.Id.VideoId , new Image(searchResult.Snippet.Thumbnails.Default__.Url)) ); } } return videos; }
public static List<YoutubeChanelObject> GetChanelByUser(string username) { YouTubeService youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = WebConfigurationManager.AppSettings["ApiKey"], ApplicationName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name }); var searchListRequest = youtubeService.Channels.List("snippet"); searchListRequest.ForUsername = username; searchListRequest.MaxResults = 50; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = searchListRequest.Execute();//.ExecuteAsync(); List<YoutubeChanelObject> ListChanel = new List<YoutubeChanelObject>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { YoutubeChanelObject Chanel = new YoutubeChanelObject(); Chanel.UChanelID = searchResult.Id; Chanel.UTitle = searchResult.Snippet.Title; ListChanel.Add(Chanel); } return ListChanel; }
public static YouTubeService AuthenticateOauthService(string clientId, string clientSecret, string userName) { string[] scopes = new string[] { YouTubeService.Scope.Youtube}; try { UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret }, scopes, userName, CancellationToken.None, new FileDataStore("dtuit.YouTube.Auth.Store")).Result; YouTubeService service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "YouTube Data Api Wrapper" }); return service; } catch (Exception ex) { Console.WriteLine(ex.InnerException); return null; } }
private async void HomePage_Loaded(object sender, RoutedEventArgs e) { if (_activityReq == null) { var userCredential = await GoogleWebAuthorizationBroker.AuthorizeAsync( new Uri("ms-appx:///client_id.json"), new[] { YouTubeService.Scope.Youtube }, "user", CancellationToken.None); var youtube = new YouTubeService(new BaseClientService.Initializer() { //ApiKey = "AIzaSyC7enbf9xtdebb4EDHXeeqHXk2qUuLfeuc", HttpClientInitializer = userCredential, ApplicationName = "ProTube" }); _activityReq = youtube.Activities.List("snippet,contentDetails"); _activityReq.Home = true; _activityReq.MaxResults = 50; _activityReq.PublishedAfter = DateTime.Now.AddDays(-14); } if (_activityRes == null) { _activityRes = await _activityReq.ExecuteAsync(); VideosList.ItemsSource = _activityRes.Items; NextButton.IsEnabled = true; } }
public async Task AuthenticateWithGoogle() { if (_googleCredential != null) { await _googleCredential.RefreshTokenAsync(CancellationToken.None); } else { using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read)) { _googleCredential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.Youtube }, "user", CancellationToken.None, new FileDataStore(StringConstants.ApplicationName)); } } if (Service == null) { Service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = _googleCredential, ApplicationName = StringConstants.ApplicationName }); } }
public async void OAuthConnect() { UserCredential credientials; using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read)) { credientials = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.Youtube }, "Blissea", CancellationToken.None); } YouTubeService service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credientials, ApplicationName = "YoutubeOrganizer" }); PlaylistsResource.ListRequest listRequest = service.Playlists.List("id"); listRequest.MaxResults = 50; listRequest.Mine = true; PlaylistListResponse listResponse = await listRequest.ExecuteAsync(); var count = listResponse.Items.Count; Debug.WriteLine(count); }
public async Task UploadFileToYouTube(PodcastEpisode episode) { try { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = await BuildAccountCredentialFromClientSecret(), ApplicationName = "PodcastUploader" }); var video = BuildVideo(episode); using (var fileStream = new FileStream(episode.LocalVideoFile, FileMode.Open)) { var videosInsertRequest = youtubeService.Videos.Insert(video, "snippet,status", fileStream, "video/*"); videosInsertRequest.ResponseReceived += (v) => videosInsertRequest_ResponseReceived(v, episode); var chunkSize = 256 * 0x400 * 4; videosInsertRequest.ChunkSize = chunkSize; videosInsertRequest.Upload(); } } catch (Exception e) { throw; } }
public void Disconnect() { IsAuthorized = false; _credential = null; _youtubeService.Dispose(); _youtubeService = null; }
public async void Load() { Items.Clear(); YouTubeService service = new YouTubeService( new BaseClientService.Initializer() { HttpClientInitializer = await _authenticationService.GetUserCredential() }); var activititiesRequest = service.Activities.List("snippet"); activititiesRequest.Home = true; ItemsGroup activities = new ItemsGroup( new IncLoadingCollection(d => activititiesRequest.ExecuteAsync(d)), "Recent activities"); await activities.Items.LoadMoreItemsAsync(8); Items.Add(activities); var videosRequest = service.Videos.List("snippet"); videosRequest.Chart = VideosResource.ListRequest.ChartEnum.MostPopular; ItemsGroup videos = new ItemsGroup( new IncLoadingCollection(d => videosRequest.ExecuteAsync(d)), "Popular videos"); await videos.Items.LoadMoreItemsAsync(8); Items.Add(videos); }
public async Task<Dictionary<string, PostAnalysisResults>> Analyze( List<rs.Post> posts ) { var toReturn = new Dictionary<string, PostAnalysisResults>(); var youTubePosts = new Dictionary<string, List<rs.Post>>(); var amWrangler = new BotFunctions.AutoModWrangler( Program.Client.GetSubreddit( Program.Subreddit ) ); var bannedChannels = amWrangler.GetBannedList( Models.BannedEntity.EntityType.Channel ); foreach ( var post in posts ) { //TODO error handling toReturn.Add( post.Id, new PostAnalysisResults( post, ModuleEnum ) ); string postYTID = YouTubeHelpers.ExtractVideoId( post.Url.ToString() ); if ( !string.IsNullOrWhiteSpace( postYTID ) ) { if ( !youTubePosts.ContainsKey( postYTID ) ) youTubePosts.Add( postYTID, new List<rs.Post>() ); youTubePosts[postYTID].Add( post ); } } var yt = new YouTubeService( new BaseClientService.Initializer { ApiKey = YouTubeAPIKey } ); var req = yt.Videos.List( "snippet" ); for ( var i = 0; i < youTubePosts.Keys.Count; i += 50 ) { req.Id = string.Join( ",", youTubePosts.Keys.Skip( i ).Take( 50 ) ); var response = req.ExecuteAsync(); await Task.WhenAll( response, bannedChannels ); foreach ( var vid in response.Result.Items ) { //if the channel is banned var chan = bannedChannels.Result.Where( c => c.EntityString == vid.Snippet.ChannelId ).FirstOrDefault(); if ( chan != null ) { foreach ( var ytPost in youTubePosts[vid.Id] ) { //ring 'er up toReturn[ytPost.Id].Scores.Add( new AnalysisScore( 9999, $"Channel ID: {chan.EntityString} was banned by {chan.BannedBy} on {chan.BanDate} for reason: {chan.BanReason}", "Banned Channel", ModuleName ) ); } } } } return toReturn; }
/// <summary> /// Authenticate to Google Using Oauth2 /// Documentation https://developers.google.com/accounts/docs/OAuth2 /// </summary> /// <param name="clientId">From Google Developer console https://console.developers.google.com</param> /// <param name="clientSecret">From Google Developer console https://console.developers.google.com</param> /// <param name="userName">A string used to identify a user.</param> /// <returns></returns> public static YouTubeService AuthenticateOauth(string clientId, string clientSecret, string userName) { string[] scopes = new string[] { YouTubeService.Scope.Youtube, // view and manage your YouTube account YouTubeService.Scope.YoutubeForceSsl, YouTubeService.Scope.Youtubepartner, YouTubeService.Scope.YoutubepartnerChannelAudit, YouTubeService.Scope.YoutubeReadonly, YouTubeService.Scope.YoutubeUpload}; try { // here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData% UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret } , scopes , userName , CancellationToken.None , new FileDataStore("Daimto.YouTube.Auth.Store")).Result; YouTubeService service = new YouTubeService(new YouTubeService.Initializer() { HttpClientInitializer = credential, ApplicationName = "YouTube Data API Sample", }); return service; } catch (Exception ex) { Console.WriteLine(ex.InnerException); return null; } }
public List<YouTubeModel> GetYTResults(string searchString) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyD9pT1ig_V3DrzF-9xTUENXyS3Nf7reWAk", ApplicationName = "Movie Search", }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = searchString; searchListRequest.MaxResults = 50; var searchListResponse = searchListRequest.Execute(); // instead of Aync Call, i used Sync call List<YouTubeModel> videos = new List<YouTubeModel>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { switch (searchResult.Id.Kind) { case "youtube#video": videos.Add(new YouTubeModel { Title = searchResult.Snippet.Title, Description = searchResult.Snippet.Description, VideoId = searchResult.Id.VideoId, Thumbnal = new Uri(searchResult.Snippet.Thumbnails.Medium.Url) }); break; } } return videos; }
private async Task Run(SteamID toID, string[] query, bool room) { YouTubeService ys = new YouTubeService(new BaseClientService.Initializer() { ApiKey = Options.ChatCommandApi.ApiKey, ApplicationName = "Steam Chat Bot" }); SearchResource.ListRequest search = ys.Search.List("snippet"); string q = ""; for (int i = 1; i < query.Length; i++) { q += query[i] + " "; } q = q.Trim(); search.Q = q; search.MaxResults = 1; SearchListResponse response = await search.ExecuteAsync(); foreach (SearchResult result in response.Items) { if (result.Id.Kind == "youtube#video") { SendMessageAfterDelay(toID, "https://youtube.com/watch?v=" + result.Id.VideoId, room); } else if(result.Id.Kind == "youtube#channel") { SendMessageAfterDelay(toID, "https://youtube.com/channel/" + result.Id.ChannelId, room); } } }
private async Task<YouTubeResult> Run(string searchTerm) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = ConfigurationManager.AppSettings["YouTubeApiKey"], ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = searchTerm; // Replace with your search term. searchListRequest.MaxResults = 50; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); List<string> videos = new List<string>(); List<string> channels = new List<string>(); List<string> playlists = new List<string>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. YouTubeResult videoRes = searchListResponse.Items .Where(x => x.Id.Kind == "youtube#video") .Select(x => new YouTubeResult { Title = x.Snippet.Title, VideoId = x.Id.VideoId }).FirstOrDefault(); return videoRes; }
public YouTubeUtilities(String refresh_token, String client_secret, String client_id) { CLIENT_ID = client_id; CLIENT_SECRET = client_secret; REFRESH_TOKEN = refresh_token; youtube = BuildService(); }
static YoutubeViewModel() { Youtube = new YouTubeService(new BaseClientService.Initializer() { ApiKey = YoutubeApiKey.ApiKey, ApplicationName = "MediaViewer" }); }
public Service() { _youtube = new YouTubeService(new BaseClientService.Initializer { ApplicationName = "mutube-1090", ApiKey = "AIzaSyBeU5QR5N0qOphQkp816JUDOqLpmxIMqSU", }); }
public YouTubeTrackProvider() { youtubeService = new YouTubeService(new BaseClientService.Initializer { ApiKey = Constants.YouTubeApiKey(), ApplicationName = Constants.YoutubeApplicationName }); }
public ProcessDownload(string apiKey, string applicationName) { youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = apiKey, ApplicationName = applicationName }); _youtubeService = this.youtubeService; }
public YouMixServiceContainer() { AssemblyHandler.RedirectAssembly("System.Net.Http.Primitives", new Version(4, 2, 28, 0), "b03f5f7f11d50a3a"); Service = new YouTubeService(new BaseClientService.Initializer { ApiKey = "AIzaSyD8ZsvvMyOSftpldDtxeRmDkjGYmyzhnAQ", ApplicationName = "YouMixVS" }); }
public async Task<ActionResult> YouTubeViewUploads(CancellationToken cancellationToken) { var result = await new AuthorizationCodeMvcApp(this, new AppFlowMetadata()).AuthorizeAsync(cancellationToken); if (result.Credential != null) { var youTubeChannels = new List<YouTubeChannel>(); var service = new YouTubeService(new BaseClientService.Initializer { HttpClientInitializer = result.Credential, ApplicationName = this.ApplicationName }); // Grab users owned channels var channelListRequest = service.Channels.List("snippet,contentDetails"); channelListRequest.Mine = true; var channelListResponse = await channelListRequest.ExecuteAsync(); foreach(var channel in channelListResponse.Items) { var youTubeChannel = new YouTubeChannel(channel); // Grab the ID of the Upload List from the channel var uploadListId = channel.ContentDetails.RelatedPlaylists.Uploads; // Fetch the videos belonging to the Upload List - We'll have to use paging here var nextPageToken = string.Empty; while(nextPageToken != null) { var playlistItemsListRequest = service.PlaylistItems.List("snippet"); playlistItemsListRequest.PlaylistId = uploadListId; playlistItemsListRequest.MaxResults = 50; playlistItemsListRequest.PageToken = nextPageToken; var playlistItemsResponse = await playlistItemsListRequest.ExecuteAsync(); foreach(var playlistItem in playlistItemsResponse.Items) { youTubeChannel.Videos.Add(new YouTubeVideo(playlistItem)); } nextPageToken = playlistItemsResponse.NextPageToken; } youTubeChannels.Add(youTubeChannel); } return View(youTubeChannels); } else { return new RedirectResult(result.RedirectUri); } }
public static async Task<List<YouTubeDTO>> SearchYouTube(string searchTerm) { List<YouTubeDTO> DTOs = null; try { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "<ApiKey goes here>", ApplicationName = "YouTube.Utils.YouTubeUtils" }); string youTubeSearchTerm = searchTerm; int maxResults = 25; var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = youTubeSearchTerm; searchListRequest.MaxResults = maxResults; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); YouTubeDTO y = new VideoDTO(); DTOs = new List<YouTubeDTO>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { if (searchResult.Id.Kind == "youtube#video") { switch (searchResult.Id.Kind) { case "youtube#video": DTOs.Add(new VideoDTO { Title = searchResult.Snippet.Title, Id = searchResult.Id.VideoId }); break; case "youtube#channel": DTOs.Add(new ChannelDTO { Title = searchResult.Snippet.Title, Id = searchResult.Id.ChannelId }); break; case "youtube#playlist": DTOs.Add(new PlayListDTO { Title = searchResult.Snippet.Title, Id = searchResult.Id.PlaylistId }); break; } } } // http://stackoverflow.com/questions/3163922/sort-a-custom-class-listt //DTOs.Sort((a, b) => a.Title.CompareTo(b.Title)); //videoDTOs.Sort(delegate(VideoDTO v1, VideoDTO v2) { return v1.Title.CompareTo(v2.Title); }); } catch (Exception x) { string msg = x.Message; } return DTOs; }
public static YouTubeService CreateService(string applicationName) { // Create the service. var service = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyAAgEriOPPuK_eVLn-RGaOsFw8SHjVl0tg", ApplicationName = applicationName }); return service; }
private async Task Run() { var ics = new BaseClientService.Initializer { ApiKey = "AIzaSyD9pT1ig_V3DrzF-9xTUENXyS3Nf7reWAk", ApplicationName = "Test", }; var youtubeService = new YouTubeService(ics); /* var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyB5VEzoWa9suKGKl6NNW6Hc_M-og0Wn2Xw", ApplicationName = this.GetType().ToString() }); * */ var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = "Jurasic Park"; // Replace with your search term. searchListRequest.MaxResults = 5; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); List<string> videos = new List<string>(); List<string> channels = new List<string>(); List<string> playlists = new List<string>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { switch (searchResult.Id.Kind) { case "youtube#video": videos.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.VideoId)); break; case "youtube#channel": channels.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.ChannelId)); break; case "youtube#playlist": playlists.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.PlaylistId)); break; } } Console.WriteLine(String.Format("Videos:\n{0}\n", string.Join("\n", videos))); Console.WriteLine(String.Format("Channels:\n{0}\n", string.Join("\n", channels))); Console.WriteLine(String.Format("Playlists:\n{0}\n", string.Join("\n", playlists))); }
public static async Task<PlaylistItem> AddVideoToPlaylist(YouTubeService service, string playlistId, string videoId) { // Add a video to the newly created playlist. var newPlaylistItem = new PlaylistItem(); newPlaylistItem.Snippet = new PlaylistItemSnippet(); newPlaylistItem.Snippet.PlaylistId = playlistId; newPlaylistItem.Snippet.ResourceId = new ResourceId(); newPlaylistItem.Snippet.ResourceId.Kind = "youtube#video"; newPlaylistItem.Snippet.ResourceId.VideoId = videoId; var playlistItemInsertReq = service.PlaylistItems.Insert(newPlaylistItem, "snippet"); var item = await playlistItemInsertReq.ExecuteAsync(); return item; }
public GoogleApiService() { var bcs = new BaseClientService.Initializer { ApplicationName = "Nadeko Bot", ApiKey = NadekoBot.Credentials.GoogleApiKey }; _log = LogManager.GetCurrentClassLogger(); yt = new YouTubeService(bcs); sh = new UrlshortenerService(bcs); }
public static async Task<string> CreatePlaylist(YouTubeService service, string title, string description) { // Create a new, public playlist in the authorized user's channel. var newPlaylist = new Playlist(); newPlaylist.Snippet = new PlaylistSnippet(); newPlaylist.Snippet.Title = title; newPlaylist.Snippet.Description = description; newPlaylist.Status = new PlaylistStatus(); newPlaylist.Status.PrivacyStatus = "public"; var playlistInsertReq = service.Playlists.Insert(newPlaylist, "snippet,status"); newPlaylist = await playlistInsertReq.ExecuteAsync(); return newPlaylist.Id; }
public PrintingBox() { InitializeComponent(); ReloadConfig(); button_download.Enabled = false; _youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyDzqeoR5mWrtJJ1Qt1SL_DLRDJvVKStdSo", ApplicationName = this.GetType().ToString() }); }
public async Task<List<WebSong>> SearchYoutube(string title, string artist, string album = null, int limit = 5, bool includeAudioTag = true) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = ApiKeys.YoutubeId, ApplicationName = "Audiotica" }); youtubeService.HttpClient.DefaultRequestHeaders.Referrer = new Uri("http://audiotica.fm"); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = CreateQuery(title, artist, album, false) + (includeAudioTag ? " (Audio)" : ""); searchListRequest.MaxResults = limit; searchListRequest.SafeSearch = SearchResource.ListRequest.SafeSearchEnum.None; try { // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); var songs = new List<WebSong>(); foreach (var vid in from searchResult in searchListResponse.Items where searchResult.Id.Kind == "youtube#video" select new WebSong(searchResult)) { try { vid.AudioUrl = await GetYoutubeUrl(vid.Id); } catch { // ignored } if (!string.IsNullOrEmpty(vid.AudioUrl)) songs.Add(vid); } var results = await IdentifyMatches(songs, title, artist, false); // try redoing the search without "(audio)" if (!results.Any(p => p.IsMatch) && includeAudioTag) return await SearchYoutube(title, artist, album, limit, false); return results; } catch { return null; } }
public async Task UploadVideoAsync(string youtubeChannel, string title, string description, string[] tags, string videoFilePath) { if (youtubeChannel == null || title == null || description == null || tags == null || videoFilePath == null) { throw new ArgumentNullException(); } Console.WriteLine($"Uploading youtube video \"{title}\"" + $" from path \"{videoFilePath}\" to youtube channel \"{youtubeChannel}\""); YouTubeService youtubeService = await GetYouTubeService(youtubeChannel); Video video = new Video { Snippet = new VideoSnippet { Title = title, Description = description, Tags = tags, CategoryId = "20" // gaming, see https://developers.google.com/youtube/v3/docs/videoCategories/list }, Status = new VideoStatus { PrivacyStatus = "public" // "unlisted", "private" or "public" } }; using (FileStream fileStream = new FileStream(videoFilePath, FileMode.Open)) { var videosInsertRequest = youtubeService.Videos.Insert(video, "snippet,status", fileStream, "video/*"); videosInsertRequest.ProgressChanged += VideosInsertRequest_ProgressChanged; videosInsertRequest.ResponseReceived += VideosInsertRequest_ResponseReceived; await videosInsertRequest.UploadAsync(); } }
private async Task PerformYouTubeSearchAsync(YouTubeModel model) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyCTnrb4UFBFj3NknsqAKem6Chf1fbLdhT0", ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = model.Keywords; // Replace with your search term. searchListRequest.MaxResults = 10; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { switch (searchResult.Id.Kind) { case "youtube#video": model.Videos.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.VideoId)); break; case "youtube#channel": model.Channels.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.ChannelId)); break; case "youtube#playlist": model.Playlists.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.PlaylistId)); break; } } }
public async Task GetPlaylistVideosAsyncWithProgressTest() { var progressCalled = 0; var progressIndicator = new Progress <int>(i => Interlocked.Increment(ref progressCalled)); // Mock var httpMock = new Mock <ISafeHttpClient>(MockBehavior.Strict); var youTubeService = new YouTubeService(httpMock.Object, config); httpMock.SetupSequence(x => x.GetAsync <YouTube.OnlyIdResponse>(It.Is <string>(s => checkApiCall(s, "playlistItems", null)))) .ReturnsAsync(_mockOnlyIdResponse) .ReturnsAsync(_mockOnlyIdResponseSecondPage); httpMock.Setup(x => x.GetAsync <YouTube.VideoResponse>(It.Is <string>(s => checkApiCall(s, "videos", null)))) .ReturnsAsync(new YouTube.VideoResponse { Items = new List <YouTube.Video> { _mockVideoResponse.Items[0], _mockVideoResponse.Items[1], _mockVideoResponse.Items[2], _mockVideoResponseSecondPage.Items[0] } }); // Run var videos = await youTubeService.GetPlaylistVideosAsync("1", progressIndicator); // Wait for progress Thread.Sleep(10); // Assert Assert.AreEqual(4, videos.Count); Assert.Greater(progressCalled, 0); // Verify httpMock.VerifyAll(); }
public async Task <IEnumerable <Show> > GetShows(int numberOfShows = 25) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = YouTubeApiKey, ApplicationName = YouTubeAppName }); //var shows = new List<Show>(numberOfShows); var request = youtubeService.PlaylistItems.List("snippet"); request.PlaylistId = YouTubePlaylistId; request.MaxResults = numberOfShows; //playlistItemsListRequest.PageToken = nextPageToken; // Retrieve the list of videos uploaded to the authenticated user's channel. var response = await request.ExecuteAsync(); var shows = response.Items.Select(item => new Show { Id = item.Snippet.ResourceId.VideoId, Title = item.Snippet.Title, Description = item.Snippet.Description, ThumbnailUrl = item.Snippet.Thumbnails.Medium.Url, Url = GetVideoUrl(item.Snippet.ResourceId.VideoId, YouTubePlaylistId, item.Snippet.Position.GetValueOrDefault()) }).ToList(); await UpdateLiveStreamingDetails(youtubeService, shows); return(shows.OrderByDescending(s => s.ScheduledStartTime)); }
public async Task <IList <SearchResult> > byQuery(string query, type type = type.All) { string stype = ""; switch (type) { case type.Video: stype = "video"; break; case type.Channel: stype = "channel"; break; case type.Playlist: stype = "playlist"; break; } var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyBSFxNBKeB-vPSUz7yZFONWZq6_fHsXUHM", ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = query; // Replace with your search term. searchListRequest.MaxResults = 50; searchListRequest.Type = stype; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); return(searchListResponse.Items); }
private async Task Run(string[] args) { UserCredential credential; using (var stream = new FileStream(this.clientSecretFilePath, FileMode.Open, FileAccess.Read)) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, // This OAuth 2.0 access scope allows an application to upload files to the // authenticated user's YouTube channel, but doesn't allow other types of access. new[] { YouTubeService.Scope.YoutubeUpload }, "user", CancellationToken.None ); } var youtubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = Assembly.GetExecutingAssembly().GetName().Name }); var video = this.GetYtVideoObject(args); string filePath = @"C:\Projects\YouTube\sample1.mp4"; // Replace with path two actual movie file. using (var fileStream = new FileStream(filePath, FileMode.Open)) { var videosInsertRequest = youtubeService.Videos.Insert(video, "snippet,status", fileStream, "video/*"); videosInsertRequest.ProgressChanged += videosInsertRequest_ProgressChanged; videosInsertRequest.ResponseReceived += videosInsertRequest_ResponseReceived; await videosInsertRequest.UploadAsync(); } }
/// <summary> /// Manage play list with given youtube service /// required scope : Youtube /// </summary> /// <param name="youtubeService"></param> public static async void ManagePlaylist(YouTubeService youtubeService) { // Create a new, private playlist in the authorized user's channel. var newPlaylist = new Playlist(); newPlaylist.Snippet = new PlaylistSnippet(); newPlaylist.Snippet.Title = "Test Playlist"; newPlaylist.Snippet.Description = "A playlist created with the YouTube API v3"; newPlaylist.Status = new PlaylistStatus(); newPlaylist.Status.PrivacyStatus = "public"; newPlaylist = await youtubeService.Playlists.Insert(newPlaylist, "snippet,status").ExecuteAsync(); // Add a video to the newly created playlist. var newPlaylistItem = new PlaylistItem(); newPlaylistItem.Snippet = new PlaylistItemSnippet(); newPlaylistItem.Snippet.PlaylistId = newPlaylist.Id; newPlaylistItem.Snippet.ResourceId = new ResourceId(); newPlaylistItem.Snippet.ResourceId.Kind = "youtube#video"; newPlaylistItem.Snippet.ResourceId.VideoId = "GNRMeaz6QRI"; newPlaylistItem = await youtubeService.PlaylistItems.Insert(newPlaylistItem, "snippet").ExecuteAsync(); Console.WriteLine("Playlist item id {0} was added to playlist id {1}.", newPlaylistItem.Id, newPlaylist.Id); }
private void btnLogin_Click(object sender, EventArgs e) { var service = new YouTubeService("iSpy", MainForm.Conf.YouTubeKey); service.setUserCredentials(txtYouTubeUsername.Text, txtYouTubePassword.Text); string token = ""; try { token = service.QueryClientLoginToken(); } catch (InvalidCredentialsException) { MessageBox.Show(this, "Login Failed"); } catch (Exception ex) { MessageBox.Show(ex.Message); } if (token != "") { MessageBox.Show(this, "Login OK"); } }
public async void Login() { //https://developers.google.com/youtube/v3/code_samples/dotnet 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 full read/write access to the // authenticated user's account. new[] { YouTubeService.Scope.Youtube }, "user", CancellationToken.None, new FileDataStore("Webplayer") ); } //https://docs.microsoft.com/en-us/aspnet/core/security/app-secrets var youtubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = this.GetType().ToString() }); }
public override async Task Initialize() { string appName = GetType().Assembly.GetName().Name; Service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = await GoogleWebAuthorizationBroker.AuthorizeAsync(UploaderSettings.GoogleSecrets, new [] { YouTubeService.Scope.Youtube }, "youtube", CancellationToken.None, UploaderSettings.GoogleDataStore ), ApplicationName = appName, GZipEnabled = true, }); Service.HttpClient.Timeout = TimeSpan.FromMinutes(2); if (!Directory.Exists(Path.Combine(Path.GetTempPath(), "MatchUploader"))) { Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "MatchUploader")); } }
async Task Init() { WebRequest.DefaultWebProxy = _proxySettings.GetWebProxy(); var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync ( new ClientSecrets { ClientId = _apiKeys.YouTubeClientId, ClientSecret = _apiKeys.YouTubeClientSecret }, // This OAuth 2.0 access scope allows an application to upload files to the // authenticated user's YouTube channel, but doesn't allow other types of access. new[] { YouTubeService.Scope.YoutubeUpload }, "user", CancellationToken.None ); _youtubeService = new YouTubeService(new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = nameof(Captura) }); }
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 var playlistItems = await listRequest.ExecuteAsync(); var result = new ShowList { PreviousShows = 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() }; if (!string.IsNullOrEmpty(playlistItems.NextPageToken)) { result.MoreShowsUrl = GetPlaylistUrl(_appSettings.YouTubePlaylistId); } return(result); } }
/// <summary> /// Uploads a custom video thumbnail to YouTube and sets it for a video. /// Documentation https://developers.google.com/youtube/v3/reference/thumbnails/set /// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong. /// </summary> /// <param name="service">Authenticated YouTube service.</param> /// <param name="videoId">The videoId parameter specifies a YouTube video ID for which the custom video thumbnail is being provided.</param> /// <param name="optional">Optional paramaters.</param> /// <returns>ThumbnailSetResponseResponse</returns> public static ThumbnailSetResponse Set(YouTubeService service, string videoId, ThumbnailsSetOptionalParms optional = null) { try { // Initial validation. if (service == null) throw new ArgumentNullException("service"); if (videoId == null) throw new ArgumentNullException(videoId); // Building the initial request. var request = service.Thumbnails.Set(videoId); // Applying optional parameters to the request. request = (ThumbnailsResource.SetRequest)SampleHelpers.ApplyOptionalParms(request, optional); // Requesting data. return request.Execute(); } catch (Exception ex) { throw new Exception("Request Thumbnails.Set failed.", ex); } }
public Youtube GetYouTube(Imdb imdb) { Youtube youtube = new Youtube(); var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyDPdiKDpjnwevDYtAMuMiFI0Zhdadl5QzY", ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); var titleDescription = RetrieveTitleDescriptionForSearch(imdb.TitleDescription); searchListRequest.Q = string.Format("{0} {1} trailer", imdb.Title, titleDescription); searchListRequest.MaxResults = 1; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = searchListRequest.Execute(); youtube.Id = searchListResponse.Items.FirstOrDefault().Id.VideoId; youtube.Thumbnail = searchListResponse.Items.FirstOrDefault().Snippet.Thumbnails.Default__.Url; return(youtube); }
static void Main(string[] args) { var configuration = new ConfigurationBuilder() .AddUserSecrets(Assembly.GetEntryAssembly()) .Build(); var service = new YouTubeService(new BaseClientService.Initializer() { ApiKey = configuration["YouTubeApiKey"] }); var playlistId = service.GetUploadPlaylist("CaseyNeistat"); var items = service.GetAllItems(playlistId); File.WriteAllText($"{playlistId}.json", JsonConvert.SerializeObject(items.Select(i => new { title = i.Snippet.Title, videoId = i.Snippet.ResourceId.VideoId, publishedAt = i.Snippet.PublishedAt }))); Console.WriteLine($"Downloaded {playlistId}"); }
private async Task LoadDataCollection() { var youtubeService = new YouTubeService( new BaseClientService.Initializer() { ApiKey = "AIzaSyBws9qCw7wjp-jsYeUWNX_MImMGjFl3e1Y", ApplicationName = this.GetType().ToString() }); var request = youtubeService.Search.List("snippet"); request.Q = (string)LblMovieName.Content; // {영화이름} 예고편 request.MaxResults = 10; // 사이즈가 크면 멈춰버림 var response = await request.ExecuteAsync(); // 검색시작(Youtube OpenApi 호출) foreach (var item in response.Items) { if (item.Id.Kind == "youtube#video") { YoutubeItem youtube = new YoutubeItem() { Title = item.Snippet.Title, Author = item.Snippet.ChannelTitle, URL = $"https://www.youtube.com/watch?v={item.Id.VideoId}" }; // 썸네일 이미지 youtube.Thumbnail = new BitmapImage(new Uri(item.Snippet.Thumbnails.Default__.Url, UriKind.RelativeOrAbsolute)); Youtubes.Add(youtube); } } }
public void FillInViews(List <YoutubeItemDataType> collection, YouTubeService service) { if (collection.Count <= 0) { return; } for (int i = 0; i <= (collection.Count - 1) / 50; i++) { string VideoIDs = ""; int j = 0; foreach (var video in collection) { if (video == null) { collection.RemoveAt(j); break; } VideoIDs += video.Id + ","; j++; } var getViewsRequest = service.Videos.List("statistics, contentDetails"); getViewsRequest.Id = VideoIDs.Remove(VideoIDs.Length - 1); var videoListResponse = getViewsRequest.Execute(); for (int k = 0; k < collection.Count; k++) { try { collection[k + i * 50].Length = ISO8601Converter(videoListResponse.Items[k].ContentDetails.Duration); collection[k + i * 50].ViewsAndDate = YoutubeMethodsStatic.ViewCountShortner(videoListResponse.Items[k].Statistics.ViewCount) + collection[k + i * 50].ViewsAndDate; } catch { collection[k + i * 50].ViewsAndDate = "Unknown" + collection[k + i * 50].ViewsAndDate; } } } }
public async Task Startup() { var disclaimer = "This is a note to those looking either in the source code or decompiled. Please do not use my secret :( This is a client-only" + "application so i have to leave my secret in here."; _credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = "632529535771-jfhmk689ql38k5cc4bg7clplvhorfi4i.apps.googleusercontent.com", ClientSecret = "DawckKBXVnuC32bCqL_ZIQkY" }, new[] { YouTubeService.Scope.Youtube }, "user", CancellationToken.None, new FileDataStore("Youtube.SuperChatter")); Service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = _credential, ApplicationName = "SuperChatter" }); await GetSuperChats(); }
static public async Task GetLiveChatMessage(string liveChatId, YouTubeService youtubeService, string nextPageToken) { var liveChatRequest = youtubeService.LiveChatMessages.List(liveChatId, "snippet,authorDetails"); liveChatRequest.PageToken = nextPageToken; System.IO.StreamWriter sw = new System.IO.StreamWriter(path, true); var liveChatResponse = await liveChatRequest.ExecuteAsync(); foreach (var liveChat in liveChatResponse.Items) { try { Console.WriteLine($"{liveChat.Snippet.DisplayMessage},{liveChat.AuthorDetails.DisplayName}"); sw.WriteLine(liveChat.Snippet.DisplayMessage); } catch { } } sw.Close(); await Task.Delay((int)liveChatResponse.PollingIntervalMillis); await GetLiveChatMessage(liveChatId, youtubeService, liveChatResponse.NextPageToken); }
public void YouTubeUploaderTest() { Tracing.TraceMsg("Entering YouTubeUploaderTest"); YouTubeQuery query = new YouTubeQuery(); query.Uri = new Uri(CreateUri(Path.Combine(this.resourcePath, "uploaderyt.xml"))); YouTubeService service = new YouTubeService("NETUnittests", this.ytDevKey); if (!string.IsNullOrEmpty(this.ytUser)) { service.Credentials = new GDataCredentials(this.ytUser, this.ytPwd); } YouTubeFeed feed = service.Query(query); YouTubeEntry entry = feed.Entries[0] as YouTubeEntry; YouTube.MediaCredit uploader = entry.Uploader; Assert.IsTrue(uploader != null); Assert.IsTrue(uploader.Role == "uploader"); Assert.IsTrue(uploader.Scheme == "urn:youtube"); Assert.IsTrue(uploader.Value == "GoogleDevelopers"); }
/// <summary> /// Get access and refresh tokens from user's account /// </summary> /// <param name="youTubeClientId"></param> /// <param name="youTubeClientSecret"></param> public override async Task <bool> GetAuthAsync(string youTubeClientId, string youTubeClientSecret) { try { string clientSecrets = @"{ 'installed': {'client_id': '" + youTubeClientId + "', 'client_secret': '" + youTubeClientSecret + "'} }"; UserCredential credential; using (Stream stream = clientSecrets.ToStream()) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.Youtube }, "user", CancellationToken.None, new FileDataStore("Twitch Bot") ); } YouTubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "Twitch Bot" }); return(true); } catch (Exception ex) { if (!ex.Message.Contains("access_denied")) // record unknown error { await _errHndlrInstance.LogError(ex, "YouTubeClient", "GetAuth(string, string)", false); } return(false); } }
// Sending comment private static async Task <string> SendComment(string url) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = key, HttpClientInitializer = credential, ApplicationName = "YoutubeApp" }); // Making a comment var commentThread = new CommentThread(); CommentThreadSnippet snippet = new CommentThreadSnippet(); Comment topLevelComment = new Comment(); CommentSnippet commentSnippet = new CommentSnippet(); commentSnippet.TextOriginal = GetRandomComment(); topLevelComment.Snippet = commentSnippet; snippet.TopLevelComment = topLevelComment; snippet.VideoId = url; commentThread.Snippet = snippet; // Sending a query var query = youtubeService.CommentThreads.Insert(commentThread, "snippet"); try { var resp = await query.ExecuteAsync(); Console.WriteLine("Комментарий отправлен"); return(resp.Id); } catch (Exception ex) { Console.WriteLine(ex.Message); } return(string.Empty); }
/// <param name="optional">Optional paramaters.</param> /// <returns>SubscriptionListResponseResponse</returns> public static SubscriptionListResponse List(YouTubeService service, string part, SubscriptionsListOptionalParms optional = null) { try { // Initial validation. if (service == null) throw new ArgumentNullException("service"); if (part == null) throw new ArgumentNullException(part); // Building the initial request. var request = service.Subscriptions.List(part); // Applying optional parameters to the request. request = (SubscriptionsResource.ListRequest)SampleHelpers.ApplyOptionalParms(request, optional); // Requesting data. return request.Execute(); } catch (Exception ex) { throw new Exception("Request Subscriptions.List failed.", ex); } }
private async Task <YouTubeService> AuthenticateUserServiceAsync() { var folder = System.IO.Path.GetFullPath(@"..\..\"); UserCredential credential; using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read)) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.Youtube }, Environment.UserName, CancellationToken.None, new FileDataStore(folder) ); } var youtubeService = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "Music App" }); return(youtubeService); }
private async Task Run(string searchString) { var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = API_KEY, ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = searchString; searchListRequest.MaxResults = numberSearchResult; var searchListResponse = searchListRequest.Execute(); foreach (var searchResult in searchListResponse.Items) { if (searchResult.Id.Kind == "youtube#video") { video.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.VideoId)); } } }
public List <SearchResult> GetVidsForNewsEntity(string channelId) { List <SearchResult> newVids = new List <SearchResult>(); var youtTubeApiKey = Configuration["IntegrationSettings:YouTube:ApiKey"]; var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = youtTubeApiKey, ApplicationName = this.GetType().ToString() }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.MaxResults = 20; searchListRequest.ChannelId = channelId; searchListRequest.Order = 0; try { var searchLasistResponse = searchListRequest.Execute(); } catch (Exception ex) { var test = ex.Message; } var searchListResponse = searchListRequest.Execute(); newVids = new List <SearchResult>(searchListResponse.Items); return(newVids); }
/// Guts of the program that actually calls service and retrieves our video result private async Task Run(string searchParams) { // Instantiate the service and set ApiKey var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = this.ApiKey, ApplicationName = this.GetType().ToString() }); // Instantiate the search request and set the params and num of results var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = searchParams; // Replace with your search term. searchListRequest.MaxResults = 1; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); // Grab the first video ID from the search.list respons var vidurl = searchListResponse.Items[0].Id.VideoId; // Propagate the video ID yturl = vidurl; }
private async Task <VideoDto> GetCurrentLiveStream() { YouTubeService t = new YouTubeService(new Google.Apis.Services.BaseClientService.Initializer() { ApiKey = ApiKey, ApplicationName = "TimeStampBot" }); SearchResource.ListRequest request = t.Search.List("id"); request.ChannelId = "UC_a1ZYZ8ZTXpjg9xUY9sj8w"; request.EventType = SearchResource.ListRequest.EventTypeEnum.Live; request.MaxResults = 1; request.Type = "video"; request.Fields = "items(id(videoId))"; SearchListResponse result = await request.ExecuteAsync(); SearchResult livestream = result.Items.FirstOrDefault(); return(new VideoDto() { VideoId = livestream?.Id.VideoId, StartTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Parse(livestream.Snippet.PublishedAt)) }); }
public async Task <bool> Authorization() { UserCredential credential; GetAPIKeyAndClientSecret(out string apiKey, out Stream stream); using ( stream ) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load ( stream ).Secrets, new [] { YouTubeService.Scope.Youtube, YouTubeService.Scope.YoutubeUpload }, "user", CancellationToken.None ); } if (credential == null) { return(false); } YouTubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = apiKey, ApplicationName = "DaramYouTubeUploader", GZipEnabled = true, HttpClientInitializer = credential, HttpClientFactory = new MyHttpClientFactory(), }); YouTubeService.HttpClient.Timeout = TimeSpan.FromMinutes(5); PC(nameof(IsAuthorized)); PC(nameof(IsAlreadyAuthorized)); return(true); }
public async Task CommunityVideosCommand(string url, [Remainder] string desc = "") { bool validUser = false; var channelId = ""; using (var communityVideoIds = new StreamReader($"Resources{Path.DirectorySeparatorChar}CommunityVideoIds.csv")) { while (!communityVideoIds.EndOfStream && !validUser) { var person = (await communityVideoIds.ReadLineAsync()) !.Split(','); if (Context.User.Id == Convert.ToUInt64(person[0])) { validUser = true; channelId = person[1]; } } } if (!validUser) { await ReplyAsync(new StringBuilder("It doesn't look like you're allowed to post in <#442474624417005589>.\n\n") .Append("If you have more than 25 subs, post reasonable Algodoo-related content and are in good standing with the rules, sign up here: https://goo.gl/forms/opPSzUg30BECNku13 \n\n") .Append("If you're an accepted user, please notify Doc671.") .ToString()); return; } using var youtubeService = new YouTubeService(new BaseClientService.Initializer { ApiKey = _botCredentials.GoogleApiKey, ApplicationName = GetType().ToString() }); string videoId = url.Contains("https://www.youtube.com/watch?v=") ? url[32..] // removes "https://www.youtube.com/watch?v="
public static List<YoutubePlaylistObject> FeedRelatedVideo(string youtubeId) { List<YoutubePlaylistObject> ListVideo = new List<YoutubePlaylistObject>(); var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = WebConfigurationManager.AppSettings["ApiKey"], ApplicationName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name }); var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.RelatedToVideoId = youtubeId; searchListRequest.MaxResults = 50; searchListRequest.Type = "video"; //Call fist request // Call the search.list method to retrieve results matching the specified query term. Google.Apis.YouTube.v3.Data.SearchListResponse searchListResponse; searchListResponse = searchListRequest.Execute();//.ExecuteAsync(); //Break if nothing to feed int Round = 0; do { searchListResponse = searchListRequest.Execute();//.ExecuteAsync(); //Break if nothing to feed ListVideo.AddRange(ProcessResult(searchListResponse, null)); searchListRequest.PageToken = searchListResponse.NextPageToken; Round++; } while (!string.IsNullOrEmpty(searchListResponse.NextPageToken) || Round > 10); return ListVideo; }