public FunctionalSvc(IOptions <AppUserOptions> appUserOptions, IOptions <AdminUserOptions> adminUserOptions,
UserManager <ApplicationUser> userManager)
{
_adminUserOptions = adminUserOptions.Value;
_appUserOptions = appUserOptions.Value;
_userManager = userManager;
}
public static async Task SeedUsersAsync(UserManager <User> userManager, IConfiguration configuration)
{
var adminUserOptions = new AdminUserOptions();
configuration.Bind(nameof(AdminUserOptions), adminUserOptions);
var adminUserEmail = adminUserOptions.DefaultAdminUserEmail;
var adminPassword = adminUserOptions.DefaultAdminUserPassword;
var exists = await userManager.FindByNameAsync(adminUserEmail) != null;
if (exists)
{
return;
}
var user = new User
{
UserName = adminUserEmail,
Email = adminUserEmail,
FirstName = "Boss",
LastName = "Man"
};
var result = await userManager.CreateAsync(user, adminPassword);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, CaffStoreRoles.Admin);
}
}
/*private readonly IHostingEnvironment _env;*/
public FunctionalSvc(IOptions <AppUserOptions> appUserOptions,
IOptions <AdminUserOptions> adminUserOptions,
UserManager <ApplicationUser> userManager /*, IHostingEnvironment env*/)
{
_adminUserOptions = adminUserOptions.Value;
_appUserOptions = appUserOptions.Value;
_userManager = userManager;
/*_env = env;*/
}
// private readonly IHostingEnvironment _hostEnv;
//dependency injection to pupulate the object
public ComFunction(IOptions <AdminUserOptions> adminOptions,
IOptions <AppUserOptions> appOptions,
UserManager <ApplicationUser> userManager, IWebHostEnvironment env)
{
_adminUserOptions = adminOptions.Value;
_appUserOptions = appOptions.Value;
_UserManager = userManager;
_env = env;
}
public FunctionalService(
IOptions <AppUserOptions> appUserOptions,
IOptions <AdminUserOptions> adminUserOptions,
UserManager <ApplicationUser> userManager,
ApplicationDbContext db,
IWebHostEnvironment env)
{
_adminUserOptions = adminUserOptions.Value;
_appUserOptions = appUserOptions.Value;
_userManager = userManager;
_db = db;
_env = env;
}
private async Task SetUpRolesAndAdminUser(IServiceProvider serviceProvider, AdminUserOptions adminUserOptions)
{
IServiceScopeFactory scopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
using (IServiceScope scope = scopeFactory.CreateScope())
{
RoleManager <IdentityRole> roleManager = scope.ServiceProvider.GetRequiredService <RoleManager <IdentityRole> >();
UserManager <ApplicationUser> userManager = scope.ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >();
await addRequiredRoles(roleManager);
if (adminUserOptions.CreateAdminUser)
{
await addAdminUser(userManager);
}
}
async Task addRequiredRoles(RoleManager <IdentityRole> roleManager)
{
string[] requiredRoles = { "Admin" };
foreach (string roleName in requiredRoles)
{
var roleExist = await roleManager.RoleExistsAsync(roleName);
if (!roleExist)
{
IdentityResult result = await roleManager.CreateAsync(new IdentityRole(roleName));
if (!result.Succeeded)
{
aggregateErrors(result);
}
}
}
}
async Task addAdminUser(UserManager <ApplicationUser> userManager)
{
string userName = adminUserOptions.UserName;
string userEmail = adminUserOptions.UserName;
string defaultPassword = adminUserOptions.DefaultPassword;
ApplicationUser adminUser = await userManager.FindByNameAsync(userName);
if (adminUser == null)
{
adminUser = new ApplicationUser
{
UserName = userName,
Email = userEmail,
};
IdentityResult result = await userManager.CreateAsync(adminUser, defaultPassword);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(adminUser, "Admin");
}
else
{
aggregateErrors(result);
}
}
}
void aggregateErrors(IdentityResult result)
{
throw new AggregateException(result.Errors.Select(err =>
{
var setupException = new AppSetupException(err.Description);
setupException.Data.Add("Code", err.Code);
return(setupException);
}));
}
}
public BlogContext(IOptions <AdminUserOptions> adminOptions,
DbContextOptions contextOptions)
: base(contextOptions)
{
_adminOptions = adminOptions?.Value;
}
