private static void UpdateDatabase(IApplicationBuilder app)
{
using (IServiceScope serviceScope = app.ApplicationServices.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (ApplicationDbContext context = serviceScope.ServiceProvider.GetService <ApplicationDbContext>())
using (ApplicationIdentityDbContext identityContext = serviceScope.ServiceProvider.GetService <ApplicationIdentityDbContext>())
{
identityContext.Database.Migrate();
context.Database.Migrate();
// Seeding identity
UserManager <ApplicationUser> userMgr =
serviceScope.ServiceProvider.GetService <UserManager <ApplicationUser> >();
RoleManager <IdentityRole> roleMgr =
serviceScope.ServiceProvider.GetService <RoleManager <IdentityRole> >();
IdentitySeedData identitySeeder = new IdentitySeedData(identityContext, userMgr, roleMgr);
identitySeeder.Seed();
try
{
SeedData.EnsurePopulated(context);
}
catch (Exception ex)
{
ILogger <Startup> logger = serviceScope.ServiceProvider.GetRequiredService <ILogger <Startup> >();
logger.LogError(ex, "An error occured seeding the database.");
}
}
}
}
public AccountController(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IConfiguration configuration, ApplicationIdentityDbContext applicationIdentityDbContext)
{
_userManager = userManager;
_signInManager = signInManager;
_configuration = configuration;
_context = applicationIdentityDbContext;
}
public Tools(IApplicationBuilder builder)
{
this.app = builder;
ApplicationIdentityDbContext context = app.ApplicationServices.GetRequiredService <ApplicationIdentityDbContext>();
context.Database.Migrate();
}
public ServiceRepository(
ApplicationDbContext applicationDbContext,
ApplicationIdentityDbContext applicationIdentityDbContext)
{
_applicationDbContext = applicationDbContext;
_applicationIdentityDbContext = applicationIdentityDbContext;
}
public static async Task <ApplicationUser> SeedRootAdmin(ApplicationIdentityDbContext context, IServiceProvider serviceProvider)
{
const string ROOT_ADMIN_EMAIL = "*****@*****.**";
var owner = context.Users.FirstOrDefault(user => user.UserName == ROOT_ADMIN_EMAIL);
if (owner is null)
{
var userManager = serviceProvider.GetService <UserManager <ApplicationUser> >();
owner = new ApplicationUser()
{
Email = ROOT_ADMIN_EMAIL,
NormalizedEmail = ROOT_ADMIN_EMAIL.ToUpper(),
UserName = ROOT_ADMIN_EMAIL,
NormalizedUserName = ROOT_ADMIN_EMAIL.ToUpper(),
PhoneNumber = "+123456789",
EmailConfirmed = true,
PhoneNumberConfirmed = true,
};
await userManager.CreateAsync(owner, "`12QWEasd"); // user must be warned to change this
context.SaveChanges();
await userManager.AddToRoleAsync(owner, Role.Admin);
context.SaveChanges();
}
return(owner);
}
public async Task SeedAsync(ApplicationIdentityDbContext context, IWebHostEnvironment env,
ILogger <ApplicationIdentityDbContextSeed> logger, IOptions <AppSettings> settings, int?retry = 0)
{
int retryForAvaiability = retry.Value;
try
{
var useCustomizationData = settings.Value.UseCustomizationData;
var contentRootPath = env.ContentRootPath;
var webroot = env.WebRootPath;
if (!context.Users.Any())
{
context.Users.AddRange(useCustomizationData ? GetUsersFromFile(contentRootPath, logger) : GetDefaultUser());
await context.SaveChangesAsync();
}
if (useCustomizationData)
{
GetPreconfiguredImages(contentRootPath, webroot, logger);
}
}
catch (Exception ex)
{
if (retryForAvaiability < 10)
{
retryForAvaiability++;
logger.LogError(ex, "EXCEPTION ERROR while migrating {DbContextName}", nameof(ApplicationIdentityDbContext));
await SeedAsync(context, env, logger, settings, retryForAvaiability);
}
}
}
public static async Task <List <IdentityRole> > SeedRoles(ApplicationIdentityDbContext context, IServiceProvider serviceProvider)
{
var roles = context.Roles.ToList();
if (!roles.Any())
{
var roleStore = serviceProvider.GetService <RoleManager <IdentityRole> >();
roles = new List <IdentityRole>
{
new IdentityRole(Role.Admin)
{
Id = Constants.AdminRoleId
},
new IdentityRole(Role.AreaAdmin)
{
Id = Constants.AreaAdminRoleId
},
new IdentityRole(Role.ReadOnlyUser)
{
Id = Constants.ReadOnlyUserRoleId
},
new IdentityRole(Role.ReadWriteUser)
{
Id = Constants.ReadWriteUserRoleId
}
};
foreach (var role in roles)
{
await roleStore.CreateAsync(role);
}
}
return(roles);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ApplicationIdentityDbContext identityDbContext)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.Use((ctx, next) =>
{
return(next());
});
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapControllers();
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
identityDbContext.Database.Migrate();
OnConfigure(app, env);
}
public void Setup()
{
// Build service colection to create identity UserManager and RoleManager.
IServiceCollection serviceCollection = new ServiceCollection();
// Add ASP.NET Core Identity database in memory.
sqliteConnection = new SqliteConnection("DataSource=:memory:");
serviceCollection.AddDbContext <ApplicationIdentityDbContext>(options => options.UseSqlite(sqliteConnection));
identityDbContext = serviceCollection.BuildServiceProvider().GetService <ApplicationIdentityDbContext>();
identityDbContext.Database.OpenConnection();
identityDbContext.Database.EnsureCreated();
// Add Identity using in memory database to create UserManager and RoleManager.
serviceCollection.AddApplicationIdentity();
// Get UserManager and RoleManager.
userManager = serviceCollection.BuildServiceProvider().GetService <UserManager <ApplicationUser> >();
roleManager = serviceCollection.BuildServiceProvider().GetService <RoleManager <ApplicationRole> >();
// Get token validation settings.
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot configuration = builder.Build();
var tokenValidationSection = configuration.GetSection("TokenValidation");
serviceCollection.Configure <TokenValidation>(tokenValidationSection);
tokenValidationSettings = serviceCollection.BuildServiceProvider().GetService <IOptions <TokenValidation> >().Value;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
ApplicationIdentityDbContext.CreateAdminAccount(app.ApplicationServices,
Configuration).Wait();
ApplicationIdentityDbContext.CreateMentorsRole(app.ApplicationServices,
Configuration).Wait();
}
public static void Main(string[] args)
{
using (var identitycontext = new ApplicationIdentityDbContext())
{
identitycontext.Database.EnsureDeleted();
identitycontext.Database.EnsureCreated();
}
CreateHostBuilder(args).Build().Run();
}
public IndexModel(
UserManager <ApplicationUser> userManager,
RoleManager <Domain.Identity.ApplicationRole> roleManager,
ApplicationIdentityDbContext dbContext)
{
_userManager = userManager;
_roleManager = roleManager;
_dbContext = dbContext;
}
public static UserManager <ApplicationUser> UserManager(IApplicationBuilder app)
{
ApplicationIdentityDbContext context = app.ApplicationServices.GetRequiredService <ApplicationIdentityDbContext>();
context.Database.Migrate();
UserManager <ApplicationUser> userManager = app.ApplicationServices.GetRequiredService <UserManager <ApplicationUser> >();
return(userManager);
}
/// <summary>
/// Initializes a new instance of the <see cref="SeedController"/> class.
/// </summary>
/// <param name="appDbContext">Instance of <see cref="ApplicationDbContext"/>.</param>
/// <param name="userManager">Instance of <see cref="ApplicationUserManager"/>.</param>
/// <param name="identityDbContext">Instance of <see cref="ApplicationIdentityDbContext"/>.</param>
public SeedController(
ApplicationDbContext appDbContext,
ApplicationUserManager userManager,
ApplicationIdentityDbContext identityDbContext)
{
_appDbContext = appDbContext ?? throw new ArgumentNullException(nameof(appDbContext));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_identityDbContext = identityDbContext ?? throw new ArgumentNullException(nameof(identityDbContext));
}
private void SeedUser(IApplicationBuilder app)
{
ApplicationIdentityDbContext context = app.ApplicationServices.GetRequiredService <ApplicationIdentityDbContext>();
context.Database.Migrate();
var userMager = app.ApplicationServices.GetRequiredService <UserManager <ApplicationUser> >();
RoleManager <IdentityRole> roleManager = app.ApplicationServices.GetService <RoleManager <IdentityRole> >();
SeedTools.SeedRoles(roleManager);
SeedTools.SeedUsers(userMager);
}
public UsersController(
UserManager <ApplicationUser> userManager,
ApplicationIdentityDbContext context,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory)
{
_userManager = userManager;
_context = context;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <UsersController>();
}
public static ApplicationIdentityDbContext Create()
{
var options = new DbContextOptionsBuilder <ApplicationIdentityDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new ApplicationIdentityDbContext(options);
context.Database.EnsureCreated();
context.SaveChanges();
return(context);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ApplicationIdentityDbContext identityDbContext)
{
OnConfiguring(app, env);
var supportedCultures = new[]
{
new System.Globalization.CultureInfo("en-US"),
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new Microsoft.AspNetCore.Localization.RequestCulture("en-US"),
SupportedCultures = supportedCultures,
SupportedUICultures = supportedCultures
});
if (env.IsDevelopment())
{
Microsoft.IdentityModel.Logging.IdentityModelEventSource.ShowPII = true;
app.UseDeveloperExceptionPage();
}
else
{
app.Use((ctx, next) =>
{
return(next());
});
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapControllers();
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
identityDbContext.Database.Migrate();
OnConfigure(app, env);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
//https://docs.microsoft.com/ru-ru/aspnet/core/fundamentals/localization?view=aspnetcore-2.2
var supportedCultures = new[]
{
new CultureInfo("uk-UA"),
//new CultureInfo("en-US"),
//new CultureInfo("ru-RU")
};
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("uk-UA"),
//Formatting numbers, dates, etc.
SupportedCultures = supportedCultures,
//UI strings that we have localized
SupportedUICultures = supportedCultures
});
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default2",
template: "{controller}/{action}/{id?}"
);
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
ApplicationIdentityDbContext.CreateAdminAccount(app.ApplicationServices,
Configuration).Wait();
ApplicationIdentityDbContext.InitializeRolesAsync(app.ApplicationServices).Wait();
ApplicationIdentityDbContext.CreateUserAccounts(app.ApplicationServices, Configuration).Wait();
}
public SecurityService(ApplicationIdentityDbContext context,
IWebHostEnvironment env,
UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
SignInManager <ApplicationUser> signInManager,
NavigationManager uriHelper,
GlobalsService globals)
{
this.context = context;
this.userManager = userManager;
this.roleManager = roleManager;
this.signInManager = signInManager;
this.env = env;
this.uriHelper = uriHelper;
this.globals = globals;
}
public static void Initialize(ApplicationIdentityDbContext context, IServiceProvider serviceProvider)
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
SeedRoles(context, serviceProvider).Wait();
SeedRootAdmin(context, serviceProvider).Wait();
transaction.Commit();
}
catch (Exception e)
{
File.WriteAllText($"log{DateTime.UtcNow.Date.ToString("yyyyMMdd")}.txt", e.ToString());
}
}
}
public AccountController(
ApplicationIdentityDbContext appIdentityDbContext,
ApplicationDbContext appDdContext,
UserManager <ApplicationIdentityUser> userManager,
SignInManager <ApplicationIdentityUser> loginManager,
RoleManager <ApplicationIdentityRole> roleManager)
{
_appDdContext = appDdContext;
_appIdentityDdContext = appIdentityDbContext;
_appIdentityDdContext.Database.EnsureCreated();
_appDdContext.Database.EnsureCreated();
this.userManager = userManager;
this.loginManager = loginManager;
this.roleManager = roleManager;
}
public SecurityService(ApplicationIdentityDbContext context,
IWebHostEnvironment env,
UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
SignInManager <ApplicationUser> signInManager,
IHttpContextAccessor httpContextAccessor,
NavigationManager uriHelper,
AuthenticationStateProvider authenticationStateProvider)
{
this.context = context;
this.userManager = userManager;
this.roleManager = roleManager;
this.signInManager = signInManager;
this.env = env;
this.httpContextAccessor = httpContextAccessor;
this.uriHelper = uriHelper;
this.authenticationStateProvider = authenticationStateProvider;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ApplicationIdentityDbContext dbContext, IServiceProvider serviceProvider)
{
app.UseCors("AllowCors");
// ===== Create tables ======
dbContext.Database.EnsureCreated();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseAuthentication();
app.UseHttpsRedirection();
app.UseMvc();
CreateUserRoles(serviceProvider).Wait();
}
public SecurityService(ApplicationIdentityDbContext context,
IWebHostEnvironment env,
UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
SignInManager <ApplicationUser> signInManager,
IHttpContextAccessor httpContextAccessor,
NavigationManager uriHelper)
{
this.context = context;
this.userManager = userManager;
this.roleManager = roleManager;
this.signInManager = signInManager;
this.env = env;
this.httpContextAccessor = httpContextAccessor;
this.uriHelper = uriHelper;
if (httpContextAccessor.HttpContext != null)
{
Principal = httpContextAccessor.HttpContext.User;
User = context.Users.FirstOrDefault(u => u.Email == Principal.Identity.Name);
}
}
public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory,
IIdentityServerInteractionService interaction,
IHttpContextAccessor httpContext,
IClientStore clientStore,
ApplicationIdentityDbContext context)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <AccountController>();
_interaction = interaction;
_clientStore = clientStore;
_context = context;
_account = new AccountService(interaction, httpContext, clientStore);
}
public CreateModel(ApplicationIdentityDbContext context, UserManager <ApplicationUser> userManager)
{
_context = context;
_userManager = userManager;
}
public ApplicationRolesController(RoleManager <IdentityRole> roleManager, Microsoft.AspNetCore.Hosting.IWebHostEnvironment env, ApplicationIdentityDbContext context)
{
this.roleManager = roleManager;
this.env = env;
this.context = context;
}
public TodoItemsController(ApplicationIdentityDbContext context)
{
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="ApplicationUserManager"/> class.
/// </summary>
/// <param name="store">The IUserStore is responsible for commiting changes via the UpdateAsync/CreateAsync methods.</param>
/// <param name="context"><see cref="DbContext"/> for ASP.NET Identity infrastructure.</param>
public ApplicationUserManager(IUserStore <ApplicationUser> store, ApplicationIdentityDbContext context)
: base(store)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public ClaimManager(ApplicationIdentityDbContext dbContext)
{
this.dbContext = dbContext;
}
