public PipelineContinuation FindResponseCodec(ICommunicationContext context)
        {
            if (context.Response.Entity.Instance == null || context.PipelineData.ResponseCodec != null)
            {
                LogNoResponseEntity();
                return(PipelineContinuation.Continue);
            }

            string acceptHeader = context.Request.Headers[HEADER_ACCEPT];

            IEnumerable <MediaType> acceptedContentTypes =
                MediaType.Parse(string.IsNullOrEmpty(acceptHeader) ? "*/*" : acceptHeader);

            IType responseEntityType = _typeSystem.FromInstance(context.Response.Entity.Instance);

            IEnumerable <CodecRegistration> sortedCodecs = _codecs.FindMediaTypeWriter(responseEntityType,
                                                                                       acceptedContentTypes);
            int codecsCount = sortedCodecs.Count();
            CodecRegistration negotiatedCodec = sortedCodecs.FirstOrDefault();

            if (negotiatedCodec != null)
            {
                LogCodecSelected(responseEntityType, negotiatedCodec, codecsCount);
                context.Response.Entity.ContentType = negotiatedCodec.MediaType.WithoutQuality();
                context.PipelineData.ResponseCodec  = negotiatedCodec;
            }
            else
            {
                context.OperationResult = ResponseEntityHasNoCodec(acceptHeader, responseEntityType);
                return(PipelineContinuation.RenderNow);
            }

            return(PipelineContinuation.Continue);
        }
        PipelineContinuation FindResponseCodec(ICommunicationContext context)
        {
            if (context.Response.Entity.Instance == null || context.PipelineData.ResponseCodec != null)
            {
                LogNoResponseEntity();
                return(PipelineContinuation.Continue);
            }

            var acceptHeader = context.Request.Headers[HEADER_ACCEPT];

            var responseEntityType = _typeSystem.FromInstance(context.Response.Entity.Instance);
            IEnumerable <MediaType> acceptedContentTypes;

            try
            {
                acceptedContentTypes = MediaType.Parse(string.IsNullOrEmpty(acceptHeader) ? "*/*" : acceptHeader);
            }
            catch (FormatException)
            {
                Log.WriteWarning("Accept header: {0} is malformed", acceptHeader);

                context.Response.Headers["Warning"] = "199 Malformed accept header";
                context.OperationResult             = new OperationResult.BadRequest();
                return(PipelineContinuation.RenderNow);
            }

            var sortedCodecs    = _codecs.FindMediaTypeWriter(responseEntityType, acceptedContentTypes).ToList();
            var codecsCount     = sortedCodecs.Count;
            var negotiatedCodec = sortedCodecs.FirstOrDefault();

            if (negotiatedCodec != null)
            {
                LogCodecSelected(responseEntityType, negotiatedCodec, codecsCount);
                context.Response.Entity.ContentType =
                    negotiatedCodec.MediaType.IsWildCard
            ? acceptedContentTypes
                    .OrderByDescending(c => c)
                    .Where(c => c.IsWildCard == false)
                    .DefaultIfEmpty(MediaType.ApplicationOctetStream)
                    .FirstOrDefault()
            : negotiatedCodec.MediaType.WithoutQuality();
                context.PipelineData.ResponseCodec = negotiatedCodec;

                context.Response.Headers["Vary"] = "Accept";
            }
            else
            {
                Log.WriteWarning($"Cound not find codec for {responseEntityType} with Accept header {acceptHeader}");
                context.OperationResult = ResponseEntityHasNoCodec(acceptHeader, responseEntityType);
                return(PipelineContinuation.RenderNow);
            }

            return(PipelineContinuation.Continue);
        }
Exemple #3
0
        public PipelineContinuation FindResponseCodec(ICommunicationContext context)
        {
            if (context.Response.Entity.Instance == null || context.Environment.ResponseCodec != null)
            {
                LogNoResponseEntity();
                return(PipelineContinuation.Continue);
            }

            string acceptHeader = context.Request.Headers[HEADER_ACCEPT];

            IEnumerable <MediaType> acceptedContentTypes =
                MediaType.Parse(string.IsNullOrEmpty(acceptHeader) ? "*/*" : acceptHeader);
            IType responseEntityType = _typeSystem.FromInstance(context.Response.Entity.Instance);

            IEnumerable <CodecRegistration> sortedCodecs = _codecs.FindMediaTypeWriter(responseEntityType,
                                                                                       acceptedContentTypes);

            int codecsCount = sortedCodecs.Count();
            CodecRegistration negotiatedCodec = sortedCodecs.FirstOrDefault();

            if (negotiatedCodec != null)
            {
                LogCodecSelected(responseEntityType, negotiatedCodec, codecsCount);

                context.Response.Entity.ContentType = negotiatedCodec.MediaType.WithoutQuality();
                context.Environment.ResponseCodec   = negotiatedCodec;
                context.Response.Headers.Add("Vary", "Content-Type");
                try
                {
                    var resourceUri = context.OperationResult.ResponseResource.CreateUri();
                    SetAlternateRepresentationLinks(context, sortedCodecs, negotiatedCodec, resourceUri);
                    SetCanonicalLink(context, resourceUri);
                    context.Response.Entity.ContentLocation = GetContentLocationFromCodec(resourceUri, negotiatedCodec);
                }
                catch
                {
                }
            }
            else
            {
                context.OperationResult = ResponseEntityHasNoCodec(acceptHeader, responseEntityType);
                return(PipelineContinuation.RenderNow);
            }
            return(PipelineContinuation.Continue);
        }
        public PipelineContinuation FindResponseCodec(ICommunicationContext context)
        {
            if (context.Response.Entity.Instance == null || context.PipelineData.ResponseCodec != null)
            {
                LogNoResponseEntity();
                return(PipelineContinuation.Continue);
            }

            string acceptHeader = context.Request.Headers[HEADER_ACCEPT];


            var responseEntityType = _typeSystem.FromInstance(context.Response.Entity.Instance);
            IEnumerable <MediaType> acceptedContentTypes;

            try
            {
                acceptedContentTypes = MediaType.Parse(string.IsNullOrEmpty(acceptHeader) ? "*/*" : acceptHeader);
            }
            catch (FormatException)
            {
                Log.WriteWarning("Accept header: {0} is malformed", acceptHeader);

                context.Response.Headers["Warning"] = "199 Malformed accept header";
                context.OperationResult             = new OperationResult.BadRequest();
                return(PipelineContinuation.RenderNow);
            }

            var sortedCodecs    = _codecs.FindMediaTypeWriter(responseEntityType, acceptedContentTypes);
            int codecsCount     = sortedCodecs.Count();
            var negotiatedCodec = sortedCodecs.FirstOrDefault();

            if (negotiatedCodec != null)
            {
                LogCodecSelected(responseEntityType, negotiatedCodec, codecsCount);
                context.Response.Entity.ContentType = negotiatedCodec.MediaType.WithoutQuality();
                context.PipelineData.ResponseCodec  = negotiatedCodec;
            }
            else
            {
                context.OperationResult = ResponseEntityHasNoCodec(acceptHeader, responseEntityType);
                return(PipelineContinuation.RenderNow);
            }
            return(PipelineContinuation.Continue);
        }
 public void the_instance_cannot_be_null()
 {
     Executing(() => TypeSystem.FromInstance(null))
     .ShouldThrow <ArgumentNullException>();
 }