private static void PrepareQueryContext(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            if (!request.Properties.ContainsKey(Constants.PropertyNames.QueryContext))
            {
                return;
            }

            var queryContext = (QueryContext)request.Properties[Constants.PropertyNames.QueryContext];

            if (queryContext.Filtering != null)
            {
                queryContext.Filtering.QueryFilters = config.QueryFilterExpressions;
            }

            PaginationContext pagination = queryContext.Pagination;

            if (pagination != null)
            {
                if (!pagination.PageSizeLimit.HasValue)
                {
                    pagination.PageSizeLimit = config.PaginationConfig.DefaultPageSizeLimit;
                }

                if (!pagination.PerPage.HasValue)
                {
                    pagination.PerPage = config.PaginationConfig.DefaultPageSize;
                }
            }

            jsonApiSerializer.QueryContext = queryContext;
        }
        private static void PrepareUrlPathBuilder(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config,
            ApiResource resource)
        {
            var result = config.UrlPathBuilder;
            if (resource == null)
            {
                result = result ?? new DefaultUrlPathBuilder();
            }
            else if (!request.Properties.ContainsKey("MS_RequestContext"))
            {
                result = result ?? new DefaultUrlPathBuilder();
            }
            else
            {
                var routeTemplate = (request.Properties["MS_RequestContext"] as HttpRequestContext)
                    ?.RouteData.Route.RouteTemplate;
                result = result ?? new DefaultUrlPathBuilder(
                    routeTemplate, resource);
            }

            jsonApiSerializer.UrlPathBuilder = result;
        }
        internal static PreprocessResult PreprocessRequest(
            object content,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            var jsonApi = new JsonApiSerializer();
            jsonApi.JsonConverters.AddRange(config.JsonConverters);

            PrepareQueryContext(jsonApi, request, config);

            ApiResource resource = null;
            if (request.Properties.ContainsKey(Constants.RequestPropertyName))
            {
                resource = (ApiResource)request.Properties[Constants.RequestPropertyName];
            }
            else if (content != null && !(content is HttpError))
            {
                content = new JsonApiException(
                    ErrorType.Server,
                    "You must add a [ReturnsResourceAttribute] to action methods.")
                {
                    HelpLink = "https://github.com/joukevandermaas/saule/wiki"
                };
            }

            PrepareUrlPathBuilder(jsonApi, request, config);

            return jsonApi.PreprocessContent(content, resource, request.RequestUri);
        }
 internal JsonApiMediaTypeFormatter(
     HttpRequestMessage request,
     JsonApiConfiguration config)
     : this(config)
 {
     _request = request;
 }
Exemplo n.º 5
0
        /// <summary>
        ///  Sets up serialization and deserialization of Json Api resources.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
        /// <param name="jsonApiConfiguration">JsonApiConfiguration parameters for Json Api serialization.</param>
        /// <param name="formatterPriority"> Determines the relative position of the JSON API formatter.</param>
        public static void ConfigureJsonApi(
            this HttpConfiguration config,
            JsonApiConfiguration jsonApiConfiguration,
            FormatterPriority formatterPriority)
        {
            JsonApiAttribute.JsonApiConfiguration = jsonApiConfiguration;

            config.MessageHandlers.Add(new PreprocessingDelegatingHandler(jsonApiConfiguration));

            config.Services.Add(typeof(ValueProviderFactory), new JsonApiQueryValueProviderFactory());

            var formatter = new JsonApiMediaTypeFormatter(jsonApiConfiguration);

            if (formatterPriority == FormatterPriority.OverwriteOtherFormatters)
            {
                config.Formatters.Clear();
                config.Formatters.Add(formatter);
            }
            else if (formatterPriority == FormatterPriority.AddFormatterToEnd)
            {
                config.Formatters.Add(formatter);
            }
            else if (formatterPriority == FormatterPriority.AddFormatterToStart)
            {
                config.Formatters.Insert(0, formatter);
            }
        }
Exemplo n.º 6
0
        internal static void ProcessRequest(HttpRequestMessage request, HttpResponseMessage response, JsonApiConfiguration config, bool requiresMediaType)
        {
            var hasMediaType = request.Headers.Accept.Any(x => x.MediaType == Constants.MediaType);

            var statusCode = (int)response.StatusCode;

            if ((requiresMediaType && !hasMediaType) || (statusCode >= 400 && statusCode < 500))
            {
                // probably malformed request or not found
                return;
            }

            var value = response.Content as ObjectContent;

            if (config == null)
            {
                config = new JsonApiConfiguration();
            }

            var content = PreprocessingDelegatingHandler.PreprocessRequest(value?.Value, request, config);

            if (content.ErrorContent != null)
            {
                response.StatusCode = ApiError.IsClientError(content.ErrorContent)
                    ? HttpStatusCode.BadRequest
                    : HttpStatusCode.InternalServerError;
            }

            request.Properties.Add(Constants.PropertyNames.PreprocessResult, content);
        }
