Example #1
0
        public void accept___assignment_standard_orders_byquality()
        {
            var          value  = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5";
            AcceptHeader header = value;

            header.Should().NotBeNull();
            header.Value.Should().Be(value);
            header.Values.Should().NotBeNull();
            header.Values.Should().HaveCount(4);

            header.Values[0].MediaType.Should().Be("text/xml");
            header.Values[0].Type.Should().Be("text");
            header.Values[0].SubType.Should().Be("xml");
            header.Values[0].Quality.Should().Be(1f);

            header.Values[1].MediaType.Should().Be("text/plain");
            header.Values[1].Type.Should().Be("text");
            header.Values[1].SubType.Should().Be("plain");
            header.Values[1].Quality.Should().Be(0.7f);

            header.Values[2].MediaType.Should().Be("*/*");
            header.Values[2].Type.Should().Be("*");
            header.Values[2].SubType.Should().Be("*");
            header.Values[2].Quality.Should().Be(0.5f);

            header.Values[3].MediaType.Should().Be("text/json");
            header.Values[3].Type.Should().Be("text");
            header.Values[3].SubType.Should().Be("json");
            header.Values[3].Quality.Should().Be(0.1f);
        }
Example #2
0
        /// <summary>Gets the acceptable formatter.</summary>
        /// <param name="acceptHeader">The accept header.</param>
        /// <param name="objType">Type of the object.</param>
        /// <param name="formatterType">Type of the formatter.</param>
        /// <param name="writeableFormatters">The overriding formatters.</param>
        /// <param name="writeableMediaTypes">The writeable media types.</param>
        /// <returns></returns>
        public virtual Task <IDeepSleepMediaSerializer> GetAcceptableFormatter(
            AcceptHeader acceptHeader,
            Type objType,
            out string formatterType,
            IList <IDeepSleepMediaSerializer> writeableFormatters = null,
            IList <string> writeableMediaTypes = null)
        {
            formatterType = string.Empty;
            IDeepSleepMediaSerializer formatter = null;

            foreach (var mediaHeader in acceptHeader.Values.Where(m => m.Quality > 0))
            {
                formatter = this.Get(
                    contentType: $"{mediaHeader.Type}/{mediaHeader.SubType}",
                    objType: objType,
                    parameters: mediaHeader.ParameterString(),
                    forRead: false,
                    overridingFormatters: writeableFormatters,
                    overridingMediaTypes: writeableMediaTypes,
                    formatterType: out formatterType);

                if (formatter != null)
                {
                    break;
                }
            }

            return(Task.FromResult(formatter));
        }
Example #3
0
        public void accept___assignment_qualities_modified_when_outofrange()
        {
            var          value  = "text/json;q=-1, text/xml; q=1.1, text/plain; q=0.7, */*; q=0.5";
            AcceptHeader header = value;

            header.Should().NotBeNull();
            header.Value.Should().Be(value);
            header.Values.Should().NotBeNull();
            header.Values.Should().HaveCount(4);

            header.Values[0].MediaType.Should().Be("text/xml");
            header.Values[0].Type.Should().Be("text");
            header.Values[0].SubType.Should().Be("xml");
            header.Values[0].Quality.Should().Be(1f);

            header.Values[1].MediaType.Should().Be("text/plain");
            header.Values[1].Type.Should().Be("text");
            header.Values[1].SubType.Should().Be("plain");
            header.Values[1].Quality.Should().Be(0.7f);

            header.Values[2].MediaType.Should().Be("*/*");
            header.Values[2].Type.Should().Be("*");
            header.Values[2].SubType.Should().Be("*");
            header.Values[2].Quality.Should().Be(0.5f);

            header.Values[3].MediaType.Should().Be("text/json");
            header.Values[3].Type.Should().Be("text");
            header.Values[3].SubType.Should().Be("json");
            header.Values[3].Quality.Should().Be(0f);
        }
