public static IServiceCollection AddIdentityOptions(
this IServiceCollection services, BehlogSetting setting
)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
services.AddIdentity <User, Role>(_ => {
setPasswordOptions(_.Password, setting);
setSignInOptions(_.SignIn, setting);
setUserOptions(_.User);
setLockoutOptions(_.Lockout, setting);
}).AddUserStore <AppUserStore>()
.AddUserManager <AppUserManager>()
.AddRoleStore <AppRoleStore>()
.AddSignInManager <AppSignInManager>()
.AddErrorDescriber <CustomIdentityErrorDescriber>()
.AddDefaultTokenProviders();
services.AddScoped <IUserContext, UserContext>();
return(services);
}
public static IServiceCollection AddDatabaseServices(
this IServiceCollection services,
BehlogSetting setting
)
{
services.AddScoped <IDbInitializer, DbInitializerService>();
services.AddScoped <DbInitializerService, DbInitializerService>();
switch (setting.DbType)
{
case AppDatabaseType.InMemory:
services.AddConfiguredInMemoryDbContext(setting);
break;
case AppDatabaseType.LocalDb:
case AppDatabaseType.SqlServer:
services.AddSqlServerDatabase(setting);
break;
case AppDatabaseType.SQLite:
services.AddConfiguredSQLiteDbContext(setting);
break;
default:
throw new NotSupportedException("Please set the ActiveDatabase in appsettings.json file.");
}
return(services);
}
public static IServiceCollection AddConfiguredSQLiteDbContext(
this IServiceCollection services,
BehlogSetting setting)
{
services.AddScoped <IBehlogContext>(serviceProvider =>
serviceProvider.GetRequiredService <BehlogContext>());
services.AddEntityFrameworkSqlite(); // It's added to access services from the dbcontext, remove it if you are using the normal `AddDbContext` and normal constructor dependency injection.
services.AddDbContextPool <BehlogContext, SQLiteDbContext>(
(serviceProvider, optionsBuilder) => optionsBuilder.Configure(setting, serviceProvider));
return(services);
}
public static IServiceCollection AddSqlServerDatabase(this IServiceCollection services,
BehlogSetting settings)
{
services.AddTransient <IBehlogContext>(provider
=> provider.GetRequiredService <BehlogContext>());
services.AddEntityFrameworkSqlServer();
services.AddDbContextPool <BehlogContext, SqlServerDbContext>(
(provider, optionsBuilder)
=> optionsBuilder.Configure(settings, provider));
return(services);
}
private static void addConfirmEmailDataProtectorTokenOptions(
this IServiceCollection services, BehlogSetting setting
)
{
//services.Configure<IdentityOptions>(options => {
// options.Tokens.EmailConfirmationTokenProvider = EmailConfirmationTokenProviderName;
//});
//services.Configure<ConfirmEmailDataProtectionTokenProviderOptions>(options => {
// options.TokenLifespan = setting.EmailConfirmationTokenProviderLifespan;
//});
}
public static void UseConfiguredInMemoryDatabase(
this DbContextOptionsBuilder optionsBuilder,
BehlogSetting setting,
IServiceProvider services)
{
optionsBuilder.UseInMemoryDatabase(setting.ConnectionStrings.LocalDb.InitialCatalog);
optionsBuilder.UseInternalServiceProvider(services); // It's added to access services from the dbcontext, remove it if you are using the normal `AddDbContext` and normal constructor dependency injection.
optionsBuilder.AddInterceptors(new PersianDataCommandInterceptor());
optionsBuilder.ConfigureWarnings(_ => {
// ...
});
}
public static void Configure(this DbContextOptionsBuilder optionsBuilder,
BehlogSetting setting,
IServiceProvider provider)
{
optionsBuilder.UseSqlServer(setting.GetConnectionString(),
__ => {
__.CommandTimeout((int)TimeSpan.FromMinutes(3).TotalSeconds);
__.EnableRetryOnFailure();
__.MigrationsAssembly(typeof(SqlServerContextFactory).Assembly.FullName);
});
optionsBuilder.UseInternalServiceProvider(provider);
optionsBuilder.AddInterceptors(new PersianDataCommandInterceptor());
}
public static string GetSQLiteDbConnectionString(this BehlogSetting siteSettingsValue)
{
if (siteSettingsValue == null)
{
throw new ArgumentNullException(nameof(siteSettingsValue));
}
switch (siteSettingsValue.DbType)
{
case AppDatabaseType.SQLite:
return(siteSettingsValue.ConnectionStrings
.SQLite
.ReplaceDataDirectoryInConnectionString());
default:
throw new NotSupportedException(
"Please set the ActiveDatabase in appsettings.json file to `SQLite`.");
}
}
public static IServiceCollection AddDatabaseCacheStores(
this IServiceCollection services,
BehlogSetting setting
)
{
var cookieOptions = setting.CookieOptions;
if (!cookieOptions.UseDistributedCacheTicketStore)
{
return(services);
}
switch (setting.DbType)
{
case AppDatabaseType.InMemory:
services.AddMemoryCache();
services.AddScoped <ITicketStore, MemoryCacheTicketStore>();
break;
case AppDatabaseType.LocalDb:
case AppDatabaseType.SqlServer:
services.AddDistributedSqlServerCache(_ => {
var cachOptions = cookieOptions.DistributedSqlServerCacheOptions;
_.ConnectionString = string.IsNullOrWhiteSpace(cachOptions.ConnectionString)
? setting.GetConnectionString()
: cachOptions.ConnectionString;
_.SchemaName = cachOptions.SchemaName;
_.TableName = cachOptions.TableName;
});
services.AddScoped <ITicketStore, DistributedCacheTicketStore>();
break;
case AppDatabaseType.SQLite:
services.AddMemoryCache();
services.AddScoped <ITicketStore, MemoryCacheTicketStore>();
break;
default:
throw new NotSupportedException("Please set the value of [DbType] property in appsettings.json file correctly.");
}
return(services);
}
public static void Configure(
this DbContextOptionsBuilder optionsBuilder,
BehlogSetting setting,
IServiceProvider serviceProvider)
{
var connectionString = setting.GetSQLiteDbConnectionString();
optionsBuilder.UseSqlite(
connectionString,
sqlServerOptionsBuilder => {
sqlServerOptionsBuilder.CommandTimeout((int)TimeSpan.FromMinutes(3).TotalSeconds);
sqlServerOptionsBuilder.MigrationsAssembly(typeof(Extensions).Assembly
.FullName);
});
optionsBuilder
.UseInternalServiceProvider(
serviceProvider); // It's added to access services from the dbcontext, remove it if you are using the normal `AddDbContext` and normal constructor dependency injection.
optionsBuilder.AddInterceptors(new PersianDataCommandInterceptor());
optionsBuilder.ConfigureWarnings(warnings => {
// ...
});
}
public WebsiteOptionService(
IWebsiteOptionRepository repository,
IWebsiteInfo websiteInfo,
IWebsiteOptionFactory factory,
ILanguageRepository langRepository,
BehlogSetting setting) {
repository.CheckArgumentIsNull(nameof(repository));
_repository = repository;
websiteInfo.CheckArgumentIsNull(nameof(websiteInfo));
_websiteInfo = websiteInfo;
factory.CheckArgumentIsNull(nameof(factory));
_factory = factory;
langRepository.CheckArgumentIsNull(nameof(langRepository));
_langRepository = langRepository;
setting.CheckArgumentIsNull(nameof(setting));
_setting = setting;
}
private static void setApplicationCookieOptions(
IServiceProvider provider,
CookieAuthenticationOptions identityOptionsCookies,
BehlogSetting setting)
{
identityOptionsCookies.Cookie.Name = setting.CookieOptions.CookieName;
identityOptionsCookies.Cookie.HttpOnly = true;
identityOptionsCookies.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
identityOptionsCookies.Cookie.SameSite = SameSiteMode.Lax;
identityOptionsCookies.Cookie.IsEssential = true; // this cookie will always be stored regardless of the user's consent
identityOptionsCookies.ExpireTimeSpan = setting.CookieOptions.ExpireTimeSpan;
identityOptionsCookies.SlidingExpiration = setting.CookieOptions.SlidingExpiration;
identityOptionsCookies.LoginPath = setting.CookieOptions.LoginPath;
identityOptionsCookies.LogoutPath = setting.CookieOptions.LogoutPath;
identityOptionsCookies.AccessDeniedPath = setting.CookieOptions.AccessDeniedPath;
if (setting.CookieOptions.UseDistributedCacheTicketStore)
{
// To manage large identity cookies
identityOptionsCookies.SessionStore = provider.GetRequiredService <ITicketStore>();
}
}
private static void setLockoutOptions(LockoutOptions identityOptionsLockout, BehlogSetting setting)
{
identityOptionsLockout.AllowedForNewUsers = setting.LockoutOptions.AllowedForNewUsers;
identityOptionsLockout.DefaultLockoutTimeSpan = setting.LockoutOptions.DefaultLockoutTimeSpan;
identityOptionsLockout.MaxFailedAccessAttempts = setting.LockoutOptions.MaxFailedAccessAttempts;
}
private static void setSignInOptions(SignInOptions identityOptionsSignIn, BehlogSetting setting)
{
identityOptionsSignIn.RequireConfirmedEmail = setting.EnableEmailConfirmation;
}
private static void setPasswordOptions(PasswordOptions identityOptionsPassword, BehlogSetting setting)
{
identityOptionsPassword.RequireDigit = setting.PasswordOptions.RequireDigit;
identityOptionsPassword.RequireLowercase = setting.PasswordOptions.RequireLowercase;
identityOptionsPassword.RequireNonAlphanumeric = setting.PasswordOptions.RequireNonAlphanumeric;
identityOptionsPassword.RequireUppercase = setting.PasswordOptions.RequireUppercase;
identityOptionsPassword.RequiredLength = setting.PasswordOptions.RequiredLength;
}
