コード例 #1
0
        bool MatchRequesting(HttpRequest request, out string query)
        {
            query = null;

            if ("GET".Equals(request.Method, StringComparison.OrdinalIgnoreCase))
            {
                var routeValues     = new RouteValueDictionary();
                var templateMatcher = new TemplateMatcher(TemplateParser.Parse(routeTemplate), routeValues);
                if (templateMatcher.TryMatch(request.Path, routeValues))
                {
                    query = jsonqlOptions.FindQuery?.Invoke(request);

                    if (query == null)
                    {
                        query = request.Query["query"];
                    }

                    if (query == null)
                    {
                        query = request.Headers["query"];
                    }

                    if (query == null)
                    {
                        using (var reader = new StreamReader(request.Body))
                            query = reader.ReadToEnd();
                    }

                    return(true);
                }
            }

            return(false);
        }
コード例 #2
0
    public bool HandleRequest(HttpContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        var values          = new RouteValueDictionary();
        var templateMatcher = new TemplateMatcher(_routeTemplate, values);
        var isMatch         = templateMatcher.TryMatch(context.Request.Path, values);

        if (!isMatch)
        {
            return(false);
        }

        var httpRequestConverter = new HttpRequestConverter(_jsonSerializerService);
        var arguments            = httpRequestConverter.WrapContext(context);

        try
        {
            var result = _handler(arguments) ?? new Dictionary <object, object>();
            httpRequestConverter.UnwrapContext(result, context);
            return(true);
        }
        catch (Exception exception)
        {
            _logger.LogError(exception, "Error while intercepting HTTP request.");
        }

        return(false);
    }
コード例 #3
0
        public async Task GivenMultipleTemplates_WhenRetrievingTemplates_ThenReturnsTemplateWithMostMatchedFields()
        {
            Mock <IRequest> mockrequest = new Mock <IRequest>();

            mockrequest.Setup(x => x.GetProperties()).Returns(new[] { "a", "b", "c" });

            var templateOne      = CreateTemplate(response: "{ \"a\":\"1\" }", properties: new [] { "a" });
            var templateTwo      = CreateTemplate(response: "{ \"a\": \"1\",\"b\": \"2\" }", properties: new[] { "a", "b" });
            var templateThree    = CreateTemplate(response: "{ \"a\": \"1\",\"b\": \"2\",\"c\": \"3\", \"d\": \"4\" }", properties: new[] { "a", "b", "c", "d" });
            var expectedTemplate = CreateTemplate(response: "{ \"a\": \"1\",\"b\": \"2\",\"c\": \"3\" }", properties: new[] { "a", "b", "c" });

            Mock <ITemplateStore <ITemplate> >     mockTemplateStore     = new Mock <ITemplateStore <ITemplate> >();
            Mock <ITemplateContainer <ITemplate> > mockTemplateContainer = new Mock <ITemplateContainer <ITemplate> >();

            mockTemplateContainer.Setup(x => x.Templates).Returns(new[] { templateOne, templateTwo, templateThree, expectedTemplate }.ToList());

            mockTemplateStore.Setup(x => x.GetTemplateContainerAsync(It.IsAny <Uri>(), CancellationToken.None))
            .ReturnsAsync(mockTemplateContainer.Object);

            TemplateMatcher <ITemplate> templateMatcher = new TemplateMatcher <ITemplate>(mockTemplateStore.Object);

            var actualTemplate = await templateMatcher.MatchAsync(new Uri("http://anything"), mockrequest.Object, CancellationToken.None);

            Assert.That(actualTemplate, Is.EqualTo(expectedTemplate));
        }
コード例 #4
0
        public static TemplateMatcher GetTemplateMatcher(string routeTemplate)
        {
            var template = TemplateParser.Parse(routeTemplate);
            var matcher  = new TemplateMatcher(template, GetDefaults(template));

            return(matcher);
        }
コード例 #5
0
 public ReDocMiddleware(RequestDelegate next, string path, string swaggerPath, string title)
 {
     _next           = next;
     _requestMatcher = new TemplateMatcher(TemplateParser.Parse(path), new RouteValueDictionary());
     _swaggerPath    = swaggerPath;
     _title          = title;
 }
