public async Task <ActionResult> Update(RoleUpdateViewModel data)
{
if (ModelState.IsValid)
{
try
{
data.active = true;
data.modifiedBy = Session["user_id"].ToString();
data.modifiedDatetime = DateTime.Now;
client.BaseAddress = baseurl;
var postTask = await client.PostAsJsonAsync("/api/Roles/Update", data);
if (postTask.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Roles"));
}
else
{
ViewBag.Error = postTask.ReasonPhrase;
return(View("Update", ViewBag.Error));
}
}
catch (Exception e)
{
ViewBag.Error = e.Message;
return(View("Index", ViewBag.Error));
}
}
return(RedirectToActionPermanent("Index"));
}
/// <summary>
/// ویرایش یک نقش
/// </summary>
/// <param name="roleName"></param>
/// <param name="roleTitle"></param>
/// <returns></returns>
public void UpdateRole(RoleUpdateViewModel vm)
{
var model = Map(vm);
model.NormalizedName = vm.Name.Trim().ToUpper();
model.ConcurrencyStamp = Guid.NewGuid().ToString();
DbContext.SaveChanges();
}
public IActionResult Edit(List <UserAccessSubmitViewModel> vm, RoleUpdateViewModel role)
{
// ویرایش کردن نقش
_roleRepository.UpdateRole(role);
// اضافه کردن دسترسی های نقش جاری
_usersAccessRepository.UpdateAccessRole(vm, role.Id);
return(RedirectToAction("Index"));
}
public IActionResult UpdateRole(int id)
{
var role = _roleManager.Roles.FirstOrDefault(I => I.Id == id);
RoleUpdateViewModel model = new RoleUpdateViewModel
{
Id = role.Id,
Name = role.Name
};
return(View(model));
}
public async Task Put([FromBody] RoleUpdateViewModel model)
{
var entity = await _db.Role.FirstOrDefaultAsync(x => x.Id == model.Id);
if (null == entity)
{
throw new MessageException("角色不存在");
}
entity.Name = model.Name;
entity.RoleFunctions = BuildRoleFunctions(model, entity);
await _db.SaveChangesAsync();
}
public IActionResult UpdateRole(int id)
{
// _roleManager.FindByIdAsync string geliyor burada
var role = _roleManager.Roles.FirstOrDefault(I => I.Id == id);
RoleUpdateViewModel model = new RoleUpdateViewModel
{
Id = role.Id,
Name = role.Name
};
return(View(model));
}
public IActionResult RolGuncelle(string id)
{
var gosterilecekRol = _roleManager.FindByIdAsync(id).Result;
if (gosterilecekRol != null)
{
RoleUpdateViewModel model = new RoleUpdateViewModel
{
Id = gosterilecekRol.Id,
Name = gosterilecekRol.Name
};
return(View(model));
}
return(RedirectToAction("Roller", "Index"));
}
public async Task <IActionResult> Update(RoleUpdateViewModel model)
{
if (model.Id <= 0)
{
model.Id = await _roleService.Create(model.Name);
}
else
{
await _roleService.Update(model.Id, model.Name);
}
await _roleService.UpdateRolePermission(model.Id, model.PermissionNames);
return(Ok());
}
public async Task <IActionResult> UpdateRole(RoleUpdateViewModel model)
{
var tobeUpdatedRole = _roleManager.Roles.Where(I => I.Id == model.Id).FirstOrDefault();
tobeUpdatedRole.Name = model.Name;
var identityResult = await _roleManager.UpdateAsync(tobeUpdatedRole);
if (identityResult.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var error in identityResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
/// <summary>
/// ویرایش یک نقش
/// </summary>
/// <param name="roleName"></param>
/// <param name="roleTitle"></param>
/// <returns></returns>
public async Task <SweetAlertExtenstion> UpdateRole(RoleUpdateViewModel vm)
{
try
{
var entity = await GetByIdAsync(vm.Id);
entity.Name = vm.Name;
entity.RoleTitle = vm.RoleTitle;
entity.NormalizedName = vm.Name.Trim().ToUpper();
entity.ConcurrencyStamp = Guid.NewGuid().ToString();
await DbContext.SaveChangesAsync();
return(SweetAlertExtenstion.Ok());
}
catch (Exception e)
{
return(SweetAlertExtenstion.Error());
}
}
public IActionResult RolGuncelle(RoleUpdateViewModel model)
{
if (ModelState.IsValid)
{
var guncellenecekRol = _roleManager.FindByIdAsync(model.Id).Result;
guncellenecekRol.Name = model.Name;
var sonuc = _roleManager.UpdateAsync(guncellenecekRol).Result;
if (sonuc.Succeeded)
{
return(RedirectToAction("Roller", "Admin"));
}
else
{
foreach (var item in sonuc.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
return(View(model));
}
public async Task <ActionResult> Edit(string comp_id, string role_id)
{
if (comp_id != null && role_id != null)
{
RoleUpdateViewModel model = new RoleUpdateViewModel();
var postTask = await client.GetAsync("/api/Roles/View/?comp_id=" + comp_id + "&role_id=" + role_id);
model = await postTask.Content.ReadAsAsync <RoleUpdateViewModel>();
if (model != null)
{
return(View("Edit", model));
}
else
{
RoleIndexViewModel data = new RoleIndexViewModel();
ViewBag.Error = "No Role Found !";
return(View("Index", data));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task <IActionResult> Edit(List <UserAccessSubmitViewModel> vm, RoleUpdateViewModel role)
{
// ویرایش کردن نقش
var result = await _roleRepository.UpdateRole(role);
if (result.Succeed)
{
vm.Add(new UserAccessSubmitViewModel {
Actions = new List <string> {
"Index", "Profile"
}, Controller = "HomeController"
});
// اضافه کردن دسترسی های نقش جاری
TempData.AddResult(await _usersAccessRepository.UpdateAccessRole(vm, role.Id));
}
else
{
TempData.AddResult(result);
}
return(RedirectToAction("Index"));
}
