private static void ApplyGlobalAfterHook(IApplicationBuilder builder, CarterOptions options, ILogger logger)
{
if (options?.After != null)
{
builder.Use(async(ctx, next) =>
{
await next();
logger.LogDebug("Executing global after hook");
await options.After(ctx);
});
}
}
private static void ApplyGlobalAfterHook(IApplicationBuilder builder, CarterOptions options)
{
if (options?.After != null)
{
builder.Use(async(ctx, next) =>
{
var loggerFactory = ctx.RequestServices.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("Carter.GlobalAfterHook");
await next();
logger.LogDebug("Executing global after hook");
await options.After(ctx);
});
}
}
private static void ApplyGlobalBeforeHook(IApplicationBuilder builder, CarterOptions options, ILogger logger)
{
if (options?.Before != null)
{
builder.Use(async(ctx, next) =>
{
logger.LogDebug("Executing global before hook");
var carryOn = await options.Before(ctx);
if (carryOn)
{
logger.LogDebug("Executing next handler after global before hook");
await next();
}
});
}
}
private static void ApplyGlobalBeforeHook(IApplicationBuilder builder, CarterOptions options)
{
if (options?.Before != null)
{
builder.Use(async(ctx, next) =>
{
var loggerFactory = ctx.RequestServices.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("Carter.GlobalBeforeHook");
logger.LogDebug("Executing global before hook");
var carryOn = await options.Before(ctx);
if (carryOn)
{
logger.LogDebug("Executing next handler after global before hook");
await next();
}
});
}
}
/// <summary>
/// Adds Carter to the specified <see cref="IApplicationBuilder"/>.
/// </summary>
/// <param name="builder">The <see cref="IApplicationBuilder"/> to configure.</param>
/// <param name="options">A <see cref="CarterOptions"/> instance.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IApplicationBuilder UseCarter(this IApplicationBuilder builder, CarterOptions options = null)
{
var diagnostics = builder.ApplicationServices.GetService <CarterDiagnostics>();
var loggerFactory = builder.ApplicationServices.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(typeof(CarterDiagnostics));
diagnostics.LogDiscoveredCarterTypes(logger);
ApplyGlobalBeforeHook(builder, options, loggerFactory.CreateLogger("Carter.GlobalBeforeHook"));
ApplyGlobalAfterHook(builder, options, loggerFactory.CreateLogger("Carter.GlobalAfterHook"));
var routeBuilder = new RouteBuilder(builder);
//Create a "startup scope" to resolve modules from
using (var scope = builder.ApplicationServices.CreateScope())
{
var statusCodeHandlers = scope.ServiceProvider.GetServices <IStatusCodeHandler>();
//Get all instances of CarterModule to fetch and register declared routes
foreach (var module in scope.ServiceProvider.GetServices <CarterModule>())
{
var moduleLogger = scope.ServiceProvider
.GetService <ILoggerFactory>()
.CreateLogger(module.GetType());
var distinctPaths = module.Routes.Keys.Select(route => route.path).Distinct();
foreach (var path in distinctPaths)
{
routeBuilder.MapRoute(path, CreateRouteHandler(path, module, statusCodeHandlers, moduleLogger));
}
}
}
return(builder.UseRouter(routeBuilder.Build()));
}
/// <summary>
/// Adds Carter to the specified <see cref="IApplicationBuilder"/>.
/// </summary>
/// <param name="builder">The <see cref="IApplicationBuilder"/> to configure.</param>
/// <param name="options">A <see cref="CarterOptions"/> instance.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IEndpointConventionBuilder MapCarter(this IEndpointRouteBuilder builder, CarterOptions options = null)
{
var carterConfigurator = builder.ServiceProvider.GetService <CarterConfigurator>();
var loggerFactory = builder.ServiceProvider.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(typeof(CarterConfigurator));
carterConfigurator.LogDiscoveredCarterTypes(logger);
var builders = new List <IEndpointConventionBuilder>();
var routeMetaData = new Dictionary <(string verb, string path), RouteMetaData>();
//Create a "startup scope" to resolve modules from
using (var scope = builder.ServiceProvider.CreateScope())
{
var statusCodeHandlers = scope.ServiceProvider.GetServices <IStatusCodeHandler>().ToList();
//Get all instances of CarterModule to fetch and register declared routes
foreach (var module in scope.ServiceProvider.GetServices <CarterModule>())
{
var moduleLogger = scope.ServiceProvider
.GetService <ILoggerFactory>()
.CreateLogger(module.GetType());
routeMetaData = routeMetaData.Concat(module.RouteMetaData).ToDictionary(x => x.Key, x => x.Value);
foreach (var route in module.Routes)
{
var conventionBuilder = builder.MapMethods(route.Key.path, new[] { route.Key.verb },
CreateRouteHandler(route.Key.path, module.GetType(), statusCodeHandlers, moduleLogger));
if (module.AuthPolicies.Any())
{
conventionBuilder.RequireAuthorization(module.AuthPolicies);
}
else if (module.RequiresAuth)
{
conventionBuilder.RequireAuthorization();
}
route.Value.conventions.Apply(conventionBuilder);
builders.Add(conventionBuilder);
}
}
}
builders.Add(builder.MapGet("openapi", BuildOpenApiResponse(options, routeMetaData)));
return(new CompositeConventionBuilder(builders));
}
/// <summary>
/// Adds Carter to the specified <see cref="IApplicationBuilder"/>.
/// </summary>
/// <param name="builder">The <see cref="IApplicationBuilder"/> to configure.</param>
/// <param name="options">A <see cref="CarterOptions"/> instance.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IApplicationBuilder UseCarter(this IApplicationBuilder builder, CarterOptions options = null)
{
var carterConfigurator = builder.ApplicationServices.GetService <CarterConfigurator>();
var loggerFactory = builder.ApplicationServices.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(typeof(CarterConfigurator));
carterConfigurator.LogDiscoveredCarterTypes(logger);
ApplyGlobalBeforeHook(builder, options, loggerFactory.CreateLogger("Carter.GlobalBeforeHook"));
ApplyGlobalAfterHook(builder, options, loggerFactory.CreateLogger("Carter.GlobalAfterHook"));
var routeBuilder = new RouteBuilder(builder);
var routeMetaData = new Dictionary <(string verb, string path), RouteMetaData>();
//Create a "startup scope" to resolve modules from so that they're cleaned up post-startup
using (var scope = builder.ApplicationServices.CreateScope())
{
var statusCodeHandlers = scope.ServiceProvider.GetServices <IStatusCodeHandler>().ToList();
//Get all instances of CarterModule to fetch and register declared routes
foreach (var module in scope.ServiceProvider.GetServices <CarterModule>())
{
var moduleLogger = scope.ServiceProvider
.GetService <ILoggerFactory>()
.CreateLogger(module.GetType());
routeMetaData = routeMetaData.Concat(module.RouteMetaData).ToDictionary(x => x.Key, x => x.Value);
var distinctPaths = module.Routes.Keys.Select(route => route.path).Distinct();
foreach (var path in distinctPaths)
{
routeBuilder.MapRoute(path, CreateRouteHandler(path, module.GetType(), statusCodeHandlers, moduleLogger));
}
}
}
routeBuilder.MapRoute("openapi", BuildOpenApiResponse(options, routeMetaData));
return(builder.UseRouter(routeBuilder.Build()));
}