コード例 #6
0
    public bool paused = false;                                                                                     // This variable is set by the pause() method and unset by the resume() method - when true it disables frame monitoring temporarily.

    //renderableGesture = null; // Implementations that record a gestures for graphical rendering should store the data for the last detected gesture in this array.

    /**
     * The controller initialization function - this is called just after a new instance of the controller is created to parse the options array,
     * connect to the Leap Motion device (unless an existing Leap.Controller object was passed as a parameter), and register a frame listener with
     * the leap controller.
     *
     * @param options
     */
    void Awake()
    {
        /*
         * The current DEFAULT recognition algorithm is geometric template matching - which is initialized here.
         */
        this.templateMatcher = new GeometricalMatcher();
    }
コード例 #7
0
        public void Configure(IApplicationBuilder app)
        {
            app.Use(async(context, next) =>
            {
                var path1 = "/page/10";
                RouteTemplate template = TemplateParser.Parse("page/{id}");
                var templateMatcher    = new TemplateMatcher(template, new RouteValueDictionary());

                var routeData = new RouteValueDictionary();//This dictionary will be populated by the parameter template part (in this case "title")
                var isMatch1  = templateMatcher.TryMatch(path1, routeData);
                await context.Response.WriteAsync($"{path1} is match? {isMatch1} => route data value for 'id' is {routeData["id"]} \n");
                await next.Invoke();
            });

            app.Use(async(context, next) =>
            {
                var path = "/page/gone/a";
                RouteTemplate template = TemplateParser.Parse("page/gone/{id}");
                var templateMatcher    = new TemplateMatcher(template, new RouteValueDictionary());

                var routeData = new RouteValueDictionary();//This dictionary will be populated by the parameter template part (in this case "title")
                var isMatch1  = templateMatcher.TryMatch(path, routeData);
                await context.Response.WriteAsync($"{path} is match? {isMatch1} => route data value for 'id' is {routeData["id"]} \n");
            });
        }
コード例 #8
0
        public async Task Invoke(HttpContext context)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                await _next.Invoke(context);

                return;
            }

            var defatuls = new RouteValueDictionary();
            var matcher  = new TemplateMatcher(_routeTemplate, defatuls);
            var ret      = matcher.TryMatch(new PathString(context.Request.Path.Value), defatuls);

            if (!ret)
            {
                await _next.Invoke(context);

                return;
            }

            var process = (WebSocketMiddleware)System.Activator.CreateInstance(this.GetType(), _next);

            process._defautls = defatuls;
            await process.ProcessMessage(context);
        }
コード例 #9
0
        public ApiHelpMiddleware(RequestDelegate next, ApiHelpUIOptions options)
        {
            _next             = next;
            _options          = options;
            _requestMatcher   = new TemplateMatcher(TemplateParser.Parse(_options.IndexPath), new RouteValueDictionary());
            _resourceAssembly = GetType().GetTypeInfo().Assembly;

            // set the index resource name.
            _templateResourceName = "Microsoft.AspNetCore.ApiHelp.UI.";
            switch (_options.UI)
            {
            case ApiHelpUI.Swagger:
                _templateResourceName += "Swagger.dist.index.html";
                break;

            case ApiHelpUI.JsonH:
                _templateResourceName += "JsonH.index.html";
                break;

            case ApiHelpUI.JsonEditor:
                _templateResourceName += "JsonEditor.index.html";
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(options));
            }
        }
コード例 #10
0
        public IDictionary <string, object> Match(string routeTemplate, string requestPath, IQueryCollection query = null)
        {
            // The TemplateParser can only parse the route part (path), and not the query string.
            // If the template provided by the user also has a query string, we separate that and match it manually.
            requestPath = requestPath.SliceTill("?");
            var regex = new Regex(@"(.*)(\?[^{}]*$)");
            var match = regex.Match(routeTemplate);

            if (match.Success)
            {
                var queryString = match.Groups[2].Value;
                routeTemplate = match.Groups[1].Value;
                var queryInTemplate = QueryHelpers.ParseQuery(queryString);

                if (query?.All(arg => queryInTemplate.ContainsKey(arg.Key.TrimStart('?')) && queryInTemplate[arg.Key.TrimStart('?')] == arg.Value) != true)
                {
                    return(null);
                }
            }

            var template = TemplateParser.Parse(routeTemplate.SliceTill("?"));
            var matcher  = new TemplateMatcher(template, this.GetDefaults(template));
            var values   = new RouteValueDictionary();

            if (matcher.TryMatch(requestPath.StartsWith("/", StringComparison.OrdinalIgnoreCase) ? requestPath : $"/{requestPath}", values))
            {
                return(this.EnsureParameterConstraints(template, values));
            }
            else
            {
                return(null);
            }
        }
