/// <inheritdoc /> public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } foreach (var filter in _mvcOptions.Filters) { context.Result.Filters.Add(filter); } foreach (var controllerType in context.ControllerTypes) { var controllerModel = CreateControllerModel(controllerType); if (controllerModel == null) { continue; } context.Result.Controllers.Add(controllerModel); controllerModel.Application = context.Result; foreach (var propertyHelper in PropertyHelper.GetProperties(controllerType.AsType())) { var propertyInfo = propertyHelper.Property; var propertyModel = CreatePropertyModel(propertyInfo); if (propertyModel != null) { propertyModel.Controller = controllerModel; controllerModel.ControllerProperties.Add(propertyModel); } } foreach (var methodInfo in controllerType.AsType().GetMethods()) { var actionModel = CreateActionModel(controllerType, methodInfo); if (actionModel == null) { continue; } actionModel.Controller = controllerModel; controllerModel.Actions.Add(actionModel); foreach (var parameterInfo in actionModel.ActionMethod.GetParameters()) { var parameterModel = CreateParameterModel(parameterInfo); if (parameterModel != null) { parameterModel.Action = actionModel; actionModel.Parameters.Add(parameterModel); } } } } }
private static ApplicationModelProviderContext CreateProviderContext(Type controllerType) { var defaultProvider = new DefaultApplicationModelProvider( Options.Create(new MvcOptions()), new EmptyModelMetadataProvider()); var context = new ApplicationModelProviderContext(new[] { controllerType.GetTypeInfo() }); defaultProvider.OnProvidersExecuting(context); return(context); }
private static ApplicationModelProviderContext GetContext( Type type, IModelMetadataProvider modelMetadataProvider = null) { var context = new ApplicationModelProviderContext(new[] { type.GetTypeInfo() }); var mvcOptions = Options.Create(new MvcOptions()); modelMetadataProvider = modelMetadataProvider ?? new EmptyModelMetadataProvider(); var convention = new DefaultApplicationModelProvider(mvcOptions, modelMetadataProvider); convention.OnProvidersExecuting(context); return(context); }
private static ApplicationModelProviderContext GetContext( Type type, IModelMetadataProvider modelMetadataProvider = null) { var context = new ApplicationModelProviderContext(new[] { type.GetTypeInfo() }); var mvcOptions = Options.Create(new MvcOptions { AllowValidatingTopLevelNodes = true }); modelMetadataProvider = modelMetadataProvider ?? new EmptyModelMetadataProvider(); var provider = new DefaultApplicationModelProvider(mvcOptions, modelMetadataProvider); provider.OnProvidersExecuting(context); return(context); }
internal ApplicationModel BuildModel() { var controllerTypes = GetControllerTypes(); var context = new ApplicationModelProviderContext(controllerTypes); for (var i = 0; i < _applicationModelProviders.Length; i++) { _applicationModelProviders[i].OnProvidersExecuting(context); } for (var i = _applicationModelProviders.Length - 1; i >= 0; i--) { _applicationModelProviders[i].OnProvidersExecuted(context); } return(context.Result); }
public void OnProvidersExecuting_AppliesConventions() { // Arrange var controllerModel = new ControllerModel(typeof(TestApiController).GetTypeInfo(), new[] { new ApiControllerAttribute() }) { Selectors = { new SelectorModel { AttributeRouteModel = new AttributeRouteModel() } }, }; var method = typeof(TestApiController).GetMethod(nameof(TestApiController.TestAction)); var actionModel = new ActionModel(method, Array.Empty <object>()) { Controller = controllerModel, }; controllerModel.Actions.Add(actionModel); var parameter = method.GetParameters()[0]; var parameterModel = new ParameterModel(parameter, Array.Empty <object>()) { Action = actionModel, }; actionModel.Parameters.Add(parameterModel); var context = new ApplicationModelProviderContext(new[] { controllerModel.ControllerType }); context.Result.Controllers.Add(controllerModel); var provider = GetProvider(); // Act provider.OnProvidersExecuting(context); // Assert // Verify some of the side-effects of executing API behavior conventions. Assert.True(actionModel.ApiExplorer.IsVisible); Assert.NotEmpty(actionModel.Filters.OfType <ModelStateInvalidFilterFactory>()); Assert.NotEmpty(actionModel.Filters.OfType <ClientErrorResultFilterFactory>()); Assert.Equal(BindingSource.Body, parameterModel.BindingInfo.BindingSource); }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (_mvcOptions.EnableEndpointRouting) { // When using endpoint routing, the AuthorizationMiddleware does the work that Auth filters would otherwise perform. // Consequently we do not need to convert authorization attributes to filters. return; } foreach (var controllerModel in context.Result.Controllers) { var controllerModelAuthData = controllerModel.Attributes.OfType <IAuthorizeData>().ToArray(); if (controllerModelAuthData.Length > 0) { controllerModel.Filters.Add(GetFilter(_policyProvider, controllerModelAuthData)); } foreach (var attribute in controllerModel.Attributes.OfType <IAllowAnonymous>()) { controllerModel.Filters.Add(new AllowAnonymousFilter()); } foreach (var actionModel in controllerModel.Actions) { var actionModelAuthData = actionModel.Attributes.OfType <IAuthorizeData>().ToArray(); if (actionModelAuthData.Length > 0) { actionModel.Filters.Add(GetFilter(_policyProvider, actionModelAuthData)); } foreach (var _ in actionModel.Attributes.OfType <IAllowAnonymous>()) { actionModel.Filters.Add(new AllowAnonymousFilter()); } } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { if (!IsApiController(controller)) { continue; } foreach (var action in controller.Actions) { // Ensure ApiController is set up correctly EnsureActionIsAttributeRouted(action); foreach (var convention in ActionModelConventions) { convention.Apply(action); } } } }
public ApplicationModel CreateApplicationModel(IEnumerable <TypeInfo> controllerTypes) { if (controllerTypes == null) { throw new ArgumentNullException(nameof(controllerTypes)); } var context = new ApplicationModelProviderContext(controllerTypes); for (var i = 0; i < _applicationModelProviders.Length; i++) { _applicationModelProviders[i].OnProvidersExecuting(context); } for (var i = _applicationModelProviders.Length - 1; i >= 0; i--) { _applicationModelProviders[i].OnProvidersExecuted(context); } ApplicationModelConventions.ApplyConventions(context.Result, _conventions); return(context.Result); }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { }
/// <inheritdoc /> public void OnProvidersExecuted(ApplicationModelProviderContext context) { // Intentionally empty. }