public ActionResult Edit(EditRoleModel model)
{
try
{
if (ModelState.IsValid)
{
ApplicationRole role = RoleManager.FindById(model.Id);
if (role != null)
{
role.Description = model.Description;
role.Name = model.Name;
IdentityResult result = RoleManager.Update(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Что-то пошло не так");
}
}
}
return(View(model));
}
catch (Exception e)
{
return(RedirectToAction("Index", "Error", new { error = e.Message }));
}
}
public async Task <ActionResult> Edit(EditRoleModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var role = await RoleManager.FindByIdAsync(model.Id);
if (role == null)
{
return(View(model));
}
role.Description = model.Description;
role.Name = model.Name;
var result = await RoleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Something went wrong...");
return(View(model));
}
public ActionResult EditRole(int id)
{
var model = new EditRoleModel();
try
{
var role = db.Roles.Where(r => r.RoleId == id).FirstOrDefault();
// create user model
if (role != null)
{
model.RoleId = role.RoleId;
model.RoleName = role.RoleName;
model.Description = role.Description;
}
else
{
ModelState.AddModelError("", "Chức danh có mã #" + id + " không tồn trong hệ thống!");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.ToString());
EventWriter.WriteEventLog("SystemController - EditUser: " + ex.ToString());
}
return(View(model));
}
public async Task <IActionResult> EditRole(EditRoleModel model)
{
var theRole = await roleManager.FindByIdAsync(model.Id);
if (theRole == null)//if the role is not in the database return error
{
ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannont be found";
return(View("NotFound"));
}
else
{
theRole.Name = model.RoleName;
var didUpdate = await roleManager.UpdateAsync(theRole);
if (didUpdate.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in didUpdate.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <ActionResult> Edit(EditRoleModel model)
{
if (ModelState.IsValid)
{
ExpenditureRole role = await RoleManager.FindByIdAsync(model.Id);
if (role != null)
{
role.Description = model.Description;
role.Name = model.Name;
IdentityResult result = await RoleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Something wrong");
}
}
}
return(View(model));
}
public async Task <IActionResult> EditRole(string id)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id ={id} cannot be found";
return(View("Error"));
}
var model = new EditRoleModel
{
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> EditConfirmAsync(string roleid, [Bind("Name")] EditRoleModel model)
{
if (roleid == null)
{
return(NotFound("Không tìm thấy role"));
}
var role = await _roleManager.FindByIdAsync(roleid);
if (role == null)
{
return(NotFound("Không tìm thấy role"));
}
model.Claims = await _context.RoleClaims.Where(rc => rc.RoleId == role.Id).ToListAsync();
model.role = role;
if (!ModelState.IsValid)
{
return(View(model));
}
role.Name = model.Name;
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
StatusMessage = $"Bạn vừa đổi tên: {model.Name}";
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError(result);
}
return(View(model));
}
// [Authorize(Roles = "Admin")]
public async Task <IActionResult> Edit(string id, RoleViewModelEdit model)
{
var role = new EditRoleModel {
Name = model.Name, Id = model.Id
};
if (id != role.Id)
{
return(BadRequest());
}
await roleService.Edit(role);
try
{
await roleService.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!RoleExists(id))
{
return(NotFound("Role's not found"));
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> EditRole(EditRoleModel model)
{
var role = await _roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Rola o Id = {model.Id} nie została odnaleziona";
return(View("NotFound"));
}
else
{
role.Name = model.RoleName;
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("RolesList"));
}
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.ErrorMessage = $"Rola o Id = {id} nie została odnaleziona";
return(View("NotFound"));
}
var model = new EditRoleModel
{
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)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"role with id = {id} cannot be found";
return(View("NotFound"));
}
else
{
var modeledit = new EditRoleModel
{
Id = role.Id,
RoleName = role.Name
};
foreach (var user in _userManager.Users.ToList())
{
if (await _userManager.IsInRoleAsync(user, role.Name))
{
modeledit.Users.Add(user.UserName);
}
}
return(View(modeledit));
}
}
public async Task <ActionResult> _Edit(EditRoleModel model)
{
var nameResponse = await WepApiMethod.SendApiAsync <bool>(HttpVerbs.Get, $"Administration/Role/IsRoleNameExist?id={model.Id}&name={model.Name}");
if (nameResponse.isSuccess)
{
TempData["ErrorMessage"] = "Role Name already registered in the system";
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
var response = await WepApiMethod.SendApiAsync <bool>(HttpVerbs.Put, $"Administration/Role", model);
if (response.isSuccess)
{
TempData["SuccessMessage"] = "Role successfully updated";
await LogActivity(Modules.Setting, "Update Role", model);
return(RedirectToAction("List"));
}
}
TempData["ErrorMessage"] = "Fail to update role";
return(RedirectToAction("List"));
}
//edit the role
private string EditRole(EditRoleModel model)
{
if (ModelState.IsValid)
{
ApplicationRole role = RoleManager.FindById(model.Id);
if (role != null)
{
role.Description = model.Description;
role.Name = model.Name;
IdentityResult result = RoleManager.Update(role);
if (result.Succeeded)
{
return("User role edited successfully");
}
else
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
}
//unite all errors in one string
return(string.Join(",",
ModelState.Values.Where(E => E.Errors.Count > 0)
.SelectMany(E => E.Errors)
.Select(E => E.ErrorMessage)
.ToArray()));
}
public async Task<IActionResult> EditRole(string id)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"The role '{id} cannot be found.";
return View("NotFound");
}
var model = new EditRoleModel
{
Id = role.Id,
Name = role.Name
};
// Retrieve all the Users
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 roleId)
{
ViewBag.roleId = roleId;
var role = await _roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with id={roleId} not found";
return(View("NotFound"));
}
var roleEdit = new EditRoleModel()
{
RoleId = role.Id,
RoleName = role.Name
};
foreach (var user in _userManager.Users.ToList())
{
if (await _userManager.IsInRoleAsync(user, role.Name))
{
roleEdit.Users.Add(user.UserName);
}
}
return(View(roleEdit));
}
public ActionResult Edit(Guid id)
{
try
{
var securityRoleInfo = this.AmiClient.GetRole(id.ToString());
if (securityRoleInfo == null)
{
TempData["error"] = Locale.RoleNotFound;
return(RedirectToAction("Index"));
}
var model = new EditRoleModel(securityRoleInfo)
{
PoliciesList = new List <SelectListItem>()
};
model.PoliciesList.AddRange(this.GetAllPolicies().ToSelectList("Name", "Id", null, true));
return(View(model));
}
catch (Exception e)
{
this.TempData["error"] = Locale.UnexpectedErrorMessage;
Trace.TraceError($"Unable to retrieve role: {e}");
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> EditRole(EditRoleModel model)
{
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Rola sa id = {model.Id} ne postoji! ";
return(RedirectToAction("ListRoles", "Administrator"));
}
else
{
role.Name = model.RoleName;
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administrator"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task EditRoleAsync(EditRoleModel model)
{
if (string.IsNullOrEmpty(model.Code))
{
throw new InvalidOperationException("代码为空");
}
if (string.IsNullOrEmpty(model.Name))
{
throw new InvalidOperationException("名称为空");
}
if (await _roleRepository.CountAsync(m => m.ID != model.ID && m.Code == model.Code) > 0)
{
throw new InvalidOperationException("代码重复");
}
Role roleFromDB = await _roleRepository.FirstOrDefaultAsync(model.ID);
if (roleFromDB == null)
{
throw new InvalidOperationException("角色不存在");
}
model.CopyProperties(roleFromDB);
await EditRoleActionAuthorities(roleFromDB, model.ActionAuthorityIDs);
await EditRoleAPIAuthorities(roleFromDB, model.APIAuthorityIDs);
await EditRoleWebMenuAuthorities(roleFromDB, model.WebMenuAuthorityIDs);
_authorityUnitOfWork.RegisterEdit(roleFromDB);
await _authorityUnitOfWork.CommitAsync();
_roleRepository.ClearCache();
}
public async Task <IActionResult> EditRole(EditRoleModel 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)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role With Id = {id} cannot be found";
return(View("Error"));
}
var model = new EditRoleModel
{
Id = role.Id,
RoleName = role.Name
};
//Gather all registered users
foreach (var user in userManager.Users)
{
//If the user in this role, add the username to Users in EditRoleModel
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
//Display the model object in the EditRole View
return(View(model));
}
public IActionResult Edit(EditRoleModel model)
{
var entity = model.MapTo <Role>();
var reuslt = _roleService.Edit(entity);
return(Json(reuslt));
}
public async Task <IActionResult> DeleteRole(EditRoleModel model)
{
var role = await _roleManager.FindByIdAsync(model.Id);
await _roleManager.DeleteAsync(role);
return(RedirectToAction("ListRoles"));
}
public async Task <IdentityResult> Edit(EditRoleModel model)
{
ApplicationRole role = await _roleManager.FindByIdAsync(model.Id);
role.Name = model.Name;
IdentityResult result = await _roleManager.UpdateAsync(role);
return(result);
}
public async Task EditRoleAsync(EditRoleModel model)
{
var result = await roleManager.FindByIdAsync(model.Id.ToString());
if (result != null)
{
result.Name = model.Name;
await roleManager.UpdateAsync(result);
}
}
public ActionResult EditRole(EditRoleModel user)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
if ((UserHelper.GetUserRole(User.Identity.Name) != "admin"))
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
pszczupakEntities ent = new pszczupakEntities();
Users u = new Users();
u = ent.Users.Where(x => x.id == user.id).FirstOrDefault();
u.role = user.role;
ent.Entry(ent.Users.Where(x => x.id == u.id).First()).CurrentValues.SetValues(u);
ent.SaveChanges();
return(RedirectToAction("UsersRole"));
}
else
{
pszczupakEntities ent = new pszczupakEntities();
Users u = ent.Users.Where(x => x.id == user.id).FirstOrDefault();
var b = new List <SelectListItem>
{
new SelectListItem {
Text = "admin", Value = "admin"
},
new SelectListItem {
Text = "manager", Value = "manager"
},
new SelectListItem {
Text = "worker", Value = "worker"
},
new SelectListItem {
Text = "user", Value = "user"
}
};
ViewData["Roles"] = b;
ViewBag.login = u.login;
return(View(user));
}
}
public async Task <ActionResult> Edit(EditRoleModel model)
{
if (ModelState.IsValid)
{
var role = Mapper.Map <EditRoleModel, RoleInfo>(model);
await _roleInfoService.UpdateAsync(role, role.Id);
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult _Edit(int id, string No, string Name, string Description)
{
var model = new EditRoleModel
{
Id = id,
No = No,
Name = Name,
Description = Description,
};
return(View(model));
}
public ActionResult Edit(EditRoleModel model)
{
if (ModelState.IsValid)
{
_roleService.EditRole(model);
return(Json(AjaxResult.Success()));
}
else
{
var erros = GetModelErrors();
return(Json(AjaxResult.Fail(erros)));
}
}
public async Task <IHttpActionResult> EditRole(EditRoleModel model)
{
try
{
await _userManager.ChangeUserRoleAsync(model.UserId, model.RoleId);
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public ActionResult EditRole(int?id)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
if ((UserHelper.GetUserRole(User.Identity.Name) != "admin"))
{
return(RedirectToAction("Index", "Home"));
}
if (id == null)
{
return(HttpNotFound());
}
pszczupakEntities ent = new pszczupakEntities();
var b = new List <SelectListItem>
{
new SelectListItem {
Text = "admin", Value = "admin"
},
new SelectListItem {
Text = "manager", Value = "manager"
},
new SelectListItem {
Text = "worker", Value = "worker"
},
new SelectListItem {
Text = "user", Value = "user"
}
};
ViewData["Roles"] = b;
Users u = ent.Users.Where(x => x.id == id).FirstOrDefault();
EditRoleModel user = new EditRoleModel();
ViewBag.login = u.login;
user.id = (int)id;
user.role = u.role;
return(View(user));
}
