public static void InternalSeed(CustomDbContext db) { var userManager = HttpContext.Current.GetOwinContext().GetUserManager<CustomUserManager>(); var roleManager = HttpContext.Current.GetOwinContext().Get<CustomRoleManager>(); const string name = "*****@*****.**"; 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 CustomRole(roleName); var roleresult = roleManager.Create(role); } var user = userManager.FindByName(name); if (user == null) { user = new CustomUser { 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); } }
public async Task <ActionResult> DeleteConfirmed(string id) { CustomRole customRole = await db.CustomRoles.FindAsync(id); db.CustomRoles.Remove(customRole); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public void SeedDatabase() { const string name = "*****@*****.**"; const string password = "******"; //const string roleName = "Admin"; const string privateName = "private"; const string protectName = "protect"; const string publicName = "public"; var privateRole = _roleManager.FindRoleByName(privateName); var protectRole = _roleManager.FindRoleByName(protectName); var publicRole = _roleManager.FindRoleByName(publicName); if (privateRole == null) { privateRole = new CustomRole(privateName); var privateResult = _roleManager.CreateRole(privateRole); } if (protectRole == null) { protectRole = new CustomRole(protectName); var protectResult = _roleManager.CreateRole(protectRole); } if (publicRole == null) { publicRole = new CustomRole(publicName); var publicResult = _roleManager.CreateRole(publicRole); } //Create Role Admin if it does not exist var user = this.FindByName(name); if (user == null) { user = new ApplicationUser { UserName = name, Email = name, EmailConfirmed = true, RegisterDate = DateTime.Now.Date, DateDisableUser = DateTime.Parse("2001/1/1") }; var result = this.Create(user, password); result = this.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = this.GetRoles(user.Id); if (!rolesForUser.Contains(privateRole.Name)) { var result = this.AddToRole(user.Id, privateRole.Name); } }
private void AddUsersAndRoles() { MAPContext context = new MAPContext(); var roleManager = new RoleManager <CustomRole, int>(new RoleStore <CustomRole, int, CustomUserRole>(context)); var UserManager = new UserManager <Users, int>(new UserStore <Users, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(context)); // In Startup iam creating first Admin Role and creating a default Admin User var role = new CustomRole(); if (!roleManager.RoleExists("Client")) { role.Name = "Client"; roleManager.Create(role); } if (!roleManager.RoleExists("Ressource")) { role.Name = "Ressource"; roleManager.Create(role); } if (!roleManager.RoleExists("Applicant")) { role.Name = "Applicant"; roleManager.Create(role); } if (!roleManager.RoleExists("Responsable")) { role.Name = "Responsable"; roleManager.Create(role); } if (!roleManager.RoleExists("SuperAdmin")) { role.Name = "SuperAdmin"; roleManager.Create(role); } if (UserManager.FindByName("SuperAdmin") == null) { var user = new Users { UserName = "******", Email = "*****@*****.**", Password = "******" }; var Password = "******"; var chkUser = UserManager.Create(user, Password); if (chkUser.Succeeded) { var result1 = UserManager.AddToRole(user.Id, "SuperAdmin") ; } } }
// In this method we will create default User roles and Admin user for login private void createRolesandUsers() { ApplicationDbContext context = new ApplicationDbContext(); var roleManager = new RoleManager <CustomRole, int>(new CustomRoleStore(context)); var UserManager = new UserManager <ApplicationUser, int>(new CustomUserStore(context)); // In Startup iam creating first Admin Role and creating a default Admin User if (!roleManager.RoleExists("Admin")) { // first we create Admin rool var role = new CustomRole(); role.Name = "Admin"; roleManager.Create(role); //Here we create a Admin super user who will maintain the website var user = new ApplicationUser(); user.UserName = ConfigurationManager.AppSettings["AdminUserName"]; user.Email = ConfigurationManager.AppSettings["AdminEmailId"]; var x = ConfigurationManager.GetSection("appSettings"); string userPWD = ConfigurationManager.AppSettings["AdminPassword"]; var chkUser = UserManager.Create(user, userPWD); //Add default User to Role Admin if (chkUser.Succeeded) { var result1 = UserManager.AddToRole(user.Id, "Admin"); } } // creating Creating Teacher role if (!roleManager.RoleExists("Teacher")) { var role = new CustomRole(); role.Name = "Teacher"; roleManager.Create(role); } // creating Creating Student role if (!roleManager.RoleExists("Student")) { var role = new CustomRole(); role.Name = "Student"; roleManager.Create(role); } // creating Creating Employee role if (!roleManager.RoleExists("Staff")) { var role = new CustomRole(); role.Name = "Staff"; roleManager.Create(role); } }
public ActionResult Edit([Bind(Include = "Id,Name")] CustomRole customRole) { if (ModelState.IsValid) { db.Entry(customRole).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(customRole)); }
public async Task <ActionResult> Edit(RoleViewModel model) { var role = new CustomRole() { Id = model.Id, Name = model.Name }; await RoleManager.UpdateAsync(role); return(RedirectToAction("Index")); }
/// <summary> /// Find a role by name /// </summary> /// <param name="roleName"/> /// <returns/> Task <CustomRole> IRoleStore <CustomRole, string> .FindByNameAsync(string roleName) { var role = databaseContext.Set <RoleAggregate>() .Single(x => x.Name == roleName); var customRole = CustomRole.Create( id: role.Id.ToString(), name: role.Name); return(Task.Run(() => { return customRole; })); }
public JsonResult Create(CustomRole Role) { context.Roles.Add(Role); context.SaveChanges(); var addedRole = context.Roles .Where(r => r.Name == Role.Name) .Select(r => new { r.Id, r.Name, r.Description }); return(Json(addedRole.FirstOrDefault())); }
public static CustomRoleIdentityQueryDTO From(CustomRole data) { return(new CustomRoleIdentityQueryDTO { Id = data.Id, Name = data.Name, Description = data.Description, AccessPointKeys = data.AccessPointKeys }); }
public Task UpdateAsync(CustomRole role) { var userAggregate = databaseContext .Set <RoleAggregate>() .SingleOrDefault(x => x.Id.ToString() == role.Id); // update logic return(databaseContext.SaveChangesAsync()); }
public void SeedDatabase() { const string name = "*****@*****.**"; const string password = "******"; const string roleName = "Admin"; //Create Role Admin if it does not exist var role = _roleManager.FindRoleByName(roleName); if (role == null) { role = new CustomRole(roleName); var roleResult = _roleManager.CreateRole(role); if (!roleResult.Succeeded) { throw new InvalidOperationException(string.Join(", ", roleResult.Errors)); } } try { var user = this.FindByName(name); if (user == null) { user = new User { UserName = name, Email = name }; var createResult = this.Create(user, password); if (!createResult.Succeeded) { throw new InvalidOperationException(string.Join(", ", createResult.Errors)); } var setLockoutResult = this.SetLockoutEnabled(user.Id, false); if (!setLockoutResult.Succeeded) { throw new InvalidOperationException(string.Join(", ", setLockoutResult.Errors)); } } // Add user admin to Role Admin if not already added var rolesForUser = this.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var addToRoleResult = this.AddToRole(user.Id, role.Name); if (!addToRoleResult.Succeeded) { throw new InvalidOperationException(string.Join(", ", addToRoleResult.Errors)); } } } catch (Exception) { throw; } }
public async Task <JsonResult> CreateRole([FromBody] CustomRole odata) { var response = "false"; try { if (odata.Id == null || odata.Id == "") { odata.Id = db.GenerateUniqueId(); odata.Name = odata.RoleName; var result = await roleManager.CreateAsync(odata); if (result.Succeeded) { response = "true"; } else { foreach (var error in result.Errors) { response = response + "," + error.Code; } } } else { var existing = await db.CustomRoleList.AsNoTracking().FirstOrDefaultAsync(x => x.Id == odata.Id); if (existing != null) { existing.RoleName = odata.RoleName; var result = await roleManager.UpdateAsync(existing); if (result.Succeeded) { response = "true"; } else { foreach (var error in result.Errors) { response = response + "," + error.Code; } } } } } catch (Exception ex) { throw ex; } return(Json(response)); }
public Task DeleteAsync(CustomRole role) { var roleAggregate = databaseContext .Set <RoleAggregate>() .Where(x => x.Id.ToString() == role.Id) .Single(); databaseContext.Set <RoleAggregate>().Remove(roleAggregate); return(databaseContext.SaveChangesAsync()); }
public async Task UpdateAsync(CustomRole entity) { var updateEntity = await _context.Roles.FirstOrDefaultAsync(r => r.Id == entity.Id); if (updateEntity is null) { throw new ArgumentException("Can't find a role by Id", "entity"); } updateEntity.UserRole = entity.UserRole; }
public ActionResult Create([Bind(Include = "Id,Name")] CustomRole customRole) { if (ModelState.IsValid) { db.Roles.Add(customRole); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(customRole)); }
/// <summary> /// Method SetAuthorize, mengatur autorisasi pengguna yang memiliki hak akses terhadap SFS /// </summary> private void SetAuthorize() { CustomAuthentication.CustomRole customeRole = new CustomRole(); bool isPPC = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.PPC); bool isAdmin = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.Administrator); bool isPE = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.PE); bool isForeman = customeRole.IsUserInRole(User.Identity.Name, Constants.RoleNames.Foreman); bool isInspector = customeRole.IsUserInRole(User.Identity.Name, RoleNames.Inspector); Session["IsViewOnly"] = isPPC || isAdmin || isPE || isForeman || isInspector; }
public static string ToFriendlyString(CustomRole role) { switch (role) { case CustomRole.User: return("@everyone"); case CustomRole.Moderator: return("Moderator"); } return(""); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new ApplicationUser { UserName = Input.Email, Email = Input.Email, Name = Input.Name, Surname = Input.Surname, PhoneNumber = Input.PhoneNumber }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); if (!_roleManager.RoleExistsAsync("Editor").Result) { CustomRole role = new CustomRole(); role.Name = "Editor"; await _roleManager.CreateAsync(role); await _userManager.AddToRoleAsync(user, role.Name); } else { _userManager.AddToRoleAsync(user, "Editor").Wait(); } //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); //var callbackUrl = Url.Page( // "/Account/ConfirmEmail", // pageHandler: null, // values: new { userId = user.Id, code = code }, // protocol: Request.Scheme); //await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", // $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); await _signInManager.SignInAsync(user, isPersistent : false); return(LocalRedirect(returnUrl)); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(Page()); }
// Post: Admin/Tag/Delete/id public virtual ActionResult Delete(int id) { CustomRole tag = _roleService.FindByIdAsync(id).Result; if (tag == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } _roleService.DeleteAsync(tag); _uow.SaveAllChanges(); return(Json(new { success = true })); }
// In this method we will create default User roles and Admin user for login private void createRolesandUsers() { ApplicationDbContext context = new ApplicationDbContext(); var roleManager = new RoleManager <CustomRole, int>(new CustomRoleStore(context)); var UserManager = new UserManager <ApplicationUser, int>(new CustomUserStore(context)); //// In Startup iam creating first Admin Role and creating a default Admin User //if (!roleManager.RoleExists("Admin")) //{ // // first we create Admin rool // var role = new CustomRole(); // role.Name = "Admin"; // roleManager.Create(role); // //Here we create a Admin super user who will maintain the website // var user = new ApplicationUser(); // user.UserName = "******"; // user.Email = "*****@*****.**"; // string userPWD = "A@Z200711"; // var chkUser = UserManager.Create(user, userPWD); // //Add default User to Role Admin // if (chkUser.Succeeded) // { // var result1 = UserManager.AddToRole(user.Id, "Admin"); // } //} // creating Creating Manager role if (!roleManager.RoleExists("Manager")) { var role = new CustomRole(); role.Name = "Manager"; roleManager.Create(role); } // creating Creating User role if (!roleManager.RoleExists("User")) { var role = new CustomRole(); role.Name = "User"; roleManager.Create(role); } }
public override void OnEnabled() { Singleton = this; CustomRole.RegisterRoles(); EventHandlers = new EventHandlers(this); Npc = new NestingObjects.Npc(this); Playable = new NestingObjects.Playable(this); Server.WaitingForPlayers += EventHandlers.OnWaitingForPlayers; Exiled.Events.Handlers.Player.SpawningRagdoll += EventHandlers.OnSpawningRagdoll; base.OnEnabled(); }
/// <inheritdoc /> public override void OnDisabled() { _harmony.UnpatchAll(_harmonyId); CustomItem.UnregisterItems(); CustomRole.RegisterRoles(); Exiled.Events.Handlers.Server.EndingRound -= EventHandlers.OnEndingRound; Exiled.Events.Handlers.Player.SpawningRagdoll -= EventHandlers.OnSpawningRagdoll; EventHandlers = null; Instance = null; base.OnDisabled(); }
public async Task <IActionResult> AddRole([Bind("Description,Id, Name")] CustomRole applicationRole) { applicationRole.DateCreated = DateTime.Now; if (ModelState.IsValid) { await _roleManager.CreateAsync(applicationRole); _context.Add(applicationRole); // await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(applicationRole)); }
public int AddRole(string name) { CustomRole role = new CustomRole { Name = name }; var result = _roleManager.CreateAsync(role).Result; if (result.Succeeded) { return(role.Id); } return(0); }
// GET: CustomRoles/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } CustomRole customRole = db.Roles.Find(id); if (customRole == null) { return(HttpNotFound()); } return(View(customRole)); }
// GET: CustomRoles/Details/5 public async Task <ActionResult> Details(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } CustomRole customRole = await db.CustomRoles.FindAsync(id); if (customRole == null) { return(HttpNotFound()); } return(View(customRole)); }
public async Task<ActionResult> Create(RoleViewModel roleViewModel) { if (ModelState.IsValid) { var role = new CustomRole(roleViewModel.Name); var roleresult = await RoleManager.CreateAsync(role); if (!roleresult.Succeeded) { ModelState.AddModelError("", roleresult.Errors.First()); return View(); } return RedirectToAction("Index"); } return View(); }
public async Task <ActionResult> Create(RoleViewModel roleViewModel) { if (ModelState.IsValid) { var role = new CustomRole(roleViewModel.Name); var roleresult = await _roleManager.CreateAsync(role).ConfigureAwait(false); if (!roleresult.Succeeded) { ModelState.AddModelError("", roleresult.Errors.First()); return(View()); } return(RedirectToAction("Index")); } return(View()); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new user { Email = model.Email, UserName = model.Email, fName = model.fName, AccountState = true, DTYPE = "user", //a ne plus toucher age = model.age, pwd = model.Password, //il va sauvgarder dans password la valeur entrer MyOrganization_id = null }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); CustomRole role = new CustomRole(user.DTYPE); var manage = HttpContext.GetOwinContext().GetUserManager <gloventdbContext>(); if (manage.Roles.Count(r => r.Name.Equals(user.DTYPE)) == 0) { manage.Roles.Add(role); manage.SaveChanges(); } UserManager.AddToRole(user.Id, user.DTYPE); // 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("Login", "Account")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public override void OnDisabled() { CustomRole.UnregisterRoles(); foreach (CoroutineHandle handle in EventHandlers.Coroutines) { Timing.KillCoroutines(handle); } EventHandlers.Coroutines.Clear(); Server.WaitingForPlayers -= EventHandlers.OnWaitingForPlayers; Exiled.Events.Handlers.Player.SpawningRagdoll -= EventHandlers.OnSpawningRagdoll; EventHandlers = null; Npc = null; Playable = null; base.OnDisabled(); }
public void SeedDatabase() { const string name = "*****@*****.**"; const string password = "******"; const string roleName = "Admin"; //Create Role Admin if it does not exist var role = _roleManager.FindRoleByName(roleName); if (role == null) { role = new CustomRole(roleName); var roleresult = _roleManager.CreateRole(role); } var user = this.FindByName(name); if (user == null) { user = new ApplicationUser { UserName = name, Email = name }; var result = this.Create(user, password); result = this.SetLockoutEnabled(user.Id, false); } // Add user admin to Role Admin if not already added var rolesForUser = this.GetRoles(user.Id); if (!rolesForUser.Contains(role.Name)) { var result = this.AddToRole(user.Id, role.Name); } //_postService.Create(new ViewModel.PostViewModel //{ // PostedByUserId = user.Id, // Body = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx", // AddedBy = "Kamal", // Title = "new title", // ViewNumber = 0 //}); }
public async Task<IHttpActionResult> AddRole(CreateRoleModel role) { CustomRole r = new CustomRole(role.NewRole); IdentityResult result = await RoleManager.CreateAsync(r); if (!result.Succeeded) { return GetErrorResult(result); } return Ok(); }
public async Task<ActionResult> RoleCreate(string roleName) { //RoleManager.CreateAsync(new CustomRole(roleName)); // Use ApplicationRole, not IdentityRole: var role = new CustomRole(roleName); var roleresult = await RoleManager.CreateAsync(role); if (roleresult.Succeeded) { ViewBag.ResultMessage = "Role created successfully !"; return RedirectToAction("RoleIndex", "Account"); } return RedirectToAction("Index", "Home"); }