protected override async Task <Paging <UserDto> > HandleEx(
SearchUsersQuery query, CancellationToken cancellationToken = default)
{
await Task.CompletedTask;
throw new System.NotImplementedException();
}
public void ReteivesAllUsersThatContainWordA()
{
var query = new SearchUsersQuery {
Keyword = "A"
};
Users.Where(query.AsQuery.Compile()).Should().HaveCount(3);
}
public void SearchWorksForPartOffLastName(string keyword)
{
var query = new SearchUsersQuery
{
Keyword = keyword
};
Users.Where(query.AsQuery.Compile()).Should().HaveCount(1);
}
public async Task <IEnumerable <UserVM> > Handle(SearchUsersQuery request, CancellationToken cancellationToken)
{
Expression <Func <User, bool> > whereExpresion = BuildExpresion(request);
var result = await _context.Users.AsNoTracking()
.Where(whereExpresion)
.ToMap(request.PageSize, request.Page)
.ToListAsync(cancellationToken);
return(result);
}
public IActionResult Get([FromServices] IUnitOfWork unitOfWork,
[FromServices] IQueryHandlerDispatcher queryHandlerDispatcher,
string criteria = "", int page = 1, int pageSize = 10)
{
var query = new SearchUsersQuery("corrid", criteria, page, pageSize, "", true);
var dto = queryHandlerDispatcher.Handle <SearchUsersQuery, PaginatedSearchedUserDto>(query);
return(Ok(dto));
}
public async Task <IActionResult> Get([FromQuery(Name = "email")] string email, CancellationToken token)
{
var query = new SearchUsersQuery
{
Email = email
};
var result = await _mediator.Send(query, token).ConfigureAwait(false);
return(Ok(result));
}
private Expression <Func <User, bool> > BuildExpresion(SearchUsersQuery request)
{
var normalizedName = request.UserName;
Expression <Func <User, bool> > whereExpresion = r => r.IsEnabled;
if (!string.IsNullOrWhiteSpace(normalizedName))
{
whereExpresion.And(r => r.UserName.Contains(normalizedName));
}
return(whereExpresion);
}
public IActionResult Get([FromQuery] SearchUsersQuery request)
{
try
{
return(Ok(Mediator.Send(request).Result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private Task <IResult> IsValidAsync(SearchUsersQuery query)
{
return(_validator
.Require <UserExistsRule>()
.WithOptions(x => x.StopIfFailed())
.WithData(query.CurrentUserId)
.Require <SearchTextLengthValidRule>()
.WithOptions(x => x.StopIfFailed())
.WithData(query.SearchText)
.Require <SkipTakeValuesValidRule>()
.WithOptions(x => x.StopIfFailed())
.WithData((query.Skip, query.Take))
.ValidateAsync());
}
public async Task <IEnumerable <UserViewModel> > Handle(SearchUsersQuery request, CancellationToken cancellationToken)
{
var users = await _dbContext.Users
.Where(x => EF.Functions.Like(x.Email, $"%{request.Email}%"))
.ToListAsync(cancellationToken).ConfigureAwait(false);
return(users.Select(x => new UserViewModel
{
Id = x.Id,
Email = x.Email,
IsEmailVerified = x.IsEmailVerified,
UpdatedAt = x.UpdatedAt
}));
}
public async Task <UserSearchResultsViewModel> Search(string queryString, int page, int pageSize = 20, OrderBy orderBy = OrderBy.UserName, OrderDirection orderDirection = OrderDirection.ASC)
{
// We don't use the GetAccountListQuery in the controller method otherwise Swagger tries to use a POST on our GET call
var accountListQuery = new SearchUsersQuery {
QueryString = queryString, Page = page, PageSize = pageSize, OrderBy = orderBy, OrderDirection = orderDirection
};
var result = await _mediator.Send(accountListQuery);
return(result);
//-----------------------------------------------------
// Uses Azure Search
//-----------------------------------------------------
}
public void Arrange()
{
_users = new Users {
UserCount = 123, UserList = new[] { new User(), new User() }
};
_query = new SearchUsersQuery {
Criteria = "xyz", PageNumber = 2, PageSize = 100
};
_userRepository = new Mock <IUserRepository>();
_userRepository.Setup(r => r.SearchUsers(_query.Criteria, _query.PageSize, _query.PageNumber)).ReturnsAsync(_users);
_handler = new SearchUsersQueryHandler(_userRepository.Object);
}
public IActionResult Search([FromQuery] string username, [FromQuery] string firstName, [FromQuery] string lastName, [FromQuery] int pageIndex = 0, [FromQuery] int pageSize = 10)
{
var request = new SearchUsersQuery
{
PageIndex = pageIndex,
PageSize = pageSize,
Username = username,
FirstName = firstName,
LastName = lastName
};
var response = _usersService.SearchUsers(request);
return(Ok(response));
}
public async Task <IActionResult> Search(
[FromQuery] string name = "",
[FromQuery] string job = "",
[FromQuery] int page = 1,
[FromQuery] int limit = 60)
{
// move parameters to object
var searchQuery = new SearchUsersQuery
{
Name = name,
Job = job,
Limit = limit,
Page = page
};
var searhResults = await this.searchQueryHandler.HandleAsync(searchQuery).ConfigureAwait(false);
return(this.Ok(searhResults));
}
public DataSourceResult SearchUsers(SearchUsersQuery request)
{
if (request == null)
{
throw new System.ArgumentNullException(nameof(request));
}
var query = _context.UserProfiles.Include(x => x.User).AsQueryable();
if (!string.IsNullOrEmpty(request.Username))
{
query = query.Where(x => x.User.Username.Contains(request.Username.ToLower()));
}
if (!string.IsNullOrEmpty(request.FirstName))
{
query = query.Where(x => x.FirstName.ToLower().Contains(request.FirstName.ToLower()));
}
if (!string.IsNullOrEmpty(request.LastName))
{
query = query.Where(x => x.LastName.ToLower().Contains(request.LastName.ToLower()));
}
query = query.OrderByDescending(x => x.CreatedOn);
var result = new PagedResult <UserProfile>(query, request.PageIndex, request.PageSize);
var response = new DataSourceResult
{
Data = result.AsQueryable().ProjectTo <UserDto>(_mapper.ConfigurationProvider),
HasPreviousPage = result.HasPreviousPage,
HasNextPage = result.HasNextPage,
PageIndex = result.PageIndex,
PageSize = result.PageSize,
RecordsFiltered = result.Count,
RecordsTotal = result.TotalCount,
TotalPages = result.TotalPages
};
return(response);
}
public async Task <ActionResult <SearchUsersQueryResult> > Search([FromQuery] SearchUsersQuery query, CancellationToken cancellationToken)
{
return(await Mediator.Send(query, cancellationToken));
}
public async Task <IResult <IReadOnlyCollection <UserProfileResponse> > > HandleAsync(SearchUsersQuery query)
{
var validationResult = await IsValidAsync(query);
if (validationResult.HasFailed())
{
return(validationResult.Map <IReadOnlyCollection <UserProfileResponse> >());
}
return((await _searchService
.SearchUsers(query.SearchText, query.CurrentUserId, query.Skip, query.Take))
.ToSuccessfulResult());
}
public async Task <IActionResult> Search([FromQuery] SearchUsersQuery searchQuery, CancellationToken cancellationToken)
{
var result = await Mediator.Send(searchQuery, cancellationToken);
return(Json(result));
}
public void RetreivesAllActiveUsersWhenNoKeywordIsSent()
{
var query = new SearchUsersQuery();
Users.Where(query.AsQuery.Compile()).Should().HaveCount(3);
}
