public HttpResponseMessage Enrich(HttpResponseMessage response)
        {
            PostModel post;
            UrlHelper urlHelper = response.RequestMessage.GetUrlHelper();

            if (response.TryGetContentValue<PostModel>(out post))
            {
                Enrich(post, urlHelper);
                return response;
            }

            PostFeed feed;
            if (response.TryGetContentValue<PostFeed>(out feed))
            {
                foreach (var p in feed.Posts)
                {
                    Enrich(p, urlHelper);
                }

                string selfUrl = urlHelper.Link("DefaultApi", new { controller = "posts" });
                feed.AddLink(new SelfLink(selfUrl));
            }

            return response;
        }
        private static HttpResponseMessage BuildApiResponse(HttpRequestMessage request, HttpResponseMessage response)
        {
            object content;
            string errorMessage = null;

            if (response.TryGetContentValue(out content) && !response.IsSuccessStatusCode)
            {
                HttpError error = content as HttpError;

                if (error != null)
                {
                    content = null;
                    errorMessage = error.Message;

#if DEBUG
                    errorMessage = string.Concat(errorMessage, error.ExceptionMessage, error.StackTrace);
#endif
                }
            }

            var newResponse = request.CreateResponse(response.StatusCode, new ApiResponse(response.StatusCode, content, errorMessage));

            foreach (var header in response.Headers)
            {
                newResponse.Headers.Add(header.Key, header.Value);
            }

            return newResponse;
        }
        private HttpResponseMessage GetResponseMessage(HttpRequestMessage request, HttpResponseMessage response)
        {
            object content;

            if (response.TryGetContentValue(out content))
            {
                var error = content as HttpError;

                if (content is string && !response.IsSuccessStatusCode)
                {
                    content = new {error = content};
                }
                else if (error != null)
                {
                    if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        error.Message = "Internal server error.";
                    }
                    content = GetErrorResult(error);
                }
                else
                {
                    content = new {result = content};
                }
            }

            if (content != null)
                response.Content = new ObjectContent(content.GetType(), content, JsonFormatter);
            return response;
        }
        public HttpResponseMessage Enrich(HttpResponseMessage response) {

            Car car;
            UrlHelper urlHelper = response.RequestMessage.GetUrlHelper();
            if (response.TryGetContentValue<Car>(out car)) {
                Enrich(car, urlHelper);
            }

            IEnumerable<Car> cars;
            if (response.TryGetContentValue<IEnumerable<Car>>(out cars)) {
                foreach (var carItem in cars) {
                    Enrich(carItem, urlHelper);
                }
            }

            return response;
        }
        public HttpResponseMessage Enrich(HttpResponseMessage response)
        {
            TodoRepresentation todo;

            var urlHelper = response.RequestMessage.GetUrlHelper();

            if (response.TryGetContentValue(out todo))
            {
                Enrich(todo, urlHelper);
                return response;
            }

            List<TodoRepresentation> representations;
            if (response.TryGetContentValue(out representations))
            {
                representations.ToList().ForEach(p => Enrich(p, urlHelper));
            }

            return response;
        }
        public HttpResponseMessage Enrich(HttpResponseMessage response) {

            MediaModel media;

            var urlHelper = response.RequestMessage.GetUrlHelper();

            if (response.TryGetContentValue<MediaModel>(out media)) {
                Enrich(media, urlHelper);
            }

            return response;
        }
        protected virtual void WrapResultIfNeeded(HttpRequestMessage request, HttpResponseMessage response)
        {
            if (!response.IsSuccessStatusCode)
            {
                return;
            }

            if (_configuration.SetNoCacheForAllResponses)
            {
                //Based on http://stackoverflow.com/questions/49547/making-sure-a-web-page-is-not-cached-across-all-browsers
                response.Headers.CacheControl = new CacheControlHeaderValue
                {
                    NoCache = true,
                    NoStore = true,
                    MaxAge = TimeSpan.Zero,
                    MustRevalidate = true
                };
            }

            var wrapAttr = HttpActionDescriptorHelper.GetWrapResultAttributeOrNull(request.GetActionDescriptor())
                           ?? _configuration.DefaultWrapResultAttribute;

            if (!wrapAttr.WrapOnSuccess)
            {
                return;
            }

            if (IsIgnoredUrl(request.RequestUri))
            {
                return;
            }

            object resultObject;
            if (!response.TryGetContentValue(out resultObject) || resultObject == null)
            {
                response.StatusCode = HttpStatusCode.OK;
                response.Content = new ObjectContent<AjaxResponse>(
                    new AjaxResponse(),
                    _configuration.HttpConfiguration.Formatters.JsonFormatter
                    );
                return;
            }

            if (resultObject is AjaxResponseBase)
            {
                return;
            }

            response.Content = new ObjectContent<AjaxResponse>(
                new AjaxResponse(resultObject),
                _configuration.HttpConfiguration.Formatters.JsonFormatter
                );
        }
        public void TryGetContentValue_WhenResponseHasNoContent_ReturnsFalse <T>(T expectedResult)
        {
            T value;

            Assert.False(_response.TryGetContentValue <T>(out value));

            Assert.Equal(expectedResult, value);
        }
