private FilterDefinition <User> BuildUsersQuery(SearchUsersFilters filters)
{
FilterDefinition <User> filter = null;
if (filters.IsActive != null)
{
filter = filter.FilterJoin(Builders <User> .Filter.Eq(x => x.Security.IsBlocked, !filters.IsActive));
}
if (string.IsNullOrWhiteSpace(filters.Role) == false && string.IsNullOrWhiteSpace(filters.PermissionKey) == false)
{
filter = filter.FilterJoin(Builders <User> .Filter
.ElemMatch(x => x.Roles, x => x.Keys.Contains(filters.PermissionKey) & x.Type == filters.Role));
}
else if (string.IsNullOrWhiteSpace(filters.Role) == false)
{
filter = filter.FilterJoin(Builders <User> .Filter.ElemMatch(x => x.Roles, x => x.Type == filters.Role));
}
else if (string.IsNullOrWhiteSpace(filters.PermissionKey) == false)
{
filter = filter.FilterJoin(Builders <User> .Filter.ElemMatch(x => x.Roles, x => x.Keys.Contains(filters.PermissionKey)));
}
if (string.IsNullOrWhiteSpace(filters.Keywords) == false)
{
var regexFilter = Regex.Escape(filters.Keywords);
var bsonRegex = new BsonRegularExpression(filters.Keywords, "i");
var name = Builders <User> .Filter.Regex(x => x.Name, bsonRegex);
var email = Builders <User> .Filter.Regex(x => x.Contacts.Email, bsonRegex);
var phone = Builders <User> .Filter.Regex(x => x.Contacts.Phone, bsonRegex);
var company = Builders <User> .Filter.Regex(x => x.Company, bsonRegex);
var keywordFilter = (name | company | email | phone);
filter = filter.FilterJoin(keywordFilter);
}
if (filter == null)
{
filter = Builders <User> .Filter.Empty;
}
return(filter);
}
public SearchContainer <User> ListUsers(SearchUsersFilters filters)
{
FilterDefinition <User> filter = this.BuildUsersQuery(filters);
var result = this.Collection.Find(filter)
.WithSorting(filters)
.WithPaging(filters).ToList();
return(new SearchContainer <User>()
{
Items = result,
Total = result.Count,
PageNumber = filters.PageNumber,
PageSize = filters.PageSize
});
}
public static SearchUsersFilters Map(SearchUsersRequest request)
{
SearchUsersFilters filters = new SearchUsersFilters
{
IsActive = request.IsActive,
Role = request.Role,
PermissionKey = request.PermissionKey,
PageSize = request.PageSize,
PageNumber = request.PageNumber,
SortField = request.SortField,
SortMode = request.SortMode.ToString(),
Keywords = request.Keywords
};
return(filters);
}
private static Func <QueryContainerDescriptor <UserIndex>, QueryContainer> BuildSearchUsersQuery(SearchUsersFilters filters)
{
var nameFilter = new QueryContainerDescriptor <UserIndex>()
.Match(m => m
.Field(f => f.Name)
.Analyzer("standard")
.Fuzziness(Fuzziness.Auto)
.Lenient()
.FuzzyTranspositions()
.Query(filters.Name));
var jobFilter = new QueryContainerDescriptor <UserIndex>()
.Match(m => m
.Field(f => f.Job)
.Analyzer("standard")
.Fuzziness(Fuzziness.Auto)
.Lenient()
.FuzzyTranspositions()
.Query(filters.Job));
Func <QueryContainerDescriptor <UserIndex>, QueryContainer> searchQuery = sq => sq;
if (!string.IsNullOrEmpty(filters.Name) && !string.IsNullOrEmpty(filters.Job))
{
searchQuery = sq => + nameFilter && jobFilter;
}
else
{
if (!string.IsNullOrEmpty(filters.Name))
{
searchQuery = sq => + nameFilter;
}
else
{
if (!string.IsNullOrEmpty(filters.Job))
{
searchQuery = sq => + jobFilter;
}
}
}
return(searchQuery);
}
public async Task <IEnumerable <UserSearchResponse> > SearchUserWithFiltersAsync(SearchUsersFilters filters)
{
SearchDescriptor <UserIndex> Search(SearchDescriptor <UserIndex> s) => s.From((filters.Page - 1) * filters.Limit)
.Size(filters.Limit)
.Index(IndexName)
.Type(TypeName);
var searchQuery = BuildSearchUsersQuery(filters);
var searchResponse = await this.client
.SearchAsync <UserIndex>(
s => Search(s)
.Query(searchQuery))
.ConfigureAwait(false);
return(searchResponse.Documents.Select(
d =>
new UserSearchResponse
{
Name = d.Name,
Job = d.Job,
Id = d.Id,
LastSnapshot = d.LastSnapshot
}));
}
public SearchUsersFilterBuilder Create(int page, int limit)
{
this.searchFilters = new SearchUsersFilters(page, limit);
return(this);
}
