public async Task <IList <string> > ExecuteQueryAsync(Query query, string indexName, int start, int end)
{
var contentItemIds = new List <string>();
await _luceneIndexManager.SearchAsync(indexName, searcher =>
{
if (end > 0)
{
var collector = TopScoreDocCollector.Create(end, true);
searcher.Search(query, collector);
var hits = collector.GetTopDocs(start, end);
foreach (var hit in hits.ScoreDocs)
{
var d = searcher.Doc(hit.Doc, IdSet);
contentItemIds.Add(d.GetField("ContentItemId").GetStringValue());
}
}
return(Task.CompletedTask);
});
return(contentItemIds);
}
public async Task <IEnumerable <ContentPickerResult> > Search(ContentPickerSearchContext searchContext)
{
var indexName = "Search";
var fieldSettings = searchContext.PartFieldDefinition?.GetSettings <ContentPickerFieldLuceneEditorSettings>();
if (!string.IsNullOrWhiteSpace(fieldSettings?.Index))
{
indexName = fieldSettings.Index;
}
if (!_luceneIndexProvider.Exists(indexName))
{
return(new List <ContentPickerResult>());
}
var results = new List <ContentPickerResult>();
await _luceneIndexProvider.SearchAsync(indexName, searcher =>
{
Query query = null;
if (string.IsNullOrWhiteSpace(searchContext.Query))
{
query = new MatchAllDocsQuery();
}
else
{
query = new WildcardQuery(new Term("Content.ContentItem.DisplayText.Analyzed", searchContext.Query.ToLowerInvariant() + "*"));
}
var filter = new FieldCacheTermsFilter("Content.ContentItem.ContentType", searchContext.ContentTypes.ToArray());
var docs = searcher.Search(query, filter, 50, Sort.RELEVANCE);
foreach (var hit in docs.ScoreDocs)
{
var doc = searcher.Doc(hit.Doc);
results.Add(new ContentPickerResult
{
ContentItemId = doc.GetField("ContentItemId").GetStringValue(),
DisplayText = doc.GetField("Content.ContentItem.DisplayText").GetStringValue(),
HasPublished = doc.GetField("Content.ContentItem.Published").GetStringValue() == "true" ? true : false
});
}
return(Task.CompletedTask);
});
return(results.OrderBy(x => x.DisplayText));
}
public async Task <Tuple <List <string>, int> > ExecuteQueryAsync(Query query, string indexName, int start = 0, int end = 20)
{
var contentItemIds = new List <string>();
var totalCount = 0;
await _luceneIndexManager.SearchAsync(indexName, searcher =>
{
TopDocs hits;
if (query is MatchAllDocsQuery)
{
hits = searcher.Search(query, end, new Sort(new SortField("Content.ContentItem.CreatedUtc", SortFieldType.DOUBLE, true)));
}
else
{
var collector = TopScoreDocCollector.Create(end, true);
searcher.Search(query, collector);
hits = collector.GetTopDocs(start, end);
}
totalCount = hits.TotalHits;
if (start >= totalCount)
{
return(Task.CompletedTask);
}
var size = end - start;
if (start + size > totalCount)
{
size = totalCount - start;
}
foreach (var hit in hits.ScoreDocs.AsSpan().Slice(start, size))
{
var d = searcher.Doc(hit.Doc, IdSet);
contentItemIds.Add(d.GetField("ContentItemId").GetStringValue());
}
return(Task.CompletedTask);
});
return(Tuple.Create(contentItemIds, totalCount));
}
public async Task <IActionResult> Query(AdminQueryViewModel model, [FromServices] ITokenizer tokenizer)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
{
return(Unauthorized());
}
model.Indices = _luceneIndexManager.List().ToArray();
// Can't query if there are no indices
if (model.Indices.Length == 0)
{
return(RedirectToAction("Index"));
}
if (String.IsNullOrEmpty(model.IndexName))
{
model.IndexName = model.Indices[0];
}
if (!_luceneIndexManager.Exists(model.IndexName))
{
return(NotFound());
}
if (String.IsNullOrWhiteSpace(model.DecodedQuery))
{
return(View(model));
}
if (String.IsNullOrEmpty(model.Parameters))
{
model.Parameters = "{ }";
}
var luceneSettings = await _luceneIndexingService.GetLuceneSettingsAsync();
var stopwatch = new Stopwatch();
stopwatch.Start();
await _luceneIndexManager.SearchAsync(model.IndexName, async searcher =>
{
var analyzer = _luceneAnalyzerManager.CreateAnalyzer("standardanalyzer");
var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer);
var tokenizedContent = tokenizer.Tokenize(model.DecodedQuery, JObject.Parse(model.Parameters));
try
{
var parameterizedQuery = JObject.Parse(tokenizedContent);
var docs = await _queryService.SearchAsync(context, parameterizedQuery);
model.Documents = docs.ScoreDocs.Select(hit => searcher.Doc(hit.Doc)).ToList();
}
catch (Exception e)
{
Logger.LogError("Error while executing query: {0}", e.Message);
ModelState.AddModelError(nameof(model.DecodedQuery), "Invalid query");
}
stopwatch.Stop();
model.Elapsed = stopwatch.Elapsed;
});
return(View(model));
}
public async Task <IActionResult> Query(AdminQueryViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
{
return(Forbid());
}
model.Indices = (await _luceneIndexSettingsService.GetSettingsAsync()).Select(x => x.IndexName).ToArray();
// Can't query if there are no indices
if (model.Indices.Length == 0)
{
return(RedirectToAction("Index"));
}
if (String.IsNullOrEmpty(model.IndexName))
{
model.IndexName = model.Indices[0];
}
if (!_luceneIndexManager.Exists(model.IndexName))
{
return(NotFound());
}
if (String.IsNullOrWhiteSpace(model.DecodedQuery))
{
return(View(model));
}
if (String.IsNullOrEmpty(model.Parameters))
{
model.Parameters = "{ }";
}
var stopwatch = new Stopwatch();
stopwatch.Start();
await _luceneIndexManager.SearchAsync(model.IndexName, async searcher =>
{
var analyzer = _luceneAnalyzerManager.CreateAnalyzer(await _luceneIndexSettingsService.GetIndexAnalyzerAsync(model.IndexName));
var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer);
var templateContext = _liquidTemplateManager.Context;
var parameters = JsonConvert.DeserializeObject <Dictionary <string, object> >(model.Parameters);
foreach (var parameter in parameters)
{
templateContext.SetValue(parameter.Key, parameter.Value);
}
var tokenizedContent = await _liquidTemplateManager.RenderAsync(model.DecodedQuery, _javaScriptEncoder);
try
{
var parameterizedQuery = JObject.Parse(tokenizedContent);
var luceneTopDocs = await _queryService.SearchAsync(context, parameterizedQuery);
if (luceneTopDocs != null)
{
model.Documents = luceneTopDocs.TopDocs.ScoreDocs.Select(hit => searcher.Doc(hit.Doc)).ToList();
model.Count = luceneTopDocs.Count;
}
}
catch (Exception e)
{
_logger.LogError(e, "Error while executing query");
ModelState.AddModelError(nameof(model.DecodedQuery), S["Invalid query : {0}", e.Message]);
}
stopwatch.Stop();
model.Elapsed = stopwatch.Elapsed;
});
return(View(model));
}
public async Task <LuceneQueryResults> Query(AdminQueryViewModel model, Boolean returnContentItems)
{
//if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
//{
// return Unauthorized();
//}
// model.Indices = _luceneIndexManager.List().ToArray();
model.Indices = (await _luceneIndexSettingsService.GetSettingsAsync()).Select(x => x.IndexName).ToArray();
// Can't query if there are no indices
//if (model.Indices.Length == 0)
//{
// return RedirectToAction("Index");
//}
if (String.IsNullOrEmpty(model.IndexName))
{
model.IndexName = model.Indices[0];
}
//if (!_luceneIndexManager.Exists(model.IndexName))
//{
// return NotFound();
//}
//if (String.IsNullOrWhiteSpace(model.DecodedQuery))
//{
// return View(model);
//}
if (String.IsNullOrEmpty(model.Parameters))
{
model.Parameters = "{ }";
}
// var luceneSettings = await _luceneIndexingService.GetLuceneSettingsAsync();
// var stopwatch = new Stopwatch();
//stopwatch.Start();
var luceneQueryResults = new LuceneQueryResults();
await _luceneIndexManager.SearchAsync(model.IndexName, async searcher =>
{
var analyzer = _luceneAnalyzerManager.CreateAnalyzer("standardanalyzer");
var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer);
var templateContext = _liquidTemplateManager.Context;// new TemplateContext();
var parameters = JsonConvert.DeserializeObject <Dictionary <string, object> >(model.Parameters);
foreach (var parameter in parameters)
{
templateContext.SetValue(parameter.Key, parameter.Value);
}
var tokenizedContent = await _liquidTemplateManager.RenderAsync(model.DecodedQuery, NullEncoder.Default, templateContext);
try
{
var parameterizedQuery = JObject.Parse(tokenizedContent);
var docs = await _queryService.SearchAsync(context, parameterizedQuery);
// model.Documents = docs.ScoreDocs.Select(hit => searcher.Doc(hit.Doc)).ToList();
if (returnContentItems)
{
// Load corresponding content item versions
var contentItemVersionIds = docs.TopDocs.ScoreDocs.Select(x => searcher.Doc(x.Doc).Get("Content.ContentItem.ContentItemVersionId")).ToArray();
var contentItems = await _session.Query <ContentItem, ContentItemIndex>(x => x.ContentItemVersionId.IsIn(contentItemVersionIds)).ListAsync();
// Reorder the result to preserve the one from the lucene query
var indexed = contentItems.ToDictionary(x => x.ContentItemVersionId, x => x);
luceneQueryResults.Items = contentItemVersionIds.Select(x => indexed[x]).ToArray();
}
else
{
var results = new List <JObject>();
foreach (var document in docs.TopDocs.ScoreDocs.Select(hit => searcher.Doc(hit.Doc)))
{
results.Add(new JObject(document.Select(x => new JProperty(x.Name, x.GetStringValue()))));
}
luceneQueryResults.Items = results;
}
}
catch (Exception e)
{
Logger.LogError(e, "Error while executing query");
// ModelState.AddModelError(nameof(model.DecodedQuery), "Invalid query");
}
// stopwatch.Stop();
// model.Elapsed = stopwatch.Elapsed;
});
return(luceneQueryResults);
}
public async Task <IActionResult> Index(string id, string q, PagerParameters pagerParameters)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var indexName = "Search";
if (!string.IsNullOrWhiteSpace(id))
{
indexName = id;
}
if (!_luceneIndexProvider.Exists(indexName))
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(q))
{
return(View(new SearchIndexViewModel
{
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var luceneSettings = await _luceneIndexingService.GetLuceneSettingsAsync();
if (luceneSettings == null)
{
Logger.LogInformation("Couldn't execute search. No Lucene settings was defined.");
return(View(new SearchIndexViewModel
{
HasMoreResults = false,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var queryParser = new MultiFieldQueryParser(LuceneSettings.DefaultVersion, luceneSettings.DefaultSearchFields, new StandardAnalyzer(LuceneSettings.DefaultVersion));
var query = queryParser.Parse(QueryParser.Escape(q));
var contentItemIds = new List <string>();
await _luceneIndexProvider.SearchAsync(indexName, searcher =>
{
// Fetch one more result than PageSize to generate "More" links
var collector = TopScoreDocCollector.Create(pager.PageSize + 1, true);
searcher.Search(query, collector);
var hits = collector.GetTopDocs(pager.GetStartIndex(), pager.PageSize + 1);
foreach (var hit in hits.ScoreDocs)
{
var d = searcher.Doc(hit.Doc, IdSet);
contentItemIds.Add(d.GetField("ContentItemId").GetStringValue());
}
return(Task.CompletedTask);
});
var contentItems = new List <ContentItem>();
foreach (var contentItemId in contentItemIds.Take(pager.PageSize))
{
var contentItem = await _contentManager.GetAsync(contentItemId);
if (contentItem != null)
{
contentItems.Add(contentItem);
}
}
var model = new SearchIndexViewModel
{
HasMoreResults = contentItemIds.Count > pager.PageSize,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = contentItems
};
return(View(model));
}
public async Task <AdminSearchResult> SearchContent(AdminSearchContext searchContext)
{
var searchResult = new AdminSearchResult();
await _luceneIndexProvider.SearchAsync(searchContext.Index, async searcher =>
{
Query query;
if (string.IsNullOrWhiteSpace(searchContext.SearchTerm))
{
query = new MatchAllDocsQuery();
}
else
{
var luceneVersion = LuceneSettings.DefaultVersion;
var analyzer = new StandardAnalyzer(luceneVersion);
var multiFieldQuery = new MultiFieldQueryParser(luceneVersion, searchContext.IndexFieldsToSearch, analyzer);
query = multiFieldQuery.Parse(QueryParserBase.Escape(searchContext.SearchTerm));
}
searchContext.PageNumber -= 1;
var start = searchContext.PageNumber * searchContext.PageSize;
var end = searchContext.PageNumber * searchContext.PageSize + searchContext.PageSize;
var collector = TopScoreDocCollector.Create(end, true);
var filter = new BooleanFilter();
if (searchContext.ContentTypes.Any())
{
filter.Add(new FieldCacheTermsFilter("Content.ContentItem.ContentType", searchContext.ContentTypes), Occur.MUST);
}
if (searchContext.Filters != null && searchContext.Filters.Any())
{
await _searchFilters.InvokeAsync(x => x.Filter(searchContext, filter), null);
}
if (filter.Any())
{
searcher.Search(query, filter, collector);
}
else
{
searcher.Search(query, collector);
}
var docs = collector.GetTopDocs(start, end);
searchResult.TotalRecordCount = docs.TotalHits;
var contentItemIds = docs.ScoreDocs.Select(hit =>
{
var doc = searcher.Doc(hit.Doc);
return(doc.GetField("ContentItemId").GetStringValue());
});
searchResult.ContentItems = await _contentManager.GetAsync(contentItemIds);
});
return(searchResult);
}