示例#1
0
        public async Task <ActionResult> DeleteConfirmed(string id, string deleteUser)
        {
            if (ModelState.IsValid)
            {
                if (id == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
                var role = await _roleManager.FindByIdAsync(id);

                if (role == null)
                {
                    return(HttpNotFound());
                }
                IdentityResult result;
                if (deleteUser != null)
                {
                    result = await _roleManager.DeleteAsync(role);
                }
                else
                {
                    result = await _roleManager.DeleteAsync(role);
                }
                if (!result.Succeeded)
                {
                    ModelState.AddModelError("", result.Errors.First());
                    return(View());
                }
                return(RedirectToAction("Index"));
            }
            return(View());
        }
示例#2
0
        // DELETE: Roles/Delete/5
        public async Task <IHttpActionResult> Delete(Guid id)
        {
            var role = _roleManager.Roles.SingleOrDefault(r => r.Id == id.ToString());
            await _roleManager.DeleteAsync(role);

            return(Ok(role));
        }
示例#3
0
        public async Task <string> DeleteRoleAsync(string roleName)
        {
            string message = string.Empty;

            try
            {
                ApplicationRole role = await roleManager.FindByNameAsync(roleName);

                if (role != null)
                {
                    // check whether the role is assigned to any existing users
                    if (role.Users.Count == 0)
                    {
                        await roleManager.DeleteAsync(role);

                        message = string.Format("Success : {0} role deleted successfuly", roleName);
                    }
                    else
                    {
                        message = string.Format("Warning : Role {0} cannot be deleted, as the role is assigned to {1} users", roleName, role.Users.Count);
                    }
                }
                else
                {
                    message = string.Format("Error : Role with such name - {0} does not exist", roleName);
                }
            }
            catch (Exception ex)
            {
                message = string.Format("Error : Exception occured at deleting role {0}", ex.Message);
            }
            return(message);
        }
        public async Task <string> Get(string roleName, string action)
        {
            var context     = ApplicationDbContext.Create();
            var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context));

            switch (action)
            {
            case createAction:
                if (roleManager.RoleExists(roleName))
                {
                    return("新增角色失败,该角色名称已存在");
                }
                await roleManager.CreateAsync(new ApplicationRole(roleName));

                return("新增角色成功");

            case deleteAction:
                if (!roleManager.RoleExists(roleName))
                {
                    return("删除角色失败,该角色名称不存在");
                }
                var role = roleManager.FindByName(roleName);
                await roleManager.DeleteAsync(role);

                return("删除角色成功");

            default:
                return("无效的操作指令");
            }
        }
示例#5
0
        public async Task <ActionResult> DeleteConfirm(string id)
        {
            var role = await RoleManager.FindByIdAsync(id);

            await _roleMangager.DeleteAsync(role);

            return(RedirectToAction("Index"));
        }
        public async Task <IdentityResult> DeleteRole(Guid id)
        {
            var identityRole = await _applicationRoleManager.FindByIdAsync(id.ToString());

            if (identityRole.Users.Count > 0)
            {
                return(new IdentityResult($"The {identityRole.Name} is in using."));
            }
            return(await _applicationRoleManager.DeleteAsync(identityRole));
        }
示例#7
0
        public async Task <ActionResult> Delete(string id)
        {
            var role = await _roleManager.FindByIdAsync(id);

            if (role != null)
            {
                IdentityResult result = await _roleManager.DeleteAsync(role);
            }
            return(RedirectToAction("Index"));
        }
示例#8
0
        public RemoveResultStatus Remove(int id)
        {
            var role   = _applicationRoleManager.FindByIdAsync(id).Result;
            var result = _applicationRoleManager.DeleteAsync(role);

            if (result.Result.Succeeded)
            {
                return(RemoveResultStatus.Success);
            }
            return(RemoveResultStatus.Failed);
        }
示例#9
0
        public override async Task RemoveAsync(object id)
        {
            if (!await ExistsAsync(id))
            {
                CustomException.ThrowNotFoundException($"There is no role with id = {id}.");
            }

            var role = await _roleManager.FindByIdAsync((string)id);

            await _roleManager.DeleteAsync(role);
        }
示例#10
0
        public async Task <JsonResult> DeleteRole(string role)
        {
            IdentityRole irole = await _roleManager.FindByNameAsync(role);

            if (irole != null)
            {
                await _roleManager.DeleteAsync(irole);
            }
            var model = _roleManager.Roles;

            return(Json(model));
        }
