public void BuildActionModels_BaseAuthorizeFiltersAreStillValidWhenOverriden() { // Arrange var options = new TestOptionsManager<AuthorizationOptions>(); options.Value.AddPolicy("Base", policy => policy.RequireClaim("Basic").RequireClaim("Basic2")); options.Value.AddPolicy("Derived", policy => policy.RequireClaim("Derived")); var provider = new AuthorizationApplicationModelProvider(new DefaultAuthorizationPolicyProvider(options)); var defaultProvider = new DefaultApplicationModelProvider(new TestOptionsManager<MvcOptions>()); var context = new ApplicationModelProviderContext(new[] { typeof(DerivedController).GetTypeInfo() }); defaultProvider.OnProvidersExecuting(context); // Act provider.OnProvidersExecuting(context); // Assert var controller = Assert.Single(context.Result.Controllers); var action = Assert.Single(controller.Actions); Assert.Equal("Authorize", action.ActionName); var attributeRoutes = action.Selectors.Where(sm => sm.AttributeRouteModel != null); Assert.Empty(attributeRoutes); var authorizeFilters = action.Filters.OfType<AuthorizeFilter>(); Assert.Single(authorizeFilters); Assert.NotNull(authorizeFilters.First().PolicyProvider); Assert.Equal(2, authorizeFilters.First().AuthorizeData.Count()); // Base + Derived authorize }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } foreach (var controllerModel in context.Result.Controllers) { controllerModel.Filters.Add(new AuthorizeFilter(_policyProvider, controllerModel.Attributes.OfType<IAuthorizeData>())); foreach (var attribute in controllerModel.Attributes.OfType<IAllowAnonymous>()) { controllerModel.Filters.Add(new AllowAnonymousFilter()); } foreach (var actionModel in controllerModel.Actions) { actionModel.Filters.Add(new AuthorizeFilter(_policyProvider, actionModel.Attributes.OfType<IAuthorizeData>())); foreach (var attribute in actionModel.Attributes.OfType<IAllowAnonymous>()) { actionModel.Filters.Add(new AllowAnonymousFilter()); } } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Intentionally empty. }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var item in context.Result.Controllers) { var pluginInfo = _pluginManager[item.ControllerType]; if (pluginInfo != null) item.RouteConstraints.Add(new PluginRouteConstraintProvider(pluginInfo.Plugin.UrlPrefix)); } }
/// <inheritdoc /> public virtual void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } foreach (var filter in _globalFilters) { 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); } } } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { foreach (var action in controller.Actions) { action.Filters.Add(new ProducesResponseTypeAttribute(typeof(ExceptionResponse), StatusCodes.Status500InternalServerError)); } } }
private static ApplicationModelProviderContext GetApplicatonModelProviderContext(Type controllerType) { var context = new ApplicationModelProviderContext(new[] { controllerType.GetTypeInfo() }); var defaultProvider = new DefaultApplicationModelProvider( Options.Create(new MvcOptions()), new EmptyModelMetadataProvider()); defaultProvider.OnProvidersExecuting(context); return(context); }
private void FillContext(IEnumerable <IFileInfo> sources, ApplicationModelProviderContext context) { var reflector = new TypeReflectionEngine(); MachineInstance.Current.PrepareThread(_fw.Environment); foreach (var virtualPath in sources) { LoadedModule module; FileInfoCodeSource codeSrc; string typeName; if (virtualPath.IsDirectory) { var info = FindModule(virtualPath.Name, MODULE_FILENAME) ?? FindModule(virtualPath.Name, virtualPath.Name + ".os"); if (info == null) { continue; } codeSrc = new FileInfoCodeSource(info); typeName = virtualPath.Name; } else { codeSrc = new FileInfoCodeSource(virtualPath); typeName = System.IO.Path.GetFileNameWithoutExtension(virtualPath.Name); } module = CompileControllerModule(codeSrc); var reflectedType = reflector.Reflect <ScriptedController>(module, typeName); var attrList = MapAnnotationsToAttributes(_classAttribResolver.Attributes); var cm = new ControllerModel(typeof(ScriptedController).GetTypeInfo(), attrList.AsReadOnly()); cm.ControllerName = reflectedType.Name; var recompileInfo = new DynamicCompilationInfo() { Module = module, CodeSource = codeSrc, Tag = cm }; cm.Properties.Add("CompilationInfo", recompileInfo); cm.Properties.Add("type", reflectedType); ChangeToken.OnChange(() => CreateWatchToken(codeSrc), RecompileController, recompileInfo); FillActions(cm, reflectedType); FillFilters(cm); context.Result.Controllers.Add(cm); } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { var feature = _typeFeatureProvider.GetFeatureForDependency(controller.ControllerType.AsType()); if (feature != null) { controller.RouteConstraints.Add(new AreaAttribute(feature.Descriptor.Id)); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { var schema = _provider.GetFeatureForDependency(controller.ControllerType.AsType()); if (schema != null) { controller.RouteValues.Add("area", schema.Plugin.Id); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controllerModel in context.Result.Controllers) { if (controllerModel.Filters.OfType <IAsyncAuthorizationFilter>().FirstOrDefault() == null) { //default policy only used when there is no authorize filter in the controller controllerModel.Filters.Add(new AuthorizeFilter(_authorizationOptions.DefaultPolicy)); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { if (controller.ControllerName.EndsWith(_controllerEndwith, StringComparison.OrdinalIgnoreCase)) { controller.ControllerName = controller.ControllerName.Substring(0, controller.ControllerName.Length - "Kishan".Length); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (ControllerModel controller in context.Result.Controllers) { foreach (ActionModel action in controller.Actions) { action.Filters.Add(new ProducesResponseTypeAttribute(typeof(ValidationErrorViewModel), StatusCodes.Status400BadRequest)); action.Filters.Add(new ProducesResponseTypeAttribute(typeof(ErrorViewModel), StatusCodes.Status500InternalServerError)); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { var feature = _typeFeatureProvider.GetFeatureForDependency(controller.ControllerType.AsType()); if (feature != null) { controller.RouteValues.Add("area", feature.Descriptor.Id); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { ControllerBlueprintItem item = this.FindBlueprintItem(controller.ControllerType); if (item != null) { controller.RouteValues.Add(ModuleRouteKeyName, item.Feature.Descriptor.ModuleName); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var item in context.Result.Controllers) { var pluginInfo = _pluginManager[item.ControllerType]; if (pluginInfo != null && pluginInfo.Plugin is IAspNetCorePlugin plugin) { item.RouteValues.Add("plugin", plugin.UrlPrefix); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { var feature = _typeFeatureProvider.GetFeatureForDependency(controller.ControllerType.AsType()); if (feature != null) { controller.RouteValues.Add("area", feature.Id); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { // This code is called only once per tenant during the construction of routes foreach (var controller in context.Result.Controllers) { var feature = _typeFeatureProvider.GetFeatureForDependency(controller.ControllerType.AsType()); if (feature != null) { controller.RouteValues.Add("area", feature.Extension.Id); } } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controllerModel in context.Result.Controllers) { controllerModel.Attributes .OfType <InversionOfControlAttribute>().ToList() .ForEach(a => a.InjectServices(_urlHelperFactory)); controllerModel.Actions.SelectMany(a => a.Attributes) .OfType <InversionOfControlAttribute>().ToList() .ForEach(a => a.InjectServices(_urlHelperFactory)); } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { this.ReplaceFilters(context.Result.Filters); foreach (var controller in context.Result.Controllers) { this.ReplaceFilters(controller.Filters); foreach (var action in controller.Actions) { this.ReplaceFilters(action.Filters); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (ControllerModel controller in context.Result.Controllers) { foreach (ActionModel action in controller.Actions) { action.Filters.Add(new SwaggerResponseAttribute((int)HttpStatusCode.BadRequest, _badRequestDescription, typeof(ModelErrorResponse))); action.Filters.Add(new SwaggerResponseAttribute((int)HttpStatusCode.NotFound, _notFoundDescription, typeof(string))); action.Filters.Add(new SwaggerResponseAttribute((int)HttpStatusCode.Unauthorized, _unAuthorizedDescription, typeof(string))); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (!_mvcOptions.EnableEndpointRouting) { ConfigureCorsFilters(context); } }
/// <summary> /// Executed for the second pass of <see cref="ApplicationModel"/> built. /// </summary> /// <param name="context">The <see cref="ApplicationModelProviderContext"/>.</param> public void OnProvidersExecuted(ApplicationModelProviderContext context) { var routes = _options.Models; foreach (var route in routes) { IEdmModel model = route.Value.Item1; if (model == null || model.EntityContainer == null) { continue; } foreach (var controller in context.Result.Controllers) { // Skip the controller with [NonODataController] attribute decorated. if (controller.HasAttribute <NonODataControllerAttribute>()) { continue; } // Apply to ODataModelAttribute if (!CanApply(route.Key, controller)) { continue; } ODataControllerActionContext odataContext = BuildContext(route.Key, model, controller); odataContext.ServiceProvider = route.Value.Item2; // consider to replace the Linq with others? IODataControllerActionConvention[] conventions = _controllerActionConventions.Where(c => c.AppliesToController(odataContext)).ToArray(); if (conventions.Length > 0) { foreach (var action in controller.Actions.Where(a => !a.IsNonODataAction())) { // Reset the action on the context. odataContext.Action = action; foreach (var convention in conventions) { if (convention.AppliesToAction(odataContext)) { break; } } } } } } }
private void FillContext(IEnumerable <IFileInfo> sources, ApplicationModelProviderContext context) { var reflector = new TypeReflectionEngine(); _fw.Environment.LoadMemory(MachineInstance.Current); foreach (var virtualPath in sources) { LoadedModule module; ICodeSource codeSrc; string typeName; if (virtualPath.IsDirectory) { var info = FindModule(virtualPath.Name, MODULE_FILENAME) ?? FindModule(virtualPath.Name, virtualPath.Name + ".os"); if (info == null) { continue; } codeSrc = new FileInfoCodeSource(info); typeName = virtualPath.Name; } else { codeSrc = new FileInfoCodeSource(virtualPath); typeName = System.IO.Path.GetFileNameWithoutExtension(virtualPath.Name); } try { _classAttribResolver.BeforeCompilation(); module = LoadControllerCode(codeSrc); } finally { _classAttribResolver.AfterCompilation(); } var reflectedType = reflector.Reflect <ScriptedController>(module, typeName); var attrList = MapAnnotationsToAttributes(_classAttribResolver.Attributes); var cm = new ControllerModel(typeof(ScriptedController).GetTypeInfo(), attrList.AsReadOnly()); cm.ControllerName = reflectedType.Name; cm.Properties.Add("module", module); cm.Properties.Add("type", reflectedType); FillActions(cm, reflectedType); FillFilters(cm); context.Result.Controllers.Add(cm); } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controller in context.Result.Controllers) { foreach (var action in controller.Actions) { TryAddDefaultErrorsFilters(action); TryAddProduces201Filter(action); TryAddProducesFilter(action); TryAddConsumesFilter(action); } } }
private void AddVersion( ApplicationModelProviderContext context, string version, IReadOnlyDictionary <string, TypeInfo> controllers) { foreach (KeyValuePair <string, TypeInfo> controller in controllers) { ControllerModel controllerModel = CreateControllerModel(controller.Value); controllerModel.ControllerName = $"{controller.Key}/{version}"; controllerModel.RouteValues.Add("version", version); if (controllerModel.Selectors.Count > 1) { throw new InvalidOperationException("Versioned Controllers cannot have more than one route."); } SelectorModel selector = controllerModel.Selectors.Count == 1 ? controllerModel.Selectors[0] : GetDefaultControllerSelector(controller); if (selector.AttributeRouteModel.IsAbsoluteTemplate) { throw new InvalidOperationException( "versioned api controllers are not allowed to have absolute routes."); } controllerModel.Selectors.Clear(); Options.VersioningScheme.Apply(selector, version); controllerModel.Selectors.Add(selector); context.Result.Controllers.Add(controllerModel); controllerModel.Application = context.Result; foreach (MethodInfo methodInfo in controller.Value.AsType().GetMethods()) { ActionModel actionModel = CreateActionModel(controller.Value, methodInfo); if (actionModel == null) { continue; } actionModel.Controller = controllerModel; controllerModel.Actions.Add(actionModel); foreach (ParameterInfo parameter in actionModel.ActionMethod.GetParameters()) { ParameterModel parameterModel = CreateParameterModel(parameter); parameterModel.Action = actionModel; actionModel.Parameters.Add(parameterModel); } } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } foreach (var controllerModel in context.Result.Controllers) { var controllerEnableThrottling = controllerModel.Attributes.OfType <IEnableThrottlingAttribute>().FirstOrDefault(); foreach (var actionModel in controllerModel.Actions) { if (actionModel.Attributes.OfType <IDisableThrottlingAttribute>().Any()) { continue; } IFilterMetadata filter = null; var enableThrottling = actionModel.Attributes.OfType <IEnableThrottlingAttribute>().FirstOrDefault(); var controllerRouteModels = controllerModel.Selectors.Select(s => s.AttributeRouteModel); string policyName = null; if (enableThrottling != null) { policyName = enableThrottling.PolicyName; } else if (controllerEnableThrottling != null) { policyName = controllerEnableThrottling.PolicyName; } if (policyName != null) { foreach (var selector in actionModel.Selectors) { var actionRouteModel = selector.AttributeRouteModel; var httpMethods = selector .ActionConstraints .OfType <HttpMethodActionConstraint>() .SelectMany(c => c.HttpMethods) .Distinct(); filter = new ThrottleFilterFactory(httpMethods, actionRouteModel, controllerRouteModels, policyName); actionModel.Filters.Add(filter); } } } } }
public void on_providers_executed_should_apply_api_version_model_conventions() { // arrange var supported = new[] { new ApiVersion(1, 0), new ApiVersion(2, 0), new ApiVersion(3, 0) }; var deprecated = new[] { new ApiVersion(0, 9) }; var type = typeof(object); var attributes = new object[] { new ApiVersionAttribute("1.0"), new ApiVersionAttribute("2.0"), new ApiVersionAttribute("3.0"), new ApiVersionAttribute("0.9") { Deprecated = true } }; var actionMethod = type.GetRuntimeMethod(nameof(object.ToString), EmptyTypes); var controller = new ControllerModel(type.GetTypeInfo(), attributes) { Actions = { new ActionModel(actionMethod, attributes) } }; var options = Options.Create(new ApiVersioningOptions()); var context = new ApplicationModelProviderContext(new[] { controller.ControllerType }); var provider = new ApiVersioningApplicationModelProvider(options); context.Result.Controllers.Add(controller); // act provider.OnProvidersExecuted(context); // assert controller.GetProperty <ApiVersionModel>().Should().BeEquivalentTo( new { IsApiVersionNeutral = false, DeclaredApiVersions = deprecated.Union(supported).ToArray(), ImplementedApiVersions = deprecated.Union(supported).ToArray(), SupportedApiVersions = supported, DeprecatedApiVersions = deprecated }); controller.Actions.Single().GetProperty <ApiVersionModel>().Should().BeEquivalentTo( new { IsApiVersionNeutral = false, DeclaredApiVersions = deprecated.Union(supported).ToArray(), ImplementedApiVersions = deprecated.Union(supported).ToArray(), SupportedApiVersions = supported, DeprecatedApiVersions = deprecated }); }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { foreach (var controllerModel in context.Result.Controllers) { // pass the depencency to controller attibutes controllerModel.Attributes .OfType <MyAttribute>().ToList() .ForEach(a => a.UrlHelperFactory = _urlHelperFactory); // pass the dependency to action attributes controllerModel.Actions.SelectMany(a => a.Attributes) .OfType <MyAttribute>().ToList() .ForEach(a => a.UrlHelperFactory = _urlHelperFactory); } }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { if (List.Count != 0) { return; } lock (List) { foreach (var controller in context.Result.Controllers) { List.Add(controller.ControllerName); } } }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { foreach (var controllerModel in context.Result.Controllers) { var isApiController = controllerModel.Attributes.OfType <IApiBehaviorMetadata>().Any(); if (isApiController && controllerModel.ApiExplorer.IsVisible == null) { // Enable ApiExplorer for the controller if it wasn't already explicitly configured. controllerModel.ApiExplorer.IsVisible = true; } if (isApiController) { InferBoundPropertyModelPrefixes(controllerModel); } var controllerHasSelectorModel = controllerModel.Selectors.Any(s => s.AttributeRouteModel != null); var conventions = controllerModel.Attributes.OfType <ApiConventionTypeAttribute>().ToArray(); if (conventions.Length == 0) { var controllerAssembly = controllerModel.ControllerType.Assembly; conventions = controllerAssembly.GetCustomAttributes <ApiConventionTypeAttribute>().ToArray(); } foreach (var actionModel in controllerModel.Actions) { if (!isApiController && !actionModel.Attributes.OfType <IApiBehaviorMetadata>().Any()) { continue; } EnsureActionIsAttributeRouted(controllerHasSelectorModel, actionModel); AddInvalidModelStateFilter(actionModel); AddClientErrorFilter(actionModel); InferParameterBindingSources(actionModel); InferParameterModelPrefixes(actionModel); AddMultipartFormDataConsumesAttribute(actionModel); DiscoverApiConvention(actionModel, conventions); DiscoverErrorResponseType(actionModel); } } }
/// <inheritdoc /> public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } for (var i = 0; i < context.Result.Controllers.Count; i++) { var controller = context.Result.Controllers[i]; for (var j = 0; j < controller.Actions.Count; j++) { var action = controller.Actions[j]; var attribute = action.Attributes.OfType <WebHookAttribute>().FirstOrDefault(); if (attribute == null) { // Not a WebHook handler. continue; } WebHookBodyType?bodyType; var properties = action.Properties; var bodyTypeMetadataObject = properties[typeof(IWebHookBodyTypeMetadataService)]; if (bodyTypeMetadataObject is IWebHookBodyTypeMetadataService bodyTypeMetadata) { bodyType = bodyTypeMetadata.BodyType; } else if (properties.TryGetValue(typeof(IWebHookBodyTypeMetadata), out bodyTypeMetadataObject)) { // Reachable only in [GeneralWebHook(WebHookBodyType)] cases. That attribute implements // IWebHookBodyTypeMetadata and WebHookActionModelPropertyProvider passed it along because its // BodyType is not null. var actionBodyTypeMetadata = (IWebHookBodyTypeMetadata)bodyTypeMetadataObject; bodyType = actionBodyTypeMetadata.BodyType; } else { // Reachable only in [GeneralWebHook] cases. SourceData will warn if a data parameter is found. bodyType = null; } properties.TryGetValue(typeof(IWebHookBindingMetadata), out var bindingMetadata); for (var k = 0; k < action.Parameters.Count; k++) { var parameter = action.Parameters[k]; Apply((IWebHookBindingMetadata)bindingMetadata, bodyType, parameter); } } } }
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); }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } IEnableCorsAttribute enableCors; IDisableCorsAttribute disableCors; foreach (var controllerModel in context.Result.Controllers) { enableCors = controllerModel.Attributes.OfType <IEnableCorsAttribute>().FirstOrDefault(); if (enableCors != null) { controllerModel.Filters.Add(new CorsAuthorizationFilterFactory(enableCors.PolicyName)); } disableCors = controllerModel.Attributes.OfType <IDisableCorsAttribute>().FirstOrDefault(); if (disableCors != null) { controllerModel.Filters.Add(new DisableCorsAuthorizationFilter()); } foreach (var actionModel in controllerModel.Actions) { enableCors = actionModel.Attributes.OfType <IEnableCorsAttribute>().FirstOrDefault(); if (enableCors != null) { actionModel.Filters.Add(new CorsAuthorizationFilterFactory(enableCors.PolicyName)); } disableCors = actionModel.Attributes.OfType <IDisableCorsAttribute>().FirstOrDefault(); if (disableCors != null) { actionModel.Filters.Add(new DisableCorsAuthorizationFilter()); } } } }
public void CreateControllerModel_AuthorizeAttributeAddsAuthorizeFilter() { // Arrange var provider = new AuthorizationApplicationModelProvider(new DefaultAuthorizationPolicyProvider(new TestOptionsManager<AuthorizationOptions>())); var defaultProvider = new DefaultApplicationModelProvider(new TestOptionsManager<MvcOptions>()); var context = new ApplicationModelProviderContext(new[] { typeof(AccountController).GetTypeInfo() }); defaultProvider.OnProvidersExecuting(context); // Act provider.OnProvidersExecuting(context); // Assert var controller = Assert.Single(context.Result.Controllers); Assert.Single(controller.Filters, f => f is AuthorizeFilter); }
internal protected 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(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } IEnableCorsAttribute enableCors; IDisableCorsAttribute disableCors; foreach (var controllerModel in context.Result.Controllers) { enableCors = controllerModel.Attributes.OfType<IEnableCorsAttribute>().FirstOrDefault(); if (enableCors != null) { controllerModel.Filters.Add(new CorsAuthorizationFilterFactory(enableCors.PolicyName)); } disableCors = controllerModel.Attributes.OfType<IDisableCorsAttribute>().FirstOrDefault(); if (disableCors != null) { controllerModel.Filters.Add(new DisableCorsAuthorizationFilter()); } foreach (var actionModel in controllerModel.Actions) { enableCors = actionModel.Attributes.OfType<IEnableCorsAttribute>().FirstOrDefault(); if (enableCors != null) { actionModel.Filters.Add(new CorsAuthorizationFilterFactory(enableCors.PolicyName)); } disableCors = actionModel.Attributes.OfType<IDisableCorsAttribute>().FirstOrDefault(); if (disableCors != null) { actionModel.Filters.Add(new DisableCorsAuthorizationFilter()); } } } }
public void OnProvidersExecuted_SetRouteConstaraintIfControllerInPlugin() { var pluginName = "testP"; var typeInfo1 = typeof(PluginInfo).GetTypeInfo(); var typeInfo2 = typeof(PluginManager).GetTypeInfo(); var pluginManagerMock = new Mock<IPluginManager>(); pluginManagerMock.Setup(pm => pm[It.Is<TypeInfo>(ti=>ti==typeInfo1)]) .Returns(new PluginInfo(new ModuleStub { UrlPrefix = pluginName }, null, null, null)); var target = new PluginApplicationModelProvider(pluginManagerMock.Object); var context = new ApplicationModelProviderContext(new[] { typeInfo1, typeInfo2 }); context.Result.Controllers.Add( new ControllerModel(typeInfo1, new object[0])); context.Result.Controllers.Add( new ControllerModel(typeInfo2, new object[0])); target.OnProvidersExecuted(context); Assert.Equal(2, context.Result.Controllers.Count); var controllerInPlugin = context.Result.Controllers.Single(cm => cm.ControllerType == typeInfo1); Assert.Equal(1, controllerInPlugin.RouteConstraints.Count); Assert.Equal(pluginName, controllerInPlugin.RouteConstraints[0].RouteValue); Assert.Equal("plugin", controllerInPlugin.RouteConstraints[0].RouteKey); var controllerNotInPlugin = context.Result.Controllers.Single(cm => cm.ControllerType == typeInfo2); Assert.Equal(0, controllerNotInPlugin.RouteConstraints.Count); }
public void OnProvidersExecuted(ApplicationModelProviderContext context) { // Intentionally empty. }
public void OnProvidersExecuting(ApplicationModelProviderContext context) { }