public async Task <IActionResult> OnGet(string roleId)
{
if (roleId == null)
{
return(RedirectToPage("./NotFound"));
}
var role = await this.serviceFactory.RolesService.GetById(roleId);
if (role == null)
{
return(RedirectToPage("./NotFound"));
}
EditRoleVm = new EditRoleVm();
EditRoleVm.Id = role.Id;
EditRoleVm.RoleName = role.Name;
foreach (var user in this.userManager.Users)
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
EditRoleVm.Users.Add(user.UserName);
}
}
return(Page());
}
public async Task <IActionResult> EditRole(string id)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Szerepkör ezzel az id-val: {id} nem található!";
return(View("NotFound"));
}
var model = new EditRoleVm
{
Id = role.Id,
RoleName = role.Name
};
foreach (var user in userManager.Users)
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
return(View(model));
}
public async Task <IActionResult> EditRole(EditRoleVm model)
{
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Szerepkör ezzel az id-val: {model.Id} nem található!";
return(View("NotFound"));
}
else
{
role.Name = model.RoleName;
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction(nameof(ListRoles)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> editRole(EditRoleVm role)
{
if (ModelState.IsValid)
{
var oldrole = await roleManager.FindByIdAsync(role.Id);
if (oldrole == null)
{
ModelState.AddModelError("", "Rold Not Found"); return(View("NotFound"));
}
else
{
oldrole.Name = role.RoleName;
}
var res = await roleManager.UpdateAsync(oldrole);
if (res.Succeeded)
{
// Update Role Users
return(RedirectToAction("RoleList", "Administration"));
}
else
{
foreach (var err in res.Errors)
{
ModelState.AddModelError("", err.Description);
}
return(View(role));
}
}
return(View(role));
}
public async Task <IActionResult> EditRole(EditRoleVm model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.Message = $"Role with id = {model.Id} not found.";
return(View("NotFound"));
}
role.Name = model.RoleName;
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
TempData["Success"] = $"Role '{role.Name}' was updated successfully.";
return(RedirectToAction("ListRoles"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(String.Empty, error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> EditRole(EditRoleVm model)
{
var role = await _roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannot be found";
return(View("NotFound"));
}
else
{
role.Name = model.RoleName;
// Update the Role using UpdateAsync
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> EditRole(string id)
{
// Find the role by Role ID
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found";
return(View("NotFound"));
}
var model = new EditRoleVm
{
Id = role.Id,
RoleName = role.Name
};
// Retrieve all the Users
foreach (var user in _userManager.Users)
{
// If the user is in this role, add the username to
// Users property of EditRoleViewModel. This model
// object is then passed to the view for display
if (await _userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
return(View(model));
}
public async Task <IActionResult> EditRole(EditRoleVm model)
{
// trouver le role que nous voulons modifié
var role = await roleManager.FindByIdAsync(model.Id);
role.Name = model.RoleName; // effectuer la modification
// Update le nouveau role
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
public async Task <IActionResult> EditRole(string id)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.Message = $"Role with id = {id} not found.";
return(View("NotFound"));
}
var model = new EditRoleVm {
Id = role.Id, RoleName = role.Name
};
foreach (var user in userManager.Users)
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
return(View(model));
}
public async Task <IActionResult> EditRole(string id)
{
// Nous recuperons le role de l'id recuperé via URL
var role = await roleManager.FindByIdAsync(id);
//Initialiser les propriétés de notre ViewModel avec le role que nous venons de récuperer
var model = new EditRoleVm
{
Id = role.Id,
RoleName = role.Name
};
//maintenant que les deux propriété sont connues , nous voulons la liste des users coreespondant a ce role
foreach (var user in userManager.Users)
{
// avec la methode de notre classe RoleManager IsInRole nous recuperons la liste des user correspondant a ce role
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);// et nous ajoutons les users trouvés a notre model ( pour le completer)
}
}
return(View(model));// retourner le model complet ( id,Nom,List(User))
}
