/// <summary>
/// Performs searching
/// </summary>
public async Task <EsFound <TDoc> > SearchAsync(
string queryStr,
IEsSearchEngineStrategy <TDoc> strategy = null,
string filterKey = null,
string sortKey = null,
EsPaging paging = null,
CancellationToken cancellationToken = default)
{
var sp = new SearchParams <TDoc>(d => CreateSearchQuery(d, queryStr, filterKey, strategy))
{
Page = paging
};
if (!string.IsNullOrWhiteSpace(sortKey))
{
sp.Sort = GetSort(sortKey);
}
else
{
var defaultSort = strategy?.DefaultSort ?? DefaultSort;
if (defaultSort != null)
{
sp.Sort = defaultSort.Sort;
}
}
return(await _searcher.ForIndex(_indexName).SearchAsync(sp, cancellationToken));
}
/// <summary>
/// Initializes a new instance of <see cref="SearchEngine"/>
/// </summary>
public EsSearchEngine(IIndexNameProvider indexNameProvider, IEsSearcher <TDoc> searcher,
IEsSearchEngineStrategy <TDoc> defaultStrategy)
{
_indexName = indexNameProvider.Provide <TDoc>();
_searcher = searcher ?? throw new ArgumentNullException(nameof(searcher));
_defaultStrategy = defaultStrategy;
}
IEnumerable <Func <QueryContainerDescriptor <TDoc>, QueryContainer> > GetPropertySearch(string[] queryWords, IEsSearchEngineStrategy <TDoc> strategy)
{
var searchFuncs = new List <Func <QueryContainerDescriptor <TDoc>, QueryContainer> >();
if (queryWords.Length > 0)
{
var queryStr = string.Join(' ', queryWords);
var termProps = strategy.GetTermProperties().ToArray();
searchFuncs.Add(d =>
d.MultiMatch(mm =>
mm.Fields(termProps).Query(queryStr)));
foreach (var word in queryWords)
{
if (long.TryParse(word, out var longWord))
{
foreach (var numProperty in strategy.GetNumProperties())
{
searchFuncs.Add(d =>
d.Term(p =>
p.Field(numProperty).Value(longWord)
)
);
}
}
foreach (var termProperty in strategy.GetTermProperties())
{
searchFuncs.Add(d =>
d.Prefix(p =>
p.Field(termProperty).Value(word)
)
);
}
foreach (var textProperty in strategy.GetTextProperties())
{
searchFuncs.Add(d =>
d.Prefix(matchD =>
matchD.Field(textProperty).Value(word)
)
);
}
}
}
else
{
searchFuncs.Add(d => d.MatchAll());
}
return(searchFuncs);
}
private QueryContainer CreateSearchQuery(QueryContainerDescriptor <TDoc> d, string queryStr, string filterKey, IEsSearchEngineStrategy <TDoc> strategy)
{
var actualStrategy = strategy ?? _defaultStrategy;
if (actualStrategy == null)
{
throw new InvalidOperationException("Search strategy not specified");
}
var filters = new List <Func <QueryContainerDescriptor <TDoc>, QueryContainer> >(GetPredefinedFilters(actualStrategy));
IEnumerable <Func <QueryContainerDescriptor <TDoc>, QueryContainer> > propSearch = null;
if (!string.IsNullOrWhiteSpace(queryStr))
{
var words = queryStr
.Split(' ', StringSplitOptions.RemoveEmptyEntries)
.ToList();
filters.AddRange(ExtractFiltersAndRemoveWords(words, actualStrategy));
propSearch = GetPropertySearch(words.ToArray(), actualStrategy);
}
if (!string.IsNullOrWhiteSpace(filterKey))
{
var registeredFilter = GetFilter(filterKey);
if (registeredFilter != null)
{
filters.Add(registeredFilter);
}
}
else
{
var defaultFilter = actualStrategy.DefaultFilter ?? DefaultFilter;
if (defaultFilter != null)
{
filters.Add(defaultFilter.Filter);
}
}
return(d.Bool(boolSd =>
{
var cs = boolSd;
if (propSearch != null)
{
cs = cs.Should(propSearch).MinimumShouldMatch(1);
}
cs = cs.Filter(filters);
return cs;
}));
}
IEnumerable <Func <QueryContainerDescriptor <TDoc>, QueryContainer> > ExtractFiltersAndRemoveWords(List <string> words, IEsSearchEngineStrategy <TDoc> strategy)
{
foreach (var word in words.ToArray())
{
var filter = strategy.GetFilterFromQueryWord(word);
if (filter != null)
{
words.Remove(word);
yield return(filter.Filter);
}
}
}
IEnumerable <Func <QueryContainerDescriptor <TDoc>, QueryContainer> > GetPredefinedFilters(IEsSearchEngineStrategy <TDoc> strategy)
{
return(strategy
.GetPredefinedFilters()
.Select <IEsSearchFilter <TDoc>, Func <QueryContainerDescriptor <TDoc>, QueryContainer> >(filter =>
filter.Filter));
}
