public void InvokingConstructorWithHomeControllerShouldReturnDefaultActionAndParameter() { var actionDescriptor = new ActionDescriptor("/Home"); Assert.AreEqual("Index", actionDescriptor.ActionName); Assert.AreEqual(string.Empty, actionDescriptor.Parameter); }
public IActionResult InvokeAction(Controller controller, ActionDescriptor actionDescriptor) { /* * Child processes that use such C run-time functions as printf() and fprintf() can behave poorly when redirected. * The C run-time functions maintain separate IO buffers. When redirected, these buffers might not be flushed immediately after each IO call. * As a result, the output to the redirection pipe of a printf() call or the input from a getch() call is not flushed immediately and delays, sometimes-infinite delays occur. * This problem is avoided if the child process flushes the IO buffers after each call to a C run-time IO function. * Only the child process can flush its C run-time IO buffers. A process can flush its C run-time IO buffers by calling the fflush() function. */ var methodWithIntParameter = controller.GetType() .GetMethods() .FirstOrDefault(x => x.Name.ToLower() == actionDescriptor.ActionName.ToLower() && x.GetParameters().Length == 1 && x.GetParameters()[0].ParameterType == typeof(string) && x.ReturnType == typeof(IActionResult)); if (methodWithIntParameter == null) { throw new HttpNotFoundException( string.Format( "Expected method with signature IActionResult {0}(string) in class {1}Controller", actionDescriptor.ActionName, actionDescriptor.ControllerName)); } try { var actionResult = (IActionResult) methodWithIntParameter.Invoke(controller, new object[] { actionDescriptor.Parameter }); return actionResult; } catch (TargetInvocationException ex) { throw ex.InnerException; } }
public void Accept_RejectsActionMatchWithMissingParameter() { // Arrange var action = new ActionDescriptor(); action.Parameters = new List<ParameterDescriptor>() { new ParameterDescriptor() { BindingInfo = new BindingInfo() { BindingSource = (new FromUriAttribute()).BindingSource, }, Name = "id", ParameterType = typeof(int), }, }; var constraint = new OverloadActionConstraint(); var context = new ActionConstraintContext(); context.Candidates = new List<ActionSelectorCandidate>() { new ActionSelectorCandidate(action, new [] { constraint }), }; context.CurrentCandidate = context.Candidates[0]; context.RouteContext = CreateRouteContext(); // Act & Assert Assert.False(constraint.Accept(context)); }
/// <summary> /// Creates a new <see cref="ActionContext"/>. /// </summary> /// <param name="httpContext">The <see cref="Http.HttpContext"/> for the current request.</param> /// <param name="routeData">The <see cref="AspNet.Routing.RouteData"/> for the current request.</param> /// <param name="actionDescriptor">The <see cref="Abstractions.ActionDescriptor"/> for the selected action.</param> /// <param name="modelState">The <see cref="ModelStateDictionary"/>.</param> public ActionContext( HttpContext httpContext, RouteData routeData, ActionDescriptor actionDescriptor, ModelStateDictionary modelState) { if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } if (routeData == null) { throw new ArgumentNullException(nameof(routeData)); } if (actionDescriptor == null) { throw new ArgumentNullException(nameof(actionDescriptor)); } if (modelState == null) { throw new ArgumentNullException(nameof(modelState)); } HttpContext = httpContext; RouteData = routeData; ActionDescriptor = actionDescriptor; ModelState = modelState; }
/// <summary> /// Creates a new <see cref="ActionContext"/>. /// </summary> /// <param name="httpContext">The <see cref="Http.HttpContext"/> for the current request.</param> /// <param name="routeData">The <see cref="AspNet.Routing.RouteData"/> for the current request.</param> /// <param name="actionDescriptor">The <see cref="Abstractions.ActionDescriptor"/> for the selected action.</param> public ActionContext( HttpContext httpContext, RouteData routeData, ActionDescriptor actionDescriptor) : this(httpContext, routeData, actionDescriptor, new ModelStateDictionary()) { }
public IActionResult InvokeAction(Controller controller, ActionDescriptor actionDescriptor) { var methodWithIntParameter = controller.GetType() .GetMethods() .FirstOrDefault( x => x.Name.ToLower() == actionDescriptor.ActionName.ToLower() && x.GetParameters().Length == 1 && x.GetParameters()[0].ParameterType == typeof(string) && x.ReturnType == typeof(IActionResult)); if (methodWithIntParameter == null) { throw new HttpNotFoundException( string.Format( "Expected method with signature IActionResult {0}(string) in class {1}", actionDescriptor.ActionName, actionDescriptor.ControllerName)); } try { var actionResult = (IActionResult)methodWithIntParameter.Invoke(controller, new object[] { actionDescriptor.Parameter }); return actionResult; } catch (TargetInvocationException ex) { throw ex.InnerException; } }
public void InvokingConstructorWithNormalUriShouldReturnProperlyControllerActionAndParameter() { var actionDescriptor = new ActionDescriptor("/Api/ResponseMessage/someParam123"); Assert.AreEqual("Api", actionDescriptor.ControllerName); Assert.AreEqual("ResponseMessage", actionDescriptor.ActionName); Assert.AreEqual("someParam123", actionDescriptor.Parameter); }
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var rubyType = ((RubyController) controllerContext.Controller).RubyType; var controllerFilters = (Hash) RubyEngine.CallMethod(rubyType, "action_filters"); var info = controllerFilters.ToFilterInfo("controller").MergedWith(actionDescriptor.GetFilters()); return info; }
protected ActionContext(ControllerContext context, ActionDescriptor action) { Precondition.Require(context, () => Error.ArgumentNull("context")); Precondition.Require(action, () => Error.ArgumentNull("action")); _action = action; _context = context; }
public IEnumerable<Filter> GetFilters(ControllerContext context, ActionDescriptor action) { Precondition.Require(context, () => Error.ArgumentNull("context")); Precondition.Require(action, () => Error.ArgumentNull("action")); if (context.Controller != null) yield return new Filter(context.Controller, FilterScope.First, Int32.MinValue); }
protected override System.Collections.Generic.IEnumerable<FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var attributes = base.GetControllerAttributes(controllerContext, actionDescriptor); foreach (var attribute in attributes) { _container.BuildUp(attribute); } return attributes; }
public AuthenticationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor) : base(controllerContext) { if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } _actionDescriptor = actionDescriptor; }
public ReflectedParameterDescriptor(ParameterInfo parameter, ActionDescriptor action) : base() { Precondition.Require(parameter, () => Error.ArgumentNull("parameter")); Precondition.Require(action, () => Error.ArgumentNull("action")); _parameter = parameter; _action = action; _binding = new ReflectedParameterBinding(parameter); }
protected override IEnumerable<FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var attributes = base.GetActionAttributes(controllerContext, actionDescriptor); foreach (var attribute in attributes) { _container.BuildUp(attribute.GetType(), attribute); } return attributes; }
public void OnBeforeAction(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData) { string name = this.GetNameFromRouteContext(routeData); var telemetry = httpContext.RequestServices.GetService<RequestTelemetry>(); if (!string.IsNullOrEmpty(name) && telemetry != null && telemetry is RequestTelemetry) { name = httpContext.Request.Method + " " + name; ((RequestTelemetry)telemetry).Name = name; } }
public HarvestableResourceDescriptor(ItemDefinition itmDef, ActionDescriptor action, int quantity) { if (itmDef == null) throw new ArgumentNullException("itmDef"); if (action == null) throw new ArgumentNullException("action"); harvestedItem = itmDef; performedAction = action; quantityPerHarvest = quantity; }
/// <summary>Initializes a new instance of the <see cref="AuthenticationContext"/> class.</summary> /// <param name="controllerContext">The controller context.</param> /// <param name="actionDescriptor">The action descriptor.</param> /// <param name="principal">The current principal.</param> public AuthenticationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IPrincipal principal) : base(controllerContext) { if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } ActionDescriptor = actionDescriptor; Principal = principal; }
/// <summary> /// Executes binding action to context /// </summary> /// <param name="action"> </param> /// <param name="context"> </param> public void Bind(ActionDescriptor action, IMvcContext context) { lock (this) { if (null == _binders) { Setup(action.ActionType); } if (_binders != null) { foreach (var binder in _binders) { binder.Bind(action.Action, context); } } } }
public void GetApiDescription_IgnoresNonReflectedActionDescriptor() { // Arrange var action = new ActionDescriptor(); action.SetProperty(new ApiDescriptionActionData()); // Act var descriptions = GetApiDescriptions(action); // Assert Assert.Empty(descriptions); }
protected override FilterInfo GetFilters( ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var filterInfo = base.GetFilters(controllerContext, actionDescriptor); filterInfo.ExceptionFilters.Add(this.filter); return filterInfo; }
public void ActionDescriptor_ActionModel_Returns_Correct_Type() { //Arrange var genDescriptorMock = GetMockDescriptor(typeof(CodeGeneratorSample).GetTypeInfo()); var actionDescriptor = new ActionDescriptor(genDescriptorMock.Object, typeof(CodeGeneratorSample).GetMethod("GenerateCode")); //Act var actionModel = actionDescriptor.ActionModel; //Assert Assert.Equal(typeof(CodeGeneratorModel), actionModel); }
public ActionExecutedContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, bool canceled, Exception exception) : base(controllerContext) { if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } ActionDescriptor = actionDescriptor; Canceled = canceled; Exception = exception; }
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; }
public void EmptyResult_ExecuteResult_IsANoOp() { // Arrange var emptyResult = new EmptyResult(); var httpContext = new Mock<HttpContext>(MockBehavior.Strict); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var context = new ActionContext(httpContext.Object, routeData, actionDescriptor); // Act & Assert (does not throw) emptyResult.ExecuteResult(context); }
public virtual IEnumerable<Filter> GetFilters(ControllerContext context, ActionDescriptor action) { Precondition.Require(context, () => Error.ArgumentNull("context")); Precondition.Require(action, () => Error.ArgumentNull("action")); ControllerBase controller = context.Controller; if (controller == null) return Enumerable.Empty<Filter>(); return GetControllerAttributes(context, action) .Select(attr => new Filter(attr, FilterScope.Controller, null)) .Concat(GetActionAttributes(context, action) .Select(attr => new Filter(attr, FilterScope.Action, null))) .ToList(); }
public void ActionDescriptor_Parameters_Returns_Parameters_Writeable_And_Of_Supported_Type() { //Arrange var genDescriptorMock = GetMockDescriptor(typeof(CodeGeneratorSample).GetTypeInfo()); var actionDescriptor = new ActionDescriptor(genDescriptorMock.Object, typeof(CodeGeneratorSample).GetMethod("GenerateCode")); //Act var parameters = actionDescriptor.Parameters; //Assert var propertyNames = parameters.Select(pd => pd.Property.Name); var expectedProperties = new[] { "BoolProperty", "StringProperty" }.ToList(); Assert.Equal(expectedProperties, propertyNames, StringComparer.Ordinal); }
public AuthenticationChallengeContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, ActionResult result) : base(controllerContext) { if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } if (result == null) { throw new ArgumentNullException("result"); } _actionDescriptor = actionDescriptor; _result = result; }
public void HttpStatusCodeResult_ExecuteResultSetsResponseStatusCode() { // Arrange var result = new HttpStatusCodeResult(StatusCodes.Status404NotFound); var httpContext = GetHttpContext(); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var context = new ActionContext(httpContext, routeData, actionDescriptor); // Act result.ExecuteResult(context); // Assert Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); }
public void CreateController_ThrowsIfActionDescriptorIsNotControllerActionDescriptor() { // Arrange var expected = "The action descriptor must be of type 'Microsoft.AspNet.Mvc.ControllerActionDescriptor'." + Environment.NewLine + "Parameter name: actionContext"; var actionDescriptor = new ActionDescriptor(); var controllerFactory = new DefaultControllerFactory(Mock.Of<IControllerActivator>()); var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, new RouteData(), actionDescriptor); // Act and Assert var ex = Assert.Throws<ArgumentException>(() => controllerFactory.CreateController(actionContext)); Assert.Equal(expected, ex.Message); Assert.Equal("actionContext", ex.ParamName); }
private object PerformDataBindedExecution(ControllerExecutionContext executionCtx, ActionDescriptor descriptor) { var args = new List<object>(); foreach (var param in descriptor.Parameters.Values) { if (!param.DemandsCustomDataBinding) { DoDefaultDataBind(param, args, executionCtx); } else { DoCustomDataBind(param, args, executionCtx); } } return descriptor.Action(executionCtx.Controller, args.ToArray()); }
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters) { var allFilters = FiltersStore(controllerContext); var calledFilters = CallStore(controllerContext); var action = GlimpseFilterCallMetadata.ControllerAction(actionDescriptor, controllerContext.IsChildAction); allFilters.Add(action); calledFilters.Add(action.Guid); var invokeActionMethod = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters); return(invokeActionMethod); }
protected override AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList <IAuthorizationFilter> filters, ActionDescriptor actionDescriptor) { var invokeAuthorizationFilters = base.InvokeAuthorizationFilters(controllerContext, filters, actionDescriptor); return(invokeAuthorizationFilters); }
protected override ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList <IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters) { var invokeActionMethodWithFilters = base.InvokeActionMethodWithFilters(controllerContext, filters, actionDescriptor, parameters); return(invokeActionMethodWithFilters); }
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters) { var uowParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork)); if (uowParam != null) { var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>(); if (connectionKey == null) { throw new ArgumentNullException("connectionKey"); } using (var connection = SqlConnections.NewByKey(connectionKey.Value)) using (var uow = new UnitOfWork(connection)) { parameters[uowParam.ParameterName] = uow; var result = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters); uow.Commit(); return(result); } } var cnnParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IDbConnection)); if (cnnParam != null) { var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>(); if (connectionKey == null) { throw new ArgumentNullException("connectionKey"); } using (var cnn = SqlConnections.NewByKey(connectionKey.Value)) { parameters[cnnParam.ParameterName] = cnn; return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters)); } } return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters)); }
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var info = base.GetFilters(controllerContext, actionDescriptor); if (!info.ActionFilters.Any(x => x is JsonFilter)) { info.ActionFilters.Add(new JsonFilter()); } return(info); }
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue) { if (!(actionReturnValue is ActionResult)) { controllerContext.Controller.ViewData.Model = actionReturnValue; return(new PocoActionResult(ServiceLocator, actionReturnValue)); } return(base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue)); }
public BeforeViewComponent(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, object viewComponent) { ActionDescriptor = actionDescriptor; ViewComponentContext = viewComponentContext; ViewComponent = viewComponent; }
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { return(registeredFilters .Where(e => e.IsValid(controllerContext, actionDescriptor)) .Select(e => new Filter(e, e.Scope, e.Order))); }
private void AddActionDataToBuilder( EndpointBuilder builder, HashSet <string> routeNames, ActionDescriptor action, string routeName, RouteValueDictionary dataTokens, bool suppressLinkGeneration, bool suppressPathMatching, IReadOnlyList <Action <EndpointBuilder> > conventions, IReadOnlyList <Action <EndpointBuilder> > perRouteConventions) { // Add action metadata first so it has a low precedence if (action.EndpointMetadata != null) { foreach (var d in action.EndpointMetadata) { builder.Metadata.Add(d); } } builder.Metadata.Add(action); // MVC guarantees that when two of it's endpoints have the same route name they are equivalent. // // The case for this looks like: // // [HttpGet] // [HttpPost] // [Route("/Foo", Name = "Foo")] // public void DoStuff() { } // // However, Endpoint Routing requires Endpoint Names to be unique. // // We can use the route name as the endpoint name if it's not set. Note that there's no // attribute for this today so it's unlikley. Using endpoint name on a if (routeName != null && !suppressLinkGeneration && routeNames.Add(routeName) && builder.Metadata.OfType <IEndpointNameMetadata>().LastOrDefault()?.EndpointName == null) { builder.Metadata.Add(new EndpointNameMetadata(routeName)); } if (dataTokens != null) { builder.Metadata.Add(new DataTokensMetadata(dataTokens)); } builder.Metadata.Add(new RouteNameMetadata(routeName)); // Add filter descriptors to endpoint metadata if (action.FilterDescriptors != null && action.FilterDescriptors.Count > 0) { foreach (var filter in action.FilterDescriptors.OrderBy(f => f, FilterDescriptorOrderComparer.Comparer).Select(f => f.Filter)) { builder.Metadata.Add(filter); } } if (action.ActionConstraints != null && action.ActionConstraints.Count > 0) { // We explicitly convert a few types of action constraints into MatcherPolicy+Metadata // to better integrate with the DFA matcher. // // Other IActionConstraint data will trigger a back-compat path that can execute // action constraints. foreach (var actionConstraint in action.ActionConstraints) { if (actionConstraint is HttpMethodActionConstraint httpMethodActionConstraint && !builder.Metadata.OfType <HttpMethodMetadata>().Any()) { builder.Metadata.Add(new HttpMethodMetadata(httpMethodActionConstraint.HttpMethods)); } else if (actionConstraint is ConsumesAttribute consumesAttribute && !builder.Metadata.OfType <ConsumesMetadata>().Any()) { builder.Metadata.Add(new ConsumesMetadata(consumesAttribute.ContentTypes.ToArray())); }
/// <inheritdoc /> protected override IEnumerable <FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var attributes = base.GetControllerAttributes(controllerContext, actionDescriptor).ToArray(); foreach (var filterAttribute in attributes) { this.dependencyResolver.BuildUp(filterAttribute); } return(attributes); }
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue) { var actionResult = base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue); return(actionResult); }
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { return(fluentMvcResolver.GetFilters(controllerContext, actionDescriptor, actionDescriptor.ControllerDescriptor)); }
public override IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var filters = base.GetFilters(controllerContext, actionDescriptor); foreach (var filter in filters) { _container.BuildUp(filter.Instance); yield return(filter); } }
public static MethodInfo GetMethodInfo(this ActionDescriptor actionDescriptor) { return(actionDescriptor.AsControllerActionDescriptor().MethodInfo); }
protected override IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var parameterValues = base.GetParameterValues(controllerContext, actionDescriptor); return(parameterValues); }
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue) { return((actionReturnValue as ActionResult) ?? new Result <object>(actionReturnValue)); }
protected override IEnumerable <FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var attributes = base.GetActionAttributes(controllerContext, actionDescriptor).ToList(); foreach (var attribute in attributes) { _container.BuildUp(attribute.GetType(), attribute); } return(attributes); }
protected virtual bool IsRemoteService(ActionDescriptor actionDescriptor) { var remoteServiceAttr = ReflectionHelper.GetSingleAttributeOfMemberOrDeclaringTypeOrDefault <RemoteServiceAttribute>(actionDescriptor.GetMethodInfo()); return(remoteServiceAttr != null && remoteServiceAttr.IsEnabled); }
public bool JoinsTo(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { return(controllerContext.HttpContext.Request["outputType"] != null); }
/// <summary> /// Aggregates the filters from all of the filter providers into one collection. /// </summary> /// <returns> /// The collection filters from all of the filter providers. /// </returns> /// <param name="controllerContext">The controller context.</param> /// <param name="actionDescriptor">The action descriptor.</param> public override IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var filters = base.GetFilters(controllerContext, actionDescriptor).ToArray(); foreach (var filter in filters) { serviceContainer.InjectProperties(filter.Instance); } return(filters); }
public void AddEndpoints( List <Endpoint> endpoints, HashSet <string> routeNames, ActionDescriptor action, IReadOnlyList <ConventionalRouteEntry> routes, IReadOnlyList <Action <EndpointBuilder> > conventions, bool createInertEndpoints) { if (endpoints == null) { throw new ArgumentNullException(nameof(endpoints)); } if (routeNames == null) { throw new ArgumentNullException(nameof(routeNames)); } if (action == null) { throw new ArgumentNullException(nameof(action)); } if (routes == null) { throw new ArgumentNullException(nameof(routes)); } if (conventions == null) { throw new ArgumentNullException(nameof(conventions)); } if (createInertEndpoints) { var builder = new InertEndpointBuilder() { DisplayName = action.DisplayName, RequestDelegate = _requestDelegate, }; AddActionDataToBuilder( builder, routeNames, action, routeName: null, dataTokens: null, suppressLinkGeneration: false, suppressPathMatching: false, conventions, Array.Empty <Action <EndpointBuilder> >()); endpoints.Add(builder.Build()); } if (action.AttributeRouteInfo == null) { // Check each of the conventional patterns to see if the action would be reachable. // If the action and pattern are compatible then create an endpoint with action // route values on the pattern. foreach (var route in routes) { // A route is applicable if: // 1. It has a parameter (or default value) for 'required' non-null route value // 2. It does not have a parameter (or default value) for 'required' null route value var updatedRoutePattern = _routePatternTransformer.SubstituteRequiredValues(route.Pattern, action.RouteValues); if (updatedRoutePattern == null) { continue; } // We suppress link generation for each conventionally routed endpoint. We generate a single endpoint per-route // to handle link generation. var builder = new RouteEndpointBuilder(_requestDelegate, updatedRoutePattern, route.Order) { DisplayName = action.DisplayName, }; AddActionDataToBuilder( builder, routeNames, action, route.RouteName, route.DataTokens, suppressLinkGeneration: true, suppressPathMatching: false, conventions, route.Conventions); endpoints.Add(builder.Build()); } } else { var attributeRoutePattern = RoutePatternFactory.Parse(action.AttributeRouteInfo.Template); // Modify the route and required values to ensure required values can be successfully subsituted. // Subsitituting required values into an attribute route pattern should always succeed. var(resolvedRoutePattern, resolvedRouteValues) = ResolveDefaultsAndRequiredValues(action, attributeRoutePattern); var updatedRoutePattern = _routePatternTransformer.SubstituteRequiredValues(resolvedRoutePattern, resolvedRouteValues); if (updatedRoutePattern == null) { // This kind of thing can happen when a route pattern uses a *reserved* route value such as `action`. // See: https://github.com/aspnet/AspNetCore/issues/14789 var formattedRouteKeys = string.Join(", ", resolvedRouteValues.Keys.Select(k => $"'{k}'")); throw new InvalidOperationException( $"Failed to update the route pattern '{resolvedRoutePattern.RawText}' with required route values. " + $"This can occur when the route pattern contains parameters with reserved names such as: {formattedRouteKeys} " + $"and also uses route constraints such as '{{action:int}}'. " + $"To fix this error, choose a different parmaeter name."); } var builder = new RouteEndpointBuilder(_requestDelegate, updatedRoutePattern, action.AttributeRouteInfo.Order) { DisplayName = action.DisplayName, }; AddActionDataToBuilder( builder, routeNames, action, action.AttributeRouteInfo.Name, dataTokens: null, action.AttributeRouteInfo.SuppressLinkGeneration, action.AttributeRouteInfo.SuppressPathMatching, conventions, perRouteConventions: Array.Empty <Action <EndpointBuilder> >()); endpoints.Add(builder.Build()); } }
/// <summary> /// Performs the query composition after action is executed. It first tries to retrieve the IQueryable from the /// returning response message. It then validates the query from uri based on the validation settings on /// <see cref="EnableQueryAttribute"/>. It finally applies the query appropriately, and reset it back on /// the response message. /// </summary> /// <param name="actionExecutedContext">The context related to this action, including the response message, /// request message and HttpConfiguration etc.</param> public override void OnActionExecuted(ActionExecutedContext actionExecutedContext) { if (actionExecutedContext == null) { throw Error.ArgumentNull("actionExecutedContext"); } HttpRequest request = actionExecutedContext.HttpContext.Request; if (request == null) { throw Error.Argument("actionExecutedContext", SRResources.ActionExecutedContextMustHaveRequest); } ActionDescriptor actionDescriptor = actionExecutedContext.ActionDescriptor; if (actionDescriptor == null) { throw Error.Argument("actionExecutedContext", SRResources.ActionContextMustHaveDescriptor); } HttpResponse response = actionExecutedContext.HttpContext.Response; // Check is the response is set and successful. if (response != null && IsSuccessStatusCode(response.StatusCode) && actionExecutedContext.Result != null) { // actionExecutedContext.Result might also indicate a status code that has not yet // been applied to the result; make sure it's also successful. StatusCodeResult statusCodeResult = actionExecutedContext.Result as StatusCodeResult; if (statusCodeResult == null || IsSuccessStatusCode(statusCodeResult.StatusCode)) { ObjectResult responseContent = actionExecutedContext.Result as ObjectResult; if (responseContent != null) { //throw Error.Argument("actionExecutedContext", SRResources.QueryingRequiresObjectContent, // actionExecutedContext.Result.GetType().FullName); // Get collection from SingleResult. IQueryable singleResultCollection = null; SingleResult singleResult = responseContent.Value as SingleResult; if (singleResult != null) { // This could be a SingleResult, which has the property Queryable. // But it could be a SingleResult() or SingleResult<T>. Sort by number of parameters // on the property and get the one with the most parameters. PropertyInfo propInfo = responseContent.Value.GetType().GetProperties() .OrderBy(p => p.GetIndexParameters().Count()) .Where(p => p.Name.Equals("Queryable")) .LastOrDefault(); singleResultCollection = propInfo.GetValue(singleResult) as IQueryable; } // Execution the action. object queryResult = OnActionExecuted( responseContent.Value, singleResultCollection, new WebApiActionDescriptor(actionDescriptor as ControllerActionDescriptor), new WebApiRequestMessage(request), (elementClrType) => GetModel(elementClrType, request, actionDescriptor), (queryContext) => CreateAndValidateQueryOptions(request, queryContext), (statusCode) => actionExecutedContext.Result = new StatusCodeResult((int)statusCode), (statusCode, message, exception) => actionExecutedContext.Result = CreateBadRequestResult(message, exception)); if (queryResult != null) { responseContent.Value = queryResult; } } } } }
private static (RoutePattern resolvedRoutePattern, IDictionary <string, string> resolvedRequiredValues) ResolveDefaultsAndRequiredValues(ActionDescriptor action, RoutePattern attributeRoutePattern) { RouteValueDictionary updatedDefaults = null; IDictionary <string, string> resolvedRequiredValues = null; foreach (var routeValue in action.RouteValues) { var parameter = attributeRoutePattern.GetParameter(routeValue.Key); if (!RouteValueEqualityComparer.Default.Equals(routeValue.Value, string.Empty)) { if (parameter == null) { // The attribute route has a required value with no matching parameter // Add the required values without a parameter as a default // e.g. // Template: "Login/{action}" // Required values: { controller = "Login", action = "Index" } // Updated defaults: { controller = "Login" } if (updatedDefaults == null) { updatedDefaults = new RouteValueDictionary(attributeRoutePattern.Defaults); } updatedDefaults[routeValue.Key] = routeValue.Value; } } else { if (parameter != null) { // The attribute route has a null or empty required value with a matching parameter // Remove the required value from the route if (resolvedRequiredValues == null) { resolvedRequiredValues = new Dictionary <string, string>(action.RouteValues); } resolvedRequiredValues.Remove(parameter.Name); } } } if (updatedDefaults != null) { attributeRoutePattern = RoutePatternFactory.Parse(action.AttributeRouteInfo.Template, updatedDefaults, parameterPolicies: null); } return(attributeRoutePattern, resolvedRequiredValues ?? action.RouteValues); }
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var filters = base.GetFilters(controllerContext, actionDescriptor); foreach (var filter in filters.AuthorizationFilters.Cast <object>() .Concat(filters.ActionFilters.Cast <object>()) .Concat(filters.ExceptionFilters.Cast <object>()) .Concat(filters.ResultFilters.Cast <object>())) { var filterType = filter.GetType(); if (typeof(IRequiresRoutableRequestContext).IsAssignableFrom(filterType)) { ((IRequiresRoutableRequestContext)filter).RoutableRequestContext = RoutableRequestContext; } } return(filters); }
private static bool ValidationDisabled(ActionDescriptor actionDescriptor) { return(actionDescriptor.GetCustomAttributes(typeof(SkipAjaxValidation), false).Cast <SkipAjaxValidation>().Any()); }
public static ApiVersionModel GetApiVersion(this ActionDescriptor actionDescriptor) { return(actionDescriptor?.Properties .Where(kvp => (Type)kvp.Key == typeof(ApiVersionModel)) .Select(kvp => kvp.Value as ApiVersionModel).FirstOrDefault()); }
private bool MustActionBeWrapped(ActionDescriptor descriptor) { return(null != descriptor.Parameters .Select(param => param.ParameterType) .FirstOrDefault(IsCommand)); }
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var allFilters = FiltersStore(controllerContext); FieldInfo dynField = typeof(ControllerActionInvoker).GetField("_getFiltersThunk", BindingFlags.NonPublic | BindingFlags.Instance); var filters = dynField.GetValue(this) as Func <ControllerContext, ActionDescriptor, IEnumerable <Filter> >; var filtersEnum = filters(controllerContext, actionDescriptor); var filterInfo = base.GetFilters(controllerContext, actionDescriptor); var isChild = controllerContext.IsChildAction; var actionFilters = filterInfo.ActionFilters; for (int i = 0; i < actionFilters.Count; i++) { if (!(actionFilters[i] is GlimpseActionFilter)) { //Wrap it for call logging var innerFilter = filtersEnum.Where(f => f.Instance == actionFilters[i]).SingleOrDefault(); var newFilter = new GlimpseActionFilter(actionFilters[i]) { Filter = innerFilter, OnActionExecutedGuid = Guid.NewGuid(), OnActionExecutingGuid = Guid.NewGuid() }; actionFilters[i] = newFilter; //Store metadata for later analysis allFilters.Add(new GlimpseFilterCallMetadata("Action", newFilter.OnActionExecutedGuid, "OnActionExecuted()", innerFilter, isChild)); allFilters.Add(new GlimpseFilterCallMetadata("Action", newFilter.OnActionExecutingGuid, "OnActionExecuting()", innerFilter, isChild)); } } var authorizationFilters = filterInfo.AuthorizationFilters; for (int i = 0; i < authorizationFilters.Count; i++) { if (!(authorizationFilters[i] is GlimpseAuthorizationFilter)) { var innerFilter = filtersEnum.Where(f => f.Instance == authorizationFilters[i]).SingleOrDefault(); var newFilter = new GlimpseAuthorizationFilter(authorizationFilters[i]) { Filter = innerFilter, Guid = Guid.NewGuid() }; authorizationFilters[i] = newFilter; allFilters.Add(new GlimpseFilterCallMetadata("Authorization", newFilter.Guid, "OnAuthorization()", innerFilter, isChild)); } } var exceptionFilters = filterInfo.ExceptionFilters; for (int i = 0; i < exceptionFilters.Count; i++) { if (!(exceptionFilters[i] is GlimpseExceptionFilter)) { var innerFilter = filtersEnum.Where(f => f.Instance == exceptionFilters[i]).SingleOrDefault(); var newFilter = new GlimpseExceptionFilter(exceptionFilters[i]) { Filter = innerFilter, Guid = Guid.NewGuid() }; exceptionFilters[i] = newFilter; allFilters.Add(new GlimpseFilterCallMetadata("Exception", newFilter.Guid, "OnException()", innerFilter, isChild)); } } var resultFilters = filterInfo.ResultFilters; for (int i = 0; i < resultFilters.Count; i++) { if (!(resultFilters[i] is GlimpseResultFilter)) { var innerFilter = filtersEnum.Where(f => f.Instance == resultFilters[i]).SingleOrDefault(); var newFilter = new GlimpseResultFilter(resultFilters[i]) { Filter = innerFilter, OnResultExecutedGuid = Guid.NewGuid(), OnResultExecutingGuid = Guid.NewGuid() }; resultFilters[i] = newFilter; allFilters.Add(new GlimpseFilterCallMetadata("Result", newFilter.OnResultExecutedGuid, "OnResultExecuted()", innerFilter, isChild)); allFilters.Add(new GlimpseFilterCallMetadata("Result", newFilter.OnResultExecutingGuid, "OnResultExecuting()", innerFilter, isChild)); } } return(filterInfo); }
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { return(registeredFilters.Select(m => m.Invoke(controllerContext, actionDescriptor)).Where(m => m != null)); }
public static bool IsControllerAction(this ActionDescriptor actionDescriptor) { return(actionDescriptor is ControllerActionDescriptor); }