public async Task <ActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { var roleFind = await RoleManager.FindByNameAsync(model.Name); if (roleFind != null) { ModelState.AddModelError("", "Role name has already exist. Please choose another role name."); return(View(model)); } var role = new IdentityRole { Name = model.Name }; var result = await RoleManager.CreateAsync(role); if (result.Succeeded) { return(RedirectToAction("Role")); } AddErrors(result); } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole role = new IdentityRole { Name = model.RoleName }; IdentityResult result = await roleManager.CreateAsync(role); if (result.Succeeded) { return(RedirectToAction("RolesList", "Administration")); } foreach (IdentityError error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole { Name = model.RoleName }; IdentityResult result = await roleManager.CreateAsync(identityRole); //zapisz do bazy danych if (result.Succeeded) { return(RedirectToAction("listroles", "administration")); } // jesli zapis sie nie powiedzie foreach (IdentityError error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel createRoleViewModel) { if (ModelState.IsValid) { var identityRole = new IdentityRole() { Name = createRoleViewModel.RoleName }; var result = await roleManager.CreateAsync(identityRole); if (result.Succeeded) { return(RedirectToAction("ListRole", "Administration")); } else { foreach (var item in result.Errors) { ModelState.AddModelError(null, item.Description); } } } return(View(createRoleViewModel)); }
public async Task <ActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole Role = new IdentityRole { Name = model.UserRole }; IdentityResult result = await roleManager.CreateAsync(Role); if (result.Succeeded) { return(RedirectToAction("ListRoles", "RolesAdmin")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, result.Errors.First()); //var errors = string.Join(",", result.Errors); //ModelState.AddModelError("", errors); } return(View(model)); } } //if (!roleresult.Succeeded) //{ // ModelState.AddModelError("", roleresult.Errors.First()); // return View(); //} //return RedirectToAction("Index"); return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { RoleCreateDto identityRole = new RoleCreateDto { Name = model.RoleName }; var result = await _userService.CreateRole(identityRole); if (result.IsSuccess) { return(RedirectToAction("ListRoles", "Admin")); } else { ModelState.AddModelError("", "No se pudo crear el Role"); throw new Exception("No se pudo crear el Role"); } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole() { Name = model.RoleName }; //如果您尝试创建具有已存在的同名的角色,则会收到验证错误 IdentityResult result = await roleManager.CreateAsync(identityRole); if (result.Succeeded) { return(RedirectToAction("ListRoles", "Admin")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <IActionResult> CreateRoleAsync(CreateRoleViewModel createRoleViewModel) { if (ModelState.IsValid) { Role identityRole = new Role() { Name = createRoleViewModel.RoleName, Description = createRoleViewModel.Description }; IdentityResult result = await _roleManager.CreateAsync(identityRole); if (result.Succeeded) { return(RedirectToAction("roleIndex", "administration")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(createRoleViewModel)); }
public async Task <ActionResult> Create(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityResult result = await RoleManager.CreateAsync(new Role { Name = model.Name, Description = model.Description }); if (result.Succeeded) { return(RedirectToAction("Index")); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error); } } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel createRoleViewModel) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole() { Name = createRoleViewModel.Name }; IdentityResult identityResult = await roleManager.CreateAsync(identityRole); if (identityResult.Succeeded) { return(RedirectToAction("ListRoles", "Administrator")); } else { foreach (IdentityError error in identityResult.Errors) { ModelState.AddModelError("", error.Description); } } } return(View(createRoleViewModel)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole { Name = model.RoleName }; IdentityResult result = await _roleManager.CreateAsync(identityRole); if (result.Succeeded) { return(RedirectToAction("ListRoles")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var newRole = new IdentityRole { Name = model.RoleName }; var result = await _roleManager.CreateAsync(newRole).ConfigureAwait(false); if (result.Succeeded) { return(RedirectToAction("ShowList")); } foreach (var err in result.Errors) { ModelState.AddModelError(err.Code, err.Description); } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { var role = new IdentityRole { Name = model.RoleName }; var result = await _roleManager.CreateAsync(role); if (result.Succeeded) { return(RedirectToAction("Index", "Home")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole { Name = model.RoleName }; IdentityResult result = await roleManager.CreateAsync(identityRole); if (result.Succeeded) { return(RedirectToAction("DisplayAllRoles", "Role")); } foreach (IdentityError error in result.Errors) { ModelState.AddModelError(String.Empty, error.Description); } } return(View("Views/Admin/Role/CreateRole.cshtml")); }
public async Task <IActionResult> EditRole(CreateRoleViewModel roleVieModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { ApplicationRole role = await _rolesRepository.FindRoleById(roleVieModel.RoleId); if (role == null) { return(Ok("Role not exist...")); } role.Name = roleVieModel.RoleName; IdentityResult result = await _rolesRepository.EditRole(role); //if (result.Succeeded) //{ // return Ok(result); //} //else //{ // return Ok("Not able to edit role"); //} return(Ok(result)); } catch (Exception x) { return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task<IActionResult> CreateRole(CreateRoleViewModel model) { if (ModelState.IsValid) { IdentityRole identityRole = new IdentityRole { Name = model.RoleName }; IdentityResult result = await roleManager.CreateAsync(identityRole); if (result.Succeeded) { return RedirectToAction("index", "home"); } foreach (IdentityError error in result.Errors) { ModelState.AddModelError("",error.Description); } } return View(); }
public async Task <IActionResult> Create(CreateRoleViewModel model) { if (ModelState.IsValid) { model.RoleName = model.RoleName.Trim(); if (await _roleManager.FindByNameAsync(model.RoleName) != null) { ModelState.AddModelError(string.Empty, T["The role is already used."]); } } if (ModelState.IsValid) { var role = new Role { RoleName = model.RoleName }; var result = await _roleManager.CreateAsync(role); if (result.Succeeded) { _notifier.Success(TH["Role created successfully"]); return(RedirectToAction(nameof(Index))); } _session.Cancel(); foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel createRoleViewModel) { if (ModelState.IsValid) { ApplicationRole applicationRole = new ApplicationRole { Name = createRoleViewModel.RoleName }; IdentityResult result = await _roleManager.CreateAsync(applicationRole); if (result.Succeeded) { return(View()); } foreach (IdentityError error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(createRoleViewModel)); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel model) { if (this.ModelState.IsValid) { ApplicationRole applicationRole = new ApplicationRole() { Name = model.RoleName, }; IdentityResult result = await this.roleManager.CreateAsync(applicationRole); if (result.Succeeded) { return(this.Redirect("Index")); } foreach (IdentityError error in result.Errors) { this.ModelState.AddModelError(string.Empty, error.Description); } } return(this.View(model)); }
public IActionResult CreateRole([FromBody] CreateRoleViewModel model) => OnAction(model, () => _systemUserRepo.CreateRole(model.Name, model.Description));
public async Task <IdentityResult> CreateRole(RoleManager <IdentityRole> roleManager, CreateRoleViewModel model) { IdentityRole identityRole = new IdentityRole { Name = model.RoleName }; IdentityResult result = await roleManager.CreateAsync(identityRole); return(result); }
public async Task <JsonResult> CreateRolePartialView(CreateRoleViewModel model) { if (!ModelState.IsValid) { return(Json(new { success = false, message = "Model is not valid" })); } var applicationRole = new GearRole { Name = model.Name, Title = model.Title, IsDeleted = model.IsDeleted, Created = DateTime.Now, Author = User.Identity.Name, ClientId = model.ClientId, }; var result = await _roleManager.CreateAsync(applicationRole); if (!result.Succeeded) { return(Json(new { success = false, message = "Error on create role" })); } var roleId = await _applicationDbContext.Roles.AsNoTracking() .SingleOrDefaultAsync(x => x.Name == model.Name); if (roleId == null) { return(Json(new { success = false, message = "Role not found!!!" })); } if (model.SelectedPermissionId.Any()) { foreach (var _ in model.SelectedPermissionId) { var permission = await _applicationDbContext.Permissions.SingleOrDefaultAsync(x => x.Id == Guid.Parse(_)); if (permission != null) { var newRolePermission = new RolePermission { RoleId = roleId.Id, PermissionId = permission.Id }; try { await _applicationDbContext.RolePermissions.AddAsync(newRolePermission); await _applicationDbContext.SaveChangesAsync(); } catch (Exception e) { _logger.LogError(e.Message); return(Json(new { success = false, message = "Error on save!" })); } } } } return(Json(new { success = true, message = "Save success!!!" })); }
public async Task <IActionResult> CreateRole(CreateRoleViewModel vm) { var result = await _roleManager.CreateAsync(new IdentityRole(vm.Name)); return(RedirectToAction("IndexRole")); }
public async Task <IActionResult> Create(CreateRoleViewModel model) { if (!ModelState.IsValid) { model.Clients = await ConfigurationDbContext.Clients.AsNoTracking().ToListAsync(); return(View(model)); } if (ApplicationRoleExists(model.Name)) { model.Clients = await ConfigurationDbContext.Clients.AsNoTracking().ToListAsync(); ModelState.AddModelError("", "Role with same name exist!"); return(View(model)); } var applicationRole = new GearRole { Name = model.Name, Title = model.Title, IsDeleted = model.IsDeleted, ClientId = model.ClientId, }; var result = await _roleManager.CreateAsync(applicationRole); var user = await _signInManager.UserManager.GetUserAsync(User); var client = ConfigurationDbContext.Clients.AsNoTracking().FirstOrDefault(x => x.Id.Equals(model.ClientId)) ?.ClientName; await _notify.SendNotificationAsync(new Notification { Content = $"{user?.UserName} created the role {applicationRole.Name} for {client}", Subject = "Info", NotificationTypeId = NotificationType.Info }); if (!result.Succeeded) { model.Clients = await ConfigurationDbContext.Clients.AsNoTracking().ToListAsync(); foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } else { var role = await _applicationDbContext.Roles.AsNoTracking().SingleOrDefaultAsync(m => m.Name == model.Name); if (role == null) { return(RedirectToAction(nameof(Index))); } if (model.SelectedPermissionId.Any()) { var listOfRolePermission = new List <RolePermission>(); foreach (var _ in model.SelectedPermissionId) { var permission = await _permissionsContext.Permissions.AsNoTracking() .SingleOrDefaultAsync(x => x.Id == Guid.Parse(_)); if (permission != null) { listOfRolePermission.Add(new RolePermission { PermissionId = permission.Id, RoleId = role.Id }); } } await _permissionsContext.RolePermissions.AddRangeAsync(listOfRolePermission); } try { await _permissionsContext.SaveChangesAsync(); await _permissionService.RefreshCacheByRoleAsync(applicationRole.Name); } catch (Exception e) { Console.WriteLine(e); } return(RedirectToAction(nameof(Index))); } return(View(model)); }
public async Task <IActionResult> Create(CreateRoleViewModel model) { var role = await this.roleManagerWrapper.CreateRoleAsync(model.Name); return(this.RedirectToAction(nameof(Index), "Role")); }
public ActionResult Create(CreateRoleViewModel roleAndFeature) { roleFeatureService.CreateRole(roleAndFeature); return(RedirectToAction("Index")); }
public IActionResult IsEnableRole([FromBody] CreateRoleViewModel model) => OnAction <CreateRoleViewModel, System.IsEnableDto>(model, _systemUserRepo.IsEnableRole);
public IActionResult Create() { var model = new CreateRoleViewModel(); return(View(model)); }
public async Task <RoleViewModel> Add(int appId, CreateRoleViewModel createRole) { return(await Add(appId, createRole.Name, createRole.Description, createRole.ModifiedBy)); }
public ActionResult Create(CreateRoleViewModel model) { if (ModelState.IsValid) { try { if (roleLogic.isRoleNameExists(model.Name)) { ModelState.AddModelError("", "Role name must be unique"); return(View(model)); } Role role = new Role { Name = model.Name }; db.Roles.Add(role); db.SaveChanges(); int roleid = db.Roles.OrderByDescending(r => r.ID).FirstOrDefault().ID; #region addingRoleClaimsToDatabase if (model.BranchMgt) { db.RoleClaims.Add(new RoleClaim { Name = "BranchMgt", RoleID = roleid }); } if (model.RoleMgt) { db.RoleClaims.Add(new RoleClaim { Name = "RoleMgt", RoleID = roleid }); } if (model.CustomerMgt) { db.RoleClaims.Add(new RoleClaim { Name = "CustomerMgt", RoleID = roleid }); } if (model.CustomerAccountMgt) { db.RoleClaims.Add(new RoleClaim { Name = "CustomerAccountMgt", RoleID = roleid }); } if (model.FinancialReport) { db.RoleClaims.Add(new RoleClaim { Name = "FinancialReport", RoleID = roleid }); } if (model.GLMgt) { db.RoleClaims.Add(new RoleClaim { Name = "GLMgt", RoleID = roleid }); } if (model.GLPosting) { db.RoleClaims.Add(new RoleClaim { Name = "GLPosting", RoleID = roleid }); } if (model.PostingAuth) { db.RoleClaims.Add(new RoleClaim { Name = "PostingAuth", RoleID = roleid }); } if (model.AccountConfigMgt) { db.RoleClaims.Add(new RoleClaim { Name = "AccountConfigMgt", RoleID = roleid }); } if (model.RunEOD) { db.RoleClaims.Add(new RoleClaim { Name = "RunEOD", RoleID = roleid }); } if (model.TellerMgt) { db.RoleClaims.Add(new RoleClaim { Name = "TellerMgt", RoleID = roleid }); } if (model.TellerPosting) { db.RoleClaims.Add(new RoleClaim { Name = "TellerPosting", RoleID = roleid }); } if (model.UserMgt) { db.RoleClaims.Add(new RoleClaim { Name = "UserMgt", RoleID = roleid }); } #endregion db.SaveChanges(); return(RedirectToAction("RoleClaims")); } catch (Exception ex) { ModelState.AddModelError("", ex.ToString()); return(View(model)); } } ModelState.AddModelError("", "Please enter valid data"); return(View(model)); }