Пример #9
0
        public void CreateBadRequest_CreatesDefaultResponse()
        {
            // Arrange
            HttpError error;

            // Act
            HttpResponseMessage response = this.request.CreateBadRequestResponse();

            response.TryGetContentValue(out error);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Contains("The request is invalid as submitted", error.Message);
        }
Пример #10
0
        public void CreateNotFound_CreatesDefaultResponse()
        {
            // Arrange
            HttpError error;

            // Act
            HttpResponseMessage response = this.request.CreateNotFoundResponse();

            response.TryGetContentValue(out error);

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
            Assert.Contains("No HTTP resource was found that matches", error.Message);
        }
Пример #11
0
        public void CreateBadRequestResponse_CreatesResponse(string format, object[] args)
        {
            // Arrange
            HttpError error;
            string    expected = (args != null && args.Length > 0) ? string.Format(format, args) : format;

            // Act
            HttpResponseMessage response = this.request.CreateBadRequestResponse(format, args);

            response.TryGetContentValue(out error);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal(expected, error.Message);
        }
Пример #12
0
        public void CreateErrorResponse_Respects_IncludeErrorDetail(IncludeErrorDetailPolicy errorDetail, bool?isLocal, bool?includeErrorDetail, bool detailIncluded)
        {
            HttpConfiguration config = new HttpConfiguration()
            {
                IncludeErrorDetailPolicy = errorDetail
            };
            HttpRequestMessage request = new HttpRequestMessage();

            request.SetConfiguration(config);
            if (isLocal.HasValue)
            {
                request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy <bool>(() => isLocal.Value));
            }
            if (includeErrorDetail.HasValue)
            {
                request.Properties.Add(HttpPropertyKeys.IncludeErrorDetailKey, new Lazy <bool>(() => includeErrorDetail.Value));
            }
            ODataError error = new ODataError()
            {
                ErrorCode       = "36",
                Message         = "Bad stuff",
                MessageLanguage = "en-US",
                InnerError      = new ODataInnerError()
                {
                    Message = "Exception message"
                }
            };

            HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, error);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            ODataError contentError;

            Assert.True(response.TryGetContentValue <ODataError>(out contentError));
            Assert.Equal("36", contentError.ErrorCode);
            Assert.Equal("Bad stuff", contentError.Message);
            Assert.Equal("en-US", contentError.MessageLanguage);
            if (detailIncluded)
            {
                Assert.NotNull(contentError.InnerError);
                Assert.Equal("Exception message", contentError.InnerError.Message);
            }
            else
            {
                Assert.Null(contentError.InnerError);
            }
        }
Пример #13
0
        /// <summary>
        /// SDataContent transforms OData/Web API Content/Response to SData
        /// </summary>
        /// <param name="response">The response containing the Content/Payload to transform</param>
        public SDataContent(HttpResponseMessage response)
        {
            origResponse = response;
            originalContent = origResponse.Content;

            if (originalContent == null)
            {
                throw new ArgumentNullException("response");
            }

            foreach (var header in originalContent.Headers)
            {
                Headers.Add(header.Key, header.Value);
            }

            origResponse.TryGetContentValue(out responseObject);
        }
        protected virtual void WrapResultIfNeeded(HttpRequestMessage request, HttpResponseMessage response)
        {
            if (!response.IsSuccessStatusCode)
            {
                return;
            }

            var wrapAttr = HttpActionDescriptorHelper.GetWrapResultAttributeOrNull(request.GetActionDescriptor())
                           ?? DontWrapResultAttribute.Default;

            if (!wrapAttr.WrapOnSuccess)
            {
                return;
            }

            object resultObject;
            if (!response.TryGetContentValue(out resultObject))
            {
                return;
            }

            if (resultObject == null)
            {
                response.Content = new ObjectContent<AjaxResponse>(
                    new AjaxResponse(),
                    _webApiModuleConfiguration.HttpConfiguration.Formatters.JsonFormatter
                    );
            }

            if (resultObject is AjaxResponse)
            {
                return;
            }

            response.Content = new ObjectContent<AjaxResponse>(
                new AjaxResponse(resultObject),
                _webApiModuleConfiguration.HttpConfiguration.Formatters.JsonFormatter
                );
        }