コード例 #11
0
        /// <summary>
        /// Get route values for current route
        /// </summary>
        /// <param name="context">Route context</param>
        /// <returns>Route values</returns>
        protected RouteValueDictionary GetRouteValues(RouteContext context)
        {
            var path = context.HttpContext.Request.Path.Value;

            if (this.SeoFriendlyUrlsForPathEnabled && !this.SeoFriendlyUrlsForLanguagesEnabled)
            {
                string lastpath = path.Split('/').Where(x => !string.IsNullOrEmpty(x)).LastOrDefault();
                path = $"/{lastpath}";
            }
            //remove language code from the path if it's localized URL
            if (this.SeoFriendlyUrlsForLanguagesEnabled && path.IsLocalizedUrl(context.HttpContext.Request.PathBase, false, out Language language))
            {
                path = path.RemoveLanguageSeoCodeFromUrl(context.HttpContext.Request.PathBase, false);
            }

            //parse route data
            var routeValues = new RouteValueDictionary(this.ParsedTemplate.Parameters
                                                       .Where(parameter => parameter.DefaultValue != null)
                                                       .ToDictionary(parameter => parameter.Name, parameter => parameter.DefaultValue));
            var matcher = new TemplateMatcher(this.ParsedTemplate, routeValues);

            matcher.TryMatch(path, routeValues);

            return(routeValues);
        }
コード例 #12
0
        public static PythonDictionary match_template(string template, string path)
        {
            if (template == null)
            {
                throw new ArgumentNullException(nameof(template));
            }
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            var routeTemplate   = TemplateParser.Parse(template);
            var values          = new RouteValueDictionary();
            var templateMatcher = new TemplateMatcher(routeTemplate, values);
            var isMatch         = templateMatcher.TryMatch(path, values);

            var resultValues = new PythonDictionary();

            foreach (var value in values)
            {
                resultValues.Add(value.Key, Convert.ToString(value.Value, CultureInfo.InvariantCulture));
            }

            return(new PythonDictionary
            {
                ["is_match"] = isMatch,
                ["values"] = resultValues
            });
        }
コード例 #13
0
ファイル: RouteMatcher.cs プロジェクト: vemedvedev/Stubbery
        public RouteValueDictionary Match(string routeTemplate, string requestPath, IQueryCollection query)
        {
            // The TemplateParser can only parse the route part, and not the query string.
            // If the template provided by the user also has a query string, we separate that and match it manually.
            var regex = new Regex(@"(.*)(\?[^{}]*$)");
            var match = regex.Match(routeTemplate);

            if (match.Success)
            {
                var queryString = match.Groups[2].Value;
                routeTemplate = match.Groups[1].Value;

                var queryInTemplate = QueryHelpers.ParseQuery(queryString);

                if (!query.All(arg => queryInTemplate.ContainsKey(arg.Key.TrimStart('?')) && queryInTemplate[arg.Key.TrimStart('?')] == arg.Value))
                {
                    return(null);
                }
            }

            var template = TemplateParser.Parse(routeTemplate);

            var matcher = new TemplateMatcher(template, GetDefaults(template));

            var values = new RouteValueDictionary();

            return(matcher.TryMatch(requestPath, values) ? values : null);
        }
コード例 #14
0
        private static void RunTest(
            string template,
            string path,
            RouteValueDictionary defaults,
            IDictionary <string, object> expected)
        {
            // Arrange
            var matcher = new TemplateMatcher(
                TemplateParser.Parse(template),
                defaults ?? new RouteValueDictionary());

            // Act
            var match = matcher.Match(new PathString(path));

            // Assert
            if (expected == null)
            {
                Assert.Null(match);
            }
            else
            {
                Assert.NotNull(match);
                Assert.Equal(expected.Count, match.Values.Count);
                foreach (string key in match.Keys)
                {
                    Assert.Equal(expected[key], match[key]);
                }
            }
        }
