text:
Home / Cities / Delhi News / With farmers blocking Singhu border, many truckers stranded on Kundli highway
With farmers blocking Singhu border, many truckers stranded on Kundli highway
The protest area spreads to more than four to five kilometres on the Kundli highway at the SInghu border while the queue of stuck vehicles and trucks stretches far beyond that.
Dozens of other drivers are stranded on the Kundli Highway with no place to go as they wait for the road blockade to end.(Yogesh Kumar/Hindustan Times (Representative image))
Hindustan Times, New Delhi | ByKainat Sarfaraz
It has been five days since Jaan Mohammad, 24, a truck driver, was stranded on the Kundli Highway near the Singhu border (connecting Haryana with Delhi) as thousands of farmers continued to camp on the road demanding the withdrawal of the Centre's new farm laws.
"I am the son of a farmer. I understand why farmers are protesting and I support them. But being stranded on the highway has become an ordeal for drivers like me," he said, even as at least a dozen others gathered around him nodded in agreement.
A resident of Dahej in Gujarat, Mohammad had travelled around 1,153km to his destination -- a plastic factory in the Kundli Industrial Area . He was scheduled to reach by November 27, but then the farmers' protest started and the Singhu border got blocked; his truck now stands parked merely two kilometres from its destination, unable to move an inch forward for the past five days.
Dozens of other drivers are similarly stranded on the Kundli Highway with no place to go as they wait for the road blockade to end. Since they cannot abandon their trucks laden with wares, the truckers are forced to live, eat, and sleep at the spot with the farmers. With nothing to do, groups of them could be spotted playing cards or watching protest videos on their phones on Tuesday.
Sadashiv Pandey, 48, who was to deliver thread spools to the Kundli Industrial Area on Friday, said, "While the farmers have been kind enough to feed us langar (community kitchen), it is at a little distance from where we are and so we rely on food from nearby hotels. This is increasing our daily expenses," he said.
Increasing daily expenses are not the only issue, say truckers. Karan Singh, 37, who was driving from Chandigarh to deliver chemicals at a factory in south-east Delhi's Okhla area, said the transport and logistics business would be hit if these trucks aren't able to make enough trips.
"A lot of truck owners have to pay EMIs. The lockdown had hit their business hard and they are already cash-strapped. How will they pay their loans if the vehicle remains stationary for days and aren't able to make trips? Although we are salaried employees, it will affect our earning as well. If the boss doesn't have money, how will he pay us?" he said.
"The government should listen to these farmers and solve their problems. Nobody would choose to live on the road unless they were forced to," he said.
Naveen Gupta, general secretary of the All India Motor Transport Congress (AIMTC) said the queue of trucks awaiting entry into Delhi at the Singhu border alone is as long as around 5 kilometres now.
"Entry of trucks into Delhi has almost come to a complete halt because of the ongoing protest. Though we do not have an exact number of trucks stuck at the borders, but it is safe to say that more than 1,500 trucks are stuck. Per day, the losses being faced by truck owners is around Rs 2,500 per truck, including taxes, cost of the driver and the loss in the number of trips. The problem is that because of the delay the clients are also likely to deduct money from their total payment," he said.
SP Singh of the Indian Foundation of Transport Research and Training (IFTRT), an independent research body which tracks the road transport industry along 75 trunk routes across the country, however, said the impact has been minimal so far.
"This is because most of the truckers are taking a detour to reach their destinations. Had there been any serious adverse impact on the trucking business so far, there would already have been an outcry by the transporters associations by now. However, if the agitation continues for longer, then fruits and vegetables will soon be costlier in Delhi-NCR," said Singh.
Kainat Sarfaraz
Kainat Sarfaraz covers education for Hindustan Times in Delhi. She also takes keen interest in reading and writing on the intersections of gender and other identities. ...view detail
Farmer Delhi Truck driver Farm laws Farmers protests + 3 more


Recipharm has announced that its readiness for serialization and the successful completion of a complex serialization project for China on behalf of one of its customers. A new regulation determining serialization was introduced by the Chinese regulatory authority with strict importation deadlines set in place offering zero flexibility on full compliance.
Recipharm has developed a highly adaptable solution utilizing a meticulous and methodical approach proven to ensure full and complete compliance. Fifty seven (57) serialized batches have already been supplied since February 2014.
The project, for a top ten pharmaceutical company was achieved in record time and a number of strategies to anticipate delays were adopted. Advanced planning ensured that all suppliers were thoroughly vetted and meticulously selected during the period between February and June 2013 with orders placed in early July of that year.
Integration was key, with Recipharm working closely with the pharmaceutical customer, forming project teams and a joint steering committee. Costs were minimized and success ensured via the constant interchange of ideas and information. New technology was also introduced and applied to ensure each individual box has its own 1D barcode and unique serial number.


text:
Jacek Kotus – polski geograf społeczny, doktor habilitowany, profesor na Uniwersytecie im. Adama Mickiewicza w Poznaniu.

