public async Task <IEnumerable <PermissionDto> > Handle(GetPermissionsQuery request, CancellationToken cancellationToken)
{
var username = request.Username.ToLowerInvariant();
var user = await _context.Users
.AsNoTracking()
.FirstOrDefaultAsync(u => u.UserName == username && u.IsEnabled, cancellationToken);
if (user == null)
{
throw new NotFoundException(nameof(user), username);
}
if (!user.IsEnabled)
{
throw new DisabledException(nameof(user), username);
}
var tmp = _context.Roles.Include(r => r.Users)
.Include(r => r.Applications).ToList();
var roles = await _context.Roles.AsNoTracking()
.Where(r => r.IsEnabled && r.Users.Any(u => u.User.UserName == user.UserName) &&
r.Applications.Any(a => a.Application.Name == request.ApplicationName && a.Application.IsEnabled))
.Include(r => r.Applications)
.ThenInclude(a => a.Permissions)
.ToListAsync(cancellationToken);
var permisions = new HashSet <Permission>(
roles
.SelectMany(r => r.Applications
.SelectMany(a => a.Permissions)));
cancellationToken.ThrowIfCancellationRequested();
var permisionDtos = permisions.Select(p => p.ToMap());
return(permisionDtos);
}
public async Task <IList <GetPermissionsModel> > Handle(GetPermissionsQuery request, CancellationToken cancellationToken)
{
return(await _context.Permissions.AsNoTracking().Select(permission => new GetPermissionsModel
{
Id = permission.Id,
Name = permission.Name
}).ToListAsync());
}
public Task <IEnumerable <RoleClaimViewModel> > Handle(GetPermissionsQuery request, CancellationToken cancellationToken)
{
return(Task.FromResult(Enum.GetNames(typeof(ApplicationPermissionSet))
.Select(x => new RoleClaimViewModel
{
RoleClaimType = ApplicationPermissions.ProductPermissionType,
RoleClaimDisplayName = typeof(ApplicationPermissionSet).GetMember(x)[0].GetCustomAttribute <DisplayAttribute>().Name,
RoleClaimValue = typeof(ApplicationPermissionSet).GetMember(x)[0].Name
})));
}
public async Task <IActionResult> ForId([FromQuery] GetPermissionsQuery query, int id, bool withtypePermission = false)
{
try
{
query.Id = id;
query.WithTypePermission = withtypePermission;
return(Ok(await _mediator.Send(query)));
}
catch (HttpRequestExceptionEx ex)
{
return(new NotFoundObjectResult(string.Format("Status code: {0} Message: {1}", ex.HttpCode, ex.Message)));
}
}
public async Task <IEnumerable <PermissionDto> > Handle(GetPermissionsQuery request, CancellationToken cancellationToken)
{
var app = await _context.Applications
.AsNoTracking()
.Include(a => a.Permissions)
.FirstOrDefaultAsync(u => u.Name == request.ApplicationName, cancellationToken);
if (app == null)
{
throw new NotFoundException(nameof(Domain.Applications.Application), request.ApplicationName);
}
cancellationToken.ThrowIfCancellationRequested();
var permisionDtos = app.Permissions.Select(p => p.ToMap());
return(permisionDtos);
}
public async Task When_UserGetPermissionsQuery_InputInValid_ThrowValidationException(GetPermissionsQuery query)
{
var mediator = ServiceProvider.GetService <IMediator>();
Func <Task <IEnumerable <PermissionDto> > > act = async() =>
{
var response = await mediator.Send(query);
return(response);
};
act.Should().Throw <ValidationException>();
}
public async Task <IActionResult> Get([FromQuery] GetPermissionsQuery query)
{
var result = await Mediator.Send(query);
return(Ok(result));
}