コード例 #15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="httpContext"></param>
        /// <param name="pathBase"></param>
        /// <returns></returns>
        public async Task InvokeAsync(HttpContext httpContext, string pathBase)
        {
            var request = httpContext.Request;

            if ("GET".Equals(request.HttpMethod, StringComparison.OrdinalIgnoreCase))
            {
                var routeValues     = new RouteValueDictionary();
                var templateMatcher = new TemplateMatcher(TemplateParser.Parse($"{pathBase}/schema.json"), routeValues);
                if (templateMatcher.TryMatch(request.Path, routeValues))
                {
                    var schema  = JsonQLSchema.Generate(options.ResourceTypes);
                    var content = JsonSerializer.Serialize(new
                    {
                        Title       = options?.SchemaTitle,
                        Description = options?.SchemaDescription,
                        ServerUrl   = options?.SchemaServerUrl,
                        schema.ResourceInfos,
                        schema.ResourceTypes,
                        schema.ResourceMethods,
                    });

                    var response = httpContext.Response;

                    response.Clear();
                    response.StatusCode  = 200;
                    response.ContentType = "application/json";
                    response.Write(content);

                    response.End();
                }
            }

            await Task.FromResult(0);
        }
コード例 #16
0
        public async Task InvokeAsync(HttpContext httpContext, string routeTemplate)
        {
            var request = httpContext.Request;

            if ("GET".Equals(request.HttpMethod, StringComparison.OrdinalIgnoreCase))
            {
                var routeValues     = new RouteValueDictionary();
                var templateMatcher = new TemplateMatcher(TemplateParser.Parse(routeTemplate), routeValues);
                if (templateMatcher.TryMatch(request.Path, routeValues))
                {
                    var response      = httpContext.Response;
                    var jsonQLRequest = new JsonQLRequest(httpContext, jsonQLOptions);
                    var authorized    = jsonQLOptions.AuthorizeAsync == null || await jsonQLOptions.AuthorizeAsync(jsonQLRequest);

                    if (authorized)
                    {
                        var result = await new JsonQLHandler(jsonQLOptions, jsonQLResourceTable).HandleAsync(jsonQLRequest);

                        response.Clear();
                        response.StatusCode  = 200;
                        response.ContentType = "application/json";
                        response.Write(result);
                    }
                    else
                    {
                        response.StatusCode = 403;
                    }

                    response.End();
                }
            }
        }
コード例 #17
0
 private void EnsureMatcher()
 {
     if (_matcher == null)
     {
         _matcher = new TemplateMatcher(ParsedTemplate, Defaults);
     }
 }
コード例 #18
0
 public ZipStreamerMiddleware(RequestDelegate next, ZipStreamerOptions options)
 {
     _next           = next;
     _options        = options;
     _requestMatcher = new TemplateMatcher(TemplateParser.Parse(_options.RouteTemplate), new RouteValueDictionary());
     _mime           = new FileExtensionContentTypeProvider();
 }
コード例 #19
0
        public static bool TryGetDocument(this HttpContext context, AsyncApiOptions options, out string document)
        {
            document = null;
#if NETSTANDARD2_0
            var template = TemplateParser.Parse(options.Middleware.Route);

            var values  = new RouteValueDictionary();
            var matcher = new TemplateMatcher(template, values);
            if (!matcher.TryMatch(context.Request.Path, values))
            {
                template = TemplateParser.Parse(options.Middleware.UiBaseRoute + "{*wildcard}");
                matcher  = new TemplateMatcher(template, values);
                matcher.TryMatch(context.Request.Path, values);
            }
#else
            var values = context.Request.RouteValues;
#endif
            if (!values.TryGetValue("document", out var value))
            {
                return(false);
            }

            document = value.ToString();
            return(true);
        }
        public ReportMissingMiddleware(RequestDelegate next, IOptions <ReportOptions> options, IStringLocalizerFactory factory, IOutputFormatter formatter)
        {
            _next = next;
            var reportPath = options.Value.ReportPath;

            if (string.IsNullOrEmpty(reportPath))
            {
                return;
            }
            _templateMatcher = new TemplateMatcher(TemplateParser.Parse($"{reportPath}/{{filename?}}"), new RouteValueDictionary());

            if (formatter == null)
            {
                throw new ArgumentNullException(nameof(formatter));
            }
            _formatter = formatter;

            if (factory is ReportMissingStringLocalizerFactory rmslf)
            {
                _factory = rmslf;
            }
            else
            {
                throw new InvalidOperationException($"{ nameof(ReportMissingMiddleware) } cannot be used without { nameof(ReportMissingStringLocalizerFactory) }");
            }
        }
コード例 #21
0
        /// <summary>
        /// Add a route name and template for batching.
        /// </summary>
        /// <param name="routeName">The route name.</param>
        /// <param name="routeTemplate">The route template.</param>
        public void AddRoute(string routeName, string routeTemplate)
        {
            string          newRouteTemplate = routeTemplate.StartsWith("/") ? routeTemplate.Substring(1) : routeTemplate;
            RouteTemplate   parsedTemplate   = TemplateParser.Parse(newRouteTemplate);
            TemplateMatcher matcher          = new TemplateMatcher(parsedTemplate, new RouteValueDictionary());

            templateMappings[matcher] = routeName;
        }
