/// <summary> /// Initializes a new instance of the <see cref="ApiVersionConvention"/> class. /// </summary> /// <param name="implicitlyDeclaredVersion">The implicitly declared <see cref="ApiVersion">API version</see> for /// controllers and actions that have no other API versioning information applied.</param> public ApiVersionConvention(ApiVersion implicitlyDeclaredVersion) { Arg.NotNull(implicitlyDeclaredVersion, nameof(implicitlyDeclaredVersion)); implicitVersionModel = new ApiVersionModel(implicitlyDeclaredVersion); conventionBuilder = new ApiVersionConventionBuilder(); }
/// <inheritdoc /> public virtual void OnProvidersExecuted(ApplicationModelProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var implicitVersionModel = new ApiVersionModel(Options.DefaultApiVersion); var conventionBuilder = Options.Conventions; var application = context.Result; var controllers = application.Controllers; if (Options.UseApiBehavior) { controllers = ControllerFilter.Apply(controllers); } for (var i = 0; i < controllers.Count; i++) { var controller = controllers[i]; controller.ControllerName = TrimTrailingNumbers(controller.ControllerName); if (!conventionBuilder.ApplyTo(controller)) { ApplyAttributeOrImplicitConventions(controller, implicitVersionModel); } } }
/// <inheritdoc /> public virtual void OnProvidersExecuted(ApplicationModelProviderContext context) { Arg.NotNull(context, nameof(context)); var implicitVersionModel = new ApiVersionModel(Options.DefaultApiVersion); var conventionBuilder = Options.Conventions; var application = context.Result; if (conventionBuilder.Count == 0) { foreach (var controller in application.Controllers) { ApplyAttributeOrImplicitConventions(controller, implicitVersionModel); } } else { foreach (var controller in application.Controllers) { if (!conventionBuilder.ApplyTo(controller)) { ApplyAttributeOrImplicitConventions(controller, implicitVersionModel); } } } }
/// <summary> /// Initializes a new instance of the <see cref="ApiVersionConvention"/> class. /// </summary> /// <param name="implicitlyDeclaredVersion">The implicitly declared <see cref="ApiVersion">API version</see> for /// controllers and actions that have no other API versioning information applied.</param> /// <param name="conventionBuilder">The <see cref="ApiVersionConventionBuilder">convention builder</see> /// containing the configured conventions to apply.</param> public ApiVersionConvention(ApiVersion implicitlyDeclaredVersion, ApiVersionConventionBuilder conventionBuilder) { Arg.NotNull(implicitlyDeclaredVersion, nameof(implicitlyDeclaredVersion)); Arg.NotNull(conventionBuilder, nameof(conventionBuilder)); implicitVersionModel = new ApiVersionModel(implicitlyDeclaredVersion); this.conventionBuilder = conventionBuilder; }
static void ApplyImplicitConventions(ControllerModel controller, ApiVersionModel implicitVersionModel) { for (var i = 0; i < controller.Actions.Count; i++) { var action = controller.Actions[i]; action.SetProperty(controller); action.SetProperty(implicitVersionModel); } }
static void ApplyImplicitConventions(ControllerModel controller, ApiVersionModel implicitVersionModel) { Contract.Requires(controller != null); Contract.Requires(implicitVersionModel != null); foreach (var action in controller.Actions) { action.SetProperty(implicitVersionModel); } }
static void ApplyAttributeOrImplicitConventions(ControllerModel controller, ApiVersionModel implicitVersionModel) { if (IsDecoratedWithAttributes(controller)) { var conventions = new ControllerApiVersionConventionBuilder(controller.ControllerType); conventions.ApplyTo(controller); } else { ApplyImplicitConventions(controller, implicitVersionModel); } }
public void convention_should_apply_api_version_model() { // arrange var supported = new[] { new ApiVersion(1, 0), new ApiVersion(2, 0), new ApiVersion(3, 0) }; var deprecated = new[] { new ApiVersion(0, 9) }; var model = new ApiVersionModel(supported, deprecated); 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 application = new ApplicationModel() { Controllers = { controller } }; var convention = new ApiVersionConvention(); // act convention.Apply(application); // assert controller.GetProperty <ApiVersionModel>().ShouldBeEquivalentTo( new { IsApiVersionNeutral = false, DeclaredApiVersions = deprecated.Union(supported).ToArray(), ImplementedApiVersions = deprecated.Union(supported).ToArray(), SupportedApiVersions = supported, DeprecatedApiVersions = deprecated }); controller.Actions.Single().GetProperty <ApiVersionModel>().ShouldBeEquivalentTo( new { IsApiVersionNeutral = false, DeclaredApiVersions = deprecated.Union(supported).ToArray(), ImplementedApiVersions = deprecated.Union(supported).ToArray(), SupportedApiVersions = supported, DeprecatedApiVersions = deprecated }); }
static void ApplyAttributeOrImplicitConventions(ControllerModel controller, ApiVersionModel implicitVersionModel) { Contract.Requires(controller != null); Contract.Requires(implicitVersionModel != null); if (IsDecoratedWithAttributes(controller)) { var conventions = new ControllerApiVersionConventionBuilder <ControllerModel>(); conventions.ApplyTo(controller); } else { ApplyImplicitConventions(controller, implicitVersionModel); } }
public void select_version_should_return_min_api_version(IEnumerable <ApiVersion> supportedVersions, IEnumerable <ApiVersion> deprecatedVersions, ApiVersion expectedVersion) { // arrange var options = new ApiVersioningOptions() { DefaultApiVersion = new ApiVersion(42, 0) }; var selector = new LowestImplementedApiVersionSelector(options); var request = new Mock <HttpRequest>().Object; var versionInfo = new ApiVersionModel(supportedVersions, deprecatedVersions); // act var selectedVersion = selector.SelectVersion(request, versionInfo); // assert selectedVersion.Should().Be(expectedVersion); }
private static bool ActionIsSatisfiedBy(ActionDescriptor action, ApiVersionModel model, ApiVersion version, ICollection <ActionDescriptor> implicitMatches) { Contract.Requires(action != null); Contract.Requires(implicitMatches != null); if (model == null) { return(false); } if (action.IsMappedTo(version)) { return(true); } if (action.IsImplicitlyMappedTo(version)) { implicitMatches.Add(action); } return(false); }
/// <inheritdoc /> public virtual void OnProvidersExecuted(ApplicationModelProviderContext context) { Arg.NotNull(context, nameof(context)); var implicitVersionModel = new ApiVersionModel(Options.DefaultApiVersion); var conventionBuilder = Options.Conventions; var application = context.Result; var controllers = application.Controllers; if (Options.UseApiBehavior) { controllers = ControllerFilter.Apply(controllers); } foreach (var controller in controllers) { if (!conventionBuilder.ApplyTo(controller)) { ApplyAttributeOrImplicitConventions(controller, implicitVersionModel); } } }
/// <summary> /// Initializes a new instance of the <see cref="ApiVersionConvention"/> class. /// </summary> public ApiVersionConvention() { implicitVersionModel = ApiVersionModel.Default; conventionBuilder = new ApiVersionConventionBuilder(); }
/// <summary> /// Initializes a new instance of the <see cref="ImplicitControllerVersionConvention"/> class. /// </summary> /// <param name="declaredVersion">The declared service <see cref="ApiVersion">API version</see> applied to controllers /// that do not have explicit versions.</param> public ImplicitControllerVersionConvention(ApiVersion declaredVersion) { Arg.NotNull(declaredVersion, nameof(declaredVersion)); model = new ApiVersionModel(declaredVersion); }