private async Task <bool> ExecuteApiRequest(IApiRequest request, params HttpStatusCode[] validStatusCodes)
{
try
{
IRestResponse response = await request.ExecuteRequestAsync();
// if request was successful, return immediately...
if (IsSuccessStatusCode(response.StatusCode))
{
return(true);
}
// if request is among other accepted status codes, return the corresponding value...
if (validStatusCodes != null && validStatusCodes.Contains(response.StatusCode))
{
return(true);
}
// at this point, we've eliminated all acceptable responses, throw an exception...
throw new VimeoApiException(string.Format("{1}{0}Code: {2}{0}Message: {3}",
Environment.NewLine,
"Error retrieving information from Vimeo API.",
response.StatusCode,
response.Content
));
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving information from Vimeo API.", ex);
}
}
/// <summary>
/// Get text track asynchronously
/// </summary>
/// <param name="videoId">VideoId</param>
/// <param name="trackId">TrackId</param>
/// <returns>Return text track</returns>
public async Task <TextTrack> GetTextTrackAsync(long videoId, long trackId)
{
try
{
IApiRequest request = GenerateTextTracksRequest(videoId, trackId);
IRestResponse <TextTrack> response = await request.ExecuteRequestAsync <TextTrack>();
UpdateRateLimit(response);
CheckStatusCodeError(response, "Error retrieving text track for video.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving text track for video.", ex);
}
}
/// <summary>
/// Upload new text track file asynchronously
/// </summary>
/// <param name="fileContent">File content</param>
/// <param name="videoId">VideoId</param>
/// <param name="track">Track</param>
/// <returns>New text track</returns>
public async Task <TextTrack> UploadTextTrackFileAsync(IBinaryContent fileContent, long videoId, TextTrack track)
{
if (!fileContent.Data.CanRead)
{
throw new ArgumentException("fileContent should be readable");
}
if (fileContent.Data.CanSeek && fileContent.Data.Position > 0)
{
fileContent.Data.Position = 0;
}
TextTrack ticket = await GetUploadTextTrackTicketAsync(videoId, track);
IApiRequest request = ApiRequestFactory.GetApiRequest();
request.Method = Method.PUT;
request.ExcludeAuthorizationHeader = true;
request.Path = ticket.link;
request.Headers.Add(Request.HeaderContentType, fileContent.ContentType);
request.Headers.Add(Request.HeaderContentLength, fileContent.Data.Length.ToString());
request.BinaryContent = await fileContent.ReadAllAsync();
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(null, response, "Error uploading text track file.", HttpStatusCode.BadRequest);
return(ticket);
}
public async Task CompleteFileUploadAsync(IUploadRequest uploadRequest)
{
ThrowIfUnauthorized();
try
{
IApiRequest request = GenerateCompleteUploadRequest(uploadRequest.Ticket);
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(uploadRequest, response, "Error marking file upload as complete.");
Parameter locationHeader =
response.Headers.FirstOrDefault(h => string.Compare(h.Name, "Location", true) == 0);
if (locationHeader != null && locationHeader.Value != null)
{
uploadRequest.ClipUri = locationHeader.Value as string;
}
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error marking file upload as complete.", uploadRequest, ex);
}
}
/// <summary>
/// Get all thumbnails on a video
/// </summary>
/// <param name="clipId"></param>
/// <returns></returns>
public async Task <Paginated <Picture> > GetPicturesAsync(long clipId)
{
try
{
ThrowIfUnauthorized();
IApiRequest request = ApiRequestFactory.GetApiRequest(AccessToken);
request.Method = HttpMethod.Get;
request.Path = Endpoints.Pictures;
request.UrlSegments.Add("clipId", clipId.ToString());
var response = await request.ExecuteRequestAsync <Paginated <Picture> >();
UpdateRateLimit(response);
CheckStatusCodeError(response, "Error retrieving video picture.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
return(response.Content);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving video picture.", ex);
}
}
/// <summary>
/// Get video from album by AlbumId and ClipId asynchronously
/// </summary>
/// <param name="albumId">AlbumId</param>
/// <param name="clipId">ClipId</param>
/// <returns>Video</returns>
public async Task <Video> GetAlbumVideoAsync(long albumId, long clipId)
{
try
{
IApiRequest request = GenerateAlbumVideosRequest(albumId, clipId: clipId);
IRestResponse <Video> response = await request.ExecuteRequestAsync <Video>();
UpdateRateLimit(response);
CheckStatusCodeError(response, "Error retrieving user album video.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving user album video.", ex);
}
}
// Added 28/07/2015
public async Task <Paginated <Video> > GetAlbumVideosAsync(long albumId, int?page, int?perPage, string sort = null, string direction = null)
{
try
{
IApiRequest request = GenerateAlbumVideosRequest(albumId, page: page, perPage: perPage, sort: sort, direction: direction);
IRestResponse <Paginated <Video> > response = await request.ExecuteRequestAsync <Paginated <Video> >();
CheckStatusCodeError(response, "Error retrieving account album videos.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(new Paginated <Video>
{
data = new List <Video>(),
page = 0,
total = 0
});
}
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving account album videos.", ex);
}
}
public async Task <Paginated <Video> > GetUserVideosAsync(long userId)
{
try
{
IApiRequest request = GenerateVideosRequest(userId: userId);
IRestResponse <Paginated <Video> > response = await request.ExecuteRequestAsync <Paginated <Video> >();
CheckStatusCodeError(response, "Error retrieving user videos.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(new Paginated <Video>
{
data = new List <Video>(),
page = 0,
total = 0
});
}
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving user videos.", ex);
}
}
public async Task <VerifyUploadResponse> VerifyUploadFileAsync(IUploadRequest uploadRequest)
{
try
{
IApiRequest request =
await GenerateFileStreamRequest(uploadRequest.File, uploadRequest.Ticket, verifyOnly : true);
IRestResponse response = await request.ExecuteRequestAsync();
var verify = new VerifyUploadResponse();
CheckStatusCodeError(uploadRequest, response, "Error verifying file upload.", (HttpStatusCode)308);
if (response.StatusCode == HttpStatusCode.OK)
{
verify.BytesWritten = uploadRequest.FileLength;
verify.Status = UploadStatusEnum.Completed;
}
else if (response.StatusCode == (HttpStatusCode)308)
{
verify.Status = UploadStatusEnum.InProgress;
int startIndex = 0;
int endIndex = 0;
Parameter rangeHeader =
response.Headers.FirstOrDefault(h => string.Compare(h.Name, "Range", true) == 0);
if (rangeHeader != null && rangeHeader.Value != null)
{
Match match = _rangeRegex.Match(rangeHeader.Value as string);
if (match.Success &&
int.TryParse(match.Groups["start"].Value, out startIndex) &&
int.TryParse(match.Groups["end"].Value, out endIndex))
{
verify.BytesWritten = endIndex - startIndex;
if (verify.BytesWritten == uploadRequest.FileLength)
{
verify.Status = UploadStatusEnum.Completed;
}
}
}
}
else
{
verify.Status = UploadStatusEnum.NotFound;
}
return(verify);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error verifying file upload.", uploadRequest, ex);
}
}
public async Task <VerifyUploadResponse> ContinueUploadFileAsync(IUploadRequest uploadRequest)
{
if (uploadRequest.AllBytesWritten)
{
// Already done, there's nothing to do.
return(new VerifyUploadResponse
{
Status = UploadStatusEnum.InProgress,
BytesWritten = uploadRequest.BytesWritten
});
}
try
{
IApiRequest request = await GenerateFileStreamRequest(uploadRequest.File, uploadRequest.Ticket,
chunkSize : uploadRequest.ChunkSize, written : uploadRequest.BytesWritten);
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(uploadRequest, response, "Error uploading file chunk.", HttpStatusCode.BadRequest);
if (response.StatusCode == HttpStatusCode.BadRequest)
{
// something went wrong, figure out where we need to start over
return(await VerifyUploadFileAsync(uploadRequest));
}
// Success, update total written
uploadRequest.BytesWritten += uploadRequest.ChunkSize;
uploadRequest.BytesWritten = Math.Min(uploadRequest.BytesWritten, uploadRequest.FileLength);
return(new VerifyUploadResponse
{
Status = UploadStatusEnum.InProgress,
BytesWritten = uploadRequest.BytesWritten
});
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error uploading file chunk", uploadRequest, ex);
}
}
public async Task AddTagToVideoAsync(long clipId, string tag)
{
try
{
IApiRequest request = GenerateAddTagRequest(clipId, tag);
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(response, "Error adding tag to video.");
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error tagging video.", ex);
}
}
public async Task UpdateVideoAllowedDomainAsync(long clipId, string domain)
{
try
{
IApiRequest request = GenerateVideoAllowedDomainPatchRequest(clipId, domain);
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(response, "Error updating user video allowed domain.");
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error updating user video metadata.", ex);
}
}
public async Task UpdateVideoMetadataAsync(long clipId, VideoUpdateMetadata metaData)
{
try
{
IApiRequest request = GenerateVideoPatchRequest(clipId, metaData);
IRestResponse response = await request.ExecuteRequestAsync();
CheckStatusCodeError(response, "Error updating user video metadata.");
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error updating user video metadata.", ex);
}
}
/// <summary>
/// Delete text track asynchronously
/// </summary>
/// <param name="videoId">VideoId</param>
/// <param name="trackId">TrackId</param>
/// <returns></returns>
public async Task DeleteTextTrackAsync(long videoId, long trackId)
{
try
{
IApiRequest request = GenerateDeleteTextTrackRequest(videoId, trackId);
IRestResponse <TextTrack> response = await request.ExecuteRequestAsync <TextTrack>();
UpdateRateLimit(response);
CheckStatusCodeError(response, "Error updating text track for video.", HttpStatusCode.NotFound);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error updating text track for video.", ex);
}
}
/// <summary>
/// Delete video asynchronously
/// </summary>
/// <param name="clipId">CliepId</param>
public async Task DeleteVideoAsync(long clipId)
{
try
{
IApiRequest request = GenerateVideoDeleteRequest(clipId);
IRestResponse response = await request.ExecuteRequestAsync();
UpdateRateLimit(response);
CheckStatusCodeError(response, "Error deleting video.");
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error updating user video metadata.", ex);
}
}
public async Task <User> GetAccountInformationAsync()
{
try
{
IApiRequest request = GenerateUserInformationRequest();
IRestResponse <User> response = await request.ExecuteRequestAsync <User>();
CheckStatusCodeError(response, "Error retrieving account information.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving account information.", ex);
}
}
public async Task <UploadTicket> GetUploadTicketAsync()
{
try
{
IApiRequest request = GenerateUploadTicketRequest();
IRestResponse <UploadTicket> response = await request.ExecuteRequestAsync <UploadTicket>();
CheckStatusCodeError(null, response, "Error generating upload ticket.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error generating upload ticket.", null, ex);
}
}
public async Task <Paginated <Video> > GetAlbumVideosAsync(long albumId)
{
try
{
IApiRequest request = GenerateAlbumVideosRequest(albumId);
IRestResponse <Paginated <Video> > response = await request.ExecuteRequestAsync <Paginated <Video> >();
CheckStatusCodeError(response, "Error retrieving account album videos.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving account album videos.", ex);
}
}
public async Task <Paginated <Video> > GetVideosAsync(int?page = null, int?perPage = null)
{
try
{
IApiRequest request = GenerateVideosRequest(page: page, perPage: perPage);
IRestResponse <Paginated <Video> > response = await request.ExecuteRequestAsync <Paginated <Video> >();
CheckStatusCodeError(response, "Error retrieving account videos.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving account videos.", ex);
}
}
/// <summary>
/// Create new upload ticket for replace video asynchronously
/// </summary>
/// <param name="videoId">VideoId</param>
/// <returns>Upload ticket</returns>
public async Task <UploadTicket> GetReplaceVideoUploadTicketAsync(long videoId)
{
try
{
IApiRequest request = GenerateReplaceVideoUploadTicketRequest(videoId);
IRestResponse <UploadTicket> response = await request.ExecuteRequestAsync <UploadTicket>();
UpdateRateLimit(response);
CheckStatusCodeError(null, response, "Error generating upload ticket to replace video.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error generating upload ticket to replace video.", null, ex);
}
}
/// <summary>
/// Utility method for performing API requests that retrieve data in a consistent manner.
///
/// The given request will be performed, and if the response is an outright success then
/// the response data will be unwrapped and returned.
///
/// If the call is not an outright success, but the status code is among the other acceptable
/// results (provided via validStatusCodes), the getValueForStatusCode method will be called
/// to generate a return value. This allows the caller to return null or an empty list as
/// desired.
///
/// If neither of the above is possible, an exception will be thrown.
/// </summary>
/// <typeparam name="T">Type of the expected response data.</typeparam>
/// <param name="request"></param>
/// <param name="getValueForStatusCode"></param>
/// <param name="validStatusCodes"></param>
/// <returns></returns>
private async Task <T> ExecuteApiRequest <T>(IApiRequest request, Func <HttpStatusCode, T> getValueForStatusCode,
params HttpStatusCode[] validStatusCodes) where T : new()
{
try
{
var response = await request.ExecuteRequestAsync <T>().ConfigureAwait(false);
UpdateRateLimit(response);
// if request was successful, return immediately...
if (IsSuccessStatusCode(response.StatusCode))
{
return(response.Content);
}
// if request is among other accepted status codes, return the corresponding value...
if (validStatusCodes != null && validStatusCodes.Contains(response.StatusCode))
{
return(getValueForStatusCode(response.StatusCode));
}
// at this point, we've eliminated all acceptable responses, throw an exception...
throw new VimeoApiException(string.Format("{1}{0}Code: {2}{0}Message: {3}",
Environment.NewLine,
"Error retrieving information from Vimeo API.",
response.StatusCode,
response.Text
));
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving information from Vimeo API.", ex);
}
}
private async Task <TextTrack> GetUploadTextTrackTicketAsync(long clipId, TextTrack track)
{
try
{
IApiRequest request = GenerateUploadTextTrackTicketRequest(clipId, track);
IRestResponse <TextTrack> response = await request.ExecuteRequestAsync <TextTrack>();
UpdateRateLimit(response);
CheckStatusCodeError(null, response, "Error generating upload text track ticket.");
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error generating upload text track ticket.", null, ex);
}
}
/// <summary>
/// set thumbnail picture asynchronously
/// </summary>
/// <param name="link">link</param>
/// <returns>Set thumbnail pic </returns>
public async Task SetThumbnailActiveAsync(string link)
{
try
{
ThrowIfUnauthorized();
IApiRequest request = ApiRequestFactory.GetApiRequest(AccessToken);
request.Method = new HttpMethod("PATCH");
request.Path = link;
request.Query.Add("active", "true");
var response = await request.ExecuteRequestAsync();
CheckStatusCodeError(null, response, "Error Setting thumbnail image active.");
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoUploadException("Error Setting thumbnail image active.", null, ex);
}
}
public async Task <User> GetUserInformationAsync(long userId)
{
try
{
IApiRequest request = GenerateUserInformationRequest(userId);
IRestResponse <User> response = await request.ExecuteRequestAsync <User>();
CheckStatusCodeError(response, "Error retrieving user information.", HttpStatusCode.NotFound);
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
return(response.Data);
}
catch (Exception ex)
{
if (ex is VimeoApiException)
{
throw;
}
throw new VimeoApiException("Error retrieving user information.", ex);
}
}