internal async Task <string> GetVideoId(string videoId)
{
try
{
var uri = new Uri(videoId);
var queryDict = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(uri.Query);
videoId = queryDict["v"];
}
catch
{
}
YouTubeService t = GetYoutubeService();
VideosResource.ListRequest request = t.Videos.List("id");
request.Id = videoId;
VideoListResponse response = await request.ExecuteAsync();
if (response.Items.Count > 0)
{
return(videoId);
}
else
{
return(null);
}
}
public String generateRandomVideos(bool onlyOne)
{
if (onlyOne)
{
log.Debug("Cache is empty; generating video...");
}
else
{
log.Debug(String.Format("Cache currently contains {0} items; refilling to {1}...", randomCache.Count, PluginSettings.Default.YoutubeCacheSize));
}
while (randomCache.Count < PluginSettings.Default.YoutubeCacheSize)
{
try {
log.Debug("Generating a random video...");
VideosResource.ListRequest request = youtubeService.Videos.List("snippet");
request.Fields = "items(id,snippet/title)";
request.Chart = VideosResource.ListRequest.ChartEnum.MostPopular;
request.MaxResults = 40;
log.Debug("Fetching list of most popular videos...");
VideoListResponse response = request.Execute();
int count = response.Items.Count;
Video first = response.Items[random.Next(count)];
String id = first.Id;
log.Debug("Picked \"" + first.Snippet.Title + "\" as my starting point.");
for (int i = 0; i < PluginSettings.Default.YoutubeIterations; i++)
{
SearchResource.ListRequest relatedRequest = youtubeService.Search.List("snippet");
relatedRequest.Fields = "items(id,snippet/title)";
relatedRequest.Type = "video";
relatedRequest.RelatedToVideoId = id;
relatedRequest.SafeSearch = SearchResource.ListRequest.SafeSearchEnum.None;
relatedRequest.MaxResults = 20;
SearchListResponse relatedResponse = relatedRequest.Execute();
count = relatedResponse.Items.Count;
SearchResult result = relatedResponse.Items[random.Next(count)];
id = result.Id.VideoId;
log.Debug("Next link: " + result.Snippet.Title);
}
log.Debug("Found my random video!");
String url = "https://youtu.be/" + id;
if (onlyOne)
{
return(url);
}
log.Debug("Adding to cache...");
randomCache.Enqueue(url);
} catch (Exception e) {
log.Error("Failed in generating a video.", e);
}
}
return(null);
}
/// <summary>
/// 获取用户已经发布得视频列表 分页
/// </summary>
/// <param name="open_id">用户应用标识</param>
/// <param name="access_token">用户授权token</param>
/// <param name="cursor">分页游标, 默认传0。</param>
/// <param name="count">每页数量</param>
/// <returns></returns>
public List <VideoData> GetVideoList(string open_id, string access_token, long cursor, int count)
{
VideoListRequest request = new VideoListRequest()
{
OpenId = open_id
,
AccessToken = access_token
,
Cursor = cursor
,
Count = count
};
VideoListResponse response = Execute <VideoListResponse>(request);
if (response != null)
{
if (response.Data != null && response.Data.List != null && response.Data.List.Count > 0)
{
return(response.Data.List);
}
else
{
return(new List <VideoData>());
}
}
else
{
throw new Exception("error code:" + response.Data.ErrorCode + ",error msg:" + response.Data.Description);
}
}
/// <summary>
/// Get List Of Videos with video info details
/// </summary>
/// <param name="withConversions"></param>
/// <returns></returns>
public VideoListResponse GetVideoList(bool withConversions)
{
VideoListResponse response = new VideoListResponse();
//List<JwVideo> list = new List<JwVideo>();
try
{
string responseJson = Call("/videos/list");
//JObject job = JObject.Parse(response);
response = JsonConvert.DeserializeObject <VideoListResponse>(responseJson);
if (withConversions && response.Videos != null && response.Videos.Count > 0)
{
response.Videos.ForEach(x => x.VideoDetails = GetVideoConversionList(x.Key));
}
}
catch (Exception ex)
{
response.ErrorMessage = ex.Message;
response.Status = CallExecutionStatus.Error;
}
return(response);
}
public async Task <ActionResult <string> > LocalizeVideo([Required, FromBody] AppVideoLocalizeRequest body)
{
string localizationCountHash = Guid.NewGuid().ToString();
intStore[localizationCountHash] = 0;
string[] videos = body.MineChannelVideoUploadCollection;
Task <Video>[] tasks = new Task <Video> [videos.Length];
string userId = User.GetLocalAuthorityNameIdentifier();
YouTubeService service = await youtubeServiceAccessor.InitializeServiceAsync(userId);
VideosResource.ListRequest request = service.Videos.List(VIDEO_LOCALIZE_PART);
request.Id = string.Join(',', videos);
int i = 0;
do
{
VideoListResponse response = await request.ExecuteAsync();
IList <Video> items = response.Items;
foreach (Video item in items)
{
tasks[i++] = LocalizeVideoTask(item, body, localizationCountHash, service); // All other tasks begin their life cycle in a hot state.
}
request.PageToken = response.NextPageToken;
} while (request.PageToken != null);
_ = Task.WhenAll(tasks); // errors will not be caught because no await
return(new ActionResult <string>(localizationCountHash));
}
public async Task GetVideoItemByIdentifierAsync_Should_Return_ValidResult()
{
var fixture = new Fixture();
var expected = fixture.Build <VideoItem>().Without(w => w.PlaylistVideoItems).Create();
var myResponse = new VideoListResponse
{
Items = new List <Video> {
_mapper.Map <Video>(expected)
}
};
_youTubeServiceWrapper.Setup(wrapper => wrapper.VideosListExecuteAsync(It.IsAny <string>()))
.ReturnsAsync(myResponse);
var actual = await _youtubeSearchService
.GetVideoItemByIdentifierAsync(expected.VideoIdentifier)
.ConfigureAwait(false);
actual.Should()
.BeEquivalentTo(expected,
options => options.Excluding(item => item.PlaylistVideoItems)
.Excluding(item => item.Id));
}
/// <summary>
/// 查询指定视频数据
/// </summary>
/// <param name="open_id">用户应用标识</param>
/// <param name="access_token">用户授权token</param>
/// <param name="item_ids">视频ids</param>
/// <returns></returns>
public List <VideoData> GetVideoData(string open_id, string access_token, List <string> item_ids)
{
VideoDataRequest request = new VideoDataRequest()
{
OpenId = open_id
,
AccessToken = access_token
};
request.JsonData = new VideoDataRequestBody()
{
ItemIds = item_ids
};
VideoListResponse response = Execute <VideoListResponse>(request);
if (response != null)
{
if (response.Data.List != null)
{
return(response.Data.List);
}
else
{
return(new List <VideoData>());
}
}
else
{
throw new Exception("error code:" + response.Data.ErrorCode + ",error msg:" + response.Data.Description);
}
}
private static List <VideoItem> GetVideoItemsList(VideoListResponse videoListResponse)
{
var videoItemList = new List <VideoItem>();
foreach (var item in videoListResponse.Items)
{
var snippet = item.Snippet;
var statistics = item.Statistics;
var vdItem = new VideoItem
{
Title = snippet.Title,
Description = snippet.Description,
ChannelTitle = snippet.ChannelTitle,
PublishedAt = snippet.PublishedAt,
VideoId = item?.Id,
DefaultThumbnailUrl = snippet?.Thumbnails?.Default__?.Url,
MediumThumbnailUrl = snippet?.Thumbnails?.Medium?.Url,
HighThumbnailUrl = snippet?.Thumbnails?.High?.Url,
StandardThumbnailUrl = snippet?.Thumbnails?.Standard?.Url,
MaxResThumbnailUrl = snippet?.Thumbnails?.Maxres?.Url,
ViewCount = (int?)(statistics?.ViewCount),
LikeCount = (int?)(statistics?.LikeCount),
DislikeCount = (int?)statistics?.DislikeCount,
CommentCount = (int?)statistics?.CommentCount,
Player = item.Player
};
videoItemList.Add(vdItem);
}
return(videoItemList);
}
async Task <Video> requestVideoInfo(String videoId)
{
var request = YoutubeViewModel.Youtube.Videos.List("snippet");
request.Id = videoId;
if (RequestVideoInfoTask != null && !RequestVideoInfoTask.IsCompleted)
{
RequestVideoInfoTaskTokenSource.Cancel();
await RequestVideoInfoTask;
RequestVideoInfoTaskTokenSource = new CancellationTokenSource();
}
try
{
RequestVideoInfoTask = request.ExecuteAsync(RequestVideoInfoTaskTokenSource.Token);
VideoListResponse response = await RequestVideoInfoTask;
if (response.Items.Count > 0)
{
return(response.Items[0]);
}
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
Logger.Log.Error("Error requesting youtube video info: " + videoId, e);
}
return(null);
}
/// <summary>
/// Gets the videos for the specified IDs
/// </summary>
/// <param name="ids">The IDs of the videos</param>
/// <param name="isOwned">Indicates whether the video is owned by the currently authenticated user and includes additional details if so</param>
/// <returns>The video information</returns>
public async Task <IEnumerable <Video> > GetVideosByID(IEnumerable <string> ids, bool isOwned = false)
{
Validator.ValidateList(ids, "ids");
return(await this.YouTubeServiceWrapper(async() =>
{
List <Video> results = new List <Video>();
List <string> searchIDs = new List <string>(ids);
string pageToken = null;
do
{
int searchAmount = Math.Min(searchIDs.Count, 50);
string parts = "snippet,contentDetails,statistics,liveStreamingDetails,recordingDetails,status,topicDetails";
if (isOwned)
{
parts += ",fileDetails,processingDetails";
}
VideosResource.ListRequest request = this.connection.GoogleYouTubeService.Videos.List(parts);
request.MaxResults = searchAmount;
request.Id = string.Join(",", searchIDs.Take(searchAmount));
request.PageToken = pageToken;
VideoListResponse response = await request.ExecuteAsync();
results.AddRange(response.Items);
searchIDs = new List <string>(searchIDs.Skip(searchAmount));
pageToken = response.NextPageToken;
} while (searchIDs.Count > 0 && !string.IsNullOrEmpty(pageToken));
return results;
}));
}
public SongRequest(string videoId, string whoRequested)
{
VideosResource.ListRequest list = youtubeService.Videos.List("snippet,contentDetails,statistics,status");
requester = whoRequested;
list.Id = videoId;
id = videoId;
VideoListResponse response = list.Execute();
title = response.Items.First().Snippet.Title;
uploader = response.Items.First().Snippet.ChannelTitle;
views = response.Items.First().Statistics.ViewCount;
thumbUrl = response.Items.First().Snippet.Thumbnails.Default__.Url;
embeddable = response.Items.First().Status.Embeddable;
duration = new TimeSpan();
Regex r = new Regex(@"PT((?<hours>\d+)H)?((?<minutes>\d+)M)?((?<seconds>\d+)S)?");
Match m = r.Match(response.Items.First().ContentDetails.Duration);
if (m.Groups["hours"].Value != "")
{
duration = duration.Add(new TimeSpan(Int32.Parse(m.Groups["hours"].Value), 0, 0));
}
if (m.Groups["minutes"].Value != "")
{
duration = duration.Add(new TimeSpan(0, Int32.Parse(m.Groups["minutes"].Value), 0));
}
if (m.Groups["seconds"].Value != "")
{
duration = duration.Add(new TimeSpan(0, 0, Int32.Parse(m.Groups["seconds"].Value)));
}
}
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 static List <YoutubeVideoItem> GetVideos(List <string> videoIds)
{
List <YoutubeVideoItem> videos = new List <YoutubeVideoItem>();
HttpCacheProvider cacheProvider = new HttpCacheProvider();
// Todo: Return result object with status message and result
try
{
var youTube = GetYouTubeService();
//Build up request
var videoRequest = youTube.PlaylistItems.List("snippet,contentDetails, statistics");
videoRequest.MaxResults = _noPerPage; //3 per page
foreach (var videoId in videoIds)
{
var cacheItem = cacheProvider.GetItem <YoutubeVideoItem>(videoId);
if (cacheItem != null)
{
videos.Add(cacheItem);
continue;
}
//Perform request
VideoListResponse videoResponse = GetVideo(videoId);
if (videoResponse == null && !videoResponse.Items.Any())
{
continue;
}
var videoItem = new YoutubeVideoItem()
{
Title = videoResponse.Items.FirstOrDefault().Snippet.Title,
Id = videoResponse.Items.FirstOrDefault().Id,
PublishDate = videoResponse.Items.FirstOrDefault().Snippet.PublishedAt,
Image = videoResponse.Items.FirstOrDefault().Snippet.Thumbnails.High.Url,
Url = string.Format("https://www.youtube.com/embed/{0}?rel=0", videoResponse.Items.FirstOrDefault().Id),
ExternalUrl = string.Format("https://www.youtube.com/watch?v={0}", videoResponse.Items.FirstOrDefault().Id),
WatchCount = videoResponse.Items.FirstOrDefault().Statistics.ViewCount.ToString()
};
videos.Add(videoItem);
cacheProvider.InsertItem <YoutubeVideoItem>(videoId, videoItem, TimeSpan.FromHours(1));
}
}
catch (Exception ex)
{
// Todo: Implement error handling
}
//Return the list of videos we find
return(videos);
}
public MVideoList(VideoListResponse response, IPlaylistItemList playListItems) : this()
{
NextPageToken = playListItems.NextPageToken;
PageInfo = playListItems.PageInfo;
PrevPageToken = playListItems.PrevPageToken;
var items = response.Items.Where(i => i.Snippet.Title != "Deleted video");
Items = items.Select(i => new MVideoItem(i)).ToList <IVideoItem>();
VisitorId = playListItems.VisitorId;
}
public async Task <DateTime> getPublishedAt(YouTubeService youtubeService, String videoId)
{
VideosResource.ListRequest videosListRequest = youtubeService.Videos.List("snippet, contentDetails");
videosListRequest.Id = videoId;
VideoListResponse videosListResponse = await videosListRequest.ExecuteAsync();
DateTime publishedAt = (DateTime)videosListResponse.Items[0].Snippet.PublishedAt;
return(publishedAt);
}
public async void GetVideos()
{
IsBusy = true;
VideoListResponse videoListResponse = await YouTubeServiceClient.Instance.GetVideoList();
var videoItemList = GetVideoItemsList(videoListResponse);
VideoItems = videoItemList;
IsBusy = false;
}
public MActivityList(ActivityListResponse response, VideoListResponse videoList)
{
Kind = response.Kind;
NextPageToken = response.NextPageToken;
PageInfo = new MPageInfo(response.PageInfo);
PrevPageToken = response.PrevPageToken;
VisitorId = response.VisitorId;
Items = videoList.Items.Select(i => new MVideoItem(i)).ToList <IVideoItem>();
Id = Guid.NewGuid().ToString();
}
public void GetVideoDetails(string videoId)
{
VideosResource.ListRequest request = client.Videos.List("statistics, snippet");
request.Id = videoId;
VideoListResponse response = request.Execute();
ulong?views = response.Items[0].Statistics.ViewCount;
Console.WriteLine($"Video Name: {response.Items[0].Snippet.Title} Views: {views}");
}
/// <summary>
/// See whether a video is embeddable or not
/// NB! THis dos not always work see: http://stackoverflow.com/questions/17099980/v3-api-returns-blocked-content-even-with-videoembedable-true
/// for more information.
/// </summary>
/// <param name="VideoID"></param>
/// <returns></returns>
public static bool isEmbeddable(string VideoID, YouTubeService ys)
{
VideosResource.ListRequest lr = ys.Videos.List("status");
lr.Id = VideoID;
VideoListResponse searchResponse = lr.Execute();
if (searchResponse.Items.Count == 0)
{
throw new ArgumentException("Didn't find a video with id", "VideoID");
}
return((bool)searchResponse.Items[0].Status.Embeddable);
}
internal async Task <VideoDto> GetVideoInfo(YouTubeService ytService, string videoId, bool getScheduledTime = false, bool getActualEndTime = false)
{
try
{
VideosResource.ListRequest request = ytService.Videos.List("snippet,id,liveStreamingDetails,statistics");
request.Id = videoId;
VideoListResponse result = await request.ExecuteAsync();
Video livestream = result.Items.FirstOrDefault();
if (livestream == null)
{
return(null);
}
DateTime startTime = default;
DateTime endTime = default;
if (getScheduledTime)
{
DateTime.TryParse(livestream.LiveStreamingDetails.ScheduledStartTime, null, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out startTime);
}
else
if (!DateTime.TryParse(livestream.LiveStreamingDetails.ActualStartTime, null, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out startTime))
{
throw new StartCapturingTooSoonException(videoId);
}
if (getActualEndTime)
{
if (!DateTime.TryParse(livestream.LiveStreamingDetails.ActualEndTime, null, styles: DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out endTime))
{
throw new NoActualEndtimeException(videoId);
}
}
return(new VideoDto()
{
VideoId = livestream?.Id,
VideoTitle = livestream.Snippet.Title,
Misc = JsonConvert.SerializeObject(livestream),
StartTime = startTime,
EndTime = endTime,
});
}
catch (Exception ex)
{
logger.LogError(ex, nameof(GetVideoInfo));
throw;
}
}
// Youtube 에서 제공하는 API, 영상 제목, 영상 정보, 영상 길이, 영상 조회수, 영상 설명, 영상 좋아요,싫어요 수, 댓글 수 게시자 채널명, 해당 채널 구독자 수,
async void YoutubeAPi()
{
//비동기, 동기
//비동기 : 해결 속도 동기 보다 느림, 대신 이 명령어 하고 있을 때 다른 일을 동시에 해결 할 수 있음
//동기 : 비동기보다 빠르고 대신 이 명령어를 하는 동안 다른 명령어를 수행못함
// viewCount,likecount, dislikecount, commentcount
VideosResource.ListRequest count_like_dislike_view = youtube.Videos.List("statistics");//Videos statistics 연결
count_like_dislike_view.Id = $"{this.Id}";
VideoListResponse countview_res = await count_like_dislike_view.ExecuteAsync();
viewCount.Text = Convert.ToString(countview_res.Items[0].Statistics.ViewCount);//
likeCount.Text = Convert.ToString(countview_res.Items[0].Statistics.LikeCount);
dislikeCount.Text = Convert.ToString(countview_res.Items[0].Statistics.DislikeCount);
commentCount.Text = Convert.ToString(countview_res.Items[0].Statistics.CommentCount);
// title, description, channelId, chnnelTitle, publichedAt
VideosResource.ListRequest snippet = youtube.Videos.List("snippet");//Videos statistics 연결
snippet.Id = $"{this.Id}";
VideoListResponse snippet_res = await snippet.ExecuteAsync();
this.stitle = Convert.ToString(snippet_res.Items[0].Snippet.Title);
title.Text = this.stitle;
descriptionBox.Text = "\n\n" + Convert.ToString(snippet_res.Items[0].Snippet.Description.Replace("\n", "\r\n"));
ChannelsResource.ListRequest yChannnelId = youtube.Channels.List("statistics");
string channelId = snippet_res.Items[0].Snippet.ChannelId;
yChannnelId.Id = channelId;
ChannelListResponse yChnnelId_res = await yChannnelId.ExecuteAsync();
// 구독자 수
godog.Text = " 채널 구독자 수: " + Convert.ToString(yChnnelId_res.Items[0].Statistics.SubscriberCount) + " 명";
channelTitle.Text = Convert.ToString(snippet_res.Items[0].Snippet.ChannelTitle);
this.channelUrl = "https://www.youtube.com/channel/" + channelId;
// title, description, channelId, chnnelTitle, publichedAt
VideosResource.ListRequest contentDetials = youtube.Videos.List("contentDetails");//Videos statistics 연결
contentDetials.Id = $"{this.Id}";
VideoListResponse contentDetails_res = await contentDetials.ExecuteAsync();
int timeSeconds = TimeSeconds(contentDetails_res.Items[0].ContentDetails.Duration);
string timeString = TimeString(contentDetails_res.Items[0].ContentDetails.Duration);
videoLength.Text = timeString;
//status.embeddable 해야할것
trackBar1.Maximum = timeSeconds;
}
private static (string, string) GetYoutubeInfo(string id)
{
YoutubeRequest request = BuildRequest(id);
VideoListResponse response = request.Execute();
if (response.Items.Count == 0)
{
return(string.Empty, string.Empty);
}
VideoSnippet snippet = response.Items[0].Snippet;
return(snippet.Title, GetThumbnailUrl(snippet.Thumbnails));
}
public VideoStatistics GetVideoStats(YouTubeService youtubeService, string videoId)
{
VideosResource.ListRequest listRequest = youtubeService.Videos.List("statistics");
listRequest.Id = videoId;
VideoListResponse videoListResponse = listRequest.Execute();
IList <Video> items = videoListResponse.Items;
if (items.Count > 0)
{
return(items[0].Statistics);
}
return(null);
}
public async Task <ActionResult <VideoListResponse> > List([Required, FromQuery] AppVideoListRequest request)
{
YouTubeService service = await serviceAccessor.InitializeServiceAsync();
VideosResource.ListRequest requestActual = request.ToActualRequest(service);
try {
VideoListResponse response = await requestActual.ExecuteAsync();
return(new ActionResult <VideoListResponse>(response));
} catch (GoogleApiException ex) {
return(StatusCode((int)ex.HttpStatusCode, ex.Message));
}
}
public MVideoList(VideoListResponse response) : this()
{
if (response == null)
{
Items = new List <IVideoItem>();
return;
}
NextPageToken = response.NextPageToken;
PageInfo = new MPageInfo(response.PageInfo);
PrevPageToken = response.PrevPageToken;
var items = response.Items.Where(i => i.Snippet.Title != "Deleted video");
Items = items.Select(i => new MVideoItem(i)).ToList <IVideoItem>();
VisitorId = response.VisitorId;
}
private async Task <YouTubeVideo> GetVideo(string id)
{
VideosResource.ListRequest videoRequest = _youTubeApiService.Videos.List("snippet");
videoRequest.Id = id;
VideoListResponse videoResponse = await videoRequest.ExecuteAsync();
Video video = videoResponse.Items.First();
string statistics = await _httpClient.GetStringAsync($"https://www.googleapis.com/youtube/v3/videos?id={video.Id}&key=AIzaSyA6F0Qqlul32ly5jSbnK9FYPL2Ge8Q7nQM&part=statistics");
return(new YouTubeVideo(video, JsonConvert.DeserializeObject <VideoListResponse>(statistics)
.Items
.Single()
.Statistics
.ViewCount));
}
public void SetInfoInVideoList(List <string> videoIdList)
{
int savedCount = 0;
logger.Info("/-----Youtube Service Save Statistics Update Start-----/");
try
{
if (videoIdList.Count > 0)
{
foreach (string videoId in videoIdList)
{
VideosResource.ListRequest listRequest = youtube.Videos.List("statistics");
listRequest.Id = videoId;
VideoListResponse videoResponse = listRequest.Execute();
foreach (Video videoResult in videoResponse.Items)
{
switch (videoResult.Kind)
{
case "youtube#video":
// 데이터 저장
YoutubeT entity = new YoutubeT()
{
YoutubeId = videoResult.Id,
ViewCount = videoResult.Statistics.ViewCount,
LikeCount = videoResult.Statistics.LikeCount,
DislikeCount = videoResult.Statistics.DislikeCount,
CommentCount = videoResult.Statistics.CommentCount
};
youtubeRepository.UpdateYoutubeData(entity);
savedCount++;
break;
}
}
}
}
logger.Info("/-----Youtube Service Save Statistics Update End! Saved Count : " + savedCount + " -----/");
}
catch (Exception e)
{
logger.Error(e, "Youtube Service Step 2 Error");
}
}
public async Task Test_ContentDetails_Deserialization_Async()
{
// Get the stream.
using Stream? stream = typeof(ContentDetailsDeserializationTests).GetTypeInfo().Assembly
.GetManifestResourceStream(typeof(Marker), "ContentDetails.json");
// Deserialize.
VideoListResponse response = await JsonSerializer
.DeserializeAsync <VideoListResponse>(stream, new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
})
.ConfigureAwait(false);
// Validate.
Assert.Equal(
TimeSpan.FromMinutes(18).Add(TimeSpan.FromSeconds(8)),
response.Items.First().ContentDetails?.Duration
);
}
public async Task GetYoutubeSearchResultAsync_Should_Return_Valid_Result()
{
const string searchTerm = "searchTerm";
const int count = 2;
const string pageToken = "pageToken";
var fixture = new Fixture();
var expected = fixture.Build <YoutubeSearchResult>()
.With(result => result.Videos,
fixture.Build <VideoItem>()
.Without(item => item.PlaylistVideoItems)
.CreateMany(count)
.ToArray())
.Create();
var searchListResponse = new SearchListResponse
{
PageInfo = new PageInfo
{
TotalResults = expected.Total
},
Items = _mapper.Map <List <SearchResult> >(expected.Videos),
NextPageToken = expected.NextPageToken
};
var videoListResponse = new VideoListResponse
{
Items = _mapper.Map <List <Video> >(expected.Videos)
};
_youTubeServiceWrapper
.Setup(
wrapper => wrapper.SearchListExecuteAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(searchListResponse);
_youTubeServiceWrapper.Setup(wrapper => wrapper.VideosListFromIdsExecuteAsync(It.IsAny <string>()))
.ReturnsAsync(videoListResponse);
var actual = await _youtubeSearchService
.GetYoutubeSearchResultAsync(searchTerm, count, pageToken)
.ConfigureAwait(false);
actual.Should().BeEquivalentTo(expected, options => options.Excluding(result => result.Videos));
actual.Videos.Should()
.BeEquivalentTo(expected.Videos, options => options.WithStrictOrdering().Excluding(item => item.Id));
}
private async Task <Video> GetVideoMetadataInternalAsync(string videoId, CancellationToken cancellationToken)
{
try
{
_logger.LogTrace($"{GetType()} - BEGIN {nameof(GetVideoMetadataInternalAsync)}");
YouTubeService ytService = await _ytServiceProvider.CreateServiceAsync(cancellationToken);
VideosResource.ListRequest req = ytService.Videos.List(SNIPPET_PART_PARAM);
req.Id = videoId;
VideoListResponse res = await req.ExecuteAsync(cancellationToken);
return(res?.Items?.FirstOrDefault());
}
catch (Exception e)
{
_logger.LogError("An error occurred while retrieving video metadata", e);
throw;
}
}
