public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers) { var type = controller.ControllerType.AsType(); if (typeof(IApplicationService).IsAssignableFrom(type)) { controller.ControllerName = controller.ControllerName.RemovePostFix(ApplicationService.CommonPostfixes); var configuration = GetControllerSettingOrNull(controller.ControllerType.AsType()); ConfigureArea(controller, configuration); ConfigureRemoteService(controller, configuration); } else { var remoteServiceAtt = ReflectionHelper.GetSingleAttributeOrDefault<RemoteServiceAttribute>(type); if (remoteServiceAtt != null && remoteServiceAtt.IsEnabledFor(type)) { var configuration = GetControllerSettingOrNull(controller.ControllerType.AsType()); ConfigureRemoteService(controller, configuration); } } } }
public void Build_WithPropertiesSet_ActionOverwritesApplicationAndControllerModel() { // Arrange var applicationModel = new ApplicationModel(); applicationModel.Properties["test"] = "application"; var controller = new ControllerModel(typeof(TestController).GetTypeInfo(), new List<object>() { }); controller.Application = applicationModel; controller.Properties["test"] = "controller"; applicationModel.Controllers.Add(controller); var methodInfo = typeof(TestController).GetMethod(nameof(TestController.SomeAction)); var actionModel = new ActionModel(methodInfo, new List<object>() { }); actionModel.Selectors.Add(new SelectorModel()); actionModel.Controller = controller; actionModel.Properties["test"] = "action"; controller.Actions.Add(actionModel); // Act var descriptors = ControllerActionDescriptorBuilder.Build(applicationModel); // Assert Assert.Equal("action", descriptors.Single().Properties["test"]); }
public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers) { var hasAttributeRouteModels = controller.Selectors.Any(selector => selector.AttributeRouteModel != null); if (hasAttributeRouteModels) continue; var controllerTmpl = controller.ControllerName.PascalToSlug(); controller.Selectors[0].AttributeRouteModel = new AttributeRouteModel { Template = controllerTmpl }; var actionsToAdd = new List<ActionModel>(); foreach (var action in controller.Actions) { var hasAttributeRouteModel = action.Selectors.Any(selector => selector.AttributeRouteModel != null); if (hasAttributeRouteModel) continue; var actionSlug = action.ActionName.PascalToSlug(); var actionTmpl = $"{actionSlug}/{{id?}}"; if (actionSlug == DefaultAction) { action.Selectors.Add(new SelectorModel { AttributeRouteModel = new AttributeRouteModel { Template = "" } }); if (controllerTmpl == DefaultController) { action.Selectors.Add(new SelectorModel { AttributeRouteModel = new AttributeRouteModel { Template = "/" } }); } } action.Selectors[0].AttributeRouteModel = new AttributeRouteModel { Template = actionTmpl }; } } }
public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers) { if (controller.ControllerType == _type) { controller.ApiExplorer.IsVisible = false; } } }
public void Apply(ApplicationModel application) { foreach(var controller in application.Controllers) { var module = controller.ControllerType.Assembly.FullName; var splitIndex = module.IndexOf(','); if (splitIndex > 0) { module = module.Substring(0, splitIndex); } controller.RouteConstraints.Add(new AreaAttribute(module)); } }
public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers.Where(_controllerPredicate)) { foreach (var action in controller.Actions.Where(_actionPredicate)) { foreach (var parameter in action.Parameters.Where(parameter => parameter.BindingInfo?.BindingSource == null && !parameter.Attributes.OfType<IBindingSourceMetadata>().Any() && !parameter.ParameterInfo.ParameterType.CanBeConvertedFromString()).Where(_parameterPredicate)) { parameter.BindingInfo = parameter.BindingInfo ?? new BindingInfo(); parameter.BindingInfo.BindingSource = BindingSource.Body; } } } }
public void Build_WithControllerPropertiesSet_AddsPropertiesWithBinderMetadataSet() { // Arrange var applicationModel = new ApplicationModel(); var controller = new ControllerModel( typeof(TestController).GetTypeInfo(), new List<object>() { }); var propertyInfo = controller.ControllerType.AsType().GetProperty("BoundProperty"); controller.ControllerProperties.Add( new PropertyModel( propertyInfo, new List<object>() { }) { BindingInfo = BindingInfo.GetBindingInfo(new object[] { new FromQueryAttribute() }), PropertyName = "BoundProperty" }); controller.ControllerProperties.Add( new PropertyModel( controller.ControllerType.AsType().GetProperty("UnboundProperty"), new List<object>() { })); controller.Application = applicationModel; applicationModel.Controllers.Add(controller); var methodInfo = typeof(TestController).GetMethod(nameof(TestController.SomeAction)); var actionModel = new ActionModel(methodInfo, new List<object>() { }); actionModel.Selectors.Add(new SelectorModel()); actionModel.Controller = controller; controller.Actions.Add(actionModel); // Act var descriptors = ControllerActionDescriptorBuilder.Build(applicationModel); // Assert var controllerDescriptor = Assert.Single(descriptors); var parameter = Assert.Single(controllerDescriptor.BoundProperties); var property = Assert.IsType<ControllerBoundPropertyDescriptor>(parameter); Assert.Equal("BoundProperty", property.Name); Assert.Equal(propertyInfo, property.PropertyInfo); Assert.Equal(typeof(string), property.ParameterType); Assert.Equal(BindingSource.Query, property.BindingInfo.BindingSource); }
public void DefaultControllerModelConvention_AppliesToAllControllers() { // Arrange var options = new MvcOptions(); var app = new ApplicationModel(); app.Controllers.Add(new ControllerModel(typeof(HelloController).GetTypeInfo(), new List<object>())); app.Controllers.Add(new ControllerModel(typeof(WorldController).GetTypeInfo(), new List<object>())); options.Conventions.Add(new SimpleControllerConvention()); // Act options.Conventions[0].Apply(app); // Assert foreach (var controller in app.Controllers) { Assert.True(controller.Properties.ContainsKey("TestProperty")); } }
public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers) { var type = controller.ControllerType.AsType(); if (typeof(IApplicationService).IsAssignableFrom(type)) { controller.ControllerName = controller.ControllerName.RemovePostFix("AppService", "ApplicationService", "Service"); ConfigureRemoteService(controller); } else { var remoteServiceAtt = ReflectionHelper.GetSingleAttributeOrDefault<RemoteServiceAttribute>(type); if (remoteServiceAtt != null && remoteServiceAtt.IsEnabledFor(type)) { ConfigureRemoteService(controller); } } } }
public void Apply(ApplicationModel application) { var centralPrefix = new AttributeRouteModel(new RouteAttribute($"{routingModel.Prefix}/{routingModel.Controller}")); foreach (var controller in application.Controllers) { if (controller.ControllerType.UnderlyingSystemType == typeof(AppConfigurationController)) { var hasRouteAttributes = controller.Selectors.Any(selector => selector.AttributeRouteModel != null); if (hasRouteAttributes) { // This controller manually defined some routes, so treat this // as an override and not apply the convention here. continue; } foreach (var selector in controller.Selectors) { selector.AttributeRouteModel = centralPrefix; } } } }
public void Apply(ApplicationModel application) { foreach (var controller in application.Controllers) { var matchedSelectors = controller.Selectors.Where(x => x.AttributeRouteModel != null).ToList(); if (matchedSelectors.Any()) { foreach (var selectorModel in matchedSelectors) { selectorModel.AttributeRouteModel = AttributeRouteModel.CombineAttributeRouteModel(_centralPrefix, selectorModel.AttributeRouteModel); } } var unmatchedSelectors = controller.Selectors.Where(x => x.AttributeRouteModel == null).ToList(); if (unmatchedSelectors.Any()) { foreach (var selectorModel in unmatchedSelectors) { selectorModel.AttributeRouteModel = _centralPrefix; } } } }
/// <inheritdoc /> public void Apply(ApplicationModel application) { if (application == null) { throw new ArgumentNullException(nameof(application)); } foreach (var controller in application.Controllers) { foreach (var action in controller.Actions) { _actionModelConvention.Apply(action); } } }
public void Apply(ApplicationModel application) { application.Properties["description"] = _description; }
public static List <TResult> Flatten <TResult>( ApplicationModel application, Func <ApplicationModel, ControllerModel, ActionModel, SelectorModel, TResult> flattener) { var results = new List <TResult>(); var errors = new Dictionary <MethodInfo, IList <string> >(); var actionsByMethod = new Dictionary <MethodInfo, List <(ActionModel, SelectorModel)> >(); var actionsByRouteName = new Dictionary <string, List <(ActionModel, SelectorModel)> >(StringComparer.OrdinalIgnoreCase); var routeTemplateErrors = new List <string>(); foreach (var controller in application.Controllers) { foreach (var action in controller.Actions) { foreach (var selector in ActionAttributeRouteModel.FlattenSelectors(action)) { // PostProcess attribute routes so we can observe any errors. ReplaceAttributeRouteTokens(controller, action, selector, routeTemplateErrors); // Add to the data structures we use to find errors. AddActionToMethodInfoMap(actionsByMethod, action, selector); AddActionToRouteNameMap(actionsByRouteName, action, selector); var result = flattener(application, controller, action, selector); Debug.Assert(result != null); results.Add(result); } } } var attributeRoutingConfigurationErrors = new Dictionary <MethodInfo, string>(); foreach (var(method, actions) in actionsByMethod) { ValidateActionGroupConfiguration( method, actions, attributeRoutingConfigurationErrors); } if (attributeRoutingConfigurationErrors.Count > 0) { var message = CreateAttributeRoutingAggregateErrorMessage(attributeRoutingConfigurationErrors.Values); throw new InvalidOperationException(message); } var namedRoutedErrors = ValidateNamedAttributeRoutedActions(actionsByRouteName); if (namedRoutedErrors.Count > 0) { var message = CreateAttributeRoutingAggregateErrorMessage(namedRoutedErrors); throw new InvalidOperationException(message); } if (routeTemplateErrors.Count > 0) { var message = CreateAttributeRoutingAggregateErrorMessage(routeTemplateErrors); throw new InvalidOperationException(message); } return(results); }