/// <summary> /// 权限列表--分页及查询条件 /// </summary> /// <param name="filter"></param> /// <param name="totalCount"></param> /// <returns></returns> public IEnumerable <PermissionFunc> SearchFuncPermission(PermissionFilter filter, out int totalCount) { totalCount = 0; IEnumerable <PermissionFunc> dataList = null; var queryable = this.Repository.GetQueryable(false); if (filter != null) { if (!string.IsNullOrEmpty(filter.Code)) { queryable = queryable.Where(t => t.Code.Contains(filter.Code)); } if (!string.IsNullOrEmpty(filter.Name)) { queryable = queryable.Where(t => t.Name.Contains(filter.Name)); } } if (filter != null && filter.Start.HasValue && filter.Limit.HasValue) { totalCount = queryable.Count(); dataList = queryable.OrderBy(t => t.ID).Skip(filter.Start.Value).Take(filter.Limit.Value).ToArray(); } else { dataList = queryable.ToArray(); totalCount = dataList.Count(); } return(dataList); }
public async Task <int> Count(PermissionFilter filter) { IQueryable <PermissionDAO> Permissions = DataContext.Permission; Permissions = DynamicFilter(Permissions, filter); return(await Permissions.CountAsync()); }
public async Task <bool> ValidatePermission(Role Role) { foreach (var Permission in Role.Permissions) { PermissionFilter PermissionFilter = new PermissionFilter { Skip = 0, Take = 10, Code = new StringFilter { Equal = Permission.Code }, Selects = PermissionSelect.Code }; int count = await UOW.PermissionRepository.Count(PermissionFilter); if (count == 0) { Permission.AddError(nameof(RoleValidator), nameof(Permission.Code), ErrorCode.CodeNotExisted); } await ValidateMenu(Permission.Menu); } return(Role.Permissions.Any(s => !s.IsValidated) ? false : true); }
public List <Permission> GetAllPermissions(PermissionFilter filter, int pageIndex, int pageSize, out int totalCount) { string querySql = "SELECT \"row_number\"() OVER(ORDER BY p.\"CreateTime\" desc) \"rownum\", p.\"Id\",p.\"Name\",p.\"Description\",p.\"URL\",u.\"UserName\" as \"OperatorName\",p.\"CreateTime\",p.\"Remark\" from \"T_Permission\" p join \"T_User\" u on u.\"Id\"=p.\"OperatorId\""; string countSql = "SELECT COUNT (p.\"Id\") FROM \"T_Permission\" p join \"T_User\" u on u.\"Id\"=p.\"OperatorId\""; return(GetPagedData <Permission, PermissionFilter>(pageIndex, pageSize, out totalCount, countSql, querySql, filter)); }
private static ServiceQueryContext GetQueryContext(SnQuery query, IQueryContext context) { return(new ServiceQueryContext { UserId = context.UserId, FieldLevel = PermissionFilter.GetFieldLevel(query).ToString(), DynamicGroups = SystemAccount.Execute(() => Node.Load <User>(context.UserId)?.GetDynamicGroups(0)?.ToArray() ?? new int[0]) }); }
public override void OnActionExecuting(ActionExecutingContext filterContext) { // create and wire the actual filter // so in this way its lifetime is handled by us PermissionFilter permissionFilter = new PermissionFilter(); permissionFilter.OnActionExecuting(filterContext); base.OnActionExecuting(filterContext); }
public Permission(ulong?guildId, PermissionType type, bool isEnabled, string name, PermissionFilter filter, ulong?targetId) { GuildId = guildId; Type = type; IsEnabled = isEnabled; Name = name; Filter = filter; TargetId = targetId; }
public PagedActionResult <PermissionFunc> SearchFuncPermission([FromUri] PermissionFilter filter) { return(SafeGetPagedData <PermissionFunc>((result) => { int totalCount = 0; var temp = PermissionFuncService.SearchFuncPermission(filter, out totalCount); result.TotalCount = totalCount; result.Data = temp; })); }
public async Task <long> CountPermission([FromBody] Role_PermissionFilterDTO Role_PermissionFilterDTO) { PermissionFilter PermissionFilter = new PermissionFilter(); PermissionFilter.Id = Role_PermissionFilterDTO.Id; PermissionFilter.Code = Role_PermissionFilterDTO.Code; PermissionFilter.Name = Role_PermissionFilterDTO.Name; PermissionFilter.RoleId = Role_PermissionFilterDTO.RoleId; PermissionFilter.MenuId = Role_PermissionFilterDTO.MenuId; return(await PermissionService.Count(PermissionFilter)); }
public async Task <List <Permission> > List(PermissionFilter filter) { if (filter == null) { return(new List <Permission>()); } IQueryable <PermissionDAO> PermissionDAOs = DataContext.Permission.AsNoTracking(); PermissionDAOs = DynamicFilter(PermissionDAOs, filter); PermissionDAOs = DynamicOrder(PermissionDAOs, filter); List <Permission> Permissions = await DynamicSelect(PermissionDAOs, filter); return(Permissions); }
public async Task <bool> ValidateId(Permission Permission) { PermissionFilter PermissionFilter = new PermissionFilter { Skip = 0, Take = 10, Id = new IdFilter { Equal = Permission.Id }, Selects = PermissionSelect.Id }; int count = await UOW.PermissionRepository.Count(PermissionFilter); if (count == 0) { Permission.AddError(nameof(PermissionValidator), nameof(Permission.Id), ErrorCode.IdNotExisted); } return(count == 1); }
public IndexViewModel Create(HttpContext httpContext, PermissionFilter filter, IEnumerable <Permission> permissions, string orderBy, int skip, int take, int total) { IStringLocalizer <IndexViewModelFactory> localizer = httpContext.GetStringLocalizer <IndexViewModelFactory>(); return(new IndexViewModel() { Grid = new GridViewModelFactory().Create( httpContext, new FilterViewModelFactory().Create(httpContext, "Name.Contains", localizer["Name"]), orderBy, skip, take, total, new[] { new GridColumnViewModelFactory().Create(localizer["Name"], "Name"), new GridColumnViewModelFactory().Create(localizer["Position"], "Position"), new GridColumnViewModelFactory().CreateEmpty() }, permissions.Select(p => new PermissionViewModelFactory().Create(p)), "_Permission" ) }); }
public async Task <bool> ValidateCode(Permission Permission) { if (string.IsNullOrWhiteSpace(Permission.Code)) { Permission.AddError(nameof(PermissionValidator), nameof(Permission.Code), ErrorCode.CodeEmpty); } else { if (Permission.Code.Length > 255) { Permission.AddError(nameof(PermissionValidator), nameof(Permission.Code), ErrorCode.CodeOverLength); } PermissionFilter PermissionFilter = new PermissionFilter { Skip = 0, Take = 10, Id = new IdFilter { NotEqual = Permission.Id }, Code = new StringFilter { Equal = Permission.Code }, MenuId = new IdFilter { Equal = Permission.MenuId }, RoleId = new IdFilter { Equal = Permission.RoleId }, Selects = PermissionSelect.Code }; int count = await UOW.PermissionRepository.Count(PermissionFilter); if (count != 0) { Permission.AddError(nameof(PermissionValidator), nameof(Permission.Code), ErrorCode.CodeExisted); } } return(Permission.IsValidated); }
public async Task <int> Count(PermissionFilter PermissionFilter) { try { return(await UOW.PermissionRepository.Count(PermissionFilter)); } catch (Exception ex) { if (ex.InnerException == null) { await Logging.CreateSystemLog(ex, nameof(PermissionService)); throw new MessageException(ex); } else { await Logging.CreateSystemLog(ex.InnerException, nameof(PermissionService)); throw new MessageException(ex.InnerException); }; } }
public async Task <List <Role_PermissionDTO> > ListPermission([FromBody] Role_PermissionFilterDTO Role_PermissionFilterDTO) { PermissionFilter PermissionFilter = new PermissionFilter(); PermissionFilter.Skip = Role_PermissionFilterDTO.Skip; PermissionFilter.Take = Role_PermissionFilterDTO.Take; PermissionFilter.OrderBy = PermissionOrder.Id; PermissionFilter.OrderType = OrderType.ASC; PermissionFilter.Selects = PermissionSelect.ALL; PermissionFilter.Id = Role_PermissionFilterDTO.Id; PermissionFilter.Code = Role_PermissionFilterDTO.Code; PermissionFilter.Name = Role_PermissionFilterDTO.Name; PermissionFilter.RoleId = Role_PermissionFilterDTO.RoleId; PermissionFilter.MenuId = Role_PermissionFilterDTO.MenuId; List <Permission> Permissions = await PermissionService.List(PermissionFilter); List <Role_PermissionDTO> Role_PermissionDTOs = Permissions .Select(x => new Role_PermissionDTO(x)).ToList(); return(Role_PermissionDTOs); }
static Expression <Func <Entities.Entities.Permission, bool> > PredicateBuilderFunction(PermissionFilter filter) { var predicate = PredicateBuilder.New <Entities.Entities.Permission>(true); if (!string.IsNullOrWhiteSpace(filter.NameAr)) { predicate = predicate.And(b => b.NameAr.ToLower().Contains(filter.NameAr.ToLower())); } if (!string.IsNullOrWhiteSpace(filter.NameEn)) { predicate = predicate.And(b => b.NameEn.ToLower().Contains(filter.NameEn.ToLower())); } return(predicate); }
public async Task <IActionResult> Get(PermissionFilter filter, CancellationToken cancellationToken = default) { var groups = await authorizationAppService.FindPermissionBy(filter, cancellationToken); return(Ok(groups)); }
private async Task <List <Permission> > DynamicSelect(IQueryable <PermissionDAO> query, PermissionFilter filter) { List <Permission> Permissions = await query.Select(q => new Permission() { Id = filter.Selects.Contains(PermissionSelect.Id) ? q.Id : default(long), Code = filter.Selects.Contains(PermissionSelect.Code) ? q.Code : default(string), Name = filter.Selects.Contains(PermissionSelect.Name) ? q.Name : default(string), RoleId = filter.Selects.Contains(PermissionSelect.Role) ? q.RoleId : default(long), MenuId = filter.Selects.Contains(PermissionSelect.Menu) ? q.MenuId : default(long), StatusId = filter.Selects.Contains(PermissionSelect.Status) ? q.StatusId : default(long), Menu = filter.Selects.Contains(PermissionSelect.Menu) && q.Menu != null ? new Menu { Id = q.Menu.Id, Code = q.Menu.Code, Name = q.Menu.Name, Path = q.Menu.Path, IsDeleted = q.Menu.IsDeleted, } : null, Role = filter.Selects.Contains(PermissionSelect.Role) && q.Role != null ? new Role { Id = q.Role.Id, Code = q.Role.Code, Name = q.Role.Name, StatusId = q.StatusId } : null, }).ToListAsync(); if (filter.Selects.Contains(PermissionSelect.PermissionContent)) { List <long> Ids = Permissions.Select(x => x.Id).ToList(); List <PermissionContent> PermissionContents = await DataContext.PermissionContent .Where(x => Ids.Contains(x.PermissionId)) .Select(x => new PermissionContent { PermissionId = x.PermissionId, FieldId = x.FieldId, PermissionOperatorId = x.PermissionOperatorId, Value = x.Value, Id = x.Id }).ToListAsync(); List <PermissionActionMapping> PermissionActionMappings = await DataContext.PermissionActionMapping .Where(x => Ids.Contains(x.PermissionId)) .Select(x => new PermissionActionMapping { ActionId = x.ActionId, PermissionId = x.PermissionId, }).ToListAsync(); foreach (Permission Permission in Permissions) { Permission.PermissionContents = PermissionContents .Where(x => x.PermissionId == Permission.Id) .ToList(); Permission.PermissionActionMappings = PermissionActionMappings .Where(x => x.PermissionId == Permission.Id) .ToList(); } } return(Permissions); }
private IQueryable <PermissionDAO> DynamicOrder(IQueryable <PermissionDAO> query, PermissionFilter filter) { switch (filter.OrderType) { case OrderType.ASC: switch (filter.OrderBy) { case PermissionOrder.Id: query = query.OrderBy(q => q.Id); break; case PermissionOrder.Code: query = query.OrderBy(q => q.Code); break; case PermissionOrder.Name: query = query.OrderBy(q => q.Name); break; case PermissionOrder.Role: query = query.OrderBy(q => q.RoleId); break; case PermissionOrder.Menu: query = query.OrderBy(q => q.MenuId); break; case PermissionOrder.Status: query = query.OrderBy(q => q.StatusId); break; } break; case OrderType.DESC: switch (filter.OrderBy) { case PermissionOrder.Id: query = query.OrderByDescending(q => q.Id); break; case PermissionOrder.Code: query = query.OrderByDescending(q => q.Code); break; case PermissionOrder.Name: query = query.OrderByDescending(q => q.Name); break; case PermissionOrder.Role: query = query.OrderByDescending(q => q.RoleId); break; case PermissionOrder.Menu: query = query.OrderByDescending(q => q.MenuId); break; case PermissionOrder.Status: query = query.OrderByDescending(q => q.StatusId); break; } break; } query = query.Skip(filter.Skip).Take(filter.Take); return(query); }
public PermissionListRequestBuilder(PermissionFilter filter, FilterPager pager) : this() { this.Filter = filter; this.Pager = pager; }
public Task <IList <PermissionDto> > FindPermissionBy(PermissionFilter filter, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public static PermissionListRequestBuilder List(PermissionFilter filter = null, FilterPager pager = null) { return(new PermissionListRequestBuilder(filter, pager)); }
private IQueryable <PermissionDAO> DynamicFilter(IQueryable <PermissionDAO> query, PermissionFilter filter) { if (filter == null) { return(query.Where(q => false)); } if (filter.Id != null) { query = query.Where(q => q.Id, filter.Id); } if (filter.Code != null) { query = query.Where(q => q.Code, filter.Code); } if (filter.Name != null) { query = query.Where(q => q.Name, filter.Name); } if (filter.RoleId != null) { query = query.Where(q => q.RoleId, filter.RoleId); } if (filter.MenuId != null) { query = query.Where(q => q.MenuId, filter.MenuId); } if (filter.StatusId != null) { query = query.Where(q => q.StatusId, filter.StatusId); } query = OrFilter(query, filter); return(query); }
public EndpointPermissionFilter(EndpointFilter endpoint = null, PermissionFilter permission = null) { Endpoint = endpoint; Permission = permission; }
private IQueryable <PermissionDAO> OrFilter(IQueryable <PermissionDAO> query, PermissionFilter filter) { if (filter.OrFilter == null || filter.OrFilter.Count == 0) { return(query); } IQueryable <PermissionDAO> initQuery = query.Where(q => false); foreach (PermissionFilter PermissionFilter in filter.OrFilter) { IQueryable <PermissionDAO> queryable = query; if (PermissionFilter.Id != null) { queryable = queryable.Where(q => q.Id, PermissionFilter.Id); } if (PermissionFilter.Code != null) { queryable = queryable.Where(q => q.Code, PermissionFilter.Code); } if (PermissionFilter.Name != null) { queryable = queryable.Where(q => q.Name, PermissionFilter.Name); } if (PermissionFilter.RoleId != null) { queryable = queryable.Where(q => q.RoleId, PermissionFilter.RoleId); } if (PermissionFilter.MenuId != null) { queryable = queryable.Where(q => q.MenuId, PermissionFilter.MenuId); } if (PermissionFilter.StatusId != null) { queryable = queryable.Where(q => q.StatusId, PermissionFilter.StatusId); } initQuery = initQuery.Union(queryable); } return(initQuery); }
/// <summary> /// 获取权限列表 /// </summary> /// <param name="permissionFilter">权限筛选信息</param> /// <returns>返回权限列表</returns> public List <Permission> GetList(PermissionFilter permissionFilter) { return(GetList(permissionFilter?.CreateQuery())); }
private async ValueTask <AdminCommandResult> AddPermissionAsync(string name, bool isEnabled, PermissionFilter filter, ulong?targetId) { Permission permission; var type = Enum.Parse <PermissionType>(Context.Alias, true); if (type == PermissionType.Command) { var commandMatches = Commands.FindCommands(name); if (commandMatches.Count == 0) { return(CommandErrorLocalized("permissions_command_notfound")); } permission = new Permission(Context.Guild?.Id, type, isEnabled, string.Join(' ', commandMatches[0].Command.FullAliases[0]).ToLower(), filter, targetId); } else { if (!(Commands.GetAllModules() .FirstOrDefault(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) is { } module)) { return(CommandErrorLocalized("permissions_module_notfound")); } permission = new Permission(Context.Guild?.Id, type, isEnabled, module.Name.ToLower(), filter, targetId); } Context.Database.Permissions.Add(permission); await Context.Database.SaveChangesAsync(); var filterText = filter switch { PermissionFilter.Global => Context.Localize("permissions_global"), PermissionFilter.Guild => Context.Guild.Name.Sanitize(), PermissionFilter.Role => Context.Guild.GetRole(targetId.Value).Name.Sanitize(), PermissionFilter.Channel => Context.Guild.GetTextChannel(targetId.Value).Mention, PermissionFilter.User => Context.Guild.GetMember(targetId.Value)?.Tag.Sanitize() ?? "???", _ => throw new ArgumentOutOfRangeException() }; if (string.IsNullOrWhiteSpace(name)) { return(CommandSuccessLocalized(permission.IsEnabled ? "permissions_all_enabled" : "permissions_all_disabled", args: filterText)); } switch (permission.Type) { case PermissionType.Command: return(CommandSuccessLocalized(permission.IsEnabled ? "permissions_command_enabled" : "permissions_command_disabled", args: new object[] { Markdown.Code(permission.Name), Markdown.Bold(filterText) })); case PermissionType.Module: return(CommandSuccessLocalized(permission.IsEnabled ? "permissions_module_enabled" : "permissions_module_disabled", args: new object[] { Markdown.Code(permission.Name), Markdown.Bold(filterText) })); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// 获取权限对象 /// </summary> /// <param name="permissionFilter">权限对象筛选信息</param> /// <returns></returns> public Permission Get(PermissionFilter permissionFilter) { return(Get(permissionFilter?.CreateQuery())); }
public async Task <Permission[]> GetByFilter(PermissionFilter filter) { var permissions = await permissionRepository.FindByIds(filter.PermissionIds); return(mapper.Map <Permission[]>(permissions)); }
/// <summary> /// 返回权限分页 /// </summary> /// <param name="permissionFilter">权限筛选信息</param> /// <returns>返回权限分页</returns> public IPaging <Permission> GetPaging(PermissionFilter permissionFilter) { return(GetPaging(permissionFilter?.CreateQuery())); }