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));
}
