public async Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters) { var luceneQuery = query as LuceneQuery; var luceneQueryResults = new LuceneQueryResults(); await _luceneIndexProvider.SearchAsync(luceneQuery.Index, async searcher => { var templateContext = _liquidTemplateManager.Context; // await templateContext.ContextualizeAsync(_serviceProvider); if (parameters != null) { foreach (var parameter in parameters) { templateContext.SetValue(parameter.Key, parameter.Value); } } var tokenizedContent = await _liquidTemplateManager.RenderAsync(luceneQuery.Template, _javaScriptEncoder); var parameterizedQuery = JObject.Parse(tokenizedContent); var analyzer = _luceneAnalyzerManager.CreateAnalyzer(await _luceneIndexSettingsService.GetIndexAnalyzerAsync(luceneQuery.Index)); var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer); var docs = await _queryService.SearchAsync(context, parameterizedQuery); luceneQueryResults.Count = docs.Count; if (luceneQuery.ReturnContentItems) { // We always return an empty collection if the bottom lines queries have no results. luceneQueryResults.Items = new List <ContentItem>(); // Load corresponding content item versions var indexedContentItemVersionIds = docs.TopDocs.ScoreDocs.Select(x => searcher.Doc(x.Doc).Get("Content.ContentItem.ContentItemVersionId")).ToArray(); var dbContentItems = await _session.Query <ContentItem, ContentItemIndex>(x => x.ContentItemVersionId.IsIn(indexedContentItemVersionIds)).ListAsync(); // Reorder the result to preserve the one from the lucene query if (dbContentItems.Any()) { var dbContentItemVersionIds = dbContentItems.ToDictionary(x => x.ContentItemVersionId, x => x); var indexedAndInDB = indexedContentItemVersionIds.Where(dbContentItemVersionIds.ContainsKey); luceneQueryResults.Items = indexedAndInDB.Select(x => dbContentItemVersionIds[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; } }); return(luceneQueryResults); }
public async Task <object> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters) { var luceneQuery = query as LuceneQuery; object result = null; await _luceneIndexProvider.SearchAsync(luceneQuery.Index, async searcher => { var templateContext = new TemplateContext(); if (parameters != null) { foreach (var parameter in parameters) { templateContext.SetValue(parameter.Key, parameter.Value); } } var tokenizedContent = await _liquidTemplateManager.RenderAsync(luceneQuery.Template, templateContext); var parameterizedQuery = JObject.Parse(tokenizedContent); var analyzer = _luceneAnalyzerManager.CreateAnalyzer(LuceneSettings.StandardAnalyzer); var context = new LuceneQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer); var docs = await _queryService.SearchAsync(context, parameterizedQuery); if (luceneQuery.ReturnContentItems) { // Load corresponding content item versions var contentItemVersionIds = docs.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); result = contentItemVersionIds.Select(x => indexed[x]).ToArray(); } else { var results = new List <JObject>(); foreach (var document in docs.ScoreDocs.Select(hit => searcher.Doc(hit.Doc))) { results.Add(new JObject(document.Select(x => new JProperty(x.Name, x.GetStringValue())))); } result = results; } }); return(result); }
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); }