/// <inheritdoc /> 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; } var ticket = await GetUploadTextTrackTicketAsync(videoId, track).ConfigureAwait(false); var request = _apiRequestFactory.GetApiRequest(); request.Method = HttpMethod.Put; request.ExcludeAuthorizationHeader = true; request.Path = ticket.Link; request.Body = new ByteArrayContent(await fileContent.ReadAllAsync().ConfigureAwait(false)); var response = await request.ExecuteRequestAsync().ConfigureAwait(false); CheckStatusCodeError(null, response, "Error uploading text track file.", HttpStatusCode.BadRequest); return(ticket); }
/// <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 <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long?replaceVideoId = null) { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } UploadTicket ticket = replaceVideoId.HasValue ? await GetReplaceVideoUploadTicketAsync(replaceVideoId.Value) : await GetUploadTicketAsync(); var uploadRequest = new UploadRequest { Ticket = ticket, File = fileContent, ChunkSize = chunkSize }; VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest); return(uploadRequest); }
/// <summary> /// upload picture asynchronously /// </summary> /// <param name="fileContent">fileContent</param> /// <returns>upload pic </returns> public async Task <Picture> UploadPictureAsync(IBinaryContent fileContent, long clipId) { try { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } ThrowIfUnauthorized(); var request = ApiRequestFactory.GetApiRequest(AccessToken); request.Method = HttpMethod.Post; request.Path = Endpoints.Pictures; request.UrlSegments.Add("clipId", clipId.ToString()); request.Body = new ByteArrayContent(await fileContent.ReadAllAsync()); var response = await request.ExecuteRequestAsync <Picture>(); CheckStatusCodeError(null, response, "Error generating upload ticket to replace video."); return(response.Content); } catch (Exception ex) { if (ex is VimeoApiException) { throw; } throw new VimeoUploadException("Error Uploading picture.", null, ex); } }
public async Task <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } UploadTicket ticket = await GetUploadTicketAsync(); var uploadRequest = new UploadRequest { Ticket = ticket, File = fileContent, ChunkSize = chunkSize }; VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest); uploadRequest.BytesWritten = uploadStatus.BytesWritten; return(uploadRequest); }
/// <summary> /// Start upload file asynchronously /// </summary> /// <param name="fileContent">FileContent</param> /// <param name="chunkSize">ChunkSize</param> /// <param name="replaceVideoId">ReplaceVideoId</param> /// <returns></returns> private async Task <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent, int chunkSize = DefaultUploadChunkSize, long?replaceVideoId = null) { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } var ticket = replaceVideoId.HasValue ? await GetReplaceVideoUploadTicketAsync(replaceVideoId.Value).ConfigureAwait(false) : await GetUploadTicketAsync().ConfigureAwait(false); var uploadRequest = new UploadRequest { Ticket = ticket, File = fileContent, ChunkSize = chunkSize }; return(uploadRequest); }
static public async Task <AES256WithKey> Encrypt(IContentContext context, IBinaryContent keyData, Content content) { var result = new AES256WithKey() { Key = keyData }; await result.Create(await keyData.GetBinContent(context), content.Serialize()); return(result); }
public IUploadRequest UploadEntireFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long?replaceVideoId = null) { try { return(UploadEntireFileAsync(fileContent, chunkSize, replaceVideoId).RunSynchronouslyWithCurrentCulture()); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); } return(null); }
public IUploadRequest UploadEntireFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { try { return(Task.Run(async() => await UploadEntireFileAsync(fileContent, chunkSize)).Result); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); } }
public IUploadRequest StartUploadFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { try { return(StartUploadFileAsync(fileContent, chunkSize).RunSynchronouslyWithCurrentCulture()); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); } }
public Picture UploadThumbnail(long clipId, IBinaryContent fileContent) { try { var pic = UploadPictureAsync(fileContent, clipId).RunSynchronouslyWithCurrentCulture(); SetThumbnailActiveAsync(pic.uri).RunSynchronouslyWithCurrentCulture(); return(pic); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); } }
private async Task <IApiRequest> GenerateFileStreamRequest(IBinaryContent fileContent, UploadTicket ticket, long written = 0, int?chunkSize = null, bool verifyOnly = false) { if (string.IsNullOrWhiteSpace(ticket?.TicketId)) { throw new ArgumentException("Invalid upload ticket."); } if (fileContent.Data.Length > ticket.User.UploadQuota.Space.Free) { throw new InvalidOperationException( "User does not have enough free space to upload this video. Remaining space: " + ticket.Quota.FreeSpace + "."); } var request = _apiRequestFactory.GetApiRequest(); request.Method = HttpMethod.Put; request.ExcludeAuthorizationHeader = true; request.Path = ticket.UploadLinkSecure; if (verifyOnly) { var body = new ByteArrayContent(new byte[0]); body.Headers.Add("Content-Range", "bytes */*"); body.Headers.ContentLength = 0; request.Body = body; } else { if (chunkSize.HasValue) { var startIndex = fileContent.Data.CanSeek ? fileContent.Data.Position : written; var endIndex = Math.Min(startIndex + chunkSize.Value, fileContent.Data.Length); var byteArray = await fileContent.ReadAsync(startIndex, endIndex).ConfigureAwait(false); var body = new ByteArrayContent(byteArray, 0, byteArray.Length); body.Headers.Add("Content-Range", $"bytes {startIndex}-{endIndex}/*"); body.Headers.ContentLength = endIndex - startIndex; request.Body = body; } else { request.Body = new ByteArrayContent(await fileContent.ReadAllAsync().ConfigureAwait(false)); } } return(request); }
private async Task <IApiRequest> GenerateFileStreamRequest(IBinaryContent fileContent, UploadTicket ticket, long written = 0, int?chunkSize = null, bool verifyOnly = false) { if (ticket == null || string.IsNullOrWhiteSpace(ticket.ticket_id)) { throw new ArgumentException("Invalid upload ticket."); } if (fileContent.Data.Length > ticket.user.upload_quota.space.free) { throw new InvalidOperationException( "User does not have enough free space to upload this video. Remaining space: " + ticket.quota.free_space + "."); } IApiRequest request = _apiRequestFactory.GetApiRequest(); request.Method = Method.PUT; request.ExcludeAuthorizationHeader = true; request.Path = ticket.upload_link_secure; request.Headers.Add(Request.HeaderContentType, fileContent.ContentType); if (verifyOnly) { request.Headers.Add(Request.HeaderContentLength, "0"); request.Headers.Add(Request.HeaderContentRange, "bytes */*"); } else { if (chunkSize.HasValue) { long startIndex = fileContent.Data.CanSeek ? fileContent.Data.Position : written; long endIndex = Math.Min(startIndex + chunkSize.Value, fileContent.Data.Length); request.Headers.Add(Request.HeaderContentLength, (endIndex - startIndex).ToString()); request.Headers.Add(Request.HeaderContentRange, string.Format("bytes {0}-{1}/{2}", startIndex, endIndex, fileContent.Data.Length)); request.BinaryContent = await fileContent.ReadAsync(startIndex, endIndex); } else { request.Headers.Add(Request.HeaderContentLength, fileContent.Data.Length.ToString()); request.BinaryContent = await fileContent.ReadAllAsync(); } } return(request); }
/// <summary> /// Upload and set thumbnail active /// </summary> /// <param name="clipId"></param> /// <param name="fileContent"></param> /// <returns></returns> /// <exception cref="VimeoUploadException"></exception> public async Task <Picture> UploadThumbnailAsync(long clipId, IBinaryContent fileContent) { try { var pic = await UploadPictureAsync(fileContent, clipId); await SetThumbnailActiveAsync(pic.uri); return(pic); } catch (Exception ex) { if (ex is VimeoApiException) { throw; } throw new VimeoUploadException("Error generating upload ticket.", null, ex); } }
public async Task <IUploadRequest> UploadEntireFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long?replaceVideoId = null) { IUploadRequest uploadRequest = await StartUploadFileAsync(fileContent, chunkSize, replaceVideoId); VerifyUploadResponse uploadStatus = null; while (!uploadRequest.IsVerifiedComplete) { uploadStatus = await ContinueUploadFileAsync(uploadRequest); if (uploadRequest.AllBytesWritten) { // We presumably wrote all the bytes in the file, so verify with Vimeo that it // is completed uploadStatus = await VerifyUploadFileAsync(uploadRequest); if (uploadStatus.Status == UploadStatusEnum.Completed) { // If completed, mark file as complete await CompleteFileUploadAsync(uploadRequest); uploadRequest.IsVerifiedComplete = true; } else if (uploadStatus.BytesWritten == uploadRequest.FileLength) { // Supposedly all bytes are written, but Vimeo doesn't think so, so just // bail out throw new VimeoUploadException( string.Format( "Vimeo failed to mark file as completed, Bytes Written: {0:N0}, Expected: {1:N0}.", uploadStatus.BytesWritten), uploadRequest); } } } return(uploadRequest); }
private async Task <IApiRequest> GenerateFileStreamRequest(IBinaryContent fileContent, UploadTicket ticket, long written = 0, int?chunkSize = null, bool verifyOnly = false) { if (ticket == null || string.IsNullOrWhiteSpace(ticket.ticket_id)) { throw new ArgumentException("Invalid upload ticket."); } if (fileContent.Data.Length > ticket.user.upload_quota.space.free) { throw new InvalidOperationException( "User does not have enough free space to upload this video. Remaining space: " + ticket.quota.free_space + "."); } var request = ApiRequestFactory.GetApiRequest(); request.Method = HttpMethod.Put; request.ExcludeAuthorizationHeader = true; request.Path = ticket.upload_link_secure; if (verifyOnly) { request.Body = new ByteArrayContent(new byte [0]); } else { if (chunkSize.HasValue) { var startIndex = fileContent.Data.CanSeek ? fileContent.Data.Position : written; var endIndex = Math.Min(startIndex + chunkSize.Value, fileContent.Data.Length); request.Body = new ByteArrayContent(await fileContent.ReadAsync(startIndex, endIndex), (int)startIndex, (int)endIndex); } else { request.Body = new ByteArrayContent(await fileContent.ReadAllAsync()); } } return(request); }
/// <inheritdoc /> public async Task <IUploadRequest> UploadEntireFileAsync(IBinaryContent fileContent, int chunkSize = DefaultUploadChunkSize, long?replaceVideoId = null, Action <double> statusCallback = null) { var uploadRequest = await StartUploadFileAsync(fileContent, chunkSize, replaceVideoId).ConfigureAwait(false); while (!uploadRequest.IsVerifiedComplete) { var uploadStatus = await ContinueUploadFileAsync(uploadRequest).ConfigureAwait(false); statusCallback?.Invoke(Math.Round(((double)uploadStatus.BytesWritten / uploadRequest.FileLength) * 100)); if (uploadStatus.Status == UploadStatusEnum.InProgress) { continue; } // We presumably wrote all the bytes in the file, so verify with Vimeo that it // is completed uploadStatus = await VerifyUploadFileAsync(uploadRequest).ConfigureAwait(false); if (uploadStatus.Status == UploadStatusEnum.Completed) { // If completed, mark file as complete await CompleteFileUploadAsync(uploadRequest).ConfigureAwait(false); uploadRequest.IsVerifiedComplete = true; } else if (uploadStatus.BytesWritten == uploadRequest.FileLength) { // Supposedly all bytes are written, but Vimeo doesn't think so, so just // bail out throw new VimeoUploadException( $"Vimeo failed to mark file as completed, Bytes Written: {uploadStatus.BytesWritten:N0}, Expected: {uploadRequest.FileLength:N0}.", uploadRequest); } } return(uploadRequest); }
/// <summary> /// upload picture asynchronously /// </summary> /// <param name="fileContent">fileContent</param> /// <param name="link">link</param> /// <returns>upload pic </returns> public async Task UploadPictureAsync(IBinaryContent fileContent, string link) { try { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } ThrowIfUnauthorized(); var request = ApiRequestFactory.GetApiRequest(AccessToken); request.Method = HttpMethod.Put; request.Path = link; //request.Header.Add(Request.HeaderContentType, "image/jpeg"); //request.Headers.Add(Request.HeaderContentLength, fileContent.Data.Length.ToString()); request.Body = new ByteArrayContent(await fileContent.ReadAllAsync()); var response = await request.ExecuteRequestAsync(); 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 Uploading picture.", null, ex); } }
public IUploadRequest UploadEntireFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { try { return UploadEntireFileAsync(fileContent, chunkSize).RunSynchronouslyWithCurrentCulture(); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return null; } }
public IUploadRequest UploadEntireFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { try { return Task.Run(async () => await UploadEntireFileAsync(fileContent, chunkSize)).Result; } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return null; } }
private async Task<IApiRequest> GenerateFileStreamRequest(IBinaryContent fileContent, UploadTicket ticket, long written = 0, int? chunkSize = null, bool verifyOnly = false) { if (ticket == null || string.IsNullOrWhiteSpace(ticket.ticket_id)) { throw new ArgumentException("Invalid upload ticket."); } if (fileContent.Data.Length > ticket.user.upload_quota.space.free) { throw new InvalidOperationException( "User does not have enough free space to upload this video. Remaining space: " + ticket.quota.free_space + "."); } IApiRequest request = _apiRequestFactory.GetApiRequest(); request.Method = Method.PUT; request.ExcludeAuthorizationHeader = true; request.Path = ticket.upload_link_secure; request.Headers.Add(Request.HeaderContentType, fileContent.ContentType); if (verifyOnly) { request.Headers.Add(Request.HeaderContentLength, "0"); request.Headers.Add(Request.HeaderContentRange, "bytes */*"); } else { if (chunkSize.HasValue) { long startIndex = fileContent.Data.CanSeek ? fileContent.Data.Position : written; long endIndex = Math.Min(startIndex + chunkSize.Value, fileContent.Data.Length); request.Headers.Add(Request.HeaderContentLength, (endIndex - startIndex).ToString()); request.Headers.Add(Request.HeaderContentRange, string.Format("bytes {0}-{1}/{2}", startIndex, endIndex, fileContent.Data.Length)); request.BinaryContent = await fileContent.ReadAsync(startIndex, endIndex); } else { request.Headers.Add(Request.HeaderContentLength, fileContent.Data.Length.ToString()); request.BinaryContent = await fileContent.ReadAllAsync(); } } return request; }
public async Task<IUploadRequest> UploadEntireFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long? replaceVideoId = null) { IUploadRequest uploadRequest = await StartUploadFileAsync(fileContent, chunkSize, replaceVideoId); VerifyUploadResponse uploadStatus = null; while (!uploadRequest.IsVerifiedComplete) { uploadStatus = await ContinueUploadFileAsync(uploadRequest); if (uploadRequest.AllBytesWritten) { // We presumably wrote all the bytes in the file, so verify with Vimeo that it // is completed uploadStatus = await VerifyUploadFileAsync(uploadRequest); if (uploadStatus.Status == UploadStatusEnum.Completed) { // If completed, mark file as complete await CompleteFileUploadAsync(uploadRequest); uploadRequest.IsVerifiedComplete = true; } else if (uploadStatus.BytesWritten == uploadRequest.FileLength) { // Supposedly all bytes are written, but Vimeo doesn't think so, so just // bail out throw new VimeoUploadException( string.Format( "Vimeo failed to mark file as completed, Bytes Written: {0:N0}, Expected: {1:N0}.", uploadStatus.BytesWritten), uploadRequest); } } } return uploadRequest; }
public async Task<IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long? replaceVideoId = null) { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } UploadTicket ticket = replaceVideoId.HasValue ? await GetReplaceVideoUploadTicketAsync(replaceVideoId.Value) : await GetUploadTicketAsync(); var uploadRequest = new UploadRequest { Ticket = ticket, File = fileContent, ChunkSize = chunkSize }; VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest); return uploadRequest; }
public async Task<IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE) { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } UploadTicket ticket = await GetUploadTicketAsync(); var uploadRequest = new UploadRequest { Ticket = ticket, File = fileContent, ChunkSize = chunkSize }; VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest); uploadRequest.BytesWritten = uploadStatus.BytesWritten; return uploadRequest; }
public IUploadRequest StartUploadFile(IBinaryContent fileContent, int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE, long? replaceVideoId = null) { try { return StartUploadFileAsync(fileContent, chunkSize, replaceVideoId).RunSynchronouslyWithCurrentCulture(); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return null; } }
public override void Read(Util.DataDeserializer reader) { base.Read(reader); Key = Deserialize(reader) as IBinaryContent; }
/// <summary> /// upload picture asynchronously /// </summary> /// <param name="fileContent">fileContent</param> /// <param name="clipId">Clip Id</param> /// <returns>upload pic </returns> private async Task <string> UploadPictureAsync(IBinaryContent fileContent, long clipId) { try { if (!fileContent.Data.CanRead) { throw new ArgumentException("fileContent should be readable"); } if (fileContent.Data.CanSeek && fileContent.Data.Position > 0) { fileContent.Data.Position = 0; } // Get the URI of the thumbnail var request = _apiRequestFactory.GetApiRequest(AccessToken); request.Method = HttpMethod.Get; request.Path = Endpoints.Video; request.UrlSegments.Add("clipId", clipId.ToString()); var response = await request.ExecuteRequestAsync <Video>().ConfigureAwait(false); CheckStatusCodeError(null, response, "Error getting video settings."); // Get the upload link for the thumbnail var postRequest = _apiRequestFactory.AuthorizedRequest( AccessToken, HttpMethod.Post, response.Content.Metadata.Connections.Pictures.Uri, null ); var postResponse = await postRequest.ExecuteRequestAsync().ConfigureAwait(false); CheckStatusCodeError(null, postResponse, "Error posting thumbnail placeholder."); JObject.Parse(postResponse.Text).TryGetValue("link", out var link); JObject.Parse(postResponse.Text).TryGetValue("uri", out var uri); // Upload the thumbnail image file var putRequest = new NonApiRequest { Path = link.ToString(), Method = HttpMethod.Put, Body = new ByteArrayContent(await fileContent.ReadAllAsync().ConfigureAwait(false)) }; var putResponse = await putRequest.ExecuteRequestAsync().ConfigureAwait(false); CheckStatusCodeError(null, putResponse, "Error putting thumbnail data."); return(uri.ToString()); } catch (Exception ex) { if (ex is VimeoApiException) { throw; } throw new VimeoUploadException("Error Uploading picture.", null, ex); } }