/// <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()));
}