示例#11
0
        public async Task DeleteRoleAsync(RoleDTO role)
        {
            var existingRole = await _roleManager.FindByNameAsync(role.Name);

            if (existingRole != null)
            {
                await _roleManager.DeleteAsync(mapper.Map <IdentityRole>(existingRole));
            }
            else
            {
                throw new RoleException($"The role with name: {existingRole.Name} does not exist!");
            }
        }
示例#12
0
        public async Task <IHttpActionResult> DeleteRoleAsync(string id)
        {
            var role = await ApplicationRoleManager.FindByIdAsync(id);

            if (role == null)
            {
                return(NotFound());
            }

            var result = await ApplicationRoleManager.DeleteAsync(role);

            return(result.Succeeded ? Ok() : GetErrorResult(result));
        }
示例#13
0
        public async Task <IdentityResult> RemoveRoleAsync(string roleId)
        {
            var roleEntity = await _roleManager.FindByIdAsync(roleId);

            if (roleEntity == null)
            {
                throw new NotFoundException($"Could not locate entity with Id {roleId}");
            }

            var identityResult = await _roleManager.DeleteAsync(roleEntity);

            return(identityResult);
        }
示例#14
0
        public async Task <ActionResult> DeleteRoleConfirmed(string id, string deleteUser)
        {
            if (ModelState.IsValid)
            {
                if (id == null)
                {
                    return(View("Response", new ResponseViewModel()
                    {
                        Msg = "Record not found!"
                    }));
                }
                var role = await RoleManager.FindByIdAsync(id);

                if (role == null)
                {
                    return(View("Response", new ResponseViewModel()
                    {
                        Msg = "Record not found!"
                    }));
                }
                IdentityResult result;
                if (deleteUser != null)
                {
                    result = await RoleManager.DeleteAsync(role);
                }
                else
                {
                    result = await RoleManager.DeleteAsync(role);
                }
                if (!result.Succeeded)
                {
                    ModelState.AddModelError("", result.Errors.First());
                    return(View());
                }
                return(RedirectToAction("Index"));
            }
            return(View());
        }
示例#15
0
        public async Task <bool> DeleteRole(object roleId)
        {
            string id   = roleId.ToString();
            var    role = await roleManager.FindByIdAsync(id);

            if (role != null)
            {
                var result = await roleManager.DeleteAsync(role);

                return(result.Succeeded);
            }

            return(false);
        }
        public async Task <string> Get(string roleName)
        {
            var context     = ApplicationDbContext.Create();
            var roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context));

            if (!roleManager.RoleExists(roleName))
            {
                return("删除角色失败,该角色名称不存在");
            }
            var role = roleManager.FindByName(roleName);
            await roleManager.DeleteAsync(role);

            return("删除角色成功");
        }
示例#17
0
        public async Task <ActionResult> DeleteConfirmed(string id)
        {
            ApplicationRole applicationRole = await RoleManager.FindByIdAsync(id);

            if (applicationRole.Name == "Admin")
            {
                ModelState.AddModelError("", "You cannot delete the Admin role.");
                return(View(applicationRole));
            }

            await RoleManager.DeleteAsync(applicationRole);

            return(RedirectToAction("Index"));
        }
示例#18
0
        public async Task <bool> RemoveRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
        {
            ApplicationRole roleData = _roleManager.Roles.FirstOrDefault(x => x.Id == data.Id);

            ExtBusinessLogic.CheckRecord(roleData);

            // ReSharper disable once PossibleNullReferenceException
            roleData.ModifiedBy = ExtBusinessLogic.UserValue(claim);
            var result = await _roleManager.DeleteAsync(roleData);

            if (!result.Succeeded)
            {
                throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
            }

            return(true);
        }
        public async Task <IHttpActionResult> DeleteRole(string id)
        {
            var role = await roleManager.FindByIdAsync(id);

            if (role != null)
            {
                IdentityResult result = await roleManager.DeleteAsync(role);

                if (!result.Succeeded)
                {
                    return(NotFound());
                }

                return(Ok());
            }

            return(NotFound());
        }
示例#20
0
        public async Task <IHttpActionResult> DeleteRole(string id)
        {
            IdentityRole identityRole = await ApplicationRoleManager.FindByIdAsync(id);

            if (identityRole == null)
            {
                NotFound();
            }

            IdentityResult identityResult = await ApplicationRoleManager.DeleteAsync(identityRole);

            if (!identityResult.Succeeded)
            {
                return(GetErrorResult(identityResult));
            }

            return(Ok());
        }
