private void CreateDefaultRoles() { if (!RoleManager.RoleExists("Developer")) { RoleManager.Create(new IdentityRole() { Name = "Developer" }); } if (!RoleManager.RoleExists("SuperAdmin")) { RoleManager.Create(new IdentityRole() { Name = "SuperAdmin" }); } if (!RoleManager.RoleExists("Admin")) { RoleManager.Create(new IdentityRole() { Name = "Admin" }); } if (!RoleManager.RoleExists("User")) { RoleManager.Create(new IdentityRole() { Name = "User" }); } }
public void SetInitialData() { ApplicationRole userRole = new ApplicationRole { Name = "user" }; ApplicationRole adminRole = new ApplicationRole { Name = "admin" }; ApplicationRoleManager roleManager = repository.RoleManager; roleManager.Create(userRole); roleManager.Create(adminRole); ApplicationUser admin = new ApplicationUser { UserName = "******", Email = "admin", RegistrationDateTime = DateTime.UtcNow }; ApplicationUserManager userManager = repository.UserManager; userManager.Create(admin, "1234qwerA"); userManager.AddToRole(admin.Id, adminRole.Name); repository.Save(); }
private void InitializeUsers(PassengersContext context) { var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); var userManager = new ApplicationUserManager(new UserStore <AppUser>(context)); var roleAdmin = new ApplicationRole { Name = "Admin" }; var roleUser = new ApplicationRole { Name = "User" }; roleManager.Create(roleAdmin); roleManager.Create(roleUser); var admin = new AppUser { Email = "*****@*****.**", UserName = "******", FirstName = "Darya", LastName = "Drahun" }; var user = new AppUser { Email = "*****@*****.**", UserName = "******", FirstName = "Darya", LastName = "Drahun" }; userManager.Create(admin, "qwerty"); userManager.Create(user, "qwerty"); userManager.AddToRole(admin.Id, "Admin"); userManager.AddToRole(user.Id, "User"); base.Seed(context); }
protected override void Seed(WebTestSecirity.Models.ApplicationDbContext context) { var userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); var roleManager = new ApplicationRoleManager(new RoleStore <IdentityRole>(context)); // создаем две роли var roleAdmin = new IdentityRole { Name = "Admin" }; var roleUser = new IdentityRole { Name = "User" }; // добавляем роли в бд roleManager.Create(roleAdmin); roleManager.Create(roleUser); string email = "*****@*****.**"; string password = "******"; // создаем пользователей var admin = new ApplicationUser { Email = email, UserName = email }; var result = userManager.Create(admin, password); // если создание пользователя прошло успешно if (result.Succeeded) { // добавляем для пользователя роль userManager.AddToRole(admin.Id, roleAdmin.Name); userManager.AddToRole(admin.Id, roleUser.Name); } }
protected override void Seed(AccountingDemoApp.DAL.ApplicationDbContext db) { // This method will be called after migrating to the latest version. // You can use the DbSet<T>.AddOrUpdate() helper extension method // to avoid creating duplicate seed data. var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(db)); if (!roleManager.Roles.Any()) { roleManager.Create(new ApplicationRole { Name = "Admin" }); roleManager.Create(new ApplicationRole { Name = "User" }); } var userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(db)); if (!userManager.Users.Any()) { var admin = new ApplicationUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", UserName = "******", EmailConfirmed = true, Deposit = 25000m }; userManager.Create(admin, "jason12345"); userManager.AddToRoles(admin.Id, new string[] { "Admin", "User" }); } SaveData(db); }
protected override void Seed(IEP.Security.ApplicationSecurityDbContext context) { // This method will be called after migrating to the latest version. // You can use the DbSet<T>.AddOrUpdate() helper extension method // to avoid creating duplicate seed data. if (!context.Roles.Any()) { var store = new RoleStore <ApplicationRole, int, ApplicationUserRole>(context); var manager = new ApplicationRoleManager(store); var role = new ApplicationRole { Name = "Admin" }; manager.Create(role); role = new ApplicationRole { Name = "Registred User" }; manager.Create(role); } if (!context.Users.Any(u => u.UserName == "Admin")) { var store = new UserStore <ApplicationUser, ApplicationRole, int, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>(context); var manager = new ApplicationUserManager(store); var user = new ApplicationUser { UserName = "******", Email = "*****@*****.**", FirstName = "Admin", LastName = "Admin" }; manager.Create(user, "password"); manager.AddToRole(user.Id, "Admin"); } }
public void PerformInitialSetup(ApplicationDbContext context) { ApplicationUserManager userMgr = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); ApplicationRoleManager roleMgr = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); string roleName = "Administrators"; string roleName1 = "GS"; string userName = "******"; string password = "******"; string email = "*****@*****.**"; if (!roleMgr.RoleExists(roleName)) { roleMgr.Create(new ApplicationRole(roleName)); roleMgr.Create(new ApplicationRole(roleName1)); } ApplicationUser user = userMgr.FindByName(userName); if (user == null) { userMgr.Create(new ApplicationUser { UserName = email, Email = email }, password); user = userMgr.FindByName(email); } if (!userMgr.IsInRole(user.Id, roleName)) { userMgr.AddToRole(user.Id, roleName); userMgr.AddToRole(user.Id, roleName1); } }
public void RegistraRegras() { if (_roleManager.FindByName("Administrador") == null) { _roleManager.Create(new IdentityRole("Administrador")); _roleManager.Create(new IdentityRole("Usuario")); } }
public async Task <ActionResult> Registrar(GoltaraSoft.SysBeauty.Web.Models.RegistrarViewModel model) { if (ModelState.IsValid) { EmpresaModel empresa = null; try { _svEmpresa.Cadastrar(model.EmpresaCNPJ, model.EmpresaNome, model.Nome, model.Celular, model.Email); empresa = _svEmpresa.FindCNPJ(model.EmpresaCNPJ); } catch (Exception ex) { ModelState.AddModelError(string.Empty, ex.Message); return(View(model)); } if (empresa != null) { var user = new Usuario { Nome = model.Nome, UserName = model.Email, Email = model.Email, IdEmpresa = empresa.Id }; var result = await _userManager.CreateAsync(user, model.Senha); if (result.Succeeded) { if (_roleManager.FindByName("Administrador") == null) { _roleManager.Create(new IdentityRole("Administrador")); _roleManager.Create(new IdentityRole("Usuario")); } Usuario usr = _userManager.FindByEmail(model.Email); await _userManager.AddToRolesAsync(usr.Id, new[] { "Administrador" }); await _signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); return(RedirectToAction("Index", "Home")); } AddErrors(result); } ModelState.AddModelError(string.Empty, "Houve um erro ao tentar cadastrar a empresa."); return(View(model)); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); //Create Role Admin if it does not exist const string adminRoleName = "Admin"; //Create User Role if it does not exist const string userRoleName = "User"; var userRole = RoleManager.FindByName(userRoleName); if (userRole == null) { userRole = new IdentityRole(userRoleName); var roleResult = RoleManager.Create(userRole); } //Add the first user to the admin role var adminRole = RoleManager.FindByName(adminRoleName); if (adminRole == null) { adminRole = new IdentityRole(adminRoleName); var roleResult = RoleManager.Create(adminRole); UserManager.AddToRole(user.Id, adminRole.Name); } else { UserManager.AddToRole(user.Id, userRole.Name); } // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(RedirectToAction("Index", "Home")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
protected override void Seed(ApplicationDbContext context) { var userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); var roleManager = new ApplicationRoleManager(new RoleStore <IdentityRole>(context)); var roleAdmin = new IdentityRole() { Name = "admin" }; var roleOperator = new IdentityRole() { Name = "operator" }; var roleExecutor = new IdentityRole() { Name = "executor" }; roleManager.Create(roleAdmin); roleManager.Create(roleOperator); roleManager.Create(roleExecutor); var admin = new ApplicationUser() { Email = "*****@*****.**", UserName = "******" }; var passw = "hamster"; var res = userManager.Create(admin, passw); if (res.Succeeded) { userManager.AddToRole(admin.Id, roleAdmin.Name); } for (int i = 0; i < 60; i++) { context.SupportRequests.Add(new RequestModel() { ClientName = "client" + i, Executor = "Exec" + i, Id = i, Operator = "Operator" + i, SolutionComment = "sdfs", State = "Зарегистриван", Text = "sdf", Time = DateTime.Now }); } //context.SaveChanges(); base.Seed(context); }
private void PerformInitialSetup(ApplicationDbContext context) { var userMgr = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); var roleMgr = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); string roleName = "admin"; string password = "******"; string email = "*****@*****.**"; if (!roleMgr.RoleExists(roleName)) { roleMgr.Create(new ApplicationRole(roleName)); } var user = userMgr.FindByEmail(email); if (user == null) { userMgr.Create(new ApplicationUser { UserName = email, Email = email }, password); user = userMgr.FindByEmail(email); } if (!userMgr.IsInRole(user.Id, roleName)) { userMgr.AddToRole(user.Id, roleName); } string roleName1 = "user"; string password1 = "1_MYpassword"; string email1 = "*****@*****.**"; if (!roleMgr.RoleExists(roleName1)) { roleMgr.Create(new ApplicationRole(roleName1)); } var user1 = userMgr.FindByEmail(email1); if (user1 == null) { userMgr.Create(new ApplicationUser { UserName = email1, Email = email1 }, password1); user1 = userMgr.FindByEmail(email1); } if (!userMgr.IsInRole(user1.Id, roleName1)) { userMgr.AddToRole(user1.Id, roleName1); } }
protected override void Seed(ApplicationDbContext context) { // This method will be called after migrating to the latest version. // You can use the DbSet<T>.AddOrUpdate() helper extension method // to avoid creating duplicate seed data. var userManager = new ApplicationUserManager(new UserStore <ApplicationUser, ApplicationRole, string, IdentityUserLogin, ApplicationUserRole, IdentityUserClaim>(context)); var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole, string, ApplicationUserRole>(context)); const string name = "*****@*****.**"; const string password = "******"; //Create Role Admin if it does not exist var role = roleManager.FindByName(AppRoles.Admin); if (role == null) { role = new ApplicationRole(AppRoles.Admin); var roleresult = roleManager.Create(role); } var user = userManager.FindByName(name); if (user == null) { user = new ApplicationUser { UserName = name, Email = name }; var result = userManager.Create(user, password); result = userManager.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = userManager.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var result = userManager.AddToRole(user.Id, role.Name); } foreach (var appRole in AppRoles.GetRoleNames()) { if (roleManager.FindByName(appRole) == null) { var roleresult = roleManager .Create(new ApplicationRole(appRole)); } } }
private void InitializeRole(string roleName) { IdentityRole role = roleManager.FindByName(roleName); if (role == null) { role = new IdentityRole(roleName); IdentityResult result = roleManager.Create(role); if (!result.Succeeded) { throw new ApplicationException(result.Errors.ToString()); } } }
public void InitializeIdentityForEF() { var context = new ApplicationDbContext(); var roleStore = new ApplicationRoleStore(context); var roleManager = new ApplicationRoleManager(roleStore); var userStore = new ApplicationUserStore(context); var userManager = new ApplicationUserManager(userStore); const string adminUsername = "******"; const string password = "******"; const string adminRoleName = "Admin"; const string userRoleName = "User"; var adminRole = roleManager.FindByName(adminRoleName); if (adminRole == null) { adminRole = new ApplicationRole(adminRoleName); var roleResult = roleManager.Create(adminRole); } var userRole = roleManager.FindByName(userRoleName); if (userRole == null) { userRole = new ApplicationRole(userRoleName); var roleResult = roleManager.Create(userRole); } var adminUser = userManager.FindByName(adminUsername); if (adminUser == null) { adminUser = new ApplicationUser { UserName = adminUsername, Email = adminUsername }; var result = userManager.Create(adminUser, password); result = userManager.SetLockoutEnabled(adminUser.Id, false); } var rolesForUser = userManager.GetRoles(adminUser.Id); if (!rolesForUser.Contains(adminRole.Name)) { var result = userManager.AddToRole(adminUser.Id, adminRole.Name); } }
private void CreateAdminAccountAndApplicationRoles() { var dbContext = new ApplicationDbContext(); var userManager = new ApplicationUserManager(new UserStore <User>(dbContext)); var roleManager = new ApplicationRoleManager(new RoleStore <IdentityRole>(dbContext)); if (!roleManager.RoleExists("Administrator")) { roleManager.Create(new IdentityRole { Name = "Administrator" }); var user = new User { UserName = "******", Email = "*****@*****.**" }; var adminCreated = userManager.Create(user, "123admin123"); if (adminCreated.Succeeded) { userManager.AddToRole(user.Id, "Administrator"); } } if (!roleManager.RoleExists("Organizator")) { roleManager.Create(new IdentityRole { Name = "Organizator" }); } if (!roleManager.RoleExists("Member")) { roleManager.Create(new IdentityRole { Name = "Member" }); } if (!roleManager.RoleExists("User")) { roleManager.Create(new IdentityRole { Name = "User" }); } }
public void PerformInitialSetup(ApplicationDbContext context) { ApplicationUserManager userMgr = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); ApplicationRoleManager roleMgr = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); string roleAdmin = "Administrators"; string userName = "******"; string password = "******"; string email = "*****@*****.**"; if (!roleMgr.RoleExists(roleAdmin)) { roleMgr.Create(new ApplicationRole(roleAdmin)); } ApplicationUser user = userMgr.FindByName(userName); if (user == null) {//, City = Cities.CHICAGO, Country = Countries.USA user = new ApplicationUser { UserName = userName, Email = email }; userMgr.Create(user, password); user = userMgr.FindByName(userName); } if (!userMgr.IsInRole(user.Id, roleAdmin)) { userMgr.AddToRole(user.Id, roleAdmin); } }
protected override void Seed(ApplicationDbContext context) { var userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); const string role = "Administrators"; const string userName = "******"; const string password = "******"; const string mail = "*****@*****.**"; if (!roleManager.RoleExists(role)) { roleManager.Create(new ApplicationRole(role)); } var user = userManager.FindByName(userName); if (user == null) { userManager.Create(new ApplicationUser { UserName = userName, Email = mail }, password); user = userManager.FindByName(userName); } if (!userManager.IsInRole(user.Id, role)) { userManager.AddToRole(user.Id, role); } context.SaveChanges(); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var roles = ApplicationRoleManager.Create(HttpContext.GetOwinContext()); if (!await roles.RoleExistsAsync("Shop")) { await roles.CreateAsync(new IdentityRole { Name = "Shop" }); } await UserManager.AddToRoleAsync(user.Id, "Shop"); string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); var callbackUrl = Url.Action("ConfirmEmail", "Dashboard", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(RedirectToAction("Index", "Shops")); } AddErrors(result); } return(View(model)); }
// Add CreateAdminIfNeeded #region private void CreateAdminIfNeeded() private void CreateAdminIfNeeded() { // Get Admin Account string AdminUserName = ConfigurationManager.AppSettings["AdminUserName"]; string AdminPassword = ConfigurationManager.AppSettings["AdminPassword"]; // See if Admin exists var objAdminUser = UserManager.FindByEmail(AdminUserName); if (objAdminUser == null) { //See if the Admin role exists if (!RoleManager.RoleExists("Administrator")) { // Create the Admin Role (if needed) IdentityRole objAdminRole = new IdentityRole("Administrator"); RoleManager.Create(objAdminRole); } // Create Admin user var objNewAdminUser = new ApplicationUser { UserName = AdminUserName, Email = AdminUserName }; var AdminUserCreateResult = UserManager.Create(objNewAdminUser, AdminPassword); // Put user in Admin role UserManager.AddToRole(objNewAdminUser.Id, "Administrator"); } }
public async Task <ActionResult> AddAdmin(RegisterViewModel model) { var context = new ApplicationDbContext(); var store = new UserStore <CustomUser>(context); var manager = new UserManager <CustomUser>(store); var signInManager = new SignInManager <CustomUser, string>(manager, HttpContext.GetOwinContext().Authentication); var roles = ApplicationRoleManager.Create(HttpContext.GetOwinContext()); if (!await roles.RoleExistsAsync(SecurityRoles.Admin)) { await roles.CreateAsync(new IdentityRole { Name = SecurityRoles.Admin }); } if (ModelState.IsValid) { var user = new CustomUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Login = model.Login }; await manager.CreateAsync(user, model.Password); await manager.AddToRoleAsync(user.Id, SecurityRoles.Admin); return(RedirectToAction("Index", "Admin")); } return(View(model)); }
public ActionResult SetGlobalAdmins() { var adminRoleName = "Administrator"; if (!RoleManager.RoleExists(adminRoleName)) { var adminIdentityRole = new IdentityRole(adminRoleName); RoleManager.Create(adminIdentityRole); } var rolands = UserManager.FindByEmail("*****@*****.**"); if (rolands != null) { UserManager.AddToRole(rolands.Id, adminRoleName); } var larisa = UserManager.FindByEmail("*****@*****.**"); if (larisa != null) { UserManager.AddToRole(larisa.Id, adminRoleName); } return(View()); }
private void InitializeIdentityAdmin(PSContext db) { var userStore = new UserStore <ApplicationUser>(db); var userManager = new UserManager <ApplicationUser>(userStore); userManager.UserValidator = new UserValidator <ApplicationUser>(userManager) { AllowOnlyAlphanumericUserNames = false }; // Configure validation logic for passwords userManager.PasswordValidator = new PasswordValidator { RequiredLength = 6, RequireNonLetterOrDigit = true, RequireDigit = true, RequireLowercase = true, RequireUppercase = true, }; var roleStore = new RoleStore <IdentityRole>(db); var roleManager = new ApplicationRoleManager(roleStore); const string name = "admin"; const string password = "******"; const string roleName = "Admin"; //Create Role Admin if it does not exist var role = roleManager.FindByName(roleName); if (role == null) { role = new IdentityRole(roleName); var roleresult = roleManager.Create(role); } //Create the admin var user = userManager.FindByName(name); //Delete the current admin because we want to update him if (user != null) { userManager.Delete(user); user = null; } if (user == null) { user = new ApplicationUser { UserName = name, }; var result = userManager.Create(user, password); result = userManager.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = userManager.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var result = userManager.AddToRole(user.Id, role.Name); } }
public JsonResult Create(string model) { string roleName = string.Empty; try { RoleManagementViewModel role = JsonConvert.DeserializeObject <RoleManagementViewModel>(model); ApplicationRole newRole = new ApplicationRole() { Name = role.RoleName }; IdentityResult result = _roleManager.Create(newRole); if (result == IdentityResult.Success) { roleName = newRole.Name; role.RoleId = _roleManager.Roles.Select(r => r.Id).First(); Response.StatusCode = (int)System.Net.HttpStatusCode.OK; return(Json(role, JsonRequestBehavior.AllowGet)); } throw new System.Exception("New role cannot be created."); } catch (Exception ex) { Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError; return(Json("Create role '" + roleName + "' fails. " + ex.Message, JsonRequestBehavior.AllowGet)); } }
/// <summary> /// Registers the type mappings with the Unity container. /// </summary> /// <param name="container">The unity container to configure.</param> /// <remarks> /// There is no need to register concrete types such as controllers or /// API controllers (unless you want to change the defaults), as Unity /// allows resolving a concrete type even if it was not previously /// registered. /// </remarks> public static void RegisterTypes(IUnityContainer container) { // NOTE: To load from web.config uncomment the line below. // Make sure to add a Unity.Configuration to the using statements. // container.LoadConfiguration(); RegisterLoggerType(container); container.RegisterType <ApplicationContext>(); container.RegisterType <IIdentityMessageService, SendGridEmailService>(); container.RegisterType <ApplicationUserManager>( new InjectionFactory( c => ApplicationUserManager.Create( c.Resolve <ApplicationContext>(), c.Resolve <IIdentityMessageService>())) ); container.RegisterType <ApplicationRoleManager>( new InjectionFactory(c => ApplicationRoleManager.Create(c.Resolve <ApplicationContext>())) ); container.RegisterType <IAuthRepository, AuthRepository>(); container.RegisterType <IUserRepository, UserRepository>(); container.RegisterType <IDealRepository, DealRepository>(); container.RegisterType <IComplainRepository, ComplainRepository>(); container.RegisterType <IReportRepository, ReportRepository>(); container.RegisterType <IPhotoRepository, PhotoRepository>(); container.RegisterType <ICreditCardRepository, CreditCardRepository>(); container.RegisterType <IPushNotificationService, AndroidPushNotificationService>(); //container.RegisterType<OrdersController>(new InjectionConstructor()); }
public void PerformInitialSetup(ApplicationDbContext context) { var userMgr = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); var roleMgr = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); string roleName = "Administrator"; string userName = "******"; string password = "******"; string email = "*****@*****.**"; if (!roleMgr.RoleExists(roleName)) { roleMgr.Create(new ApplicationRole(roleName)); } ApplicationUser user = userMgr.FindByName(userName); if (user == null) { userMgr.Create(new ApplicationUser { UserName = userName, Email = email }, password); user = userMgr.FindByName(userName); } }
public bool CreateRole(string name) { var rm = new ApplicationRoleManager( new RoleStore<IdentityRole>(context)); var idResult = rm.Create(new IdentityRole(name)); return idResult.Succeeded; }
// Check if a role is exist if it is exist then private async Task <IdentityResult> AddUserRole(ApplicationUser user) { IdentityResult addtorole, roleexist = new IdentityResult(); var default_RoleName = DEFAULT_ROLE.MEMBER.ROLENAME; var default_RoleDescription = DEFAULT_ROLE.MEMBER.DESCRIPTIOIN; var role = RoleManager.FindByName(default_RoleName); if (role == null) { role = new ApplicationRole(); role.Name = default_RoleName; role.Description = default_RoleDescription; roleexist = RoleManager.Create(role); if (!roleexist.Succeeded) { return(roleexist); } else { addtorole = await UserManager.AddToRoleAsync(user.Id, default_RoleName); } } else { addtorole = await UserManager.AddToRoleAsync(user.Id, default_RoleName); } return(addtorole); }
private static void AddTestAccount(ApplicationUserManager userManager, ApplicationRoleManager roleManager, string password, string username, string rolename) { var adminRole = roleManager.FindByName(rolename); if (adminRole == null) { adminRole = new IdentityRole(rolename); var roleresult = roleManager.Create(adminRole); } var adminUser = userManager.FindByName(username); if (adminUser == null) { adminUser = new ApplicationUser { UserName = username, Email = username }; var result = userManager.Create(adminUser, password); result = userManager.SetLockoutEnabled(adminUser.Id, false); } var roleForUser = userManager.GetRoles(adminUser.Id); if (!roleForUser.Contains(adminRole.Name)) { var result = userManager.AddToRole(adminUser.Id, adminRole.Name); } }
protected override void Seed(Tamin.Models.ApplicationDbContext context) { ApplicationUserManager userMgr = new ApplicationUserManager(new UserStore <ApplicationUser>(context)); ApplicationRoleManager roleMgr = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context)); string roleName = "administrator"; string password = "******"; string email = "*****@*****.**"; if (!roleMgr.RoleExists(roleName)) { roleMgr.Create(new ApplicationRole(roleName)); } ApplicationUser user = userMgr.FindByName("supercoach"); if (user == null) { userMgr.Create(new ApplicationUser { UserName = "******", Email = email }, password); user = userMgr.FindByName("supercoach"); if (!userMgr.IsInRole(user.Id, roleName)) { userMgr.AddToRole(user.Id, roleName); } context.SaveChanges(); } }
private void CreateAdmin(ApplicationUserManager userManager, ApplicationRoleManager roleManager) { const string adminUser = "******"; const string adminEmail = "*****@*****.**"; const string roleName = "Admin"; var role = roleManager.FindByName(roleName); if (role == null) { role = new IdentityRole(roleName); roleManager.Create(role); } var user = userManager.FindByName(adminUser); if (user == null) { user = new ApplicationUser { UserName = adminUser, Email = adminEmail }; var result = userManager.Create(user, SecretKeys.Passwords.Admin); userManager.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = userManager.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var result = userManager.AddToRole(user.Id, role.Name); } }
public void CreateNewRole(Role model) { ApplicationRoleManager rm = new ApplicationRoleManager(new ApplicationRoleStore(new ApplicationDbContext())); rm.Create(new ApplicationRole(model.Name) { Id = Guid.NewGuid().ToString() }); }
public static void SeedIdentityForEF(ApplicationDbContext context) { if ((!context.Roles.Any()) && (!context.Users.Any())) { var roleStore = new ApplicationRoleStore(context); //var roleManager = new RoleManager<ApplicationRole, int>(roleStore); var roleManager = new ApplicationRoleManager(roleStore); var role = new ApplicationRole { Name = "Admin", Description = "Super Admin User group" }; roleManager.Create(role); var userStore = new UserStore<ApplicationUser, ApplicationRole, int, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>(context); var userManager = new ApplicationUserManager(userStore); var user = new ApplicationUser { Email = "*****@*****.**", UserName = "******", EmailConfirmed = true }; user.FirstName = "Jack"; user.LastName = "Smith"; userManager.Create(user, "P@ssword"); var result = userManager.SetLockoutEnabled(user.Id, false); userManager.AddToRole(user.Id, "Admin"); //added group manager var groupManager = new ApplicationGroupManager(roleManager,userManager); var newGroup = new ApplicationGroup("SuperAdmins", "Full Access to All"); groupManager.CreateGroup(newGroup); groupManager.SetUserGroups(user.Id, new int[] { newGroup.Id }); groupManager.SetGroupRoles(newGroup.Id, new string[] { role.Name }); } }