/// <summary>
/// Adds authorisation middleware and services that ensure authentication users have the correct permissions to execute
/// operations.
/// </summary>
/// <remarks>
/// New middleware builders will be added:
/// <list type="bullet">
/// <item><description><see cref="AuthorisationMiddlewareBuilder"/> added to <see cref="MiddlewareStage.Authorisation"/>.</description></item>
/// </list>
/// </remarks>
/// <param name="apiBuilder">The builder to add auth to.</param>
/// <returns>The builder.</returns>
public static BlueprintApiBuilder AddAuthorisation(this BlueprintApiBuilder apiBuilder)
{
TryAddAuthorisationServices(apiBuilder.Services);
apiBuilder.Pipeline(p =>
{
p.AddMiddleware <AuthorisationMiddlewareBuilder>(MiddlewareStage.Authorisation);
});
return(apiBuilder);
}
internal PipelineBuilder(BlueprintApiBuilder blueprintApiBuilder)
{
this._blueprintApiBuilder = blueprintApiBuilder;
this.AddMiddleware <MessagePopulationMiddlewareBuilder>(MiddlewareStage.Population);
this.Add(new OperationExecutorMiddlewareBuilder(), MiddlewareStage.Execution, 0);
// Special-case this last middleware to have high priority as we MUST have this as the very last middleware, regardless of what else will
// be registered
this.Add(new ReturnFrameMiddlewareBuilder(), MiddlewareStage.PostExecution, int.MaxValue);
}
/// <summary>
/// Conditionally executes the given child action, which means that for example you could include
/// certain middleware builders based on a configuration switch, or your environment.
/// </summary>
/// <param name="apiBuilder">The Api builder.</param>
/// <param name="include">Whether to include/execute the child action.</param>
/// <param name="action">The action to perform if <paramref name="include"/> is <c>true</c>.</param>
/// <returns>This builder.</returns>
public static BlueprintApiBuilder Conditionally(
this BlueprintApiBuilder apiBuilder,
bool include,
Action <BlueprintApiBuilder> action)
{
if (include)
{
action(apiBuilder);
}
return(apiBuilder);
}
/// <summary>
/// Adds validation middleware, which will use "validation sources" to handle different types of validation that can be
/// registered against operations.
/// </summary>
/// <seealso cref="BlueprintValidationBuilder.UseBlueprintSource" />
/// <seealso cref="BlueprintValidationBuilder.UseDataAnnotationSource" />
/// <param name="apiBuilder">The builder to add validation to.</param>
/// <param name="configure">An action that will be given an instance of <see cref="BlueprintValidationBuilder" /> to configure the validation
/// middleware.</param>
/// <returns>The builder.</returns>
public static BlueprintApiBuilder AddValidation(this BlueprintApiBuilder apiBuilder, Action <BlueprintValidationBuilder> configure)
{
apiBuilder.Pipeline(p => p.AddMiddleware <ValidationMiddlewareBuilder>(MiddlewareStage.Validation));
configure(new BlueprintValidationBuilder(apiBuilder));
if (apiBuilder.Services.All(s => s.ServiceType != typeof(IValidationSource)))
{
throw new InvalidOperationException($"At least one {nameof(IValidationSource)} must be configured");
}
return(apiBuilder);
}
public static BlueprintApiBuilder AddAuditing(this BlueprintApiBuilder apiBuilder, Action <BlueprintAuditBuilder> configure)
{
apiBuilder.Pipeline(p => p.AddMiddleware <AuditMiddleware>(MiddlewareStage.Setup));
configure(new BlueprintAuditBuilder(apiBuilder));
if (apiBuilder.Services.All(s => s.ServiceType != typeof(IAuditor)))
{
throw new InvalidOperationException($"An {nameof(IAuditor)} must be configured");
}
return(apiBuilder);
}
/// <summary>
/// Adds authentication middlewares that will responsible for finding a user through a <see cref="ClaimsIdentity" /> and an
/// application-specific <see cref="IUserAuthorisationContextFactory"/> for loading a <see cref="IUserAuthorisationContext" /> that will
/// be available to handlers for authenticated users.
/// </summary>
/// <remarks>
/// Two new middleware builders will be added:
/// <list type="bullet">
/// <item><description><see cref="AuthenticationMiddlewareBuilder"/> added to <see cref="MiddlewareStage.Authentication"/>.</description></item>
/// <item><description><see cref="UserContextLoaderMiddlewareBuilder"/> added to <see cref="MiddlewareStage.Authentication"/>.</description></item>
/// </list>
/// </remarks>
/// <param name="apiBuilder">The builder to add auth to.</param>
/// <param name="configure">An action to configure authentication pipeline.</param>
/// <returns>The builder.</returns>
public static BlueprintApiBuilder AddAuthentication(this BlueprintApiBuilder apiBuilder, Action <BlueprintAuthenticationBuilder> configure)
{
TryAddAuthenticationServices(apiBuilder);
apiBuilder.Pipeline(p =>
{
p.AddMiddleware <AuthenticationMiddlewareBuilder>(MiddlewareStage.Authentication);
p.AddMiddleware <UserContextLoaderMiddlewareBuilder>(MiddlewareStage.Authentication);
});
configure(new BlueprintAuthenticationBuilder(apiBuilder));
if (apiBuilder.Services.All(s => s.ServiceType != typeof(IUserAuthorisationContextFactory)))
{
throw new InvalidOperationException($"A {nameof(IUserAuthorisationContextFactory)} must be configured");
}
return(apiBuilder);
}
public static BlueprintApiBuilder AddNotifications(this BlueprintApiBuilder blueprintApiBuilder, params Assembly[] embeddedResourceAssemblies)
{
if (embeddedResourceAssemblies.Length == 0)
{
embeddedResourceAssemblies = new[] { Assembly.GetEntryAssembly() };
}
blueprintApiBuilder.Services.AddOptions <TemplatedEmailHandlerOptions>();
blueprintApiBuilder.Services.AddTransient <INotificationRepository>(p =>
new EmbeddedResourceNotificationRepository(embeddedResourceAssemblies, p.GetRequiredService <ILogger <EmbeddedResourceNotificationRepository> >()));
blueprintApiBuilder.Services.AddTransient <INotificationService, NotificationService>();
blueprintApiBuilder.Services.AddTransient <INotificationHandler, TemplatedEmailHandler>();
blueprintApiBuilder.Services.AddTransient <ITemplateFactory, NVelocityTemplateFactory>();
blueprintApiBuilder.Services.AddTransient <IEmailSender, SmtpClientEmailSender>();
return(blueprintApiBuilder);
}
public static BlueprintApiBuilder AddLogging(this BlueprintApiBuilder apiBuilder)
{
apiBuilder.Pipeline(p => p.AddMiddleware <LoggingMiddlewareBuilder>(MiddlewareStage.Setup));
return(apiBuilder);
}
/// <summary>
/// Adds validation middleware, by default adding both Blueprint and DataAnnotations sources.
/// </summary>
/// <seealso cref="BlueprintValidationBuilder.UseBlueprintSource" />
/// <seealso cref="BlueprintValidationBuilder.UseDataAnnotationSource" />
/// <param name="apiBuilder">The builder to add validation to.</param>
/// <returns>The builder.</returns>
public static BlueprintApiBuilder AddValidation(this BlueprintApiBuilder apiBuilder)
{
return(AddValidation(apiBuilder, o => o.UseBlueprintSource().UseDataAnnotationSource()));
}
internal BlueprintCompilationBuilder(BlueprintApiBuilder blueprintApiBuilder)
{
this._blueprintApiBuilder = blueprintApiBuilder;
}
internal BlueprintAuthenticationBuilder(BlueprintApiBuilder apiBuilder)
{
this._apiBuilder = apiBuilder;
}
internal BlueprintValidationBuilder(BlueprintApiBuilder apiBuilder)
{
this._apiBuilder = apiBuilder;
apiBuilder.Services.TryAddSingleton <IValidator, BlueprintValidator>();
}
/// <summary>
/// Adds StructureMap support to Blueprint by registering an <see cref="InstanceFrameProvider" /> that understands
/// the implicit registration nature of StructureMap.
/// </summary>
/// <param name="blueprintApiBuilder">The builder.</param>
/// <returns>The builder for further customisation.</returns>
public static BlueprintApiBuilder AddStructureMap(this BlueprintApiBuilder blueprintApiBuilder)
{
blueprintApiBuilder.Services.AddTransient <InstanceFrameProvider, StructureMapInstanceFrameProvider>();
return(blueprintApiBuilder);
}
public BlueprintAuditBuilder(BlueprintApiBuilder apiBuilder)
{
this._apiBuilder = apiBuilder;
}