Example #4
0
        public void accept___assignment_charsets_quality_set_to_0_when_quality_invalid()
        {
            var          value  = "text/json;q=0.1, text/xml; q=ABC, text/plain; q=0.7, */*; q=0.5";
            AcceptHeader header = value;

            header.Should().NotBeNull();
            header.Value.Should().Be(value);
            header.Values.Should().NotBeNull();
            header.Values.Should().HaveCount(4);

            header.Values[0].MediaType.Should().Be("text/plain");
            header.Values[0].Type.Should().Be("text");
            header.Values[0].SubType.Should().Be("plain");
            header.Values[0].Quality.Should().Be(0.7f);

            header.Values[1].MediaType.Should().Be("*/*");
            header.Values[1].Type.Should().Be("*");
            header.Values[1].SubType.Should().Be("*");
            header.Values[1].Quality.Should().Be(0.5f);

            header.Values[2].MediaType.Should().Be("text/json");
            header.Values[2].Type.Should().Be("text");
            header.Values[2].SubType.Should().Be("json");
            header.Values[2].Quality.Should().Be(0.1f);

            header.Values[3].MediaType.Should().Be("text/xml");
            header.Values[3].Type.Should().Be("text");
            header.Values[3].SubType.Should().Be("xml");
            header.Values[3].Quality.Should().Be(0f);
        }
Example #5
0
        public bool IsAcceptable(AcceptHeader acceptHeader, out string transferSyntax)
        {
            transferSyntax = null;

            // Check if payload type match
            if ((PayloadType & acceptHeader.PayloadType) == PayloadTypes.None)
            {
                return(false);
            }

            if (!StringSegment.Equals(acceptHeader.MediaType, MediaType, StringComparison.InvariantCultureIgnoreCase))
            {
                return(false);
            }

            if (StringSegment.IsNullOrEmpty(acceptHeader.TransferSyntax))
            {
                if (IsTransferSyntaxMandatory)
                {
                    return(false);
                }

                // when transfer syntax is missed from accept header, use default one
                transferSyntax = TransferSyntaxWhenMissing;
                return(true);
            }

            if (AcceptableTransferSyntaxes.Contains(acceptHeader.TransferSyntax.Value))
            {
                transferSyntax = acceptHeader.TransferSyntax.Value;
                return(true);
            }

            return(false);
        }
        public void GivenNoMatchedAcceptHeaders_WhenGetTransferSyntax_ThenShouldThrowNotAcceptableException()
        {
            // Use content type that GetStudy doesn't support
            AcceptHeader           acceptHeader = AcceptHeaderHelpers.CreateAcceptHeaderForGetStudy(mediaType: KnownContentTypes.ImageJpeg);
            AcceptHeaderDescriptor acceptHeaderDescriptor;

            Assert.ThrowsAny <NotAcceptableException>(() => _handler.GetTransferSyntax(ResourceType.Study, new[] { acceptHeader }, out acceptHeaderDescriptor));
        }
        public void WhenConstructedSetsTheValueProperty()
        {
            string expectedValue = "application/json";

            var header = new AcceptHeader(expectedValue);

            header.Value.Should().Be(expectedValue);
        }
        public void GivenMultipleAcceptHeaders_WhenGetTransferSyntax_ThenShouldThrowNotAcceptableException()
        {
            AcceptHeader           acceptHeader1 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.5, transferSyntax: DicomTransferSyntaxUids.Original);
            AcceptHeader           acceptHeader2 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.9, transferSyntax: DicomTransferSyntaxUids.Original);
            AcceptHeaderDescriptor acceptHeaderDescriptor;

            Assert.ThrowsAny <NotAcceptableException>(() => _handler.GetTransferSyntax(ResourceType.Study, new[] { acceptHeader1, acceptHeader2 }, out acceptHeaderDescriptor));
        }
Example #9
0
        public void GivenDescriptorsIsNotNull_WhenConstructAcceptHeaderDescriptors_ThenShouldSucceed()
        {
            AcceptHeader            acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader();
            AcceptHeaderDescriptor  descriptor   = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: true);
            AcceptHeaderDescriptors descriptors  = new AcceptHeaderDescriptors(descriptor);

            Assert.Single(descriptors.Descriptors);
            Assert.Same(descriptor, descriptors.Descriptors.First());
        }