示例#21
0
        public async Task<IdentityResult> DeleteRole(JObject deleteRole)
        {
            string roleName = ((dynamic)deleteRole).Name.Value;
            string roleId = ((dynamic)deleteRole).Id.Value;

            IdentityResult result = null;
            var roleStore = new RoleStore<IdentityRole>(_contextProvider.Context);
            var roleManager = new ApplicationRoleManager(roleStore);

            var role = await roleManager.FindByNameAsync(roleName);
            //var role = await roleManager.FindByIdAsync(roleId);
            if (role != null)
            {
                result = await roleManager.DeleteAsync(role);
            }

            return result;
        }
示例#22
0
        public async Task <ActionResult> Delete(string id)
        {
            var role = await _roleManager.FindByIdAsync(id);

            if (role == null)
            {
                return(NotFound());
            }

            var result = await _roleManager.DeleteAsync(role);

            if (!result.Succeeded)
            {
                throw new Exception($"Deleting role {id} failed on save.");
            }

            return(NoContent());
        }
示例#23
0
        public async Task <IHttpActionResult> DeleteRole(Guid Id)
        {
            var role = await _applicationRoleManager.FindByIdAsync(Id);

            if (role != null)
            {
                IdentityResult result = await _applicationRoleManager.DeleteAsync(role);

                if (!result.Succeeded)
                {
                    return(GetErrorResult(result));
                }

                return(Ok());
            }

            return(NotFound());
        }
示例#24
0
        public async Task <ActionResult> Delete(string id)
        {
            var role = await _roleManager.FindByIdAsync(id);

            if (role == null)
            {
                return(NotFound());
            }

            var result = await _roleManager.DeleteAsync(role);

            if (result.Succeeded)
            {
                return(NoContent());
            }

            return(BadRequest());
        }
        public async Task<string> Get(string roleName, string action)
        {
            var context = ApplicationDbContext.Create();
            var roleManager = new ApplicationRoleManager(new RoleStore<ApplicationRole>(context));
            switch (action)
            {
                case createAction:
                    if (roleManager.RoleExists(roleName)) return "新增角色失败,该角色名称已存在";
                    await roleManager.CreateAsync(new ApplicationRole(roleName));
                    return "新增角色成功";
                case deleteAction:
                    if (!roleManager.RoleExists(roleName)) return "删除角色失败,该角色名称不存在";
                    var role = roleManager.FindByName(roleName);
                    await roleManager.DeleteAsync(role);
                    return "删除角色成功";
                default:
                    return "无效的操作指令";
            }

        }
示例#26
0
        public async Task <IActionResult> DeleteRole(int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            ApplicationRole role = await rolemanager.FindByIdAsync(id.ToString());

            if (role == null)
            {
                return(NotFound());
            }

            IdentityResult result = await rolemanager.DeleteAsync(role);

            if (result.Succeeded)
            {
                return(Ok(role));
            }

            return(BadRequest(result.Errors));
        }
示例#27
0
        public async Task <object> DeleteRole(Guid roleId)
        {
            ResponseMessageModel message;
            var role = await _roleManager.FindByIdAsync(roleId.ToString());

            if (role == null)
            {
                message = new ResponseMessageModel
                {
                    Code = MessageCode.OBJECT_NOT_FOUND
                };
                return(message);
            }
            var result = await _roleManager.DeleteAsync(role);

            if (result.Succeeded)
            {
                message = new ResponseMessageModel
                {
                    Code = MessageCode.SUCCESS,
                };
                return(message);
            }
            //error occurs
            string errorMessage = "";

            foreach (var error in result.Errors)
            {
                errorMessage += error.Description + "\r\n";
            }
            message = new ResponseMessageModel
            {
                Code         = MessageCode.SQL_ACTION_ERROR,
                ErrorMessage = errorMessage
            };
            return(message);
        }
        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));
        }
示例#29
0
 public async Task <IdentityResult> DeleteAsync(IdentityRole role)
 {
     return(await _appRoleManager.DeleteAsync(role));
 }
        public async Task <Tuple <bool, string[]> > DeleteRoleAsync(ApplicationRole role)
        {
            var result = await _appRoleManager.DeleteAsync(role);

            return(Tuple.Create(result.Succeeded, result.Errors.ToArray()));
        }
示例#31
0
        public async Task Delete(string id)
        {
            var role = await RoleManager.FindByIdAsync(id);

            await RoleManager.DeleteAsync(role);
        }
 public async Task <IdentityResult> Remover(IdentityRole role)
 {
     return(await _roleManager.DeleteAsync(role));
 }