/// <summary>
/// Constructs a web request to set a page blob's sequence number.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="sequenceNumberAction">A value of type <see cref="SequenceNumberAction"/>, indicating the operation to perform on the sequence number.</param>
/// <param name="sequenceNumber">The sequence number. Set this parameter to <c>null</c> if this operation is an increment action.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage SetSequenceNumber(Uri uri, int?timeout, SequenceNumberAction sequenceNumberAction, long?sequenceNumber, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
CommonUtility.AssertInBounds("sequenceNumberAction", sequenceNumberAction, SequenceNumberAction.Max, SequenceNumberAction.Increment);
if (sequenceNumberAction == SequenceNumberAction.Increment)
{
if (sequenceNumber.HasValue)
{
throw new ArgumentException(SR.BlobInvalidSequenceNumber, "sequenceNumber");
}
}
else
{
CommonUtility.AssertNotNull("sequenceNumber", sequenceNumber);
CommonUtility.AssertInBounds("sequenceNumber", sequenceNumber.Value, 0);
}
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.Headers.Add(Constants.HeaderConstants.SequenceNumberAction, sequenceNumberAction.ToString());
if (sequenceNumberAction != SequenceNumberAction.Increment)
{
request.Headers.Add(Constants.HeaderConstants.BlobSequenceNumber, sequenceNumber.Value.ToString());
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Delete(Uri uri, int?timeout, DateTimeOffset?snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if ((snapshot != null) && (deleteSnapshotsOption != DeleteSnapshotsOption.None))
{
throw new InvalidOperationException(string.Format(SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
}
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, builder, content, operationContext);
switch (deleteSnapshotsOption)
{
case DeleteSnapshotsOption.None:
break; // nop
case DeleteSnapshotsOption.IncludeSnapshots:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.IncludeSnapshotsValue);
break;
case DeleteSnapshotsOption.DeleteSnapshotsOnly:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.SnapshotsOnlyValue);
break;
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to set user-defined metadata for the blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage SetMetadata(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.SetMetadata(uri, timeout, null /* builder */, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the ACL for a container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns><returns>A web request to use to perform the operation.</returns></returns>
public static HttpRequestMessage GetAcl(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.GetAcl(uri, timeout, GetContainerUriQueryBuilder(), content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="blobType">The type of the blob.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Put(Uri uri, int?timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext);
if (properties.CacheControl != null)
{
request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl);
}
if (content != null)
{
if (properties.ContentType != null)
{
content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType);
}
if (properties.ContentMD5 != null)
{
content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
content.Headers.ContentLanguage.Add(properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
content.Headers.ContentEncoding.Add(properties.ContentEncoding);
}
if (properties.ContentDisposition != null)
{
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition);
}
}
if (blobType == BlobType.PageBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = pageBlobSize;
}
else if (blobType == BlobType.BlockBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
}
else
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.AppendBlob);
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to get the file's content, properties, and metadata.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage Get(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, null /* builder */, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to set the ACL for a share.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="publicAccess">The type of public access to allow for the share.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns><returns>A web request to use to perform the operation.</returns></returns>
public static HttpRequestMessage SetAcl(Uri uri, int?timeout, FileSharePublicAccessType publicAccess, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, GetShareUriQueryBuilder(), content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to delete the directory and all of the files within it.
/// </summary>
/// <param name="uri">The absolute URI to the directory.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Delete(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, directoryBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates a web request to set user-defined metadata for the container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage SetMetadata(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.SetMetadata(uri, timeout, containerBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates a web request to return the properties and user-defined metadata for this share.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetProperties(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
HttpRequestMessage request = HttpRequestMessageFactory.GetProperties(uri, timeout, shareBuilder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates a web request to copy a blob.
/// </summary>
/// <param name="uri">The absolute URI to the destination blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="source">The absolute URI to the source blob, including any necessary authentication parameters.</param>
/// <param name="sourceAccessCondition">The access condition to apply to the source blob.</param>
/// <param name="destAccessCondition">The access condition to apply to the destination blob.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage CopyFrom(Uri uri, int?timeout, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext);
request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, source.AbsoluteUri);
request.ApplyAccessCondition(destAccessCondition);
request.ApplyAccessConditionToSource(sourceAccessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to create a snapshot of a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Snapshot(Uri uri, int?timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "snapshot");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the user-defined metadata for the blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage GetMetadata(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to set the ACL for a container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="publicAccess">The type of public access to allow for the container.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns><returns>A web request to use to perform the operation.</returns></returns>
public static HttpRequestMessage SetAcl(Uri uri, int?timeout, BlobContainerPublicAccessType publicAccess, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, GetContainerUriQueryBuilder(), content, operationContext);
if (publicAccess != BlobContainerPublicAccessType.Off)
{
request.Headers.Add(Constants.HeaderConstants.ContainerPublicAccessType, publicAccess.ToString().ToLower());
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to resize a page blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="newBlobSize">The new blob size, if the blob is a page blob. Set this parameter to <c>null</c> to keep the existing blob size.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Resize(Uri uri, int?timeout, long newBlobSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, newBlobSize.ToString(NumberFormatInfo.InvariantInfo));
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the list of blocks for a block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="typesOfBlocks">The types of blocks to include in the list: committed, uncommitted, or both.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage GetBlockList(Uri uri, int?timeout, DateTimeOffset?snapshot, BlockListingFilter typesOfBlocks, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
builder.Add("blocklisttype", typesOfBlocks.ToString());
BlobHttpRequestMessageFactory.AddSnapshot(builder, snapshot);
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to get the blob's content, properties, and metadata.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage Get(Uri uri, int?timeout, DateTimeOffset?snapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
if (snapshot.HasValue)
{
builder.Add("snapshot", Request.ConvertDateTimeToSnapshotString(snapshot.Value));
}
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to write or clear a range of pages in a page blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The blob's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage PutPage(Uri uri, int?timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "page");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.AddOptionalHeader(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates a web request to abort a copy operation.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="copyId">The ID string of the copy operation to be aborted.</param>
/// <param name="accessCondition">The access condition to apply to the request.
/// Only lease conditions are supported for this operation.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage AbortCopy(Uri uri, int?timeout, string copyId, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "copy");
builder.Add(Constants.QueryConstants.CopyId, copyId);
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.Headers.Add(Constants.HeaderConstants.CopyActionHeader, Constants.HeaderConstants.CopyActionAbort);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to return the list of valid ranges for a file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="offset">The starting offset of the data range over which to list file ranges, in bytes.</param>
/// <param name="count">The length of the data range over which to list file ranges, in bytes.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage ListRanges(Uri uri, int?timeout, long?offset, long?count, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (offset.HasValue)
{
CommonUtility.AssertNotNull("count", count);
}
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "rangelist");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Get, uri, timeout, builder, content, operationContext);
AddRange(request, offset, count);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Generates a web request to use to acquire, renew, change, release or break the lease for the container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="action">The lease action to perform.</param>
/// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation,
/// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param>
/// <param name="leaseDuration">The lease duration, in seconds, for acquire operations.
/// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param>
/// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken.
/// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Lease(Uri uri, int?timeout, LeaseAction action, string proposedLeaseId, int?leaseDuration, int?leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = GetContainerUriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "lease");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
// Add Headers
BlobHttpRequestMessageFactory.AddLeaseAction(request, action);
BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration);
BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId);
BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to create or update a blob by committing a block list.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request for performing the operation.</returns>
public static HttpRequestMessage PutBlockList(Uri uri, int?timeout, BlobProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "blocklist");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.AddOptionalHeader(Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to set system properties for a share.
/// </summary>
/// <param name="uri">The absolute URI to the share.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The share's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage SetProperties(Uri uri, int?timeout, FileShareProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
shareBuilder.Add(Constants.QueryConstants.Component, "properties");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, shareBuilder, content, operationContext);
if (properties.Quota.HasValue)
{
request.AddOptionalHeader(Constants.HeaderConstants.ShareQuota, properties.Quota.Value);
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to create a new file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the file.</param>
/// <param name="fileSize">For a file, the size of the file. This parameter is ignored
/// for block files.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Create(Uri uri, int?timeout, FileProperties properties, long fileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext);
if (properties.CacheControl != null)
{
request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl);
}
if (content != null)
{
if (properties.ContentType != null)
{
content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType);
}
if (properties.ContentMD5 != null)
{
content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
content.Headers.ContentLanguage.Add(properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
content.Headers.ContentEncoding.Add(properties.ContentEncoding);
}
if (properties.ContentDisposition != null)
{
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition);
}
}
request.Headers.Add(Constants.HeaderConstants.FileType, Constants.HeaderConstants.File);
request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, fileSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = fileSize;
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Constructs a web request to set system properties for a file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The file's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage SetProperties(Uri uri, int?timeout, FileProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType);
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
