Beispiel #1
0
        public async Task <IResultModel> Delete(Guid id)
        {
            var exist = await _repository.ExistsAsync(id);

            if (!exist)
            {
                return(ResultModel.Failed("角色不存在"));
            }

            exist = await _accountRoleRepository.ExistsByRole(id);

            if (exist)
            {
                return(ResultModel.Failed("有账户绑定了该角色,请先删除对应绑定关系"));
            }

            _uow.BeginTransaction();
            var result = await _repository.SoftDeleteAsync(id);

            if (result)
            {
                result = await _roleMenuRepository.DeleteByRoleId(id);

                if (result)
                {
                    result = await _roleMenuButtonRepository.DeleteByRole(id);

                    if (result)
                    {
                        _uow.Commit();
                    }
                }
            }
            return(ResultModel.Result(result));
        }
Beispiel #2
0
        public async Task<IResultModel> Delete(Guid id)
        {
            var role = await _repository.GetAsync(id);
            if (role == null)
                return ResultModel.Failed("角色不存在");
            if (role.IsSpecified)
                return ResultModel.Failed("指定角色不允许删除");

            var exist = await _accountRoleRepository.ExistsByRole(id);
            if (exist)
                return ResultModel.Failed("有账户绑定了该角色,请先删除对应绑定关系");

            using (var uow = _dbContext.NewUnitOfWork())
            {
                var result = await _repository.SoftDeleteAsync(id, uow);
                if (result)
                {
                    result = await _roleMenuRepository.DeleteByRoleId(id, uow);
                    if (result)
                    {
                        result = await _roleMenuButtonRepository.DeleteByRole(id, uow);
                        if (result)
                        {
                            uow.Commit();
                        }
                    }
                }
                return ResultModel.Result(result);
            }
        }
Beispiel #3
0
        public async Task <IResultModel> Delete(Guid id)
        {
            var role = await _repository.GetAsync(id);

            if (role == null)
            {
                return(ResultModel.Failed("角色不存在"));
            }
            if (role.IsSpecified)
            {
                return(ResultModel.Failed("指定角色不允许删除"));
            }

            var exist = await _accountRoleRepository.ExistsByRole(id);

            if (exist)
            {
                return(ResultModel.Failed("有账户绑定了该角色,请先删除对应绑定关系"));
            }

            using (var tran = _repository.BeginTransaction())
            {
                var result = await _repository.SoftDeleteAsync(id, tran);

                if (result)
                {
                    result = await _roleMenuRepository.DeleteByRoleId(id, tran);

                    if (result)
                    {
                        result = await _roleMenuButtonRepository.DeleteByRole(id, tran);

                        if (result)
                        {
                            tran.Commit();
                        }
                    }
                }
                return(ResultModel.Result(result));
            }
        }
Beispiel #4
0
        public async Task <IResultModel> BindMenu(RoleMenuBindModel model)
        {
            var exists = await _repository.ExistsAsync(model.Id);

            if (!exists)
            {
                return(ResultModel.NotExists);
            }

            List <RoleMenu> entityList = null;

            if (model.Menus != null && model.Menus.Any())
            {
                entityList = model.Menus.Select(m => new RoleMenu {
                    RoleId = model.Id, MenuId = m
                }).ToList();
            }

            /*
             * 操作逻辑
             * 1、清除已有的绑定数据
             * 2、添加新的绑定数据
             */
            _uow.BeginTransaction();

            var clear = await _roleMenuRepository.DeleteByRoleId(model.Id);

            if (clear)
            {
                if (entityList == null || !entityList.Any() || await _roleMenuRepository.AddAsync(entityList))
                {
                    _uow.Commit();

                    await ClearAccountPermissionCache(model.Id);

                    return(ResultModel.Success());
                }
            }

            _uow.Rollback();
            return(ResultModel.Failed());
        }
        public IActionResult SetMenuPermissions([FromBody] SetMenuPermissionVModel model)
        {
            var result = new ResultModel();

            return(this.Wrapper(ref result, () => {
                _roleMenuRepository.DeleteByRoleId(model.roleId);

                var roleMenus = new List <RoleMenu>();
                model.menuIds?.ForEach(ea => {
                    roleMenus.Add(new RoleMenu()
                    {
                        RoleId = model.roleId,
                        MenuId = ea
                    });
                });
                if (roleMenus?.Any() ?? false)
                {
                    _roleMenuRepository.Add(roleMenus);
                }
            }, true));
        }