Пример #1
0
        /// <summary>Processes the HTTP request accept.</summary>
        /// <param name="context">The context.</param>
        /// <param name="contextResolver">The API request context resolver.</param>
        /// <param name="formatterFactory">The formatter factory.</param>
        /// <returns></returns>
        internal static async Task <bool> ProcessHttpRequestAccept(this ApiRequestContext context, IApiRequestContextResolver contextResolver, IDeepSleepMediaSerializerFactory formatterFactory)
        {
            if (!context.RequestAborted.IsCancellationRequested)
            {
                if (context.Request != null)
                {
                    var returnType = context.Routing.Route.Location.MethodReturnType;

                    if (returnType == typeof(void) || returnType == typeof(Task))
                    {
                        return(true);
                    }

                    var accept = !string.IsNullOrWhiteSpace(context.Request.Accept)
                        ? context.Request.Accept
                        : AcceptHeader.All();

                    IDeepSleepMediaSerializer         formatter            = null;
                    IList <IDeepSleepMediaSerializer> overridingFormatters = null;

                    if (context.Configuration.ReadWriteConfiguration?.WriterResolver != null)
                    {
                        var overrides = await context.Configuration.ReadWriteConfiguration.WriterResolver(context?.RequestServices).ConfigureAwait(false);

                        overridingFormatters = overrides?.Formatters;
                    }

                    if (formatterFactory != null)
                    {
                        formatter = await formatterFactory.GetAcceptableFormatter(
                            acceptHeader : context.Configuration?.ReadWriteConfiguration?.AcceptHeaderOverride ?? accept,
                            objType : returnType,
                            writeableMediaTypes : context.Configuration?.ReadWriteConfiguration?.WriteableMediaTypes,
                            writeableFormatters : overridingFormatters,
                            formatterType : out var _).ConfigureAwait(false);


                        if (formatter == null && context.Configuration?.ReadWriteConfiguration?.AcceptHeaderFallback != null as AcceptHeader)
                        {
                            formatter = await formatterFactory.GetAcceptableFormatter(
                                acceptHeader : context.Configuration?.ReadWriteConfiguration.AcceptHeaderFallback,
                                objType : returnType,
                                writeableMediaTypes : context.Configuration?.ReadWriteConfiguration?.WriteableMediaTypes,
                                writeableFormatters : overridingFormatters,
                                formatterType : out var _).ConfigureAwait(false);
                        }
                    }

                    if (formatter == null)
                    {
                        var formatterTypes = formatterFactory != null
                            ? formatterFactory.GetWriteableTypes(objType : returnType, overridingFormatters : overridingFormatters) ?? new List <string>()
                            : new DeepSleepMediaSerializerWriterFactory(context.RequestServices).GetWriteableTypes(objType: returnType, overridingFormatters) ?? new List <string>();

                        var writeableMediaTypes = context.Configuration?.ReadWriteConfiguration?.WriteableMediaTypes ?? formatterTypes ?? new List <string>();

                        var acceptableTypes = writeableMediaTypes
                                              .Where(w => formatterTypes.Any(f => string.Equals(f, w, System.StringComparison.InvariantCultureIgnoreCase)))
                                              .ToList();

                        string acceptable = (acceptableTypes != null && acceptableTypes.Count > 0)
                            ? string.Join(", ", acceptableTypes)
                            : string.Empty;

                        context.Response.AddHeader("X-Allow-Accept", acceptable);
                        context.Response.StatusCode = 406;
                        return(false);
                    }
                }

                return(true);
            }

            return(false);
        }
Пример #2
0
        /// <summary>Processes the HTTP response body writing.</summary>
        /// <param name="context">The context.</param>
        /// <param name="contextResolver">The context resolver.</param>
        /// <param name="formatterFactory">The formatter factory.</param>
        /// <returns></returns>
        internal static async Task <bool> ProcessHttpResponseBodyWriting(this ApiRequestContext context, IApiRequestContextResolver contextResolver, IDeepSleepMediaSerializerFactory formatterFactory)
        {
            if (!context.RequestAborted.IsCancellationRequested)
            {
                var isWriteableResponse = false;

                if (context.Response.ResponseObject != null && formatterFactory != null)
                {
                    var accept = !string.IsNullOrWhiteSpace(context.Request.Accept)
                        ? context.Request.Accept
                        : AcceptHeader.All();


                    Encoding acceptEncoding = null;

                    if (context.Request.AcceptCharset != null as string)
                    {
                        foreach (var value in context.Request.AcceptCharset.Values)
                        {
                            try
                            {
                                if (!string.IsNullOrWhiteSpace(value.Charset))
                                {
                                    acceptEncoding = Encoding.GetEncoding(value.Charset);
                                }

                                if (acceptEncoding != null)
                                {
                                    break;
                                }
                            }
                            catch { }
                        }
                    }

                    IMediaSerializerOptions options = new MediaSerializerOptions
                    {
                        Culture  = context.Request.AcceptCulture,
                        Encoding = acceptEncoding ?? Encoding.UTF8
                    };

                    var returnType = context.Response.ResponseObject.GetType();

                    var formatter = await formatterFactory.GetAcceptableFormatter(
                        objType : returnType,
                        acceptHeader : context.Configuration?.ReadWriteConfiguration?.AcceptHeaderOverride ?? accept,
                        writeableMediaTypes : context.Configuration?.ReadWriteConfiguration?.WriteableMediaTypes,
                        formatterType : out var formatterType).ConfigureAwait(false);

                    if (context.Configuration.ReadWriteConfiguration?.WriterResolver != null)
                    {
                        var overrides = await context.Configuration.ReadWriteConfiguration.WriterResolver(context?.RequestServices).ConfigureAwait(false);

                        if (overrides?.Formatters != null)
                        {
                            formatter = await formatterFactory.GetAcceptableFormatter(
                                objType : returnType,
                                acceptHeader : context.Configuration?.ReadWriteConfiguration?.AcceptHeaderOverride ?? accept,
                                writeableMediaTypes : context.Configuration?.ReadWriteConfiguration?.WriteableMediaTypes,
                                writeableFormatters : overrides.Formatters,
                                formatterType : out formatterType).ConfigureAwait(false);
                        }
                    }

                    if (formatter != null)
                    {
                        isWriteableResponse                    = true;
                        context.Response.ResponseWriter        = formatter;
                        context.Response.ResponseWriterOptions = options;
                        context.Response.ContentType           = formatterType;
                    }
                }

                if (!isWriteableResponse)
                {
                    if (context.Response.HasSuccessStatus() && context.Response.StatusCode != 202 && !(context.Runtime?.Internals?.IsOverridingStatusCode ?? false))
                    {
                        context.Response.StatusCode = 204;
                    }
                }
            }

            return(true);
        }