public async Task <Paged <UserDto> > HandleAsync(BrowseUsers query)
{
var result = await _database.GetCollection <UserDocument>($"{Schema}.users")
.AsQueryable()
.OrderByDescending(x => x.CreatedAt)
.PaginateAsync(query);
var followers = new HashSet <Guid>();
if (query.UserId.HasValue)
{
var userId = query.UserId.Value;
followers = new HashSet <Guid>(await _database.GetCollection <FollowerDocument>($"{Schema}.followers")
.AsQueryable()
.Where(x => x.FollowerId == userId)
.Select(x => x.FolloweeId)
.ToListAsync());
}
var pagedResult = Paged <UserDto> .From(result, result.Items.Select(x => Map(x, followers)));
return(new Paged <UserDto>
{
CurrentPage = pagedResult.CurrentPage,
TotalPages = pagedResult.TotalPages,
ResultsPerPage = pagedResult.ResultsPerPage,
TotalResults = pagedResult.TotalResults,
Items = pagedResult.Items
});
}
public static IMongoQueryable <User> Query(this IMongoCollection <User> users,
BrowseUsers query)
{
var values = users.AsQueryable();
return(values.OrderBy(x => x.Name));
}
public async Task <IActionResult> Get()
{
var query = new BrowseUsers();
var result = await _userRepository.BrowseAsync(query);
return(Ok(result));
}
public async Task <IActionResult> Browse()
{
var query = new BrowseUsers();
var result = await _storageService
.BrowseUsersAsync(query)
.OrFailAsync();
return(Ok(result));
}
public async Task <IActionResult> Get([FromQuery] BrowseUsers query)
{
if (OrganisationId == Guid.Empty)
{
return(Forbid());
}
query.OrganisationId = OrganisationId;
var list = await _userService.BrowseOrgAsync(query);
return(Collection(list));
}
public async Task<List<UserDto>> BrowseOrgAsync(BrowseUsers query)
{
var list = await _repository.BrowseAsync();
list = list.Where(x => x.OrganisationId == query.OrganisationId);
if (!string.IsNullOrWhiteSpace(query.SearchString))
{
list = list.Where(x=>x.Email.ToLower().Contains(query.SearchString.ToLower()) ||
x.FirstName.ToLower().Contains(query.SearchString.ToLower()) ||
x.LastName.ToLower().Contains(query.SearchString.ToLower()));
}
return _mapper.Map<List<UserDto>>(list.ToList());
}
public void BrowseUsers_UsesQuery_ReturnsResultOfDispatch()
{
var query = new BrowseUsers();
var result = new Mock <IPagedResult <UserDto> >(MockBehavior.Strict).Object;
_dispatcherMock.Setup(d => d.QueryAsync(query)).ReturnsAsync(result).Verifiable();
var actionResult = _controller.BrowseUsers(query).GetAwaiter().GetResult();
Assert.AreEqual(result, actionResult);
_dispatcherMock.Verify();
}
public async Task<List<UserDto>> BrowseAdminAsync(BrowseUsers query)
{
var list = await _repository.BrowseAsync();
if (query.Role != null)
{
list = list.Where(x => x.Role == query.Role);
}
if (query.OrganisationId != null)
{
list = list.Where(x => x.OrganisationId == query.OrganisationId);
}
return _mapper.Map<List<UserDto>>(list.ToList());
}
public async Task <IActionResult> Browse()
{
var query = new BrowseUsers();
var users = await _userService.BrowseAsync(query);
var result = users
.Select(x => new UserDto
{
Id = x.Id,
Username = x.Username,
Email = x.Email,
Name = x.Name,
Lastname = x.Lastname,
Status = x.Status.ToString()
})
.ToList();
return(Ok(result));
}
public static async Task <IEnumerable <UserDto> > QueryAsync(this IMongoCollection <UserDto> users,
BrowseUsers query)
{
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 100;
}
var filterBuilder = new FilterDefinitionBuilder <UserDto>();
var filter = FilterDefinition <UserDto> .Empty;
var filteredRemarks = users.Find(filter);
var findResults = filteredRemarks
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results);
var result = await findResults.ToListAsync();
return(result);
}
protected static void Initialize()
{
UserId = "userId";
Username = "******";
Email = "*****@*****.**";
ExternalId = "externalId";
Provider = Providers.Collectively;
Password = "******";
Hash = "hash";
Role = Roles.User;
UserRepositoryMock = new Mock <IUserRepository>();
EncrypterMock = new Mock <IEncrypter>();
SecuredOperationServiceMock = new Mock <IOneTimeSecuredOperationService>();
UserService = new UserService(UserRepositoryMock.Object,
EncrypterMock.Object, SecuredOperationServiceMock.Object);
User = new User(UserId, Email, Role, Provider);
Query = new BrowseUsers();
Users = PagedResult <User> .Create(new [] { User }, 1, 1, 1, 1);
EncrypterMock.Setup(x => x.GetSalt(Moq.It.IsAny <string>())).Returns("salt");
EncrypterMock
.Setup(x => x.GetHash(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()))
.Returns(Hash);
}
public async Task <IEnumerable <UserDto> > BrowseAsync(BrowseUsers query)
{
return(await _database.Users().QueryAsync(query));
}
public async Task <Maybe <PagedResult <User> > > BrowseAsync(BrowseUsers query)
=> await _providerClient.GetCollectionAsync(
async() => await _userRepository.BrowseAsync(query));
public async Task <IPagedResult <UserDto> > BrowseUsers([FromQuery] BrowseUsers query) => await QueryAsync(query);
public async Task <Response <IEnumerable <UserDto> > > BrowseUsersAsync(BrowseUsers query)
=> await GetAsync <IEnumerable <UserDto> >("api/users");
public async Task <Maybe <PagedResult <UserInfo> > > BrowseAsync(BrowseUsers query) => await _storageClient.GetFilteredCollectionAsync <UserInfo, BrowseUsers>(query, "users");
public async Task <Maybe <PagedResult <T> > > BrowseAsync <T>(BrowseUsers query) where T : class
{
Logger.Debug($"Requesting BrowseAsync, page:{query.Page}, results:{query.Results}");
return(await _serviceClient.GetCollectionAsync <T>(_name, "users"));
}
public async Task <Maybe <PagedResult <dynamic> > > BrowseAsync(BrowseUsers query) => await BrowseAsync <dynamic>(query);
/// <inheritdoc />
public async Task <IEnumerable <User> > BrowseAsync(BrowseUsers query)
{
return(await _context.Users.ToListAsync());
}
public async Task <Maybe <PagedResult <User> > > BrowseAsync(BrowseUsers query) => await _userRepository.BrowseAsync(query);
public async Task <IActionResult> Get([FromQuery] BrowseUsers query)
{
var list = await _userService.BrowseAdminAsync(query);
return(Collection(list));
}
public async Task <IPagedResult <UserDto> > HandleAsync(BrowseUsers query)
{
var results = await _repository.BrowseAsync(query);
return(_mapper.Map <IPagedResult <UserDto> >(results));
}
public async Task <ActionResult <IPagedResult <User> > > BrowseUserSummaries([FromQuery] BrowseUsers query)
{
var pagedResult = await _usersService.BrowseUsers(query);
return(Collection(_mapper.Map <IPagedResult <User> >(pagedResult)));
}
public async Task <Maybe <PagedResult <User> > > BrowseAsync(BrowseUsers query) => await _database.Users() .Query(query) .PaginateAsync(query);
