/// <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);
}
