/// <summary>
/// Adds the IndexEngine Search module.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="filename">The optional filename for the search db</param>
/// <returns>The services</returns>
public static PiranhaServiceBuilder UseIndexEngineSearch(this PiranhaServiceBuilder serviceBuilder,
string filename = "idx.db")
{
serviceBuilder.Services.AddPiranhaIndexEngineSearch(filename);
return(serviceBuilder);
}
/// <summary>
/// Uses the Piranha Manager services if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="options">The optional options</param>
/// <param name="jsonOptions">Optional JSON options</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseManager(this PiranhaServiceBuilder serviceBuilder,
Action <ManagerOptions> options = null,
Action <MvcNewtonsoftJsonOptions> jsonOptions = null)
{
// Perform optional configuration
var managerOptions = new ManagerOptions();
options?.Invoke(managerOptions);
// Add manager services
serviceBuilder.Services.AddPiranhaManager();
// Add dependent ASP.NET services
serviceBuilder.Services.AddLocalization(o =>
o.ResourcesPath = "Resources"
);
serviceBuilder.Services.AddControllersWithViews();
serviceBuilder.Services.AddRazorPages()
.AddPiranhaManagerOptions(jsonOptions);
serviceBuilder.Services.AddAntiforgery(o =>
{
o.HeaderName = managerOptions.XsrfHeaderName;
});
// Add options
serviceBuilder.Services.Configure <ManagerOptions>(o =>
{
o.JsonOptions = managerOptions.JsonOptions;
o.XsrfCookieName = managerOptions.XsrfCookieName;
o.XsrfHeaderName = managerOptions.XsrfHeaderName;
});
return(serviceBuilder);
}
/// <summary>
/// Adds the FileStorage module if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="basePath">The optional base path for where uploaded media is stored.null Default is wwwroot/uploads/</param>
/// <param name="baseUrl">The optional base url for accessing uploaded media. Default is ~/uploads/</param>
/// <param name="scope">The optional service scope. Default is singleton</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseFileStorage(this PiranhaServiceBuilder serviceBuilder,
string basePath = null, string baseUrl = null, ServiceLifetime scope = ServiceLifetime.Singleton)
{
serviceBuilder.Services.AddPiranhaFileStorage(basePath, baseUrl, scope);
return(serviceBuilder);
}
/// <summary>
/// Adds the core Piranha services if simple startup is used.
/// </summary>
/// <param name="services">The current service collection</param>
/// <param name="options">The builder options</param>
/// <returns>The updated service collection</returns>
public static IServiceCollection AddPiranha(this IServiceCollection services, Action <PiranhaServiceBuilder> options)
{
var serviceBuilder = new PiranhaServiceBuilder(services);
options?.Invoke(serviceBuilder);
var config = new PiranhaRouteConfig
{
LoginUrl = serviceBuilder.LoginUrl,
UseAliasRouting = serviceBuilder.UseAliasRouting,
UseArchiveRouting = serviceBuilder.UseArchiveRouting,
UsePageRouting = serviceBuilder.UsePageRouting,
UsePostRouting = serviceBuilder.UsePostRouting,
UseSiteRouting = serviceBuilder.UseSiteRouting,
UseSitemapRouting = serviceBuilder.UseSitemapRouting,
UseStartpageRouting = serviceBuilder.UseStartpageRouting
};
services.AddSingleton <PiranhaRouteConfig>(config);
services.AddControllersWithViews();
var mvcBuilder = services.AddRazorPages();
if (serviceBuilder.AddRazorRuntimeCompilation)
{
mvcBuilder.AddRazorRuntimeCompilation();
}
services.AddPiranha();
services.AddPiranhaApplication();
return(serviceBuilder.Services);
}
/// <summary>
/// Adds the DbContext and the default services needed to run
/// Piranha over Entity Framework Core.
/// </summary>
/// <param name="serviceBuilder">The current service builder</param>
/// <param name="dboptions">The DbContext options builder</param>
/// <param name="poolSize">The optional connection pool size. Default value is 128</param>
/// <param name="scope">The optional lifetime</param>
/// <typeparam name="T">The DbContext type</typeparam>
/// <returns>The updated service collection</returns>
public static PiranhaServiceBuilder UseEF <T>(this PiranhaServiceBuilder serviceBuilder,
Action <DbContextOptionsBuilder> dboptions, int poolSize = 128,
ServiceLifetime scope = ServiceLifetime.Scoped) where T : DbContext, IDb
{
serviceBuilder.Services.AddPiranhaEF <T>(dboptions, poolSize, scope);
return(serviceBuilder);
}
/// <summary>
/// Extensions method for simplified setup.
/// </summary>
/// <param name="serviceBuilder">The current service builder</param>
/// <param name="dbOptions">The db options</param>
/// <param name="identityOptions">The optional identity options</param>
/// <param name="cookieOptions">The optional cookie options</param>
/// <typeparam name="T">The DbContext type</typeparam>
/// <returns>The builder</returns>
public static PiranhaServiceBuilder UseIdentityWithSeed <T>(this PiranhaServiceBuilder serviceBuilder,
Action <DbContextOptionsBuilder> dbOptions,
Action <IdentityOptions> identityOptions = null,
Action <CookieAuthenticationOptions> cookieOptions = null)
where T : Db <T>
{
serviceBuilder.Services.AddPiranhaIdentityWithSeed <T>(dbOptions, identityOptions, cookieOptions);
return(serviceBuilder);
}
/// <summary>
/// Adds authorization with the given application policies to the aplication.
/// </summary>
/// <param name="builder">The service builder</param>
/// <param name="options">The security options</param>
/// <returns>The service builder</returns>
public static PiranhaServiceBuilder UseSecurity(this PiranhaServiceBuilder builder, Action <SecurityBuilder> options)
{
// Add authentication
builder.Services.AddAuthorization(o =>
{
// Invoke the security options
var securityBuilder = new SecurityBuilder(o, builder);
options?.Invoke(securityBuilder);
});
return(builder);
}
public static PiranhaServiceBuilder UseMemoryCache(this PiranhaServiceBuilder serviceBuilder, bool clone = false)
{
// Check dependent services
if (!serviceBuilder.Services.Any(s => s.ServiceType == typeof(IMemoryCache)))
{
throw new NotSupportedException("You need to register a IMemoryCache service in order to use Memory Cache in Piranha");
}
serviceBuilder.Services.AddPiranhaMemoryCache();
return(serviceBuilder);
}
/// <summary>
/// Adds the Azure BlobStorage module.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="credential">The token credential used to sign requests.</param>
/// <param name="blobContainerUri">
/// A <see cref="Uri"/> referencing the blob service.
/// This is likely to be similar to "https://{account_name}.blob.core.windows.net".
/// </param>
/// <param name="naming">How uploaded media files should be named</param>
/// <param name="scope">The optional service scope. Default is singleton</param>
/// <returns>The service collection</returns>
public static PiranhaServiceBuilder UseBlobStorage(
this PiranhaServiceBuilder serviceBuilder,
Uri blobContainerUri,
TokenCredential credential,
BlobStorageNaming naming = BlobStorageNaming.UniqueFileNames,
ServiceLifetime scope = ServiceLifetime.Singleton)
{
serviceBuilder.Services.AddPiranhaBlobStorage(blobContainerUri, credential, naming, scope);
return(serviceBuilder);
}
/// <summary>
/// Adds the Azure BlobStorage module.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="connectionString">The connection string</param>
/// <param name="containerName">The optional container name</param>
/// <param name="naming">How uploaded media files should be named</param>
/// <param name="scope">The optional service scope. Default is singleton</param>
/// <returns>The service collection</returns>
public static PiranhaServiceBuilder UseBlobStorage(
this PiranhaServiceBuilder serviceBuilder,
string connectionString,
string containerName = "uploads",
BlobStorageNaming naming = BlobStorageNaming.UniqueFileNames,
ServiceLifetime scope = ServiceLifetime.Singleton)
{
serviceBuilder.Services.AddPiranhaBlobStorage(connectionString, containerName, naming, scope);
return(serviceBuilder);
}
/// <summary>
/// Uses the SpamDetectorService and its Piranha Manager services if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <param name="scope">The optional service scope. Default is singleton</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseSpamDetector(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddLocalization(options =>
options.ResourcesPath = "Resources"
);
//serviceBuilder.Services.AddControllersWithViews();
serviceBuilder.Services.AddRazorPages()
.AddSpamDetectorOptions();
serviceBuilder.Services.AddSpamDetector();
return(serviceBuilder);
}
public static IServiceCollection AddPiranha(this IServiceCollection services,
Action <PiranhaServiceBuilder> options = null, ServiceLifetime scope = ServiceLifetime.Scoped)
{
var serviceBuilder = new PiranhaServiceBuilder(services);
options?.Invoke(serviceBuilder);
services.AddSingleton <IContentFactory, ContentFactory>();
services.AddScoped <IApi, Api>();
services.AddScoped <Config>();
return(services);
}
/// <summary>
/// Adds authorization with the given application policies to the aplication.
/// </summary>
/// <param name="builder">The service builder</param>
/// <param name="builderOptions">The security builder options</param>
/// <param name="securityOptions">The security options</param>
/// <returns>The service builder</returns>
public static PiranhaServiceBuilder UseSecurity(this PiranhaServiceBuilder builder,
Action <SecurityBuilder> builderOptions, Action <SecurityOptions> securityOptions = null)
{
// Configure
builder.Services.Configure <SecurityOptions>(o => securityOptions?.Invoke(o));
// Add authentication
builder.Services.AddAuthorization(o =>
{
// Invoke the builder options
var securityBuilder = new SecurityBuilder(o, builder);
builderOptions?.Invoke(securityBuilder);
});
return(builder);
}
/// <summary>
/// Uses the Piranha Manager services if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseManager(this PiranhaServiceBuilder serviceBuilder)
{
// Add dependent services
serviceBuilder.Services.AddLocalization(options =>
options.ResourcesPath = "Resources"
);
serviceBuilder.Services.AddControllersWithViews();
serviceBuilder.Services.AddRazorPages()
.AddPiranhaManagerOptions();
// Add manager services
serviceBuilder.Services.AddPiranhaManager();
return(serviceBuilder);
}
public static PiranhaServiceBuilder UseMemoryCache(this PiranhaServiceBuilder serviceBuilder, bool clone = false)
{
stackVariable1 = serviceBuilder.Services;
stackVariable2 = PiranhaExtensions.u003cu003ec.u003cu003e9__2_0;
if (stackVariable2 == null)
{
dummyVar0 = stackVariable2;
stackVariable2 = new Func<ServiceDescriptor, bool>(PiranhaExtensions.u003cu003ec.u003cu003e9.u003cUseMemoryCacheu003eb__2_0);
PiranhaExtensions.u003cu003ec.u003cu003e9__2_0 = stackVariable2;
}
if (!stackVariable1.Any<ServiceDescriptor>(stackVariable2))
{
throw new NotSupportedException("You need to register a IMemoryCache service in order to use Memory Cache in Piranha");
}
dummyVar1 = serviceBuilder.Services.AddPiranhaMemoryCache(false);
return serviceBuilder;
}
/// <summary>
/// Adds the core Piranha services if simple startup is used.
/// </summary>
/// <param name="services">The current service collection</param>
/// <param name="options">The builder options</param>
/// <returns>The updated service collection</returns>
public static IServiceCollection AddPiranha(this IServiceCollection services, Action <PiranhaServiceBuilder> options)
{
var serviceBuilder = new PiranhaServiceBuilder(services);
options?.Invoke(serviceBuilder);
var config = new PiranhaRouteConfig
{
LoginUrl = serviceBuilder.LoginUrl,
UseAliasRouting = serviceBuilder.UseAliasRouting,
UseArchiveRouting = serviceBuilder.UseArchiveRouting,
UsePageRouting = serviceBuilder.UsePageRouting,
UsePostRouting = serviceBuilder.UsePostRouting,
UseSiteRouting = serviceBuilder.UseSiteRouting,
UseSitemapRouting = serviceBuilder.UseSitemapRouting,
UseStartpageRouting = serviceBuilder.UseStartpageRouting
};
services.AddSingleton <PiranhaRouteConfig>(config);
services.AddControllersWithViews();
var mvcBuilder = services.AddRazorPages();
if (serviceBuilder.AddRazorRuntimeCompilation)
{
mvcBuilder.AddRazorRuntimeCompilation();
}
services
.AddPiranha()
.AddScoped <Piranha.AspNetCore.Services.IApplicationService, Piranha.AspNetCore.Services.ApplicationService>()
.AddScoped <Piranha.AspNetCore.Services.IModelLoader, Piranha.AspNetCore.Services.ModelLoader>()
.AddAuthorization(o =>
{
o.AddPolicy(Permission.PagePreview, policy =>
{
policy.RequireClaim(Permission.PagePreview, Permission.PagePreview);
});
o.AddPolicy(Permission.PostPreview, policy =>
{
policy.RequireClaim(Permission.PostPreview, Permission.PostPreview);
});
});
return(serviceBuilder.Services);
}
/// <summary>
/// Adds the core Piranha services if simple startup is used.
/// </summary>
/// <param name="services">The current service collection</param>
/// <param name="options">The builder options</param>
/// <returns>The updated service collection</returns>
public static IServiceCollection AddPiranha(this IServiceCollection services, Action <PiranhaServiceBuilder> options)
{
var serviceBuilder = new PiranhaServiceBuilder(services);
options?.Invoke(serviceBuilder);
services.AddControllersWithViews();
var mvcBuilder = services.AddRazorPages();
if (serviceBuilder.AddRazorRuntimeCompilation)
{
mvcBuilder.AddRazorRuntimeCompilation();
}
services.AddPiranha();
services.AddPiranhaApplication();
return(serviceBuilder.Services);
}
/// <summary>
/// Uses the distributed cache service in the current application.
/// </summary>
/// <param name="serviceBuilder">The current service builder</param>
/// <param name="clone">If returned objects should be cloned</param>
/// <returns>The updated service builder</returns>
public static PiranhaServiceBuilder UseDistributedCache(this PiranhaServiceBuilder serviceBuilder, bool clone = false)
{
serviceBuilder.Services.AddPiranhaDistributedCache();
return(serviceBuilder);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="authorization">The authorization options</param>
/// <param name="builder">The service builder</param>
public SecurityBuilder(AuthorizationOptions authorization, PiranhaServiceBuilder builder)
{
_authorization = authorization;
_builder = builder;
}
public static PiranhaServiceBuilder UseIdentityServer4Auth(this PiranhaServiceBuilder serviceBuilder, System.Action <OpenIdConnectOptions> ids4Options)
{
serviceBuilder.Services.AddPiranhaIdentityServer4Auth(ids4Options);
return(serviceBuilder);
}
/// <summary>
/// Adds the Tiny MCE editor module if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseTinyMCE(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddPiranhaTinyMCE();
return(serviceBuilder);
}
/// <summary>
/// Adds the Piranha Api module.
/// </summary>
/// <param name="serviceBuilder">The service builder</param>
/// <returns>The services</returns>
public static PiranhaServiceBuilder UseApi(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddPiranhaApi();
return(serviceBuilder);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="options">The authorization options</param>
/// <param name="builder">The service builder</param>
public SecurityBuilder(AuthorizationOptions options, PiranhaServiceBuilder builder)
{
_options = options;
_builder = builder;
}
/// <summary>
/// Adds the ListModule module.
/// </summary>
/// <param name="serviceBuilder"></param>
/// <returns></returns>
public static PiranhaServiceBuilder UseListModule(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddListModule();
return(serviceBuilder);
}
public static PiranhaServiceBuilder UseEF(this PiranhaServiceBuilder serviceBuilder, Action <DbContextOptionsBuilder> dboptions,
ServiceLifetime scope = ServiceLifetime.Scoped)
{
return(serviceBuilder.UseEF <Db>(dboptions, scope));
}
/// <summary>
/// Uses the memory cache service in the current application.
/// </summary>
/// <param name="serviceBuilder">The current service builder</param>
/// <param name="clone">If returned objects should be cloned</param>
/// <returns>The updated service builder</returns>
public static PiranhaServiceBuilder UseMemoryCache(this PiranhaServiceBuilder serviceBuilder, bool clone = false)
{
serviceBuilder.Services.AddPiranhaMemoryCache(clone);
return(serviceBuilder);
}
/// <summary>
/// Adds the TemplateModule module.
/// </summary>
/// <param name="serviceBuilder"></param>
/// <returns></returns>
public static PiranhaServiceBuilder UseTemplateModule(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddTemplateModule();
return(serviceBuilder);
}
/// <summary>
/// Adds the Summernote editor module if simple startup is used.
/// </summary>
/// <param name="serviceBuilder">The current service builder</param>
/// <returns>The updated builder</returns>
public static PiranhaServiceBuilder UseSummernote(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.Services.AddPiranhaSummernote();
return(serviceBuilder);
}
/// <summary>
/// Adds the Azure Search module.
/// </summary>
/// <param name="services">The current service collection</param>
/// <returns>The services</returns>
public static PiranhaServiceBuilder UseAzureSearch(this PiranhaServiceBuilder serviceBuilder)
{
serviceBuilder.AddPiranhaAzureSearch.AddPiranhaAzureSearch();
return(serviceBuilder);
}
