public IEnumerable <News> FuzzySearchByFields(string searchQuery, List <string> fieldsName, int page)
{
var searchResponse = _elasticClient.Search <News>(s => s
.Query(q => q
.MultiMatch(mm => mm
.Fields(f => f.Fields(fieldsName.ToArray()))
.Query(searchQuery)
.Fuzziness(Fuzziness.EditDistance(1))
))
.From((page - 1) * PageSize)
.Size(PageSize));
return(searchResponse.Documents);
}
public IEnumerable <News> FuzzySearchByAllFields(string searchQuery, int page)
{
var searchResponse = _elasticClient.Search <News>(s => s
.Query(q => q
.Fuzzy(f => f
.Name(searchQuery)
.Fuzziness(Fuzziness.EditDistance(1))
.Transpositions(false))
)
.From((page - 1) * PageSize)
.Size(PageSize));
return(searchResponse.Documents);
}
public static OsobaEsSearchResult FulltextSearch(string query, int page, int pageSize, int?status = null)
{
string modifQ = Lib.Searching.SimpleQueryCreator
.GetSimpleQuery(query, new Searching.Rules.IRule[] { new Searching.Rules.RemoveAllOperators() })
.FullQuery();
if (string.IsNullOrWhiteSpace(modifQ))
{
return(new OsobaEsSearchResult()
{
OrigQuery = query,
Total = 0,
IsValid = true,
ElasticResults = null,
ElapsedTime = TimeSpan.Zero
});
}
page = page - 1 < 0 ? 0 : page - 1;
var sw = new Devmasters.DT.StopWatchEx();
sw.Start();
ISearchResponse <OsobaES> res = null;
try
{
int fuzzyDistance = 1;
if (status.HasValue)
{
res = _esClient
.Search <OsobaES>(s => s
.Size(pageSize)
.From(page * pageSize)
.Query(_query => _query
.Bool(_bool => _bool
.Must(_must => _must
.Fuzzy(_fuzzy => _fuzzy
.Field(_field => _field.FullName)
.Value(modifQ)
.Fuzziness(Fuzziness.EditDistance(fuzzyDistance))
) &&
_must.Term(_field => _field.Status, status.Value)
)
.Should(
_boostWomen => _boostWomen
.Match(_match => _match
.Field(_field => _field.FullName)
.Query(modifQ)
.Operator(Operator.And)
),
_boostExact => _boostExact
.Match(_match => _match
.Field("fullName.lower")
.Query(modifQ)
.Operator(Operator.And)
),
_boostAscii => _boostAscii
.Match(_match => _match
.Field("fullName.lowerascii")
.Query(modifQ)
.Operator(Operator.And)
)
)
)
)
.TrackTotalHits(true)
);
}
else
{
res = _esClient //.MultiSearch<OsobaES>(s => s
.Search <OsobaES>(s => s
.Size(pageSize)
.From(page * pageSize)
.Query(_query => _query
.MultiMatch(c => c
.Fields(f => f
.Field(p => p.FullName)
.Field("fullName.lower", 2)
.Field("fullName.lowerascii", 1.5)
)
.Type(TextQueryType.MostFields)
.Fuzziness(Fuzziness.EditDistance(fuzzyDistance))
.Query(modifQ)
.Operator(Operator.And)
)
)
.TrackTotalHits(true)
);
}
}
catch (Exception e)
{
Audit.Add(Audit.Operations.Search, "", "", "OsobaES", "error", query, null);
if (res != null && res.ServerError != null)
{
ES.Manager.LogQueryError <OsobaES>(res, "Exception, Orig query:"
+ query + " query:"
+ modifQ
, ex: e);
}
else
{
HlidacStatu.Util.Consts.Logger.Error("", e);
}
throw;
}
sw.Stop();
Audit.Add(Audit.Operations.Search, "", "", "OsobaES", res.IsValid ? "valid" : "invalid", query, null);
if (res.IsValid == false)
{
ES.Manager.LogQueryError <OsobaES>(res, "Exception, Orig query:"
+ query + " query:"
+ query
);
}
var search = new OsobaEsSearchResult
{
OrigQuery = query,
Total = res?.Total ?? 0,
IsValid = res?.IsValid ?? false,
ElasticResults = res,
ElapsedTime = sw.Elapsed
};
return(search);
}
public ISearchResponse <DocumentElastic> Search(
AutoCompleteSettingsElastic autoCompleteSettings,
SearchSettingsElastic searchSettings,
string text,
IEnumerable <string> documentObjectFieldNames,
string tagField,
IEnumerable <string> interPretedFields,
FilterElastic defaultFilter,
List <WeightElastic> defaultWeights
)
{
var sdesc = new SearchDescriptor <DocumentElastic>();
#region SEARCH
if (searchSettings?.Count > 0)
{
var queryContDesc = new QueryContainerDescriptor <DocumentElastic>();
var queryContainers = new List <QueryContainer>();
var searchFields = searchSettings.SearchFieldList.Select(f => MapDocumentObjectName(f)).ToArray();
//FILTER
if (searchSettings.UseDefaultFilter)
{
if (!string.IsNullOrEmpty(defaultFilter?.Query))
{
var modifiedQuery = documentObjectFieldNames?.Any() == true?
PrefixQueryFields(defaultFilter.Query, documentObjectFieldNames) :
defaultFilter.Query;
queryContainers.Add(queryContDesc.QueryString(q => q.Query(modifiedQuery)));
}
if (defaultFilter?.TagIdList?.Any() == true)
{
var shouldDesc = new BoolQueryDescriptor <DocumentElastic>();
foreach (var batchTagIds in defaultFilter.TagIdList.Batch(1000))
{
shouldDesc.Should(queryContDesc
.Terms(t => t
.Terms(batchTagIds)
.Field(MapDocumentObjectName(tagField))));
}
queryContainers.Add(queryContDesc.Bool(q => shouldDesc));
}
}
if (!string.IsNullOrEmpty(searchSettings.Filter?.Query))
{
var modifiedQuery = documentObjectFieldNames?.Any() == true?
PrefixQueryFields(searchSettings.Filter.Query, documentObjectFieldNames) :
searchSettings.Filter.Query;
queryContainers.Add(queryContDesc.QueryString(q => q.Query(modifiedQuery)));
}
if (searchSettings.Filter?.TagIdList?.Any() == true)
{
var shouldDesc = new BoolQueryDescriptor <DocumentElastic>();
foreach (var batchTagIds in searchSettings.Filter.TagIdList.Batch(1000))
{
shouldDesc.Should(queryContDesc
.Terms(t => t
.Terms(batchTagIds)
.Field(MapDocumentObjectName(tagField))));
}
queryContainers.Add(queryContDesc.Bool(q => shouldDesc));
}
// MATCH TYPE SEARCH
if (searchSettings.Type == (int)SDK.Net.Models.Enums.SearchTypeEnum.Match)
{
var mqd = new MultiMatchQueryDescriptor <DocumentElastic>()
.Query(text)
.Type(TextQueryType.BestFields)
.CutoffFrequency(searchSettings.CutOffFrequency)
.Fuzziness(searchSettings.Fuzziness < 0 ? Fuzziness.Auto : Fuzziness.EditDistance(searchSettings.Fuzziness))
.Fields(f => f.Fields(searchFields))
.Operator((Operator)searchSettings.Operator);
queryContainers.Add(queryContDesc.MultiMatch(q => mqd));
}
// QUERY(STRING) TYPE SEARCH
if (searchSettings.Type == (int)SDK.Net.Models.Enums.SearchTypeEnum.Query)
{
var modifiedQuery = documentObjectFieldNames?.Any() == true?
PrefixQueryFields(text, documentObjectFieldNames) :
text;
var qsd = new QueryStringQueryDescriptor <DocumentElastic>()
.Query(text)
//cutoff_frequency is not supported for querystring query
//.CutoffFrequency(searchSettings.CutOffFrequency)
.Fuzziness(searchSettings.Fuzziness < 0 ? Fuzziness.Auto : Fuzziness.EditDistance(searchSettings.Fuzziness))
.Fields(f => f.Fields(searchFields))
.DefaultOperator((Operator)searchSettings.Operator);
queryContainers.Add(queryContDesc.QueryString(q => qsd));
}
// WEIGHTS
// a REAL _should_ query, if we just add to the queryContainer then at least one of this condition must satisfied
var weights = new List <WeightElastic>();
if (searchSettings.UseDefaultWeights && (defaultWeights?.Any() == true))
{
weights.AddRange(defaultWeights);
}
if (searchSettings.Weights?.Any() == true)
{
weights.AddRange(searchSettings.Weights);
}
if (weights.Any())
{
var shouldQuery = string.Join(" ", weights.Select(k => $"({k.Query})^{k.Value}"));
var modifiedQuery = documentObjectFieldNames?.Any() == true?
PrefixQueryFields(shouldQuery, documentObjectFieldNames) :
shouldQuery;
sdesc.Query(q => q.Bool(b => b
.Must(queryContainers.ToArray())
.Should(sq => sq.QueryString(qs => qs.Query(modifiedQuery)))));
}
else
{
sdesc.Query(q => q.Bool(b => b.Must(queryContainers.ToArray())));
}
// ORDER
if (!string.IsNullOrEmpty(searchSettings.Order?.OrderByField))
{
var fieldName = MapDocumentObjectName(searchSettings.Order.OrderByField);
if (interPretedFields != null && interPretedFields.Contains(searchSettings.Order.OrderByField))
{
fieldName += ".raw";
}
sdesc.Sort(s => (int)SortOrder.Descending == searchSettings.Order.OrderDirection ? s.Descending(fieldName) : s.Ascending(fieldName));
}
// COUNT
sdesc.Size(searchSettings.Count);
ApplyDocumentFieldFilter(sdesc, searchSettings.ResponseFieldList.Select(f => MapDocumentObjectName(f)));
}
else
{
sdesc.Size(0);
}
#endregion
#region SUGGEST
if (autoCompleteSettings?.Count > 0)
{
var psgd = new PhraseSuggesterDescriptor <DocumentElastic>()
.Field(DocumentElastic.TextField)
.Size(autoCompleteSettings.Count)
//.RealWordErrorLikelihood(0.95), 0.95 is the default value
.Confidence(autoCompleteSettings.Confidence)
.MaxErrors(autoCompleteSettings.MaximumErrors)
.DirectGenerator(dg => dg
.Field(DocumentElastic.TextField)
.SuggestMode(SuggestMode.Always)
.MinWordLength(3)
.MinDocFrequency(3)
.Size(1))
.Collate(c => c
.Prune()
.Query(q => q
//unfortunately Params is not working here so had to hack the text field like this
.Inline($"{{\"match\": {{\"{DocumentElastic.TextField}\" : {{\"query\": \"{{{{suggestion}}}}\", \"operator\": \"and\"}}}}}}")
)
)
.Text(text);
sdesc.Suggest(s => s.Phrase(SuggestName, p => psgd));
}
#endregion
var resp = Client.Search <DocumentElastic>(sdesc);
ResponseValidator(resp);
return(resp);
}
public ISearchResponse <WebsiteInfo> FullTextSearch(string searchedContent, SearchPagination pagination)
{
var searchResult = client.Search <WebsiteInfo>(s => s
.Index(Constants.VISITED_WEBSITES_INDEX)
.Type(mapping)
.From(pagination.From)
.Size(pagination.Take)
.Query(q => q
.Bool(b => b
.Must(
m => m.MultiMatch(w => w
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta").Field("Paragraphs"))
.Query(searchedContent)
.Fuzziness(Fuzziness.EditDistance(2)))
, m => m.Term(t => t.Language, "en")
)
//.Should(m => m.Term(t => t.Language, "en"))
)
)
.Highlight(h => h
.PreTags("<b>").PostTags("</b>")
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta").Field("Paragraphs"))
)
);
return(searchResult);
}
public QueryContainer BuildQuery(
QueryContainerDescriptor <ProductDocument> qc,
SearchQuery searchQuery,
IDictionary <string, ISet <string> > tags = null,
bool addPriceFilterTags = false,
bool addNewsFilterTags = false,
bool addCategoryFilterTags = false,
bool addDefaultQuery = true)
{
var allQueries = new List <QueryContainer>();
if (addDefaultQuery)
{
allQueries.Add(qc.PublishedOnChannel());
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.Assortments).Value(_assortmentSystemId.Value)))));
if (_personStorage.CurrentSelectedOrganization != null)
{
allQueries.Add((qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.Organizations).Value(Guid.Empty)))) ||
qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.Organizations).Value(_personStorage.CurrentSelectedOrganization.SystemId))))));
}
else
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.Organizations).Value(Guid.Empty)))));
}
if (searchQuery.ProductListSystemId == null)
{
if (searchQuery.CategorySystemId != null)
{
if (searchQuery.CategoryShowRecursively)
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.ParentCategories).Value(searchQuery.CategorySystemId.Value)))));
}
else
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.Categories).Value(searchQuery.CategorySystemId.Value)))));
}
}
if (!string.IsNullOrWhiteSpace(searchQuery.Text))
{
var fuzziness = searchQuery.Text.Length > 2 ? Fuzziness.EditDistance(2) : Fuzziness.Auto;
allQueries.Add((qc.Match(x => x.Field(z => z.Name).Query(searchQuery.Text).Fuzziness(fuzziness).Boost(10).SynonymAnalyzer()) ||
qc.Match(x => x.Field(z => z.ArticleNumber).Query(searchQuery.Text.ToLower()).Boost(2).SynonymAnalyzer()) ||
qc.Match(x => x.Field(z => z.Content).Query(searchQuery.Text).Fuzziness(fuzziness).SynonymAnalyzer())));
}
}
else
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Term(t => t.Field(x => x.ProductLists).Value(searchQuery.ProductListSystemId.Value)))));
}
var pageModel = _requestModelAccessor.RequestModel.CurrentPageModel;
if (pageModel.IsBrandPageType())
{
if (tags != null)
{
if (!tags.ContainsKey(BrandListViewModel.TagName))
{
tags.Add(BrandListViewModel.TagName, new SortedSet <string>(new[] { pageModel.Page.Localizations.CurrentUICulture.Name }));
}
}
else
{
tags = new Dictionary <string, ISet <string> > {
{ BrandListViewModel.TagName, new SortedSet <string>(new[] { pageModel.Page.Localizations.CurrentUICulture.Name }) }
};
}
}
}
if (tags != null)
{
foreach (var tag in tags.Where(x => x.Value.Count > 0))
{
var filterTags = tag.Value
.Select <string, Func <QueryContainerDescriptor <ProductDocument>, QueryContainer> >(tagValue =>
s => s
.Nested(n => n
.Path(x => x.Tags)
.Query(nq
=> nq.Term(t => t.Field(f => f.Tags[0].Key).Value(tag.Key)) &&
nq.Term(t => t.Field(f => f.Tags[0].Value).Value(tagValue))
)
));
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Bool(bb => bb.Should(filterTags)))));
}
}
if (addCategoryFilterTags)
{
if (searchQuery.Category.Count > 0)
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Bool(bb => bb.Should(searchQuery.Category
.Select <Guid, Func <QueryContainerDescriptor <ProductDocument>, QueryContainer> >(x =>
s => s.Term(t => t.Field(f => f.Categories).Value(x))))))));
}
}
if (addPriceFilterTags)
{
var priceFilters = _priceFilterService
.GetPriceFilterTags(searchQuery, _priceContainer.Value, _countrySystemId.Value)
.ToList();
if (priceFilters.Count > 0)
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.Bool(bb => bb.Should(priceFilters)))));
}
}
if (addNewsFilterTags)
{
if (searchQuery.NewsDate != null)
{
allQueries.Add(qc.Bool(b => b.Filter(bf => bf.DateRange(r => r
.Field(x => x.NewsDate)
.GreaterThan(searchQuery.NewsDate.Item1)
.LessThan(searchQuery.NewsDate.Item2)))));
}
}
if (allQueries.Count == 0)
{
return(qc);
}
return(allQueries.Aggregate((a, b) => a & b));
}
public override SearchResponse Search(SearchQuery searchQuery, bool?onlyBrands = null)
{
if (!_searchClientService.IsConfigured)
{
return(_parent.Search(searchQuery, onlyBrands));
}
var fuzziness = !string.IsNullOrEmpty(searchQuery.Text) ? (searchQuery.Text.Length > 2 ? Fuzziness.EditDistance(2) : Fuzziness.Auto) : null;
return(new ElasticSearchResponse <PageDocument>(_searchClientService
.Search <PageDocument>(CultureInfo.CurrentUICulture, selector => selector
.From((searchQuery.PageNumber - 1) * searchQuery.PageSize.GetValueOrDefault(10000))
.Size(searchQuery.PageSize)
.QueryWithPermission(q =>
q.PublishedOnChannel() &&
(!string.IsNullOrEmpty(searchQuery.PageType)
? SearchByPageType(q, searchQuery) && q.PublishedOnWebsite()
: !string.IsNullOrEmpty(searchQuery.Text)
? (onlyBrands == true ? SearchInBrands(q) && q.PublishedOnWebsite() : q.PublishedOnWebsite()) &&
SearchByText(q, searchQuery.Text, fuzziness)
: q.PublishedOnWebsite()))
.Sort(x => searchQuery.PageType == PageTemplateNameConstants.NewsList ? x.Descending(f => f.NewsDate) : null)
.Source(x => x.Includes(z => z.Fields(p => p.PageSystemId))))
));
}
public void FullExample_InitializerSyntax_Search()
{
QueryContainer query = new TermQuery()
{
Field = Property.Path <ElasticsearchProject>(p => p.Name),
Value = "value"
} && new PrefixQuery()
{
Field = "prefix_field",
Value = "prefi",
Rewrite = RewriteMultiTerm.constant_score_boolean
};
var result = _client.Search <ElasticsearchProject>(new SearchRequest
{
From = 0,
Size = 20,
Index = "alternative-index",
Type = "alternative-type",
MinScore = 2.1,
Rescore = new Rescore
{
WindowSize = 10,
Query = new RescoreQuery
{
Query = new TermQuery()
{
}.ToContainer(),
QueryWeight = 1.2,
RescoreQueryWeight = 2.1
}
},
Fields = new[]
{
"field",
Property.Path <ElasticsearchProject>(p => p.Name)
},
Query = query,
Filter = new FilterContainer(new BoolFilter
{
Cache = true,
Must = new FilterContainer[]
{
new TermFilter {
Field = "value", Value = "asdasd"
}
}
}),
TrackScores = true,
Explain = true,
IndicesBoost = new Dictionary <IndexNameMarker, double>
{
{ Infer.Index <ElasticsearchProject>(), 2.3 }
},
ScriptFields = new FluentDictionary <string, IScriptFilter>()
.Add("script_field_name", new ScriptFilter
{
Script = "doc['loc'].value * multiplier",
Params = new Dictionary <string, object>
{
{ "multiplier", 4 }
}
}),
Sort = new Dictionary <PropertyPathMarker, ISort>()
{
{ "field", new Sort {
Order = SortOrder.Ascending, Missing = "_first"
} }
},
Source = new SourceFilter
{
Include = new PropertyPathMarker[]
{
"na*"
}
},
Suggest = new Dictionary <string, ISuggestBucket>
{
{
"suggestion", new SuggestBucket
{
Text = "suggest me",
Completion = new CompletionSuggester
{
Analyzer = "standard",
Field = Property.Path <ElasticsearchProject>(p => p.Content),
Size = 4,
ShardSize = 10,
Fuzzy = new FuzzySuggester
{
Fuzziness = Fuzziness.Ratio(0.3),
PrefixLength = 4
}
}
}
}
},
Facets = new Dictionary <PropertyPathMarker, IFacetContainer>()
{
{ "name", new FacetContainer
{
Terms = new TermFacetRequest
{
Field = "field",
Size = 10,
FacetFilter = new TermFilter()
{
Field = "other_field",
Value = "term"
}.ToContainer()
}
} }
},
Aggregations = new Dictionary <string, IAggregationContainer>
{
{ "my_agg", new AggregationContainer
{
Terms = new TermsAggregator
{
Field = Property.Path <ElasticsearchProject>(p => p.Name),
Size = 10,
ExecutionHint = TermsAggregationExecutionHint.ordinals,
},
Aggregations = new Dictionary <string, IAggregationContainer>
{
{ "max_count", new AggregationContainer()
{
Max = new MaxAggregator()
{
Field = "loc"
}
} }
}
} }
}
});
var json = result.ConnectionStatus.Request.Utf8String();
Assert.Pass(json);
}
public IEnumerable <IndexObject> Get([FromQuery] string searchParam)
{
var dateSearchTerm = DateTime.MinValue;
DateTime.TryParse(searchParam, out dateSearchTerm);
if (searchParam == null || String.IsNullOrEmpty(searchParam))
{
return(_client.Search <IndexObject>(s => s.Query(q => q.MatchAll())).Documents);
}
searchParam = searchParam.Insert(0, "*").Insert(searchParam.Length + 1, "*").ToLower().Trim();
var searchResponse = _client.Search <IndexObject>(s => s
.Query(q => q
.QueryString(qs => qs
.Fields(f => f.Field(a => a.ArtistName, 3.0)
.Field(v => v.VenueName, 2.0)
.Field(c => c.City, 1.5)
.Field(d => d.ConcertDate.ToShortDateString()))
//.AllowLeadingWildcard()
.Fuzziness(Fuzziness.EditDistance(3))
.Query(searchParam))).Explain(true));
return(searchResponse.Documents);
}
/// <summary>
/// Searches for the pages matching the query.
/// </summary>
public async Task <IReadOnlyList <PageDocumentSearchResult> > SearchAsync(string query, int page = 0)
{
const string PRE_TAG = "<b>";
const string POST_TAG = "</b>";
PageDocumentSearchResult Map(IHit <PageDocument> hit)
{
string GetHitValue(string fieldName, string fallback)
{
if (hit.Highlights.TryGetValue(fieldName.ToLower(), out var hitList))
{
var hitValue = hitList.Highlights.First();
var rawHitValue = hitValue.Replace(PRE_TAG, "").Replace(POST_TAG, "");
var startEllipsis = !rawHitValue.StartsWithPart(fallback, 10);
var endEllipsis = !rawHitValue.EndsWithPart(fallback, 10);
if (!startEllipsis && !endEllipsis)
{
return(hitValue);
}
return(string.Concat(
startEllipsis ? "..." : "",
hitValue,
endEllipsis ? "..." : ""
));
}
if (fallback.Length > FRAGMENT_SIZE)
{
return(fallback.Substring(0, FRAGMENT_SIZE) + "...");
}
return(fallback);
}
return(new PageDocumentSearchResult
{
Id = hit.Source.Id,
Key = hit.Source.Key,
HighlightedTitle = GetHitValue(nameof(PageDocument.Title), hit.Source.Title),
HighlightedDescription = GetHitValue(nameof(PageDocument.Description), hit.Source.Description),
});
}
var result = await _client.SearchAsync <PageDocument>(
s => s.Index(PAGE_INDEX)
.Query(q =>
q.MultiMatch(
f => f.Fields(x =>
x.Fields(
y => y.Title,
y => y.Description
)
)
.Query(query)
.Fuzziness(Fuzziness.EditDistance(1))
) ||
q.Match(
f => f.Field(x => x.Aliases)
.Query(query)
.Fuzziness(Fuzziness.EditDistance(1))
) ||
q.Prefix(f => f.Field(x => x.Title).Value(query))
)
.Skip(PAGE_SIZE *page)
.Take(PAGE_SIZE)
.Highlight(
h => h.FragmentSize(FRAGMENT_SIZE)
.PreTags(PRE_TAG)
.PostTags(POST_TAG)
.BoundaryScanner(BoundaryScanner.Sentence)
.BoundaryScannerLocale("ru-RU")
.Fields(
x => x.Field(f => f.Title),
x => x.Field(f => f.Description)
)
)
);
return(result.Hits.Select(Map).ToList());
}
private ISearchResponse <ManagementContainer> SearchingManagement(string term, int size, int page, Dictionary <string, object> arguments)
{
var managements = _elasticService.Search <ManagementContainer>(x =>
x.Index(Indices.Index("managements"))
.Size(size)
.From(page)
.Query(q =>
q.Bool(
b1 => b1.Should(
s1 => s1.Match(m1 => m1.Field("mgmt.name").Query(term).Fuzziness(Fuzziness.EditDistance(2)).Operator(Operator.And).Analyzer("stop"))
).Must(
s1 =>
{
if (arguments["market"] != null && arguments["market"].ToString().Trim() != string.Empty)
{
string[] markets = arguments["market"].ToString().Trim().Split(",");
List <QueryContainer> queries = new List <QueryContainer>();
foreach (string market in markets)
{
queries.Add(new MatchQuery()
{
Field = "mgmt.market",
Query = market
});
}
return(new QueryContainerDescriptor <ManagementContainer>().Bool(
d => d.Should(queries.ToArray())));
}
else
{
return(null);
}
})
)
)
);
return(managements);
}
public ISearchResponse <WebsiteInfo> FullTextSearchAdvanced(SearchContentDTO searchContent, SearchPagination pagination)
{
if (searchContent.MatchUncrawledWebsites)
{
return(FullTextSearchPendingWebsites(searchContent, pagination));
}
if (searchContent.MatchExactSentence)
{
return(FullTextSearchMatchSentence(searchContent, pagination));
}
var searchResult = client.Search <WebsiteInfo>(s => s
.Index(Constants.VISITED_WEBSITES_INDEX)
.Type(mapping)
.From(pagination.From)
.Size(pagination.Take)
.Query(q => q
.Bool(b => b
.Must(
m =>
m.MultiMatch(w => w
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta")
.Field("Paragraphs").Field("FullPageContent"))
.Query(searchContent.Input)
.Fuzziness(Fuzziness.EditDistance(searchContent.Fuzziness))
),
m => m.Term(t => t.Language, searchContent.Language),
m => m.DateRange(t => t
.Field(f => f.CreateDate)
.GreaterThanOrEquals(searchContent.StartDate)
.LessThanOrEquals(searchContent.EndDate))
)
)
)
.Highlight(h => h.PreTags("<b>").PostTags("</b>")
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta")
.Field("Paragraphs").Field("FullPageContent"))
)
);
return(searchResult);
}
public ISearchResponse <WebsiteInfo> FullTextSearch(string searchedContent)
{
var searchResult = client.Search <WebsiteInfo>(s => s
.AllIndices()
.Type(mapping)
.From(0)
.Size(15)
.Query(q => q
.MultiMatch(w => w
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta").Field("Paragraphs"))
.Query(searchedContent)
.Fuzziness(Fuzziness.EditDistance(1))
)
)
.Highlight(h => h
.PreTags("<b>").PostTags("</b>")
.Fields(f => f.Field("Url").Field("Title").Field("DescriptionMeta").Field("Paragraphs"))
)
);
return(searchResult);
}
//[HttpPost]
/// <summary>
/// Méthode pour faire la recherche
/// </summary>
/// <param name="recherche"></param>
/// <param name="categorie"></param>
/// <param name="currentFilter"></param>
/// <param name="page"></param>
/// <returns>la liste des élément trouvées </returns>
public ActionResult SearchAction(string recherche, string categorie, string motClé, int?page)
{
try
{
MyApp.Infrastructure.ElasticSearch.ElasticSearchServiceAgent.AssetSearchService.CreateIndex();
var connectionToEs = ElasticSearchConnectionSettings.connection();
var ListOfDataIndexed = new List <MyApp.Infrastructure.ElasticSearch.IndexDocuments.AssetDocument>();
int pageSize = 6;
int pageNumber = (page ?? 1);
//on test si les schamps de rechercher sont vides
if (string.IsNullOrEmpty(recherche) && string.IsNullOrEmpty(categorie) && string.IsNullOrEmpty(motClé))
{
return(View("DataNotFound"));
}
//au cas ou les deux champs ne sont pas null
else if (!string.IsNullOrEmpty(recherche) && !string.IsNullOrEmpty(categorie))
{
ViewBag.recherche = recherche;
ViewBag.categorie = categorie;
//on execute la connection pour élastic search
var reponse = connectionToEs.Search <MyApp.Infrastructure.ElasticSearch.IndexDocuments.AssetDocument>
(s => s.Index(MyApp.Infrastructure.ElasticSearch.ElasticSearchServiceAgent.AssetSearchService.assetIndexName)
.Size(50)
.Query(q => q.MultiMatch(m => m.Query(recherche).Fuzziness(Fuzziness.Auto)) //première recherche
&& q.Match(m => m.Field(f => f.TypeAssetName) //filtrage de la prmiere recherche
.Query(categorie))
)
);
ListOfDataIndexed = (from hits in reponse.Hits
select hits.Source).ToList();
if (!ListOfDataIndexed.Any())
{
return(View("DataNotFound"));
}
else
{
return(View(ListOfDataIndexed.ToList().ToPagedList(pageNumber, pageSize)));
}
}
//au cas ou on fais la recherche sur un seul champs avec le système de fuzinness auto
//Generates an edit distance based on the length of the term.
//Low and high distance arguments may be optionally provided AUTO:[low],[high]
// par défaut it takes [3 , 6]
else if (!string.IsNullOrEmpty(recherche))
{
ViewBag.recherche = recherche;
var reponse = connectionToEs.Search <MyApp.Infrastructure.ElasticSearch.IndexDocuments.AssetDocument>
(s => s.Index(MyApp.Infrastructure.ElasticSearch.ElasticSearchServiceAgent.AssetSearchService.assetIndexName)
.Size(50)
.Query(q => q.MultiMatch(m => m
.Query(recherche).Fuzziness(Fuzziness.Auto))
)
);
ListOfDataIndexed = (from hits in reponse.Hits
select hits.Source).ToList();
if (!ListOfDataIndexed.Any())
{
return(View("DataNotFound"));
}
else
{
return(View(ListOfDataIndexed.ToList().ToPagedList(pageNumber, pageSize)));
}
}
//faire une recherche sur base de type asset (vidéo, audio, image ...)
else if (!string.IsNullOrEmpty(categorie))
{
ViewBag.categorie = categorie;
var reponse = connectionToEs.Search <MyApp.Infrastructure.ElasticSearch.IndexDocuments.AssetDocument>
(s => s.Index(MyApp.Infrastructure.ElasticSearch.ElasticSearchServiceAgent.AssetSearchService.assetIndexName)
.Size(50)
.Query(q => q
.Match(m => m
.Field(f => f.TypeAssetName)
.Query(categorie))
)
);
ListOfDataIndexed = (from hits in reponse.Hits
select hits.Source).ToList();
if (!ListOfDataIndexed.Any()) //on verifie si la listet est vide et on retourne: data non trouvé
{
return(View("DataNotFound"));
}
else
{
return(View(ListOfDataIndexed.ToList().ToPagedList(pageNumber, pageSize)));
}
}
//faire un recherche par mot clé le système chercher le mot exact
else if (!string.IsNullOrEmpty(motClé))
{
ViewBag.motClé = motClé;
var reponse = connectionToEs.Search <MyApp.Infrastructure.ElasticSearch.IndexDocuments.AssetDocument>
(s => s.Index(MyApp.Infrastructure.ElasticSearch.ElasticSearchServiceAgent.AssetSearchService.assetIndexName)
.Size(50)
.Query(q => q.MultiMatch(m => m
.Query(motClé).Fuzziness(Fuzziness.EditDistance(0)))
)
);
ListOfDataIndexed = (from hits in reponse.Hits
select hits.Source).ToList();
if (!ListOfDataIndexed.Any())
{
return(View("DataNotFound"));
}
else
{
return(View(ListOfDataIndexed.ToList().ToPagedList(pageNumber, pageSize)));
}
}
return(View(ListOfDataIndexed.ToList().ToPagedList(pageNumber, pageSize)));
}
catch (Exception ex)
{
return(View("SearchAction2", new HandleErrorInfo(ex, "Home", "Index")));
}
}
public QueryContainer SearchByText(QueryContainerDescriptor <PageDocument> selector, string text, Fuzziness fuzziness)
{
return(selector.Match(x => x.Field(z => z.Name).Query(text).Fuzziness(fuzziness).Boost(2).SynonymAnalyzer()) ||
selector.Match(x => x.Field(z => z.Content).Query(text).Fuzziness(fuzziness).SynonymAnalyzer()) ||
SearchInBlocks(selector, text, fuzziness));
}
public async Task <IEnumerable <CatalogItem> > SearchAsync(string Phrase)
{
var response = await elasticClient.SearchAsync <CatalogItem>(s => s
.Query(q => q
.MultiMatch(c => c
.Fields(t => t.Field(m => m.Name)
.Field(m => m.CatalogBrand.Brand)
.Field(m => m.CatalogType.Type))
.Query(Phrase)
.Fuzziness(Fuzziness.AutoLength(1, 5))) ||
q.Term(x => x.Description, Phrase)));
return(response.Documents);
}
public QueryContainer SearchInBlocks(QueryContainerDescriptor <PageDocument> selector, string text, Fuzziness fuzziness)
{
return(selector.Nested(qb => qb.Path(x => x.Blocks).Query(nq => nq.Bool(b => b.Filter(bf =>
{
var q = bf.Match(t => t.Field(f => f.Blocks.First().Content).Query(text).Fuzziness(fuzziness).SynonymAnalyzer());
q &= bf.DateRange(t => t.Field(f => f.Blocks.First().ChannelStartDateTime).LessThan(DateTimeOffset.Now.UtcDateTime));
q &= bf.DateRange(t => t.Field(f => f.Blocks.First().ChannelEndDateTime).GreaterThan(DateTimeOffset.Now.UtcDateTime));
q &= bf.Bool(_permissionDescriptor);
return q;
})))
));
}
public ISearchResponse <SearchSuggestion> CompletionSuggesterSearch(string searchContent)
{
var searchResult = client.Search <SearchSuggestion>(s => s
.Index(Constants.SEARCH_SUGGESTIONS_INDEX)
.Type(mapping)
.Size(SIZE)
.Suggest(q => q
.Completion("search-suggest-fuzzy", c => c
.Fuzzy(f => f
.Fuzziness(Fuzziness.EditDistance(1))
)
.Prefix(searchContent)
.Field("name.completion")
.SkipDuplicates(true)
)
)
);
return(searchResult);
}
public ISearchResponse <WebsiteInfo> FullTextSearchPendingWebsites(SearchContentDTO searchContent, SearchPagination pagination)
{
var searchResult = client.Search <WebsiteInfo>(s => s
.Index(Constants.PENDING_WEBSITES_INDEX)
.Type(mapping)
.From(pagination.From)
.Size(pagination.Take)
.Query(q => q
.Bool(b => b
.Must(m => m
.MultiMatch(w => w
.Fields(f => f.Field("Url"))
.Query(searchContent.Input)
.Fuzziness(Fuzziness.EditDistance(searchContent.Fuzziness)))
)
)
)
.Highlight(h => h.PreTags("<b>").PostTags("</b>")
.Fields(f => f.Field("Url"))
)
);
return(searchResult);
}