Życiorys
W 1994 obronił pracę magisterską na Uniwersytecie im. Adama Mickiewicza w Poznaniu. W latach 90. był jednym z dwóch opiekunów wspierających Akademickiego Koła Naukowego Gospodarki Przestrzennej. Doktoryzował się na tej samej uczelni w 1999 w specjalności geografia społeczna oraz habilitował z nauk o ziemi w 2008. Jest kierownikiem Zakładu Zachowań Przestrzennych Człowieka UAM i był w latach 2014-2016 polskim delegatem w stowarzyszeniu AESOP (Association of European Schools of Planning).

Interesujące go tematy naukowe to zachowania przestrzenne ludzi, życie społeczności lokalnych w mieście i partycypacja obywatelska w zarządzaniu miastem. Jest również zainteresowany socjologią podróży i turystyki.

Przypisy

Linki zewnętrzne
Publikacje w Google Scholar

Polscy geografowie
Absolwenci Uniwersytetu im. Adama Mickiewicza w Poznaniu
Wykładowcy Wydziału Geografii Społeczno-Ekonomicznej i Gospodarki Przestrzennej Uniwersytetu im. Adama Mickiewicza w Poznaniu

redpajama_set_name: RedPajamaWikipedia


Miss Mani Monster!: Wednesdate nails!
So every Wednesday, my friend Jackie and I have a girls night and wind down, watch a little American Horror Story, and of course I do her nails. She saw this design somewhere (wish I knew where because I'd give credit- if you know please leave it in the comments.). This was pretty basic. White and black coats of polish, stripes with a black stripes, and mustaches with a dotting tool.
I thought the same thing when I was finished!


text:
Flipkart's app-only approach: a game changer for ecommerce?
ByHita Gupta on July 10, 2015
How many ecommerce apps do you have on your phone? Is Flipkart one of them? If you are a loyal consumer of Flipkart, then its app is soon going to feature on the list of top apps on your phone. In an internal interaction with Flipkart's employees, the ecommerce major's Chief Technology Officer Punit Soni informed that Flipkart will be going app-only from September. In a manner of speaking, Flipkart has tested waters in discontinuing the website avatar with its fashion offer Myntra, that became part of the group following an acquisition.
Changing paradigm
Will the ecommerce giant's app-only route be a game changer for the business? What do digital marketing experts in India think of this move? India is already leading the way for mobile commerce. According to a recent market research by Dyn: "In India, 65 per cent consumers make at least 25 per cent of their purchases through phones or tablets, shortly behind China at 80 per cent." It would appear Flipkart has embraced app-only after careful analysis of the mobile scenario in India. "India is poised to become world's second largest smartphone market and first computer screen that most Indian's will see is through the mobile screen. Also, analytics and customised experiences are more powerful on the hand-held devices than any other," reiterated Pratap Bose, Chairman of The Social Street, a digital marketing agency.
Myntra went app-only on May 15, 2015. Though the figures of how the move fared have not been released yet, Flipkart's decision reflects a confidence in the approach. Mr Bose explained, "Flipkart's management utilised Myntra as a beta for the mobile first strategy. With only a small drop in sales, Myntra was able to continue selling through its mobile app. Keeping the success of Myntra in mind, Flipkart has also announced the same for itself."
Upping the mobile traffic
Flipkart is also rising high on the mobile wave and increased smartphone penetration in India as about 70-75 per cent traffic for the platform comes from mobile. In an official statement, the company said, "India is gradually transitioning from a mobile first to a mobile only country. We are constantly experimenting with various aspects of our service to create the best shopping experience for our users on our app. Meanwhile, we continue to offer both desktop as well as mobile option for our customers."
Ranjoy Dey, Head of Digital at Havas Media India said, "Flipkart will be looking to convert its 70-75 per cent mobile traffic to 100 per cent. It is a futuristic, ahead of the curve move that will help it manage costs effectively. Maintaining three different platforms – desktop website, mobile website and app involve investment in terms of updating and upgrading but if the brand can make a cut in even one of the platforms, it will bring down costs substantially."
According to Sanjay Tripathy, Senior Executive Vice-President of Marketing, Product, Digital and Ecommerce at HDFC Life, a large number of marketers in India witness at least 50 per cent traction from mobile platforms. "The move is a testament to realisation that everyone is connected with mobile internet and mobile gives better penetration for the platform. Concentrating all efforts towards one platform will help Flipkart come under the category of an elite strategy profile. Flipkart will be able to save on the money it is spending to driving traffic to its website as the app will bring dedicated traffic to the platform. Through the app-only approach the platform can also create an ad network and generate a new revenue model for Flipkart," Mr Tripathy added.
Locking in the consumer
In the new age marketing arena, marketers will be looking forward to mobile optimised platforms to leverage the benefits of mobile. Analytics services offered by Google, predictive analysis for the consumer, and profile from telecom service providers, among others are more accurate if the consumer accesses the mobile platform. Therefore, while creating a buzz around Flipkart adopting the app-only strategy marketers must look at the financial and the technological front.
Gaurav Pathak, Chief Operating Officer of Razorfish further added to list of reasons for Flipkart to take the app-only call and said, "Key reason for Flipkart to take the app-only approach is that these players want to stop price comparison across different platforms in a price sensitive market like India. As we all know, comparing prices on mobile apps becomes an almost impossible task and to save time and resources the customer will have to accept the price quoted by the particular mobile app."
Consumers in India are always trying to secure the best possible deal and at the cheapest price and an array of variety gives him the liberty to do so. But with Flipkart going app-only, the e-tailers will be able to lock the consumers at the platform as this will make the toggle between different platforms difficult. "For us, 85 per cent of the business is happening on app. Retention and recall is definitely higher on app but not everyone maintains bookmarks or remembers the right URL. The app creates more loyalty and stickiness to the brand as against the website," commented Upasana Taku, Co-Founder and Chief Executive Officer of MobiKwik.
"The number of desktop users is extremely small in India. Brands are placing more attention and engineers on their app platform than their website. The opportunity is so large in mobile that we can expect more players in the industry becoming app-only," she added.
The good move
"Flipkart is unarguably the leader in the e-tailing space and this move will pressurise others to second guess their current web and mobile strategies. If the move works they will be one of very few players (leaders in their geography) across the globe that have gone mobile-app only and continued their leadership position in the market. I am sure Amazon, Snapdeal and others are closely watching Flipkart to ensure that if the strategy works, they are not left far behind," added Mr Bose.
Unlike a skeptic mood in the follow-up to Myntra going app-only, marketers have a positive sentiment following the Flipkart announcement. The e-tailing industry is projected to grow to a USD 76 billion opportunity by 2021. Therefore, marketers believe that there are immense opportunities in the app-only space and more players are expected to join the space. However, its execution will require deep insight into the mobile marketing dynamics at play.
Star Movies launches Twitter story campaign for new channel
Will Facebook's suggested videos cause stir in TV industry?
Tags: App-Only, eCommerce, Flipkart, Gaurav Pathak, Havas Media India, HDFC Life, MobiKwik, Myntra, Pratap Bose, Ranjoy Dey, Razorfish, Sanjay Tripathy, The Social Street, Upasana Taku
Hita Gupta
#sowhoknew: 'Amazon Prime Day' is now the biggest shopping event in history
New biometric study shows a halo effect for ads
Adara appoints Frank Teruel as Chief Operating officer

redpajama_set_name: RedPajamaCommonCrawl


text:
//-----------------------------------------------------------------------
// <copyright file="BlobHttpWebRequestFactory.cs" company="Microsoft">
//    Copyright 2013 Microsoft Corporation
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//      http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
// </copyright>
//-----------------------------------------------------------------------

namespace Microsoft.WindowsAzure.Storage.Blob.Protocol
{
    using Microsoft.WindowsAzure.Storage.Core;
    using Microsoft.WindowsAzure.Storage.Core.Util;
    using Microsoft.WindowsAzure.Storage.Shared.Protocol;
    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.IO;
    using System.Net;

    ///
    /// A factory class for constructing HTTP web requests for the Blob service.
    ///
    public static class BlobHttpWebRequestFactory
    {
        ///
        /// Creates a web request to get the properties of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetServiceProperties(Uri uri, UriQueryBuilder builder, int? timeout, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetServiceProperties(uri, builder, timeout, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Creates a web request to get the properties of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        internal static HttpWebRequest GetServiceProperties(Uri uri, UriQueryBuilder builder, int? timeout, bool useVersionHeader, OperationContext operationContext)
        {
            return HttpWebRequestFactory.GetServiceProperties(uri, builder, timeout, useVersionHeader, operationContext);
        }

        ///
        /// Creates a web request to set the properties of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetServiceProperties(Uri uri, UriQueryBuilder builder, int? timeout, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.SetServiceProperties(uri, builder, timeout, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Creates a web request to set the properties of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        internal static HttpWebRequest SetServiceProperties(Uri uri, UriQueryBuilder builder, int? timeout, bool useVersionHeader, OperationContext operationContext)
        {
            return HttpWebRequestFactory.SetServiceProperties(uri, builder, timeout, useVersionHeader, operationContext);
        }

        ///
        /// Creates a web request to get the stats of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetServiceStats(Uri uri, UriQueryBuilder builder, int? timeout, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetServiceStats(uri, builder, timeout, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Creates a web request to get the stats of the Blob service.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the Blob service endpoint.</param>
        /// <param name="builder">A <see cref="UriQueryBuilder"/> object specifying additional parameters to add to the URI query string.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        internal static HttpWebRequest GetServiceStats(Uri uri, UriQueryBuilder builder, int? timeout, bool useVersionHeader, OperationContext operationContext)
        {
            return HttpWebRequestFactory.GetServiceStats(uri, builder, timeout, useVersionHeader, operationContext);
        }

        ///
        /// Writes Blob service properties to a stream, formatted in XML.
        ///
        /// <param name="properties">A <see cref="ServiceProperties"/> object.</param>
        /// <param name="outputStream">The <see cref="System.IO.Stream"/> object to which the formatted properties are to be written.</param>
        public static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
        {
            CommonUtility.AssertNotNull("properties", properties);

            properties.WriteServiceProperties(outputStream);
        }

        ///
        /// Constructs a web request to create a new block blob or page blob, or to update the content
        /// of an existing block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">A <see cref="BlobProperties"/> object.</param>
        /// <param name="blobType">A <see cref="BlobType"/> enumeration value.</param>
        /// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
        /// for block blobs.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Put(uri, timeout, properties, blobType, pageBlobSize, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to create a new block blob or page blob, or to update the content
        /// of an existing block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">A <see cref="BlobProperties"/> object.</param>
        /// <param name="blobType">A <see cref="BlobType"/> enumeration value.</param>
        /// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
        /// for block blobs.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("properties", properties);

            if (blobType == BlobType.Unspecified)
            {
                throw new InvalidOperationException(SR.UndefinedBlobType);
            }

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, null /* builder */, useVersionHeader, operationContext);

            if (properties.CacheControl != null)
            {
                request.Headers[HttpRequestHeader.CacheControl] = properties.CacheControl;
            }

            if (properties.ContentType != null)
            {
                // Setting it using Headers is an exception
                request.ContentType = properties.ContentType;
            }

            if (properties.ContentMD5 != null)
            {
                request.Headers[HttpRequestHeader.ContentMd5] = properties.ContentMD5;
            }

            if (properties.ContentLanguage != null)
            {
                request.Headers[HttpRequestHeader.ContentLanguage] = properties.ContentLanguage;
            }

            if (properties.ContentEncoding != null)
            {
                request.Headers[HttpRequestHeader.ContentEncoding] = properties.ContentEncoding;
            }

            if (properties.ContentDisposition != null)
            {
                request.Headers[Constants.HeaderConstants.BlobContentDispositionRequestHeader] = properties.ContentDisposition;
            }

            if (blobType == BlobType.PageBlob)
            {
                request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.PageBlob;
                request.Headers[Constants.HeaderConstants.BlobContentLengthHeader] = pageBlobSize.ToString(NumberFormatInfo.InvariantInfo);
                properties.Length = pageBlobSize;
            }
            else if (blobType == BlobType.BlockBlob)
            {
                request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.BlockBlob;
            }
            else
            {
                request.Headers[Constants.HeaderConstants.BlobType] = Constants.HeaderConstants.AppendBlob;
            }

            request.ApplyAccessCondition(accessCondition);

            return request;
        }

        ///
        /// Adds the snapshot.
        ///
        /// <param name="builder">An object of type <see cref="UriQueryBuilder"/> that contains additional parameters to add to the URI query string.</param>
        /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
        private static void AddSnapshot(UriQueryBuilder builder, DateTimeOffset? snapshot)
        {
            if (snapshot.HasValue)
            {
                builder.Add("snapshot", Request.ConvertDateTimeToSnapshotString(snapshot.Value));
            }
        }

        ///
        /// Constructs a web request to commit a block to an append blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest AppendBlock(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.AppendBlock(uri, timeout, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to commit a block to an append blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest AppendBlock(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "appendblock");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            request.ApplyAppendCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to return the list of valid page ranges for a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="offset">The starting offset of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
        /// <param name="count">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetPageRanges(Uri uri, int? timeout, DateTimeOffset? snapshot, long? offset, long? count, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetPageRanges(uri, timeout, snapshot, offset, count, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to return the list of valid page ranges for a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="offset">The starting offset of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
        /// <param name="count">The length of the data range over which to list page ranges, in bytes. Must be a multiple of 512.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetPageRanges(Uri uri, int? timeout, DateTimeOffset? snapshot, long? offset, long? count, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            if (offset.HasValue)
            {
                CommonUtility.AssertNotNull("count", count);
            }

            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "pagelist");
            BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, builder, useVersionHeader, operationContext);
            AddRange(request, offset, count);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Adds the Range Header for Blob Service Operations.
        ///
        /// <param name="request">Request</param>
        /// <param name="offset">Starting byte of the range</param>
        /// <param name="count">Number of bytes in the range</param>
        private static void AddRange(HttpWebRequest request, long? offset, long? count)
        {
            if (count.HasValue)
            {
                CommonUtility.AssertNotNull("offset", offset);
                CommonUtility.AssertInBounds("count", count.Value, 1, long.MaxValue);
            }

            if (offset.HasValue)
            {
                string rangeStart = offset.ToString();
                string rangeEnd = string.Empty;
                if (count.HasValue)
                {
                    rangeEnd = (offset + count.Value - 1).ToString();
                }

                string rangeHeaderValue = string.Format(CultureInfo.InvariantCulture, Constants.HeaderConstants.RangeHeaderFormat, rangeStart, rangeEnd);
                request.Headers.Add(Constants.HeaderConstants.RangeHeader, rangeHeaderValue);
            }
        }

        ///
        /// Constructs a web request to return the blob's system properties.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetProperties(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetProperties(uri, timeout, snapshot, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to return the blob's system properties.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetProperties(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);

            HttpWebRequest request = HttpWebRequestFactory.GetProperties(uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to set system properties for a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">The blob's properties.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetProperties(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.SetProperties(uri, timeout, properties, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to set system properties for a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">The blob's properties.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetProperties(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("properties", properties);

            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "properties");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            if (properties != null)
            {
                request.AddOptionalHeader(Constants.HeaderConstants.BlobCacheControlHeader, properties.CacheControl);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentDispositionRequestHeader, properties.ContentDisposition);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentEncodingHeader, properties.ContentEncoding);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentTypeHeader, properties.ContentType);
            }

            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to resize a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Resize(Uri uri, int? timeout, long newBlobSize, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Resize(uri, timeout, newBlobSize, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to resize a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Resize(Uri uri, int? timeout, long newBlobSize, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "properties");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, newBlobSize.ToString(NumberFormatInfo.InvariantInfo));

            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to set a page blob's sequence number.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetSequenceNumber(Uri uri, int? timeout, SequenceNumberAction sequenceNumberAction, long? sequenceNumber, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.SetSequenceNumber(uri, timeout, sequenceNumberAction, sequenceNumber, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to set a page blob's sequence number.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetSequenceNumber(Uri uri, int? timeout, SequenceNumberAction sequenceNumberAction, long? sequenceNumber, AccessCondition accessCondition, bool useVersionHeader, 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");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
            request.ContentLength = 0;

            request.Headers.Add(Constants.HeaderConstants.SequenceNumberAction, sequenceNumberAction.ToString());
            if (sequenceNumberAction != SequenceNumberAction.Increment)
            {
                request.Headers.Add(Constants.HeaderConstants.BlobSequenceNumber, sequenceNumber.Value.ToString(CultureInfo.InvariantCulture));
            }

            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to return the user-defined metadata for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetMetadata(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetMetadata(uri, timeout, snapshot, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to return the user-defined metadata for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetMetadata(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);

            HttpWebRequest request = HttpWebRequestFactory.GetMetadata(uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to set user-defined metadata for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.SetMetadata(uri, timeout, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to set user-defined metadata for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest SetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            HttpWebRequest request = HttpWebRequestFactory.SetMetadata(uri, timeout, null /* builder */, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Adds user-defined metadata to the request as one or more name-value pairs.
        ///
        /// <param name="request">A <see cref="System.Net.HttpWebRequest"/> object.</param>
        /// <param name="metadata">A <see cref="Dictionary{TKey,TValue}"/> object containing the user-defined metadata.</param>
        public static void AddMetadata(HttpWebRequest request, IDictionary<string, string> metadata)
        {
            HttpWebRequestFactory.AddMetadata(request, metadata);
        }

        ///
        /// Adds user-defined metadata to the request as a single name-value pair.
        ///
        /// <param name="request">A <see cref="System.Net.HttpWebRequest"/> object.</param>
        /// <param name="name">A string containing the metadata name.</param>
        /// <param name="value">A string containing the metadata value.</param>
        public static void AddMetadata(HttpWebRequest request, string name, string value)
        {
            HttpWebRequestFactory.AddMetadata(request, name, value);
        }

        ///
        /// Constructs a web request to delete a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Delete(Uri uri, int? timeout, DateTimeOffset? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Delete(uri, timeout, snapshot, deleteSnapshotsOption, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to delete a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying 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">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Delete(Uri uri, int? timeout, DateTimeOffset? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            if ((snapshot != null) && (deleteSnapshotsOption != DeleteSnapshotsOption.None))
            {
                throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
            }

            UriQueryBuilder builder = new UriQueryBuilder();
            BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);

            HttpWebRequest request = HttpWebRequestFactory.Delete(uri, builder, timeout, useVersionHeader, 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;
        }

        ///
        /// Constructs a web request to create a snapshot of a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Snapshot(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Snapshot(uri, timeout, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to create a snapshot of a blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Snapshot(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "snapshot");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Generates a web request to use to acquire, renew, change, release or break the lease for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="action">A <see cref="LeaseAction"/> enumeration value indicating the lease action to perform.</param>
        /// <param name="proposedLeaseId">A string specifying the lease ID to propose for the result of an acquire or change operation,
        /// or <c>null</c> if no ID is proposed for an acquire operation. This parameter should be <c>null</c> 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 <c>null</c> 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 <c>null</c> then the default time is used. This should be <c>null</c> for acquire, renew, change, and release operations.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Lease(Uri uri, int? timeout, LeaseAction action, string proposedLeaseId, int? leaseDuration, int? leaseBreakPeriod, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Lease(uri, timeout, action, proposedLeaseId, leaseDuration, leaseBreakPeriod, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Generates a web request to use to acquire, renew, change, release or break the lease for the blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">The server timeout interval, in seconds.</param>
        /// <param name="action">A <see cref="LeaseAction"/> enumeration value indicating the lease action to perform.</param>
        /// <param name="proposedLeaseId">A string specifying the lease ID to propose for the result of an acquire or change operation,
        /// or <c>null</c> if no ID is proposed for an acquire operation. This parameter should be <c>null</c> 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 <c>null</c> 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 <c>null</c> then the default time is used. This should be <c>null</c> for acquire, renew, change, and release operations.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Lease(Uri uri, int? timeout, LeaseAction action, string proposedLeaseId, int? leaseDuration, int? leaseBreakPeriod, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "lease");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);

            // Add lease headers
            BlobHttpWebRequestFactory.AddLeaseAction(request, action);
            BlobHttpWebRequestFactory.AddLeaseDuration(request, leaseDuration);
            BlobHttpWebRequestFactory.AddProposedLeaseId(request, proposedLeaseId);
            BlobHttpWebRequestFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod);

            return request;
        }

        ///
        /// Adds a proposed lease id to a request.
        ///
        /// <param name="request">The request.</param>
        /// <param name="proposedLeaseId">The proposed lease id.</param>
        internal static void AddProposedLeaseId(HttpWebRequest request, string proposedLeaseId)
        {
            request.AddOptionalHeader(Constants.HeaderConstants.ProposedLeaseIdHeader, proposedLeaseId);
        }

        ///
        /// Adds a lease duration to a request.
        ///
        /// <param name="request">The request.</param>
        /// <param name="leaseDuration">The lease duration.</param>
        internal static void AddLeaseDuration(HttpWebRequest request, int? leaseDuration)
        {
            request.AddOptionalHeader(Constants.HeaderConstants.LeaseDurationHeader, leaseDuration);
        }

        ///
        /// Adds a lease break period to a request.
        ///
        /// <param name="request">The request.</param>
        /// <param name="leaseBreakPeriod">The lease break period.</param>
        internal static void AddLeaseBreakPeriod(HttpWebRequest request, int? leaseBreakPeriod)
        {
            request.AddOptionalHeader(Constants.HeaderConstants.LeaseBreakPeriodHeader, leaseBreakPeriod);
        }

        ///
        /// Adds a lease action to a request.
        ///
        /// <param name="request">The request.</param>
        /// <param name="leaseAction">The lease action.</param>
        internal static void AddLeaseAction(HttpWebRequest request, LeaseAction leaseAction)
        {
            request.Headers.Add(Constants.HeaderConstants.LeaseActionHeader, leaseAction.ToString().ToLower());
        }

        ///
        /// Constructs a web request to write a block to a block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="blockId">A string specifying the block ID for this block.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest PutBlock(Uri uri, int? timeout, string blockId, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.PutBlock(uri, timeout, blockId, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to write a block to a block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="blockId">A string specifying the block ID for this block.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest PutBlock(Uri uri, int? timeout, string blockId, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "block");
            builder.Add("blockid", blockId);

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyLeaseId(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to create or update a blob by committing a block list.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">A <see cref="BlobProperties"/> object specifying the properties to set for the blob.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.PutBlockList(uri, timeout, properties, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to create or update a blob by committing a block list.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="properties">A <see cref="BlobProperties"/> object specifying the properties to set for the blob.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest PutBlockList(Uri uri, int? timeout, BlobProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("properties", properties);

            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "blocklist");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            if (properties != null)
            {
                request.AddOptionalHeader(Constants.HeaderConstants.BlobCacheControlHeader, properties.CacheControl);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentTypeHeader, properties.ContentType);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentLanguageHeader, properties.ContentLanguage);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentEncodingHeader, properties.ContentEncoding);
                request.AddOptionalHeader(Constants.HeaderConstants.BlobContentDispositionRequestHeader, properties.ContentDisposition);
            }

            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to return the list of blocks for a block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="typesOfBlocks">A <see cref="BlockListingFilter"/> enumeration value.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetBlockList(Uri uri, int? timeout, DateTimeOffset? snapshot, BlockListingFilter typesOfBlocks, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.GetBlockList(uri, timeout, snapshot, typesOfBlocks, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to return the list of blocks for a block blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
        /// <param name="typesOfBlocks">A <see cref="BlockListingFilter"/> enumeration value.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest GetBlockList(Uri uri, int? timeout, DateTimeOffset? snapshot, BlockListingFilter typesOfBlocks, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "blocklist");
            builder.Add("blocklisttype", typesOfBlocks.ToString());
            BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to write or clear a range of pages in a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="pageRange">A <see cref="PageRange"/> object.</param>
        /// <param name="pageWrite">A <see cref="PageWrite"/> enumeration value indicating the operation to perform on the page blob.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.PutPage(uri, timeout, pageRange, pageWrite, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to write or clear a range of pages in a page blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="pageRange">A <see cref="PageRange"/> object.</param>
        /// <param name="pageWrite">A <see cref="PageWrite"/> enumeration value indicating the operation to perform on the page blob.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest PutPage(Uri uri, int? timeout, PageRange pageRange, PageWrite pageWrite, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("pageRange", pageRange);

            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "page");

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            request.Headers.Add(Constants.HeaderConstants.RangeHeader, pageRange.ToString());
            request.Headers.Add(Constants.HeaderConstants.PageWrite, pageWrite.ToString());

            request.ApplyAccessCondition(accessCondition);
            request.ApplySequenceNumberCondition(accessCondition);
            return request;
        }

        ///
        /// Generates a web request to copy a blob or file to another blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the destination blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="source">A <see cref="System.Uri"/> specifying the absolute URI to the source object, including any necessary authentication parameters.</param>
        /// <param name="sourceAccessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met on the source object in order for the request to proceed.</param>
        /// <param name="destAccessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met on the destination blob in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest CopyFrom(Uri uri, int? timeout, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.CopyFrom(uri, timeout, source, sourceAccessCondition, destAccessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Generates a web request to copy a blob or file to another blob.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the destination blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="source">A <see cref="System.Uri"/> specifying the absolute URI to the source object, including any necessary authentication parameters.</param>
        /// <param name="sourceAccessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met on the source object in order for the request to proceed.</param>
        /// <param name="destAccessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met on the destination blob in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest CopyFrom(Uri uri, int? timeout, Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            CommonUtility.AssertNotNull("source", source);

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, null /* builder */, useVersionHeader, operationContext);

            request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, source.AbsoluteUri);
            request.ApplyAccessCondition(destAccessCondition);
            request.ApplyAccessConditionToSource(sourceAccessCondition);

            return request;
        }

        ///
        /// Generates a web request to abort a copy operation.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="copyId">The ID string of the copy operation to be aborted.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. Only lease conditions are supported for this operation.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest AbortCopy(Uri uri, int? timeout, string copyId, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.AbortCopy(uri, timeout, copyId, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Generates a web request to abort a copy operation.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="copyId">The ID string of the copy operation to be aborted.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. Only lease conditions are supported for this operation.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest AbortCopy(Uri uri, int? timeout, string copyId, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            builder.Add(Constants.QueryConstants.Component, "copy");
            builder.Add(Constants.QueryConstants.CopyId, copyId);

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);

            request.Headers.Add(Constants.HeaderConstants.CopyActionHeader, Constants.HeaderConstants.CopyActionAbort);
            request.ApplyAccessCondition(accessCondition);

            return request;
        }

        ///
        /// Constructs a web request to get the blob's content, properties, and metadata.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot version, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Get(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Get(uri, timeout, snapshot, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to get the blob's content, properties, and metadata.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot version, if the blob is a snapshot.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
        public static HttpWebRequest Get(Uri uri, int? timeout, DateTimeOffset? snapshot, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            UriQueryBuilder builder = new UriQueryBuilder();
            if (snapshot.HasValue)
            {
                builder.Add("snapshot", Request.ConvertDateTimeToSnapshotString(snapshot.Value));
            }

            HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Get, uri, timeout, builder, useVersionHeader, operationContext);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        ///
        /// Constructs a web request to return a specified range of the blob's content, together with its properties and metadata.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot version, if the blob is a snapshot.</param>
        /// <param name="offset">The byte offset at which to begin returning content.</param>
        /// <param name="count">The number of bytes to return, or <c>null</c> to return all bytes through the end of the blob.</param>
        /// <param name="rangeContentMD5">If set to <c>true</c>, an MD5 header is requested for the specified range.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest Get(Uri uri, int? timeout, DateTimeOffset? snapshot, long? offset, long? count, bool rangeContentMD5, AccessCondition accessCondition, OperationContext operationContext)
        {
            return BlobHttpWebRequestFactory.Get(uri, timeout, snapshot, offset, count, rangeContentMD5, accessCondition, true /* useVersionHeader */, operationContext);
        }

        ///
        /// Constructs a web request to return a specified range of the blob's content, together with its properties and metadata.
        ///
        /// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
        /// <param name="timeout">An integer specifying the server timeout interval.</param>
        /// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot version, if the blob is a snapshot.</param>
        /// <param name="offset">The byte offset at which to begin returning content.</param>
        /// <param name="count">The number of bytes to return, or <c>null</c> to return all bytes through the end of the blob.</param>
        /// <param name="rangeContentMD5">If set to <c>true</c>, an MD5 header is requested for the specified range.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
        /// <param name="useVersionHeader">A boolean value indicating whether to set the x-ms-version HTTP header.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>
        /// A web request to use to perform the operation.
        /// </returns>
        public static HttpWebRequest Get(Uri uri, int? timeout, DateTimeOffset? snapshot, long? offset, long? count, bool rangeContentMD5, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
        {
            if (offset.HasValue && offset.Value < 0)
            {
                CommonUtility.ArgumentOutOfRange("offset", offset);
            }

            if (offset.HasValue && rangeContentMD5)
            {
                CommonUtility.AssertNotNull("count", count);
                CommonUtility.AssertInBounds("count", count.Value, 1, Constants.MaxBlockSize);
            }

            HttpWebRequest request = Get(uri, timeout, snapshot, accessCondition, useVersionHeader, operationContext);
            AddRange(request, offset, count);

            if (offset.HasValue && rangeContentMD5)
            {
                request.Headers.Add(Constants.HeaderConstants.RangeContentMD5Header, Constants.HeaderConstants.TrueHeader);
            }

            return request;
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
Parashat Noach 5773, 2012: "Walking With Hashem, or Before Hashem?"
Parashat Noach 5773, 2012:
Walking With Hashem, or Before Hashem?
Dedicated to the sacred memories of my mother, Miriam Tovah bat Aharon Hakohen, father-in-law, Levi ben Yitzhak, sister-in-law, Ruchama Rivka Sondra, my sister, Shulamit bat Menachem, and Shifra bat Chaim Alter, and the refuah shlaimah of Yosef Shmuel ben Miriam, Yehonatan Binyamin Halevy ben Golda Friedel, and Moshe Reuven ben Chaya.
Who was Noach and who was Avraham? This simple question is crucial in helping us analyze the nature of genuine tzidkut (righteousness) and inauthentic tzidkut. Noach is described in Sefer Bereishit 6:9 as: "…et HaElokim hithalech Noach" ("Noach walked with G-d"). In contrast, regarding Avraham, the text (ibid. , 17:1) states: "…hithalach lfani v'heyah tamim" ("…walk before me and be complete," Rashi, 1040-1105). The Midrash Rabah to Sefer Bereishit (middle of the fifth century CE) notes this intriguing disparity in language. In 30:10, Rabbi Yehudah explains this difference in allegorical terms:
"This may be compared to a nobleman who has two sons, one who is grown and one who is young. He says to the youngster: "Walk with me," whereas he says to the grown son: "Come and walk before me." So, too, was it the case regarding Avraham whose [spiritual] strength was great and thus Hashem said: "Walk before Me." In contrast, Noach who was [spiritually] weak, was merely described as "…et HaElokim hithalech Noach." ("…and Noach walked with G-d.")
Rashi summarizes this Midrash in his commentary to Sefer Bereishit 6:9. He adds that Noach needed to be supported by Hashem ("tzarich saad l'tamcho"), whereas Avraham grew stronger and stronger on his own ("hayah mitchazak u'mehalach b'tzidko m'aluv"). Indeed, as Avraham continued to grow spiritually through each of the ten trials presented to him by Hashem, he also grew in the recognition of his responsibilities toward his fellow man. Thus, Avraham, in awe and with dignity, beseeched Hashem for mercy on behalf of the men, women, and children of S'dom. He cared deeply about others, and became the master of the special and holy midah (moral quality) of chesed. He truly walked before Hashem, as he forged new paths of spiritual response to the crises and trials with which he was presented.
Noach was an entirely different story. He was, as the Yiddish statement goes, a tzadik im peltz (someone who was wrapped in furs while those around him remained cold). When Hashem told him that he was about to destroy the entire world by the impending Great Flood, we never see Noach entreat Hashem on behalf of the populace of the world. He remained silent and seemingly uncaring regarding the fate of his fellow man. In stark contrast to Avraham, therefore, Noach appears to be spiritually immature. He could only follow alongside of Hashem when He was metaphorically leading him directly by the hand. He did not, because he could not, respond in a morally creative manner to the pressing requirements of his time, even when they encompassed the needs of the entire world. How different, indeed, was Avraham, the "steward of mankind," whose watchword was clearly: "What about them?" This means he boldly and unhesitatingly asked the question: "What about those in the world who need Divine mercy and protection, and need an advocate to bring this to G-d's attention?"
On some level, at least, our challenge in this world is to decide whether we will follow in the footsteps of Noach, or those of Avraham. One thing is clear: Only when we honestly recognize our obligations to mankind in general, in conjunction with our singular responsibilities to all Jews everywhere, can we claim the title of being "bnei Avraham" (the children of Avraham).
Let us hope and pray that each of us will follow Avraham's path. Then, we will be able to be active participants in bringing Mashiach Tzidkanu (the Righteous Redeemer). May Hashem give us the strength and wisdom to be part of this glorious world-building process. V'chane yihi ratzon.
My new audio shiurim for Women on Tefilah: Haskafah and Analysis, may be found at: http://tinyurl.com/8hsdpyd
**Follow new postings on my Twitter accounts: @theRavZatzal and @Torahtech613.
*** Interested in 21st Century Jewish Education? See my new blog: http://21stcenturyjewisheducation.org