Example #10
0
        public void accept___equals_overload_not_string_or_equivelent_sccess()
        {
            AcceptHeader header1 = "en-us;";
            var          other   = 2;

            var equals = header1.Equals(other);

            equals.Should().BeFalse();
        }
Example #11
0
        public void accept___equals_overload_null_sccess()
        {
            AcceptHeader header1 = "en-us;";
            AcceptHeader header2 = null;

            var equals = header1.Equals(header2);

            equals.Should().BeFalse();
        }
        public void GivenMediaType_WhenCheckIsAcceptable_ShouldSucceed(string descriptorMediaType, string acceptHeaderMediaType, bool isAcceptable)
        {
            (AcceptHeader, AcceptHeaderDescriptor)testData = CreateAcceptHeaderAndDescriptorForMediaType(descriptorMediaType, acceptHeaderMediaType);
            string                 transferSyntax;
            AcceptHeader           acceptHeader = testData.Item1;
            AcceptHeaderDescriptor descriptor   = testData.Item2;

            Assert.Equal(isAcceptable, descriptor.IsAcceptable(acceptHeader, out transferSyntax));
        }
Example #13
0
        public void accept___ctor_basic_returns_type(string value, int expectedCount)
        {
            var header = new AcceptHeader($"{value}");

            header.Should().NotBeNull();
            header.Value.Should().Be(value);
            header.Values.Should().NotBeNull();
            header.Values.Should().HaveCount(expectedCount);
        }
Example #14
0
        public void accept___ctor_returns_default_for_null_or_whitespace(string value)
        {
            var header = new AcceptHeader(value);

            header.Should().NotBeNull();
            header.Value.Should().Be(value);
            header.Values.Should().NotBeNull();
            header.Values.Should().BeEmpty();
        }
Example #15
0
        public void accept___gethashcode_success()
        {
            AcceptHeader header = "en-us;";

            header.Should().NotBeNull();

            var hashCode = header.GetHashCode();

            hashCode.Should().NotBe(0);
        }
        public void GivenValidInput_WhenToString_ThenShouldReturnExpectedContent()
        {
            StringSegment mediaType      = KnownContentTypes.ApplicationDicom;
            PayloadTypes  payloadType    = PayloadTypes.MultipartRelated;
            StringSegment transferSytnax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID;
            double        quality        = 0.5;
            AcceptHeader  header         = new AcceptHeader(mediaType, payloadType, transferSytnax, quality);

            Assert.Equal($"MediaType:'{mediaType}', PayloadType:'{payloadType}', TransferSyntax:'{transferSytnax}', Quality:'{quality}'", header.ToString());
        }
