public void GetFormInfo() { var protector = new Mock<IDataProtector>(); var protectorProvider = new Mock<IDataProtectionProvider>(); protectorProvider.Setup(x => x.CreateProtector(It.IsAny<string>())).Returns(protector.Object); var surfaceRouteParams = $"{SurfaceFormHelper.ReservedAdditionalKeys.Controller}=mycontroller&{SurfaceFormHelper.ReservedAdditionalKeys.Action}=myaction&{SurfaceFormHelper.ReservedAdditionalKeys.Area}=myarea"; protector.Setup(dataProtector => dataProtector.Protect(It.IsAny<byte[]>())).Returns(Encoding.UTF8.GetBytes(surfaceRouteParams)); protector.Setup(dataProtector => dataProtector.Unprotect(It.IsAny<byte[]>())).Returns(Encoding.UTF8.GetBytes(surfaceRouteParams)); var helper = new SurfaceFormHelper(Mock.Of<ILoggerFactory>(), protectorProvider.Object); var request = new Mock<HttpRequest>(); request.Setup(httpRequest => httpRequest.Method).Returns("GET"); request.Setup(httpRequest => httpRequest.Query).Returns( new FormCollection(new Dictionary<string, StringValues> { {"ufprt", Convert.ToBase64String(Encoding.UTF8.GetBytes(surfaceRouteParams))} })); var httpCtxAccessor = new Mock<IHttpContextAccessor>(); var httpContext = new Mock<HttpContext>(); httpContext.Setup(context => context.Request).Returns(request.Object); httpCtxAccessor.Setup(accessor => accessor.HttpContext).Returns(httpContext.Object); var routeCtx = new RouteContext(httpContext.Object); var result = helper.GetFormInfo(routeCtx); Assert.Equal("mycontroller", result.ControllerName); Assert.Equal("myaction", result.ActionName); Assert.Equal("myarea", result.Area); }
public void Activate_PopulatesServicesFromServiceContainer() { // Arrange var urlHelper = Mock.Of<IUrlHelper>(); var service = new Mock<IServiceProvider>(); service.Setup(s => s.GetService(typeof(IUrlHelper))) .Returns(urlHelper); var httpContext = new Mock<HttpContext>(); httpContext.SetupGet(c => c.RequestServices) .Returns(service.Object); var routeContext = new RouteContext(httpContext.Object); var controller = new TestController(); var context = new ActionContext(routeContext, new ActionDescriptor()) { Controller = controller }; var activator = new DefaultControllerActivator(); // Act activator.Activate(controller, context); // Assert Assert.Same(urlHelper, controller.Helper); }
public async virtual Task RouteAsync(RouteContext context) { for (var i = 0; i < Count; i++) { var route = this[i]; var oldRouteData = context.RouteData; var newRouteData = new RouteData(oldRouteData); newRouteData.Routers.Add(route); try { context.RouteData = newRouteData; await route.RouteAsync(context); if (context.IsHandled) { break; } } finally { if (!context.IsHandled) { context.RouteData = oldRouteData; } } } }
public void Activate_SetsPropertiesFromActionContextHierarchy() { // Arrange var httpRequest = Mock.Of<HttpRequest>(); var httpContext = new Mock<HttpContext>(); httpContext.SetupGet(c => c.Request) .Returns(httpRequest); httpContext.SetupGet(c => c.RequestServices) .Returns(Mock.Of<IServiceProvider>()); var routeContext = new RouteContext(httpContext.Object); var controller = new TestController(); var context = new ActionContext(routeContext, new ActionDescriptor()) { Controller = controller }; var activator = new DefaultControllerActivator(); // Act activator.Activate(controller, context); // Assert Assert.Same(context, controller.ActionContext); Assert.Same(httpContext.Object, controller.HttpContext); Assert.Same(httpRequest, controller.GetHttpRequest()); }
public Task RouteAsync(RouteContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } EnsureServices(context.HttpContext); var actionDescriptor = _actionSelector.Select(context); if (actionDescriptor == null) { _logger.NoActionsMatched(); return TaskCache.CompletedTask; } if (actionDescriptor.RouteValueDefaults != null) { foreach (var kvp in actionDescriptor.RouteValueDefaults) { if (!context.RouteData.Values.ContainsKey(kvp.Key)) { context.RouteData.Values.Add(kvp.Key, kvp.Value); } } // Removing RouteGroup from RouteValues to simulate the result of conventional routing context.RouteData.Values.Remove(TreeRouter.RouteGroupKey); } context.Handler = (c) => InvokeActionAsync(c, actionDescriptor); return TaskCache.CompletedTask; }
public async Task RouteAsync(RouteContext context) { if (IsValidRequest(context.HttpContext)) { try { // Store the requested targetted action so that the OrchardMiddleware // can continue with it once the tenant pipeline has been executed if (_pipeline != null) { context.HttpContext.Items["orchard.Handler.Target"] = _target; context.HttpContext.Items["orchard.Handler.RouteContext"] = context; await _pipeline.Invoke(context.HttpContext); } else { await _target.RouteAsync(context); } } catch (Exception ex) { var logger = context.HttpContext.ApplicationServices.GetService<ILogger<TenantRoute>>(); logger.LogError("Error occured serving tenant route", ex); throw; } } }
public async Task Invoke(HttpContext httpContext) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Begin Routing Request"); } var shellSettings = httpContext.RequestServices.GetService<ShellSettings>(); var routerTable = httpContext.ApplicationServices.GetService<IRunningShellRouterTable>(); var router = routerTable.GetOrAdd( shellSettings.Name, name => httpContext.RequestServices.GetService<IRouteBuilder>().Build() ); var context = new RouteContext(httpContext); context.RouteData.Routers.Add(router); await router.RouteAsync(context); if (!context.IsHandled) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Request did not match any routes."); } await _next.Invoke(httpContext); } if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("End Routing Request"); } }
public async Task RouteAsync(RouteContext context) { // Saving and restoring the original route data ensures that any values we // add won't 'leak' if action selection doesn't match. var oldRouteData = context.RouteData; // For diagnostics and link-generation purposes, routing should include // a list of IRoute instances that lead to the ultimate destination. // It's the responsibility of each IRouter to add the 'next' before // calling it. var newRouteData = new RouteData(oldRouteData); newRouteData.Routers.Add(_next); var locale = GetLocale(context.HttpContext) ?? "en-US"; newRouteData.Values.Add("locale", locale); try { context.RouteData = newRouteData; await _next.RouteAsync(context); } finally { if (!context.IsHandled) { context.RouteData = oldRouteData; } } }
public async Task RouteAsync(RouteContext context) { var request = context.HttpContext.Request; Uri uri; PathString remaining; if (!request.Path.StartsWithSegments(PathString.FromUriComponent("/" + _routePrefix), out remaining)) { // Fallback to other routes. return; } uri = new Uri(remaining.ToString(), UriKind.Relative); context.HttpContext.ODataProperties().Model = _model; var parser = new ODataUriParser(_model, uri); var path = parser.ParsePath(); context.HttpContext.ODataProperties().NewPath = path; context.HttpContext.ODataProperties().Path = context.HttpContext.ODataPathHandler().Parse(_model, "http://service-root/", remaining.ToString()); context.HttpContext.ODataProperties().IsValidODataRequest = true; await m.RouteAsync(context); context.IsHandled = true; }
public async Task RouteAsync(RouteContext context) { EnsureLoggers(context.HttpContext); using(_logger.BeginScope("SubdomainTemplateRoute.RouteAsync")) { var host = context.HttpContext.Request.Host.Value; if(host.Contains(":")) { host = host.Substring(0, host.IndexOf(":")); } var values = _matcher.Match(host); if(values == null) { _logger.Log(x => x.Verbose, x => x.LogVerbose(nameof(SubdomainTemplateRoute) + " " + Name + " - Host \"" + context.HttpContext.Request.Host + "\" did not match.")); return; } var oldRouteData = context.RouteData; var newRouteData = new RouteData(oldRouteData); newRouteData.DataTokens.MergeValues(DataTokens); newRouteData.Routers.Add(_target); newRouteData.Values.MergeValues(values); try { context.RouteData = newRouteData; await _innerRoute.RouteAsync(context); } finally { if(!context.IsHandled) { context.RouteData = oldRouteData; } } } }
public async Task RouteAsync(RouteContext context) { context.RouteData.Values["controller"] = context.RouteData.Values["controller"].ToString().Replace("-", "_"); context.RouteData.Values["action"] = context.RouteData.Values["action"].ToString().Replace("-", "_"); await _target.RouteAsync(context); }
public async Task RouteAsync(RouteContext context) { context.RouteData.Routers.Add(_next); var locale = GetLocale(context.HttpContext) ?? "en-US"; context.RouteData.Values.Add("locale", locale); await _next.RouteAsync(context); }
public async Task RouteAsync(RouteContext context) { if (context.HttpContext.Request.Host.Value == _urlHost) { context.HttpContext.Items["orchard.Handler"] = new Func<Task>(async () => { await _target.RouteAsync(context); }); await _pipeline.Invoke(context.HttpContext); } }
public async Task<ActionDescriptor> SelectAsync(RouteContext context) { if (context.HttpContext.ODataProperties().IsValidODataRequest) { return await Task.FromResult(_convention.SelectAction(context)); } return await _selector.SelectAsync(context); }
public async Task RouteAsync(RouteContext context) { var name = context.RouteData.Values["name"] as string; if (String.IsNullOrEmpty(name)) { return; } await context.HttpContext.Response.WriteAsync($"Hi {name}!"); context.IsHandled = true; }
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action) { if(routeContext.HttpContext.Request.Method != "POST") { return false; } var value = routeContext.HttpContext.Request.Form[_submitButtonName]; return !string.IsNullOrEmpty(value); }
public async Task Invoke(HttpContext httpContext) { var context = new RouteContext(httpContext); context.RouteData.Routers.Add(_router); await _router.RouteAsync(context); if (!context.IsHandled) { _logger.LogVerbose("Request did not match any routes."); await _next(httpContext); } }
public async Task Invoke(HttpContext httpContext) { var rcontext = new RouteContext(httpContext); rcontext.RouteData.Routers.Add(_router); await _router.RouteAsync(rcontext); if (!rcontext.IsHandled) { await _next.Invoke(httpContext); } }
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action) { if (routeContext.RouteData.Values.ContainsKey(Name)) return false; if (routeContext.RouteData.DataTokens.ContainsKey(Name)) return false; if (routeContext.HttpContext.Request.Query.ContainsKey(Name)) return false; return true; }
/// <summary> /// Checks the request and query strings to see if it matches the definition of having a Surface controller /// posted/get value, if so, then we return a PostedDataProxyInfo object with the correct information. /// </summary> /// <param name="routeContext"></param> /// <returns></returns> public RouteDefinition GetFormInfo(RouteContext routeContext) { if (routeContext == null) throw new ArgumentNullException(nameof(routeContext)); if (routeContext.HttpContext == null) throw new ArgumentNullException(nameof(routeContext) + ".HttpContext"); if (routeContext.HttpContext.Request == null) throw new ArgumentNullException(nameof(routeContext) + ".HttpContext.Request"); var encodedVal = GetRequestSurfaceToken(routeContext.HttpContext.Request); if (string.IsNullOrWhiteSpace(encodedVal)) return null; string decryptedString; try { decryptedString = Encoding.UTF8.GetString(_dataProtector.Unprotect(Convert.FromBase64String(encodedVal))); } catch (CryptographicException) { _logger.LogWarning("A value was detected in the ufprt parameter but Umbraco could not decrypt the string"); return null; } var parsedQueryString = QueryHelpers.ParseQuery(decryptedString); var decodedParts = new Dictionary<string, string>(); foreach (var key in parsedQueryString.Keys) { decodedParts[key] = parsedQueryString[key]; } //validate all required keys exist var isValid = ValidateRequiredTokenParams(decodedParts); if (isValid == false) return null; foreach (var item in decodedParts.Where(x => new[] { ReservedAdditionalKeys.Controller, ReservedAdditionalKeys.Action, ReservedAdditionalKeys.Area }.Contains(x.Key) == false)) { // Populate route with additional values which aren't reserved values so they eventually to action parameters routeContext.RouteData.Values[item.Key] = item.Value; } //return the proxy info without the surface id... could be a local controller. return new RouteDefinition { ControllerName = WebUtility.UrlDecode(decodedParts.Single(x => x.Key == ReservedAdditionalKeys.Controller).Value), ActionName = WebUtility.UrlDecode(decodedParts.Single(x => x.Key == ReservedAdditionalKeys.Action).Value), Area = WebUtility.UrlDecode(decodedParts.Single(x => x.Key == ReservedAdditionalKeys.Area).Value), }; }
public async Task ActionSelection_IndexNotSelectedByDefaultExceptGetAndPostVerbs(string verb) { // Arrange var routeContext = new RouteContext(GetHttpContext(verb)); routeContext.RouteData.Values = new Dictionary<string, object> { { "controller", "RpcOnly" } }; // Act var result = await InvokeActionSelector(routeContext); // Assert Assert.Equal(null, result); }
public async Task ActionSelection_IndexSelectedByDefaultInAbsenceOfVerbOnlyMethod(string verb) { // Arrange var routeContext = new RouteContext(GetHttpContext(verb)); routeContext.RouteData.Values = new Dictionary<string, object> { { "controller", "RpcOnly" } }; // Act var result = await InvokeActionSelector(routeContext); // Assert Assert.Equal("Index", result.Name); }
public async Task ActionSelection_PrefersVerbOnlyMethodOverIndex(string verb) { // Arrange var routeContext = new RouteContext(GetHttpContext(verb)); routeContext.RouteData.Values = new Dictionary<string, object> { { "controller", "MixedRpcAndRest" } }; // Act var result = await InvokeActionSelector(routeContext); // Assert Assert.Equal(verb, result.Name, StringComparer.OrdinalIgnoreCase); }
public async Task RouteAsync(RouteContext context) { var lightcoreContext = context.HttpContext.LightcoreContext(); if (lightcoreContext?.Item != null) { // Only try to run routes if Lightcore context is present, request pipeline could be aborted await _defaultHandler.RouteAsync(context); } else { // Make sure that the next middleware can run context.IsHandled = false; } }
public async Task RouteAsync(RouteContext context) { if (IsValidRequest(context)) { context.HttpContext.Items["orchard.Handler"] = new Func<Task>(async () => { try { await _target.RouteAsync(context); } catch (Exception e) { Logger.Error(e, e.Message); throw; } }); await _pipeline.Invoke(context.HttpContext); } }
public async Task Invoke(HttpContext httpContext) { Console.WriteLine("Begin Routing Request"); var router = httpContext.RequestServices.GetService<IRouteBuilder>().Build(); var context = new RouteContext(httpContext); context.RouteData.Routers.Add(router); await router.RouteAsync(context); if (!context.IsHandled) { await _next.Invoke(httpContext); } Console.WriteLine("End Routing Request"); }
public async Task RouteAsync(RouteContext context) { var version = $"v{context.RouteData.Values["apiversion"] ?? "0"}"; var name = context.RouteData.Values["messagename"]?.ToString().Replace("/", "."); var body = await ReadBody(context.HttpContext); var msgItem = _protocolStringSerializer.Deserialize(body); var msg = new Message(name, msgItem); var result = await Handle(msg); var output = _protocolStringSerializer.SerializeToString(result); await context.HttpContext.Response.WriteAsync(output); }
public async Task HttpMethodAttribute_ActionWithMultipleHttpMethodAttributes_ORsMultipleHttpMethods(string verb) { // Arrange var routeContext = new RouteContext(GetHttpContext(verb)); routeContext.RouteData.Values = new Dictionary<string, object>() { { "controller", "HttpMethodAttributeTests_RestOnly" }, { "action", "Put" } }; // Act var result = await InvokeActionSelector(routeContext); // Assert Assert.Equal("Put", result.Name); }
public async Task HttpMethodAttribute_ActionDecoratedWithHttpMethodAttribute_OverridesConvention(string verb) { // Arrange // Note no action name is passed, hence should return a null action descriptor. var routeContext = new RouteContext(GetHttpContext(verb)); routeContext.RouteData.Values = new Dictionary<string, object>() { { "controller", "HttpMethodAttributeTests_RestOnly" }, }; // Act var result = await InvokeActionSelector(routeContext); // Assert Assert.Equal(null, result); }
public async Task Invoke(HttpContext httpContext) { _logger.LogInformation("Begin Routing Request"); var router = httpContext.RequestServices.GetService<IRouteBuilder>().Build(); var context = new RouteContext(httpContext); context.RouteData.Routers.Add(router); await router.RouteAsync(context); if (!context.IsHandled) { _logger.LogInformation("Request did not match any routes."); await _next.Invoke(httpContext); } _logger.LogInformation("End Routing Request"); }
public Task RouteAsync(RouteContext context) { context.IsHandled = _isHandled; return(Task.FromResult <object>(null)); }