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 OnProvidersExecuted(ApplicationModelProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Intentionally empty.
}
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)
{
}