Example #17
0
        public void accept___notequals_operator_header_success(string encoding)
        {
            var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5, text/*";

            var header1 = new AcceptHeader(encoding);
            var header2 = new AcceptHeader(value);

            var equals = header1 != header2;

            equals.Should().Be(true);
        }
Example #18
0
        public void GivenAcceptHeaders_WhenNoMatch_ThenShouldReturnFalse()
        {
            AcceptHeader            acceptHeader            = AcceptHeaderHelpers.CreateAcceptHeader();
            AcceptHeaderDescriptor  notMatchDescriptor1     = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: false);
            AcceptHeaderDescriptor  notMatchDescriptor2     = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: false);
            AcceptHeaderDescriptors acceptHeaderDescriptors = new AcceptHeaderDescriptors(notMatchDescriptor1, notMatchDescriptor2);
            AcceptHeaderDescriptor  result;
            string transferSyntax;

            Assert.False(acceptHeaderDescriptors.TryGetMatchedDescriptor(acceptHeader, out result, out transferSyntax));
        }
        public void GivenMultipleMatchedAcceptHeadersWithDifferentQuality_WhenGetTransferSyntax_ThenShouldReturnLargestQuality()
        {
            string                 expectedTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID;
            AcceptHeader           acceptHeader1          = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.5, transferSyntax: DicomTransferSyntaxUids.Original);
            AcceptHeader           acceptHeader2          = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.9, transferSyntax: expectedTransferSyntax);
            AcceptHeaderDescriptor acceptHeaderDescriptor;
            string                 transferSyntax = _handler.GetTransferSyntax(ResourceType.Frames, new[] { acceptHeader1, acceptHeader2 }, out acceptHeaderDescriptor);

            Assert.Equal(expectedTransferSyntax, transferSyntax);
            Assert.Equal(acceptHeader2.MediaType, acceptHeaderDescriptor.MediaType);
        }
 public static AcceptHeaderDescriptor CreateAcceptHeaderDescriptor(AcceptHeader acceptHeader, bool match = true)
 {
     return(new AcceptHeaderDescriptor(
                payloadType: acceptHeader.PayloadType,
                mediaType: acceptHeader.MediaType.Value,
                isTransferSyntaxMandatory: true,
                transferSyntaxWhenMissing: string.Empty,
                acceptableTransferSyntaxes: match ? new HashSet <string>()
     {
         acceptHeader.TransferSyntax.Value
     } : new HashSet <string>()));
 }
        public void GivenValidInput_WhenConstructAcceptHeader_ThenShouldSucceed()
        {
            StringSegment mediaType      = KnownContentTypes.ApplicationDicom;
            PayloadTypes  payloadType    = PayloadTypes.MultipartRelated;
            StringSegment transferSytnax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID;
            double        quality        = 0.5;
            AcceptHeader  header         = new AcceptHeader(mediaType, payloadType, transferSytnax, quality);

            Assert.Equal(mediaType, header.MediaType);
            Assert.Equal(payloadType, header.PayloadType);
            Assert.Equal(transferSytnax, header.TransferSyntax);
            Assert.Equal(quality, header.Quality);
        }
Example #22
0
        public void accept___equals_operator_string_success(string encoding)
        {
            var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5";

            var header = new AcceptHeader(encoding);

            var equals = header == value;

            equals.Should().Be(true);

            equals = value == header;
            equals.Should().Be(true);
        }
        public void GivenSinglePartHeader_WhenGetAcceptHeader_ShouldSucceed()
        {
            string mediaType                  = KnownContentTypes.ApplicationDicom;
            string transferSyntax             = DicomTransferSyntaxUids.Original;
            double quality                    = 0.9;
            MediaTypeHeaderValue headerValue  = CreateMediaTypeHeaderValue(mediaType, string.Empty, transferSyntax, quality);
            AcceptHeader         acceptHeader = headerValue.ToAcceptHeader();

            Assert.Equal(PayloadTypes.SinglePart, acceptHeader.PayloadType);
            Assert.Equal(mediaType, acceptHeader.MediaType);
            Assert.Equal(transferSyntax, acceptHeader.TransferSyntax);
            Assert.Equal(quality, acceptHeader.Quality);
        }
Example #24
0
        public void accept___equals_override_success(string encoding)
        {
            var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5";

            var header = new AcceptHeader(encoding);

            var equals = header.Equals(value);

            equals.Should().Be(true);

            equals = header.Equals(new AcceptHeader(value));
            equals.Should().Be(true);
        }
        public void GivenTransferSyntaxMandatory_WhenCheckIsAcceptable_ShouldSucceed(bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, string acceptHeaderTransferSyntax, bool isAcceptable, string expectedTransferSyntax)
        {
            (AcceptHeader, AcceptHeaderDescriptor)testData = CreateAcceptHeaderAndDescriptorForTransferSyntaxMandatory(isTransferSyntaxMandatory, transferSyntaxWhenMissing, acceptHeaderTransferSyntax);
            string                 transferSyntax;
            AcceptHeader           acceptHeader = testData.Item1;
            AcceptHeaderDescriptor descriptor   = testData.Item2;

            Assert.Equal(isAcceptable, descriptor.IsAcceptable(acceptHeader, out transferSyntax));
            if (isAcceptable)
            {
                Assert.Equal(expectedTransferSyntax, transferSyntax);
            }
        }
        public void GivenMultiPartRelatedHeader_WhenGetAcceptHeader_ShouldSucceed()
        {
            string type           = KnownContentTypes.ApplicationOctetStream;
            string transferSyntax = DicomTransferSyntaxUids.Original;

            double quality = 0.9;
            MediaTypeHeaderValue headerValue  = CreateMediaTypeHeaderValue(KnownContentTypes.MultipartRelated, type, transferSyntax, quality);
            AcceptHeader         acceptHeader = headerValue.ToAcceptHeader();

            Assert.Equal(PayloadTypes.MultipartRelated, acceptHeader.PayloadType);
            Assert.Equal(type, acceptHeader.MediaType);
            Assert.Equal(transferSyntax, acceptHeader.TransferSyntax);
            Assert.Equal(quality, acceptHeader.Quality);
        }
        private (AcceptHeader, AcceptHeaderDescriptor) CreateAcceptHeaderAndDescriptorForPayloadType(PayloadTypes descriptorPayloadType, PayloadTypes acceptHeaderPayloadType)
        {
            AcceptHeader           acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(payloadType: acceptHeaderPayloadType);
            AcceptHeaderDescriptor descriptor   = new AcceptHeaderDescriptor(
                payloadType: descriptorPayloadType,
                mediaType: acceptHeader.MediaType.Value,
                isTransferSyntaxMandatory: true,
                transferSyntaxWhenMissing: string.Empty,
                acceptableTransferSyntaxes: new HashSet <string>()
            {
                acceptHeader.TransferSyntax.Value
            });

            return(acceptHeader, descriptor);
        }
        private (AcceptHeader, AcceptHeaderDescriptor) CreateAcceptHeaderAndDescriptorForTransferSyntaxMandatory(bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, string acceptHeaderTransferSyntax)
        {
            AcceptHeader           acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(transferSyntax: acceptHeaderTransferSyntax);
            AcceptHeaderDescriptor descriptor   = new AcceptHeaderDescriptor(
                payloadType: acceptHeader.PayloadType,
                mediaType: acceptHeader.MediaType.Value,
                isTransferSyntaxMandatory: isTransferSyntaxMandatory,
                transferSyntaxWhenMissing: transferSyntaxWhenMissing,
                acceptableTransferSyntaxes: new HashSet <string>()
            {
                acceptHeader.TransferSyntax.Value
            });

            return(acceptHeader, descriptor);
        }
Example #29
0
            public void Must_parse_correctly(string headerValue)
            {
                AcceptHeader[] headers = AcceptHeader.ParseMany(headerValue).ToArray();

                Assert.That(headers, Has.Length.EqualTo(5));

                Assert.That(headers[0].Type, Is.EqualTo("text"));
                Assert.That(headers[0].Subtype, Is.EqualTo("html"));
                Assert.That(headers[0].Qvalue, Is.Null);
                Assert.That(headers[0].EffectiveQvalue, Is.EqualTo(1m));
                Assert.That(headers[0].Extensions, Is.Empty);

                Assert.That(headers[1].Type, Is.EqualTo("text"));
                Assert.That(headers[1].Subtype, Is.EqualTo("plain"));
                Assert.That(headers[1].Qvalue, Is.EqualTo(0.9m));
                Assert.That(headers[1].EffectiveQvalue, Is.EqualTo(0.9m));
                Assert.That(headers[1].Extensions.Count(), Is.EqualTo(1));
                Assert.That(headers[1].Extensions.ElementAt(0).Name, Is.EqualTo("extension1"));
                Assert.That(headers[1].Extensions.ElementAt(0).Value, Is.EqualTo("value1"));

                Assert.That(headers[2].Type, Is.EqualTo("application"));
                Assert.That(headers[2].Subtype, Is.EqualTo("json"));
                Assert.That(headers[2].Parameters.Count(), Is.EqualTo(2));
                Assert.That(headers[2].Parameters.ElementAt(0).Name, Is.EqualTo("param1"));
                Assert.That(headers[2].Parameters.ElementAt(0).Value, Is.EqualTo("value1"));
                Assert.That(headers[2].Parameters.ElementAt(1).Name, Is.EqualTo("param2"));
                Assert.That(headers[2].Parameters.ElementAt(1).Value, Is.EqualTo("value2"));
                Assert.That(headers[2].Qvalue, Is.EqualTo(1m));
                Assert.That(headers[2].EffectiveQvalue, Is.EqualTo(1m));
                Assert.That(headers[2].Extensions.Count(), Is.EqualTo(2));
                Assert.That(headers[2].Extensions.ElementAt(0).Name, Is.EqualTo("extension1"));
                Assert.That(headers[2].Extensions.ElementAt(0).Value, Is.EqualTo("value1"));
                Assert.That(headers[2].Extensions.ElementAt(1).Name, Is.EqualTo("extension2"));
                Assert.That(headers[2].Extensions.ElementAt(1).Value, Is.EqualTo("value2"));

                Assert.That(headers[3].Type, Is.EqualTo("text"));
                Assert.That(headers[3].Subtype, Is.EqualTo("*"));
                Assert.That(headers[3].Qvalue, Is.Null);
                Assert.That(headers[3].EffectiveQvalue, Is.EqualTo(1m));
                Assert.That(headers[3].Extensions, Is.Empty);

                Assert.That(headers[4].Type, Is.EqualTo("*"));
                Assert.That(headers[4].Subtype, Is.EqualTo("*"));
                Assert.That(headers[4].Qvalue, Is.EqualTo(1m));
                Assert.That(headers[4].EffectiveQvalue, Is.EqualTo(1m));
                Assert.That(headers[4].Extensions, Is.Empty);
            }
        public async Task <ResponseHandlerResult> HandleResponseAsync(HttpContextBase context, IResponse suggestedResponse, ICache cache, string cacheKey)
        {
            context.ThrowIfNull("context");
            suggestedResponse.ThrowIfNull("suggestedResponse");

            StatusAndSubStatusCode statusCode = suggestedResponse.StatusCode;

            if (!_statusCodes.Contains(statusCode))
            {
                return(ResponseHandlerResult.ResponseNotHandled());
            }

            AcceptHeader[] acceptHeaders = AcceptHeader.ParseMany(context.Request.Headers["Accept"]).ToArray();

            if (acceptHeaders.Any() && !acceptHeaders.Any(arg => arg.MediaTypeMatches("text/html")))
            {
                return(ResponseHandlerResult.ResponseNotHandled());
            }

            const string format   = @"<!DOCTYPE html>
<html>
	<head>
		<title>{0}</title>
		<style>h1 {{ margin: 0; padding: 0; }}</style>
	</head>
	<body>
		<h1>{0}</h1>
		<hr/>
		HTTP {1}{2}
	</body>
</html>";
            Response     response = new Response(statusCode)
                                    .TextHtml()
                                    .Content(String.Format(format, statusCode.StatusDescription, statusCode.StatusCode, statusCode.SubStatusCode == 0 ? "" : "." + statusCode.SubStatusCode));

            response.CachePolicy.NoClientCaching();

            await new CacheResponse(response).WriteResponseAsync(context.Response);

            context.Response.TrySkipIisCustomErrors = true;

            return(ResponseHandlerResult.ResponseWritten());
        }
Example #31
0
 /// <summary>
 /// Helper method for adding an Accept header to the request.
 /// </summary>
 /// <param name="acceptHeader">The <see cref="AcceptHeader"/>.</param>
 /// <returns>The current instance of <see cref="WebApiRequest"/>.</returns>
 public WebApiRequest AddAcceptHeader(AcceptHeader acceptHeader)
 {
     string headerValue = string.Empty;
     switch (acceptHeader)
     {
         case AcceptHeader.Json:
             headerValue += "application/json";
             break;
         case AcceptHeader.Xml:
             headerValue = "text/xml";
             break;
     }
     headers.Add("Accept", headerValue);
     return this;
 }
Example #32
0
        /// <summary>
        /// Helper method for adding an Accept header to the request.
        /// </summary>
        /// <param name="acceptHeader">The <see cref="AcceptHeader"/>.</param>
        /// <returns>The current instance of <see cref="RestClient"/>.</returns>
        public virtual IRestClient AddAcceptHeader(AcceptHeader acceptHeader)
        {
            string headerValue = string.Empty;
            switch (acceptHeader)
            {
                case AcceptHeader.Json:
                    headerValue += "application/json";
                    break;
                case AcceptHeader.Xml:
                    headerValue = "text/xml";
                    break;
            }

            foreach (var httpRequestMessage in httpRequestMessageList)
            {
                httpRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(headerValue));
            }

            return this;
        }