public async Task <IActionResult> OnGet(string videoId, string?startTime = null)
{
var video = await _getVideoService.ExecuteAsync(videoId);
if (video?.Data == null)
{
return(NotFound(videoId));
}
var oEmbed = await _getOEmbedVideoService.ExecuteAsync(video.Data.Link);
if (oEmbed?.Data == null)
{
return(NotFound(videoId));
}
var spec = new ArchiveVideoByVideoIdSpec(videoId);
var archiveVideo = await _repository.GetBySpecAsync(spec);
if (archiveVideo == null)
{
return(NotFound(videoId));
}
OEmbedViewModel = new OEmbedViewModel(oEmbed.Data);
OEmbedViewModel.Name = archiveVideo.Title;
OEmbedViewModel.Password = video.Data.Password;
OEmbedViewModel.Description = _markdownService.RenderHTMLFromMD(archiveVideo.Description);
OEmbedViewModel
.AddStartTime(startTime)
.BuildHtml(video.Data.Link);
return(Page());
}
private async Task <AnimatedThumbnailsResponse> CreateAnimatedThumbnails(long videoId)
{
Video video = new Video();
while (video.Status != "available")
{
_sleepService.Sleep(20 * 1000);
var response = await _getVideoService.ExecuteAsync(videoId.ToString());
if (response?.Data == null)
{
_logger.LogError($"Video does not exist on vimeo!");
return(null);
}
video = response.Data;
}
var startAnimation = GetRandomStart(video.Duration > 6 ? video.Duration : 0);
var addAnimatedThumbnailsToVideoRequest = new AddAnimatedThumbnailsToVideoRequest(videoId, startAnimation, video.Duration >= 6 ? 6 : video.Duration);
var addAnimatedThumbnailsToVideoResult = await _addAnimatedThumbnailsToVideoService.ExecuteAsync(addAnimatedThumbnailsToVideoRequest);
var pictureId = addAnimatedThumbnailsToVideoResult?.Data?.PictureId;
if (string.IsNullOrEmpty(pictureId))
{
_logger.LogError($"Creating Animated Thumbnails Error!");
_logger.LogError($"StatusCode: {addAnimatedThumbnailsToVideoResult?.Code}");
_logger.LogError($"Error: {addAnimatedThumbnailsToVideoResult?.Text}");
return(null);
}
var statusAnimatedThumbnails = string.Empty;
var getStatusAnimatedThumbnailRequest = new GetAnimatedThumbnailRequest(videoId, pictureId);
while (statusAnimatedThumbnails != "completed")
{
var statusResult = await _getStatusAnimatedThumbnailService.ExecuteAsync(getStatusAnimatedThumbnailRequest);
if (statusResult.Code == System.Net.HttpStatusCode.InternalServerError || statusResult.Code == System.Net.HttpStatusCode.Unauthorized || statusResult.Code == System.Net.HttpStatusCode.NotFound)
{
statusAnimatedThumbnails = string.Empty;
}
else
{
statusAnimatedThumbnails = statusResult.Data.Status;
}
_sleepService.Sleep(5 * 1000);
}
var getAnimatedThumbnailResult = await _getAnimatedThumbnailService.ExecuteAsync(getStatusAnimatedThumbnailRequest);
_logger.LogInformation($"Creating Animated Thumbnails Done!");
return(getAnimatedThumbnailResult.Data);
}
public override async Task <HttpResponse <bool> > ExecuteAsync(UploadSubtitleToVideoRequest request, CancellationToken cancellationToken = default)
{
try
{
var videoResponse = await _getVideoService.ExecuteAsync(request.VideoId, cancellationToken);
if (videoResponse == null)
{
return(new HttpResponse <bool>(false, HttpStatusCode.InternalServerError));
}
if (videoResponse.Code != System.Net.HttpStatusCode.OK)
{
return(new HttpResponse <bool>(false, videoResponse.Code));
}
var video = videoResponse.Data;
var textTracksUri = video?.Metadata?.Connections?.Texttracks?.Uri;
var getUploadLinkTextTrackRequest = new GetUploadLinkTextTrackRequest(textTracksUri, Models.TextTrackType.TextTrackEnum.Subtitles);
var getUploadLinkTextTrackresponse = await _getUploadLinkTextTrackService.ExecuteAsync(getUploadLinkTextTrackRequest, cancellationToken);
if (getUploadLinkTextTrackresponse.Code != System.Net.HttpStatusCode.OK && getUploadLinkTextTrackresponse.Code != System.Net.HttpStatusCode.Created)
{
return(new HttpResponse <bool>(false, getUploadLinkTextTrackresponse.Code));
}
var uploadTextTrackFileRequest = new UploadTextTrackFileRequest(getUploadLinkTextTrackresponse?.Data?.Link, request.SubtitleFile);
var uploadTextTrackFileResponse = await _uploadTextTrackFileService.ExecuteAsync(uploadTextTrackFileRequest);
if (uploadTextTrackFileResponse.Code != System.Net.HttpStatusCode.OK)
{
return(new HttpResponse <bool>(false, uploadTextTrackFileResponse.Code));
}
var textTracksResponse = await _getAllTextTracksService.ExecuteAsync(request.VideoId);
if (textTracksResponse.Code != System.Net.HttpStatusCode.OK || textTracksResponse.Data == null || textTracksResponse.Data.Data == null || textTracksResponse.Data.Data.Count <= 0)
{
return(new HttpResponse <bool>(false, textTracksResponse.Code));
}
var activeTextTrackRequest = new ActiveTextTrackRequest(textTracksResponse.Data.Data[textTracksResponse.Data.Data.Count - 1].Uri);
var activeTextTrackServiceResponse = await _activeTextTrackService.ExecuteAsync(activeTextTrackRequest);
if (activeTextTrackServiceResponse.Code != System.Net.HttpStatusCode.OK)
{
return(new HttpResponse <bool>(false, activeTextTrackServiceResponse.Code));
}
return(new HttpResponse <bool>(true, System.Net.HttpStatusCode.OK));
}
catch (Exception exception)
{
_logger.LogError(exception);
return(HttpResponse <bool> .FromException(exception.Message));
}
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var video = await _getVideoService.ExecuteAsync(id);
if (video?.Data == null)
{
await _deleteVideoService.ExecuteAsync(id);
return(RedirectToPage("./Index"));
}
VideoToDelete = _mapper.Map <VideoModel>(video.Data);
return(Page());
}
public async Task UpdateVideosThumbnail(AppendOnlyStringList?messages)
{
var spec = new ArchiveVideoWithoutThumbnailSpec();
var videos = await _repositoryArchiveVideo.ListAsync(spec);
foreach (var video in videos)
{
try
{
var response = await _getVideoService.ExecuteAsync(video.VideoId);
if (response?.Data == null)
{
continue;
}
var existThumbsResponse = await _getAllAnimatedThumbnailService.ExecuteAsync(new GetAnimatedThumbnailRequest(long.Parse(video.VideoId !), null));
if (existThumbsResponse.Data.Total <= 0)
{
var getAnimatedThumbnailResult = await _createAnimatedThumbnailsService.ExecuteAsync(long.Parse(video.VideoId !));
if (getAnimatedThumbnailResult == null || response?.Data.IsPlayable == false)
{
continue;
}
video.AnimatedThumbnailUri = getAnimatedThumbnailResult.AnimatedThumbnailUri;
}
else
{
video.AnimatedThumbnailUri = existThumbsResponse.Data.Data.FirstOrDefault()?.AnimatedThumbnailUri;
}
await _repositoryArchiveVideo.UpdateAsync(video);
messages?.Append($"Video {video.VideoId} updated with Thumbnails.");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error on Thumbnails for Video {video.VideoId}: {ex.Message}");
}
}
}
public async Task <IActionResult> UpdateDescriptionAsync([FromForm] UpdateDescription updateDescription)
{
var video = await _getVideoService.ExecuteAsync(updateDescription.VideoId);
if (video?.Data == null)
{
return(NotFound($"Video Not Found {updateDescription.VideoId}"));
}
var oEmbed = await _getOEmbedVideoService.ExecuteAsync(video.Data.Link);
if (oEmbed?.Data == null)
{
return(NotFound($"Video Not Found {updateDescription.VideoId}"));
}
var spec = new ArchiveVideoByVideoIdSpec(updateDescription.VideoId !);
var archiveVideo = await _repository.GetBySpecAsync(spec);
if (archiveVideo == null)
{
return(NotFound($"Video Not Found {updateDescription.VideoId}"));
}
archiveVideo.Description = updateDescription.Description;
await _repository.UpdateAsync(archiveVideo);
await _repository.SaveChangesAsync();
var oEmbedViewModel = new OEmbedViewModel(oEmbed.Data);
oEmbedViewModel.VideoId = int.Parse(archiveVideo.VideoId !);
oEmbedViewModel.DescriptionMd = _markdownService.RenderHTMLFromMD(archiveVideo.Description);
oEmbedViewModel.Description = archiveVideo.Description;
oEmbedViewModel
.BuildHtml(video.Data.Link);
return(Ok(oEmbedViewModel));
}
public async Task ReturnsVideoTest()
{
var videoId = await _testFileHelper.UploadTest();
videoId.ShouldNotBe(0);
var response = await _getVideoService
.ExecuteAsync(videoId.ToString());
await _testFileHelper.DeleteTestFile(response.Data.ToString());
response.Data.ShouldNotBe(null);
}
public async Task <IActionResult> OnGet(string videoId, string?startTime = null)
{
var video = await _getVideoService.ExecuteAsync(videoId);
if (video?.Data == null)
{
return(NotFound($"Video Not Found {videoId}"));
}
var oEmbed = await _getOEmbedVideoService.ExecuteAsync(video.Data.Link);
if (oEmbed?.Data == null)
{
return(NotFound($"Video Not Found {videoId}"));
}
var videoSpec = new ArchiveVideoByVideoIdWithMemberFavoritesSpec(videoId);
var archiveVideo = await _repository.GetBySpecAsync(videoSpec);
if (archiveVideo == null)
{
return(NotFound($"Video Not Found {videoId}"));
}
archiveVideo.Views++;
await _repository.UpdateAsync(archiveVideo);
var currentUserName = User.Identity !.Name;
var applicationUser = await _userManager.FindByNameAsync(currentUserName);
var memberSpec = new MemberByUserIdWithFavoriteArchiveVideosSpec(applicationUser.Id);
var member = await _memberRepository.GetBySpecAsync(memberSpec);
if (member == null)
{
return(NotFound($"Member Not Found {applicationUser.Id}"));
}
OEmbedViewModel = new OEmbedViewModel(oEmbed.Data);
OEmbedViewModel.VideoId = int.Parse(archiveVideo.VideoId !);
OEmbedViewModel.Name = archiveVideo.Title;
OEmbedViewModel.Password = video.Data.Password;
OEmbedViewModel.DescriptionMd = _markdownService.RenderHTMLFromMD(archiveVideo.Description);
OEmbedViewModel.Description = archiveVideo.Description;
OEmbedViewModel
.AddStartTime(startTime)
.BuildHtml(video.Data.Link);
OEmbedViewModel.IsMemberFavorite = member.FavoriteArchiveVideos.Any(fav => fav.ArchiveVideoId == archiveVideo.Id);
OEmbedViewModel.MemberFavoritesCount = archiveVideo.MemberFavorites.Count();
return(Page());
}
public async Task UpdateAnimatedThumbnailsAsync(string vimeoId)
{
_logger.LogInformation("UpdateAnimatedThumbnailsAsync Started");
var response = await _getVideoService.ExecuteAsync(vimeoId);
if (response?.Code != HttpStatusCode.OK)
{
_logger.LogInformation("Video Does Not Exist on Vimeo!");
_logger.LogError($"Vimeo ID: {vimeoId} Update Animated Thumbnails getVideoService Error!");
_logger.LogError($"Error: HTTP {response?.Code} {response?.Text}");
return;
}
var archiveVideo = new ArchiveVideo
{
VideoId = vimeoId
};
var getAnimatedThumbnailResult = await CreateAnimatedThumbnails(long.Parse(vimeoId));
_logger.LogDebug($"AnimatedThumbnailUri: {getAnimatedThumbnailResult.AnimatedThumbnailUri}");
archiveVideo.AnimatedThumbnailUri = getAnimatedThumbnailResult.AnimatedThumbnailUri;
var updateVideoThumbnailsResponse = await _updateVideoThumbnails.ExecuteAsync(archiveVideo);
if (updateVideoThumbnailsResponse == null || updateVideoThumbnailsResponse.Code != HttpStatusCode.OK)
{
_logger.LogError($"{vimeoId} Update Animated Thumbnails _updateVideoThumbnails Error!");
_logger.LogError($"Error: HTTP {updateVideoThumbnailsResponse?.Code} {updateVideoThumbnailsResponse?.Text}");
return;
}
_logger.LogInformation($"{vimeoId} Is Updated.");
}
public async Task ReturnsSuccessAddAnimatedThumbnailsTest()
{
var videoId = await _testFileHelper.UploadTest();
videoId.ShouldNotBe(0);
Video video = new Video();
while (video.Status != "available")
{
Thread.Sleep(20 * 1000);
video = (await _getVideoService.ExecuteAsync(videoId.ToString())).Data;
}
var request = new AddAnimatedThumbnailsToVideoRequest(videoId, START_TIME, DURATION);
var result = await _addAnimatedThumbnailsToVideoService.ExecuteAsync(request);
result.ShouldNotBeNull();
result.Code.ShouldNotBe(HttpStatusCode.BadRequest);
var status = string.Empty;
var getStatusAnimatedThumbnailRequest = new GetAnimatedThumbnailRequest(videoId, result.Data.PictureId);
while (status != "completed")
{
var statusResult = await _getStatusAnimatedThumbnailService.ExecuteAsync(getStatusAnimatedThumbnailRequest);
statusResult.Code.ShouldNotBe(HttpStatusCode.BadRequest);
status = statusResult.Data.Status;
Thread.Sleep(5 * 1000);
}
var getAnimatedThumbnailResult = await _getAnimatedThumbnailService.ExecuteAsync(getStatusAnimatedThumbnailRequest);
getAnimatedThumbnailResult.Code.ShouldNotBe(HttpStatusCode.BadRequest);
var deleteResult = await _testFileHelper.DeleteTestFile(videoId.ToString());
deleteResult.ShouldBe(System.Net.HttpStatusCode.NoContent);
}