Exemplo n.º 1
0
        public APIGatewayProxyResponse Handle(APIGatewayProxyRequest request)
        {
            var response = _routeHandler.Handle(request);

            if (response.Headers == null)
            {
                response.Headers = new Dictionary <string, string>();
            }

            if (_accessOrigins == null || _accessOrigins.Length == 0)
            {
                return(response);
            }

            var stringBuilder = new StringBuilder();

            stringBuilder.Append(_accessOrigins[0]);
            for (var i = 1; i < _accessOrigins.Length; ++i)
            {
                stringBuilder.Append($",{_accessOrigins[i]}");
            }

            response.Headers.Add("Access-Control-Allow-Origin", stringBuilder.ToString());
            return(response);
        }
Exemplo n.º 2
0
        public async Task ProcessRequestAsync(Stream stream)
        {
            HttpResponse response = new HttpResponse(stream);
            HttpRequest  request  = null;

            bool isParseSuccess;

            try
            {
                request = await requestParser.ParseAsync(stream);

                isParseSuccess = true;
            }
            catch (HttpRequestParseException e)
            {
                response.StatusCode = 400;
                isParseSuccess      = false;
            }

            if (!isParseSuccess)
            {
                await response.WriteAsync("Bad Request");
            }

            HttpContext context = new HttpContext
            {
                Request  = request,
                Response = response
            };

            var func = routeHandler.Handle(request);

            if (func != null)
            {
                ActionResult actionResult = func(context);
                await actionResult.ExecuteAsync(context);
            }
            else
            {
                await(new Http404NotFoundResult()).ExecuteAsync(context);
            }
        }
Exemplo n.º 3
0
        private ConcurrentDictionary <string, RouteEntry> InitializeTable()
        {
            IEnumerable <string> ThrowNotSupported(Type request) =>
            ThrowNotSupportedRouteHandler.Instance.Handle(request, null);

            var routeEntries =
                from component in _commandComponents
                let componentType = component.GetType()
                                    from routePath in _routeHandler.Handle(componentType, ThrowNotSupported)
                                    select new RouteEntry
            {
                RoutePath   = routePath.ToLower(),
                RequestType = componentType,
                HandlerType = typeof(ICommandHandler <>).MakeGenericType(componentType)
            };

            return(new ConcurrentDictionary <string, RouteEntry>(
                       routeEntries.ToDictionary(routeEntry => routeEntry.RoutePath, routeEntry => routeEntry)
                       ));
        }
Exemplo n.º 4
0
        public APIGatewayProxyResponse Handle(APIGatewayProxyRequest request)
        {
            try
            {
                return(_routeHandler.Handle(request));
            }
            catch (Exception e)
            {
                Console.WriteLine(e);

                var statusCode = HttpStatusCode.InternalServerError;

                if (_exceptionToHttpStatusCode.ContainsKey(e.GetType()))
                {
                    statusCode = _exceptionToHttpStatusCode[e.GetType()];
                }

                return(new APIGatewayErrorResponse(e, statusCode));
            }
        }
Exemplo n.º 5
0
        private ConcurrentDictionary <string, RouteEntry> InitializeTable()
        {
            IEnumerable <string> ThrowNotSupported(Type request) =>
            ThrowNotSupportedRouteHandler.Instance.Handle(request, null);

            var routeEntries =
                from component in _queryComponents
                let componentType = component.GetType()
                                    let serviceType = componentType.GetInterfaces().Single(
                    i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IQuery <>)
                    )
                                                      let resultType = serviceType.GenericTypeArguments[0]
                                                                       let handlerType = typeof(IQueryHandler <,>).MakeGenericType(componentType, resultType)
                                                                                         from routePath in _routeHandler.Handle(componentType, ThrowNotSupported)
                                                                                         select new RouteEntry
            {
                RoutePath   = routePath.ToLower(),
                RequestType = componentType,
                HandlerType = handlerType
            };

            return(new ConcurrentDictionary <string, RouteEntry>(
                       routeEntries.ToDictionary(routeEntry => routeEntry.RoutePath, routeEntry => routeEntry)
                       ));
        }