Exemplo n.º 7
0
        internal static PreprocessResult PreprocessRequest(
            object content,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            var jsonApi = new JsonApiSerializer();

            jsonApi.JsonConverters.AddRange(config.JsonConverters);

            PrepareQueryContext(jsonApi, request, config);

            ApiResource resource = null;

            if (request.Properties.ContainsKey(Constants.PropertyNames.ResourceDescriptor))
            {
                resource = (ApiResource)request.Properties[Constants.PropertyNames.ResourceDescriptor];
            }
            else if (content != null && !(content is HttpError))
            {
                content = new JsonApiException(
                    ErrorType.Server,
                    "You must add a [ReturnsResourceAttribute] to action methods.")
                {
                    HelpLink = "https://github.com/joukevandermaas/saule/wiki"
                };
            }

            PrepareUrlPathBuilder(jsonApi, request, config);

            return(jsonApi.PreprocessContent(content, resource, request.RequestUri));
        }
Exemplo n.º 8
0
 internal JsonApiMediaTypeFormatter(
     HttpRequestMessage request,
     JsonApiConfiguration config)
     : this(config)
 {
     _request = request;
 }
Exemplo n.º 9
0
 /// <summary>
 /// Sets up serialization and deserialization of Json Api resources.
 /// </summary>
 /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
 /// <param name="jsonApiConfiguration">JsonApiConfiguration parameters for Json Api serialization.</param>
 /// <param name="overwriteOtherFormatters">
 /// If true, other formatters will be cleared. Otherwise, the JSON API formatter
 /// will be inserted at the start of the collection.
 /// </param>
 public static void ConfigureJsonApi(
     this HttpConfiguration config,
     JsonApiConfiguration jsonApiConfiguration,
     bool overwriteOtherFormatters)
 {
     if (overwriteOtherFormatters)
     {
         ConfigureJsonApi(config, jsonApiConfiguration, FormatterPriority.OverwriteOtherFormatters);
     }
     else
     {
         ConfigureJsonApi(config, jsonApiConfiguration, FormatterPriority.AddFormatterToStart);
     }
 }
