//GET
public async Task <IActionResult> DeleteRole(string id)
{
var role = await roleManager.FindByIdAsync(id);
var model = new DeleteRoleViewModel
{
Id = role.Id,
RoleName = role.Name
};
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found";
return(View("NotFound"));
}
else
{
var result = await roleManager.DeleteAsync(role);
if (result.Succeeded)
{
//ViewBag.ErrorMessage = $"Role with Rolename = {model.RoleName} deleted successfully";
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public ActionResult Delete(DeleteRoleViewModel model)
{
if (ModelState.IsValid)
{
// удаление роли
if (account.DeleteRole(model.roles))
{
// обновляем хранилище ролей
RoleConfig.RepositoryRoles();
// лог
logging.Logged(
"Info"
, "Пользователь '" + User.Identity.Name + "' удалил роль(и): " + string.Join(", ", model.roles.Select(x => x.Name.ToString()).ToArray())
, this.GetType().Namespace
, this.GetType().Name
);
return(Json(new { result = "Redirect", url = Url.Action("Group", "System") }));
}
else
{
ModelState.AddModelError("", "Не удалось удалить объекты");
}
}
else
{
ModelState.AddModelError("", "Ошибка, пожалуйста проверьте данные");
}
return(PartialView(model));
}
public async Task <IActionResult> Delete([FromRoute] string id, [Bind("Id,EditedTime,ConcurrencyStamp")][FromBody] DeleteRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(Failed());
}
if (model.Id.IsNullOrEmpty())
{
return(NotFound());
}
if (id != model.Id)
{
return(BadRequest());
}
//var role = await roleManager.FindByIdAsync(models.Id);
//if (role.EditedTime != models.EditedTime)
//{
// return Json(ResponseResult.Failed("并发失败，数据已经被修改"));
//}
var role = mapper.Map <IdentityRole>(model);
role.EditeUser = User.GetUserId();
var result = await roleManager.DeleteAsync(role);
return(Json(result));
}
public async Task <ActionResult> DeleteRole(DeleteRoleViewModel 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.DeleteAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> DeleteRole(string id)
{
DeleteRoleViewModel model = new DeleteRoleViewModel();
var role = await roleManager.FindByIdAsync(id);
model.Id = role.Id;
model.RoleName = role.Name;
return(View(model));
}
public IActionResult Delete(DeleteRoleViewModel model)
{
_roleAppService.DeleteRoleById(model.Id);
return(Json(new JsonResultEntity()
{
Message = "删除角色成功！",
JsonObject = Json(new { id = model.Id })
}));
}
public IActionResult Delete(int id, DeleteRoleViewModel model)
{
var role = _roleAppService.GetRoleById(id);
model = new DeleteRoleViewModel
{
Id = role.Id,
Name = role.Name
};
return(PartialView("_Delete", model));
}
// GET: Admin/Delete/5
public async Task <ActionResult> Delete(string id)
{
var role = await roleManager.FindByIdAsync(id);
var model = new DeleteRoleViewModel()
{
RoleName = role.Name, id = role.Id
};
return(View(model));
}
public async Task <IActionResult> Delete(DeleteRoleViewModel model)
{
var role = await _roleManager.FindByIdAsync(model.Id.ToString());
if (role == null)
{
return(NotFound(model.Id));
}
await _roleManager.DeleteAsync(role);
Notifier.Success("你已成功删除一条角色记录。");
return(RedirectToAction(nameof(List)));
}
public async Task <IActionResult> DeleteRole(DeleteRoleViewModel model)
{
if (ModelState.IsValid)
{
var role = await roleManager.FindByIdAsync(model.Id.ToString());
var result = await roleManager.DeleteAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListUsers", "Administration"));
}
}
return(View(model));
}
public async Task <ActionResult> Delete(DeleteRoleViewModel model)
{
var role = await _roleManager.FindByIdAsync(model.Id);
var result = await _roleManager.DeleteAsync(role);
if (result.Succeeded)
{
_logger.LogInformation($"Role {role} was successfully deleted!");
return(RedirectToAction("List", "Role"));
}
AddErrors(result);
return(View(model));
}
//
// GET: /Roles/Delete/5
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var role = await RoleManager.FindByIdAsync(id);
if (role == null)
{
return(HttpNotFound());
}
DeleteRoleViewModel deleteRoleViewModel = new DeleteRoleViewModel(role);
return(PartialView("Delete", deleteRoleViewModel));
}
// GET: Product/Delete/5
public async Task <ActionResult> DeleteRole(string 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 DeleteRoleViewModel
{
Id = role.Id,
RoleName = role.Name
};
return(View(model));
}
public async Task <IActionResult> Delete(DeleteRoleViewModel model)
{
var delrole = await roleManager.FindByIdAsync(model.RoleId);
if (delrole != null)
{
var result = await roleManager.DeleteAsync(delrole);
if (result.Succeeded)
{
return(RedirectToAction("index", "role"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
public ActionResult Delete(string json_string)
{
// экземпляр модели
DeleteRoleViewModel model = new DeleteRoleViewModel();
// объект из списка ролей для десерелизации
List <Role> roles = new List <Role>();
// десерелизация json_string
var props = json.Deserialize(json_string, roles.GetType());
// наполняем roles списком ролей с их свойствами
roles = (List <Role>)props;
// записываем список ролей в модель
model.roles = roles;
return(PartialView(model));
}
// DELETE api/gateway/deleterole
public async Task <IActionResult> DeleteRole(DeleteRoleViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
HttpParameters httpParameters = HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.DeleteRole),
HttpMethod.Delete,
string.Empty,
authorization
);
DeleteRoleResponse deleteRoleResult = await _gWService.PostTo <DeleteRoleResponse>(httpParameters);
if (deleteRoleResult.StatusCode == 404)
{
return(await ResponseService.GetResponse <NotFoundObjectResult, DeleteRoleResponse>(deleteRoleResult, ModelState));
}
else if (deleteRoleResult.StatusCode == 409)
{
return(await ResponseService.GetResponse <ConflictObjectResult, DeleteRoleResponse>(deleteRoleResult, ModelState));
}
else if (deleteRoleResult.StatusCode == 401)
{
return(await ResponseService.GetResponse <UnauthorizedObjectResult, DeleteRoleResponse>(deleteRoleResult, ModelState));
}
else if (deleteRoleResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, DeleteRoleResponse>(deleteRoleResult, ModelState));
}
return(new OkObjectResult(deleteRoleResult));
}
public async Task <IActionResult> DeleteRole([FromRoute] int id, [FromBody] DeleteRoleViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_logger = new LogHelper(_context, vm.UserID);
var role = await _context.Roles.SingleOrDefaultAsync(m => m.ID == id);
if (role == null)
{
return(NotFound());
}
_context.Roles.Remove(role);
await _context.SaveChangesAsync();
_logger.Log(Logger.Action.Delete, role.Name);
return(Ok(role));
}
public async Task <ActionResult> DeleteRole_POST(DeleteRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var role = await RoleManager.FindByNameAsync(model.Role);
if (role == null)
{
ModelState.AddModelError("Role",
$"The role '{model.Role}' does not exist!");
}
else
{
await RoleManager.DeleteAsync(role);
TempData["Message"] = $"Role '{model.Role}' deleted successfully!";
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Delete(DeleteRoleViewModel deleteRoleViewModel)
{
return(View(deleteRoleViewModel));
}
//Delete /api/auth/deleterole
public async Task <IActionResult> DeleteRole([FromBody] DeleteRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string roleId = model.RoleId.Trim();
string roleName = model.RoleName.Trim();
if (String.IsNullOrEmpty(roleId) || String.IsNullOrEmpty(roleName))
{
return(new JsonResult(await Errors
.GetGenericErrorResponse(
new DeleteRoleResponse()
{
RoleName = "no_id",
RoleId = "no_role_name",
StatusCode = 400,
Error = "Role id or role name is empty.",
Description = "Role id or role name is empty",
Code = "role_id_or_role_name_is_empty",
})));
}
if (!await _accountsService.RoleExists(roleName))
{
return(new JsonResult(await Errors
.GetGenericErrorResponse(
new DeleteRoleResponse()
{
RoleName = roleName,
RoleId = model.RoleId,
StatusCode = 404,
Error = "Role id or role name does not match a role.",
Description = "Role id or role name does not match a current role",
Code = "role_id_or_role_name_does_not_match_a_role",
})));
}
UsersInRole listOfUsersWithCurrentRole = await _accountsService.GetUsersInRole(roleName);
if (listOfUsersWithCurrentRole.IsNull)
{
return(new JsonResult(await Errors
.GetGenericErrorResponse(
new DeleteUserResponse()
{
Id = "no_id",
Email = "no_email",
StatusCode = 422,
Error = "Get users in role error",
Description = "Unable to get users in role.",
Code = "get_users_in_role_error",
})));
}
if (listOfUsersWithCurrentRole.User.Any())
{
return(new JsonResult(
await Errors
.GetGenericErrorResponse(
new DeleteRoleResponse()
{
RoleName = roleName,
RoleId = model.RoleId,
StatusCode = 409,
Error = "Role is beinging used by users",
Description = "Current role is being used by a user. Please remove dependencies before deleting this role.",
Code = "Conflict, role_is_being_used_by_users"
})));
}
IdentityRole roleToDelete = await _accountsService.GetRoleByName(roleName);
IdentityResult deleteRoleResult = await _accountsService.DeleteRole(roleToDelete);
if (!deleteRoleResult.Succeeded)
{
return(new JsonResult(await Errors
.GetGenericErrorResponse(
new DeleteRoleResponse()
{
RoleName = roleName,
RoleId = roleId,
StatusCode = 422,
Error = "Unable to complete delete operation",
Description = "Server was unable to delete the role.",
Code = "unable_to_complete_delete_operation"
})));
}
await _context.SaveChangesAsync();
return(new JsonResult(
Wrappyfier
.WrapDeleteRole(
roleToDelete.Id,
roleToDelete.Name,
200
)));
}