コード例 #22
0
 public SwaggerMiddleware(
     RequestDelegate next,
     SwaggerOptions options)
 {
     _next           = next;
     _options        = options ?? new SwaggerOptions();
     _requestMatcher = new TemplateMatcher(TemplateParser.Parse(_options.RouteTemplate), new RouteValueDictionary());
 }
コード例 #23
0
 public DocumentationMiddleware(
     RequestDelegate next,
     DocumentationOptions options)
 {
     _next           = next;
     _options        = options ?? new DocumentationOptions();
     _requestMatcher = new TemplateMatcher(TemplateParser.Parse(options.RouteTemplate), new RouteValueDictionary());
 }
コード例 #24
0
        public McmaApiRoute(string httpMethod, string path, Func <TRequest, McmaApiResponse, Task> handler)
        {
            HttpMethod = httpMethod;
            Path       = path;
            Handler    = handler;

            Template = new TemplateMatcher(TemplateParser.Parse(path), null);
        }
コード例 #25
0
        public RouteValueDictionary Match(string routeTemplate, string requestPath)
        {
            var template = TemplateParser.Parse(routeTemplate);
            var matcher  = new TemplateMatcher(template, GetDefaults(template));
            var values   = new RouteValueDictionary();

            return(matcher.TryMatch(requestPath, values) ? values : null);
        }
コード例 #26
0
ファイル: BaseController.cs プロジェクト: paulusyeung/RT2020
 public Handler(TemplateMatcher routeTemplate,
                Func <IActionResult> actionSync,
                Func <Task <IActionResult> > actionAsync)
 {
     RouteTemplate = routeTemplate;
     ActionSync    = actionSync;
     ActionAsync   = actionAsync;
 }
        public static bool MatchRoute(string routeTemplate, string requestPath)
        {
            RouteTemplate        template = TemplateParser.Parse(routeTemplate);
            TemplateMatcher      matcher  = new TemplateMatcher(template, GetRouteDefaults(template));
            RouteValueDictionary values   = new RouteValueDictionary();

            return(matcher.TryMatch(requestPath, values));
        }
コード例 #28
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="next"></param>
 /// <param name="options"></param>
 public ApiExplorerUIInitJsonMIddleware(
     RequestDelegate next,
     ApiExplorerUIOptions options)
 {
     this.next           = next;
     this.requestMatcher = new TemplateMatcher(TemplateParser.Parse(options.InitJsonPath), new RouteValueDictionary());
     this.options        = options;
 }
コード例 #29
0
        /// <summary>
        /// Add a route name and template for openapi.
        /// </summary>
        /// <param name="prefixName">The route prefix name.</param>
        /// <param name="routeTemplate">The route template.</param>
        private void AddRoute(string prefixName, string routeTemplate)
        {
            string          newRouteTemplate = routeTemplate.StartsWith("/", StringComparison.Ordinal) ? routeTemplate.Substring(1) : routeTemplate;
            RouteTemplate   parsedTemplate   = TemplateParser.Parse(newRouteTemplate);
            TemplateMatcher matcher          = new TemplateMatcher(parsedTemplate, new RouteValueDictionary());

            _templateMappings[matcher] = prefixName;
        }
コード例 #30
0
        public void ShouldReturnFalseIfQueriesParametersNotEquals()
        {
            //Arrange
            var templateUri = new Uri("http://localhost/api/products?x={xValue}&p1=1&p2=2");
            var uri         = new Uri("http://localhost/api/products?x={xValue}&p3=1&p4=2");

            Assert.IsFalse(TemplateMatcher.Match(templateUri, uri));
        }
コード例 #31
0
        private static void RunTest(
            string template,
            string path,
            IReadOnlyDictionary<string, object> defaults,
            IDictionary<string, object> expected)
        {
            // Arrange
            var matcher = new TemplateMatcher(TemplateParser.Parse(template), defaults);

            // Act
            var match = matcher.Match(path);

            // Assert
            if (expected == null)
            {
                Assert.Null(match);
            }
            else
            {
                Assert.NotNull(match);
                Assert.Equal(expected.Count, match.Values.Count);
                foreach (string key in match.Keys)
                {
                    Assert.Equal(expected[key], match[key]);
                }
            }
        }