Exemplo n.º 10
0
        /// <summary>
        /// Sets up serialization and deserialization of Json Api resources.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
        /// <param name="jsonApiConfiguration">Configuration parameters for Json Api serialization.</param>
        /// <param name="overwriteOtherFormatters">
        /// If true, other formatters will be cleared. Otherwise, the JSON API formatter
        /// will be inserted at the start of the collection.
        /// </param>
        public static void ConfigureJsonApi(
            this HttpConfiguration config,
            JsonApiConfiguration jsonApiConfiguration,
            bool overwriteOtherFormatters)
        {
            config.MessageHandlers.Add(new PreprocessingDelegatingHandler(jsonApiConfiguration));
            var formatter = new JsonApiMediaTypeFormatter(jsonApiConfiguration);

            if (overwriteOtherFormatters)
            {
                config.Formatters.Clear();
                config.Formatters.Add(formatter);
            }
            else
            {
                config.Formatters.Insert(0, formatter);
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Sets up serialization and deserialization of Json Api resources.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
        /// <param name="jsonApiConfiguration">Configuration parameters for Json Api serialization.</param>
        /// <param name="overwriteOtherFormatters">
        /// If true, other formatters will be cleared. Otherwise, the JSON API formatter
        /// will be inserted at the start of the collection.
        /// </param>
        public static void ConfigureJsonApi(
            this HttpConfiguration config,
            JsonApiConfiguration jsonApiConfiguration,
            bool overwriteOtherFormatters)
        {
            config.MessageHandlers.Add(new PreprocessingDelegatingHandler(jsonApiConfiguration));
            var formatter = new JsonApiMediaTypeFormatter(jsonApiConfiguration);

            if (overwriteOtherFormatters)
            {
                config.Formatters.Clear();
                config.Formatters.Add(formatter);
            }
            else
            {
                config.Formatters.Insert(0, formatter);
            }
        }
Exemplo n.º 12
0
        private static void PrepareQueryContext(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            if (!request.Properties.ContainsKey(Constants.PropertyNames.QueryContext))
            {
                return;
            }

            var queryContext = (QueryContext)request.Properties[Constants.PropertyNames.QueryContext];

            if (queryContext.Filtering != null)
            {
                queryContext.Filtering.QueryFilters = config.QueryFilterExpressions;
            }

            jsonApiSerializer.QueryContext = queryContext;
        }
        internal NewSetupJsonApiServer(JsonApiConfiguration config)
        {
            var httpConfig = new HttpConfiguration();
            if (config == null)
            {
                httpConfig.ConfigureJsonApi();
            }
            else
            {
                httpConfig.ConfigureJsonApi(config);
            }

            httpConfig.MapHttpAttributeRoutes(new DefaultDirectRouteProvider());

            _server = TestServer.Create(builder =>
            {
                builder.UseWebApi(httpConfig);
            });
        }
Exemplo n.º 14
0
        /// <summary>
        ///  Sets up serialization and deserialization of Json Api resources.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
        /// <param name="jsonApiConfiguration">Configuration parameters for Json Api serialization.</param>
        /// <param name="formatterPriority"> Determines the relative position of the JSON API formatter.</param>
        public static void ConfigureJsonApi(
            this HttpConfiguration config,
            JsonApiConfiguration jsonApiConfiguration,
            FormatterPriority formatterPriority)
        {
            config.MessageHandlers.Add(new PreprocessingDelegatingHandler(jsonApiConfiguration));
            var formatter = new JsonApiMediaTypeFormatter(jsonApiConfiguration);

            if (formatterPriority == FormatterPriority.OverwriteOtherFormatters)
            {
                config.Formatters.Clear();
                config.Formatters.Add(formatter);
            }
            else if (formatterPriority == FormatterPriority.AddFormatterToEnd)
            {
                config.Formatters.Add(formatter);
            }
            else if (formatterPriority == FormatterPriority.AddFormatterToStart)
            {
                config.Formatters.Insert(0, formatter);
            }
        }
Exemplo n.º 15
0
        /// <summary>
        /// See base class documentation.
        /// </summary>
        /// <param name="context">The action context.</param>
        public override void OnActionExecuted(HttpActionExecutedContext context)
        {
            var config = new JsonApiConfiguration();

            if (context.Exception != null)
            {
                throw context.Exception;
            }

            JsonApiProcessor.ProcessRequest(context.Request, context.Response, config, requiresMediaType: false);

            var responseContent = context.Response.Content as ObjectContent;

            if (responseContent == null)
            {
                return;
            }

            var formatter = new JsonApiMediaTypeFormatter(context.Request, config);

            context.Response.Content = new ObjectContent(responseContent.ObjectType, responseContent.Value, formatter);
        }
Exemplo n.º 16
0
        private static void PrepareUrlPathBuilder(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            if (config.UrlPathBuilder != null)
            {
                jsonApiSerializer.UrlPathBuilder = config.UrlPathBuilder;
            }
            else if (!request.Properties.ContainsKey(Constants.PropertyNames.WebApiRequestContext))
            {
                jsonApiSerializer.UrlPathBuilder = new DefaultUrlPathBuilder();
            }
            else
            {
                var requestContext = request.Properties[Constants.PropertyNames.WebApiRequestContext]
                                     as HttpRequestContext;
                var routeTemplate   = requestContext?.RouteData.Route.RouteTemplate;
                var virtualPathRoot = requestContext?.VirtualPathRoot ?? "/";

                jsonApiSerializer.UrlPathBuilder = new DefaultUrlPathBuilder(
                    virtualPathRoot, routeTemplate);
            }
        }
        private static void PrepareUrlPathBuilder(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            if (config.UrlPathBuilder != null)
            {
                jsonApiSerializer.UrlPathBuilder = config.UrlPathBuilder;
            }
            else if (!request.Properties.ContainsKey(Constants.WebApiRequestContextPropertyName))
            {
                jsonApiSerializer.UrlPathBuilder = new DefaultUrlPathBuilder();
            }
            else
            {
                var requestContext = request.Properties[Constants.WebApiRequestContextPropertyName]
                    as HttpRequestContext;
                var routeTemplate = requestContext?.RouteData.Route.RouteTemplate;
                var virtualPathRoot = requestContext?.VirtualPathRoot ?? "/";

                jsonApiSerializer.UrlPathBuilder = new DefaultUrlPathBuilder(
                    virtualPathRoot, routeTemplate);
            }
        }
Exemplo n.º 18
0
 /// <summary>
 /// Sets up serialization and deserialization of Json Api resources.
 /// </summary>
 /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
 /// <param name="jsonApiConfiguration">Configuration parameters for Json Api serialization.</param>
 public static void ConfigureJsonApi(this HttpConfiguration config, JsonApiConfiguration jsonApiConfiguration)
 {
     ConfigureJsonApi(config, jsonApiConfiguration, false);
 }
Exemplo n.º 19
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PreprocessingDelegatingHandler"/> class.
 /// </summary>
 /// <param name="config">The configuration parameters for JSON API serialization.</param>
 public PreprocessingDelegatingHandler(JsonApiConfiguration config)
 {
     _config = config;
 }
        public async Task ConverterConstructor()
        {
            var config = new JsonApiConfiguration
            {
                JsonConverters = { new StringEnumConverter() }
            };

            using (var server = new NewSetupJsonApiServer(config))
            {
                var client = server.GetClient();
                var result = await client.GetJsonResponseAsync("api/companies/456/");
                _output.WriteLine(result.ToString());

                Assert.Equal("National", result["data"]["attributes"]["location"].Value<string>());
            }
        }
        public async Task BuilderAndConverterConstructor()
        {
            var config = new JsonApiConfiguration
            {
                UrlPathBuilder = new CanonicalUrlPathBuilder(),
                JsonConverters = { new StringEnumConverter() }
            };

            using (var server = new NewSetupJsonApiServer(config))
            {
                var client = server.GetClient();
                var result = await client.GetJsonResponseAsync("api/companies/456/");
                _output.WriteLine(result.ToString());

                Assert.Equal("National", result["data"]["attributes"]["location"].Value<string>());

                result = await client.GetJsonResponseAsync("api/people/");
                _output.WriteLine(result.ToString());

                var relatedUrl = result["data"][0]["relationships"]["job"]["links"]["related"]
                    .Value<string>();
                Assert.Equal("http://localhost/corporations/456/", relatedUrl);
            }
        }
        public async Task UsesQueryFilterExpression()
        {
            var config = new JsonApiConfiguration();
            config.QueryFilterExpressions.SetExpression<string>((left, right) => left != right);

            using (var server = new NewSetupJsonApiServer(config))
            {
                var client = server.GetClient();
                var result = await client.GetJsonResponseAsync("api/query/people?filter[last-name]=Russel");
                _output.WriteLine(result.ToString());

                var names = ((JArray)result["data"])
                    .Select(p => p["attributes"]["last-name"].Value<string>())
                    .ToList();

                var filtered = names.Where(a => a != "Russel").ToList();

                Assert.Equal(filtered.Count, names.Count);
            }

        }
Exemplo n.º 23
0
 /// <summary>
 /// Sets up serialization and deserialization of Json Api resources.
 /// </summary>
 /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
 /// <param name="jsonApiConfiguration">JsonApiConfiguration parameters for Json Api serialization.</param>
 public static void ConfigureJsonApi(this HttpConfiguration config, JsonApiConfiguration jsonApiConfiguration)
 {
     ConfigureJsonApi(config, jsonApiConfiguration, false);
 }
        private static void PrepareQueryContext(
            JsonApiSerializer jsonApiSerializer,
            HttpRequestMessage request,
            JsonApiConfiguration config)
        {
            if (!request.Properties.ContainsKey(Constants.QueryContextPropertyName))
            {
                return;
            }

            var queryContext = (QueryContext)request.Properties[Constants.QueryContextPropertyName];

            if (queryContext.Filtering != null)
            {
                queryContext.Filtering.QueryFilters = config.QueryFilterExpressions;
            }

            jsonApiSerializer.QueryContext = queryContext;
        }
 public PreprocessingDelegatingHandler(JsonApiConfiguration config)
 {
     _config = config;
 }
 internal JsonApiMediaTypeFormatter(JsonApiConfiguration config)
 {
     SupportedMediaTypes.Add(new MediaTypeHeaderValue(Constants.MediaType));
     _config = config;
 }
Exemplo n.º 27
0
 /// <summary>
 /// Sets up serialization and deserialization of Json Api resources.
 /// </summary>
 /// <param name="config">The <see cref="HttpConfiguration"/> that is used in the setup of the application.</param>
 /// <param name="jsonApiConfiguration">Configuration parameters for Json Api serialization.</param>
 public static void ConfigureJsonApi(this HttpConfiguration config, JsonApiConfiguration jsonApiConfiguration)
 {
     config.MessageHandlers.Add(new PreprocessingDelegatingHandler(jsonApiConfiguration));
     config.Formatters.Clear();
     config.Formatters.Add(new JsonApiMediaTypeFormatter(jsonApiConfiguration));
 }
Exemplo n.º 28
0
 public ResourceSerializer(JsonSerializer serializer = null, JsonApiConfiguration config = null, IUrlPathBuilder urlBuilder = null)
 {
     _serializer = serializer ?? new JsonSerializer { ReferenceLoopHandling = ReferenceLoopHandling.Ignore };
     _config = config ?? new JsonApiConfiguration();
     _urlBuilder = urlBuilder ?? new DefaultUrlPathBuilder();
 }
Exemplo n.º 29
0
 internal JsonApiMediaTypeFormatter(JsonApiConfiguration config)
 {
     SupportedMediaTypes.Add(new MediaTypeHeaderValue(Constants.MediaType));
     _config = config;
 }