public async Task <IActionResult> Query(AdminQueryViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
{
return(Unauthorized());
}
//model.Indices = _elasticIndexManager.List().ToArray();
var client = await _elasticIndexManager.Client();
IEnumerable <string> elasticIndices = client.Indices.Stats(new IndicesStatsRequest( )).Indices.Select(x => x.Key).Distinct();
model.Indices = elasticIndices.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 (!client.Indices.Exists(model.IndexName).Exists)
{
return(NotFound());
}
if (String.IsNullOrWhiteSpace(model.DecodedQuery))
{
return(View(model));
}
if (String.IsNullOrEmpty(model.Parameters))
{
model.Parameters = "{ }";
}
var elasticSettings = await _elasticIndexingService.GetElasticSettingsAsync();
var stopwatch = new Stopwatch();
stopwatch.Start();
/*await _elasticIndexManager.SearchAsync(model.IndexName, async searcher =>
* {
* var analyzer = _luceneAnalyzerManager.CreateAnalyzer(LuceneSettings.StandardAnalyzer);
* var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer);
*
* var templateContext = new TemplateContext();
* await templateContext.ContextualizeAsync(_serviceProvider);
* 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, System.Text.Encodings.Web.JavaScriptEncoder.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();
* }
* catch(Exception e)
* {
* Logger.LogError(e, "Error while executing query");
* ModelState.AddModelError(nameof(model.DecodedQuery), "Invalid query");
* }
*
* stopwatch.Stop();
* model.Elapsed = stopwatch.Elapsed;
* });*/
return(View(model));
}
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 (!await _elasticIndexProvider.ExistsAsync(indexName))
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(q))
{
return(View(new SearchIndexViewModel
{
Pager = pager, IndexName = id, ContentItems = Enumerable.Empty <ContentItem>()
}));
}
var luceneSettings = await _elasticIndexingService.GetElasticSettingsAsync();
if (luceneSettings == null) // || luceneSettings? .DefaultSearchFields == null)
{
Logger.LogInformation("Couldn't execute search. No Elastic settings was defined.");
return(View(new SearchIndexViewModel
{
HasMoreResults = false,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = Enumerable.Empty <ContentItem>()
}));
}
//todo
// var queryParser = new MultiFieldQueryParser(LuceneSettings.DefaultVersion, luceneSettings.DefaultSearchFields, new StandardAnalyzer(LuceneSettings.DefaultVersion));
// var query = queryParser.Parse(QueryParser.Escape(q));
object query = null;
int start = pager.GetStartIndex(),
size = pager.PageSize,
end = size + 1; // Fetch one more result than PageSize to generate "More" links
var contentItemIds = await _searchQueryService.ExecuteQueryAsync(query, indexName, start, end);
var contentItems = new List <ContentItem>();
foreach (var contentItemId in contentItemIds.Take(size))
{
var contentItem = await _contentManager.GetAsync(contentItemId);
if (contentItem != null)
{
contentItems.Add(contentItem);
}
}
var model = new SearchIndexViewModel
{
HasMoreResults = contentItemIds.Count > size,
Query = q,
Pager = pager,
IndexName = id,
ContentItems = contentItems
};
return(View(model));
}