/// <summary>
/// Returns a list of suggestions based on the specified suggestion query.
/// </summary>
/// <param name="index">The index to query for suggestions</param>
/// <param name="suggestionQuery">The suggestion query.</param>
public Task <SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}",
Uri.EscapeUriString(index),
Uri.EscapeDataString(suggestionQuery.Term),
Uri.EscapeDataString(suggestionQuery.Field),
Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()),
Uri.EscapeDataString(suggestionQuery.Distance.ToString()),
Uri.EscapeDataString(suggestionQuery.Accuracy.ToString()));
var request = HttpJsonRequest.CreateHttpJsonRequest(this, requestUri, "GET", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializer = convention.CreateSerializer();
return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(task =>
{
using (var reader = new JsonTextReader(new StringReader(task.Result)))
{
var json = (JToken)serializer.Deserialize(reader);
return new SuggestionQueryResult
{
Suggestions = json["Suggestions"].Children().Select(x => x.Value <string>()).ToArray(),
};
}
}));
}
/// <summary>
/// Returns a list of suggestions based on the specified suggestion query.
/// </summary>
/// <param name="index">The index to query for suggestions</param>
/// <param name="suggestionQuery">The suggestion query.</param>
public Task <SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}",
Uri.EscapeUriString(index),
Uri.EscapeDataString(suggestionQuery.Term),
Uri.EscapeDataString(suggestionQuery.Field),
Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()),
Uri.EscapeDataString(suggestionQuery.Distance.ToString()),
Uri.EscapeDataString(suggestionQuery.Accuracy.ToString()));
var request = jsonRequestFactory.CreateHttpJsonRequest(this, requestUri.NoCache(), "GET", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return(request.ReadResponseStringAsync()
.ContinueWith(task =>
{
using (var reader = new JsonTextReader(new StringReader(task.Result)))
{
var json = (RavenJObject)RavenJToken.Load(reader);
return new SuggestionQueryResult
{
Suggestions = ((RavenJArray)json["Suggestions"]).Select(x => x.Value <string>()).ToArray(),
};
}
}));
}
/// <summary>
/// Suggest alternative values for the queried term
/// </summary>
public static SuggestionQueryResult Suggest(this IQueryable queryable, SuggestionQuery query)
{
var ravenQueryInspector = ((IRavenQueryInspector)queryable);
SetSuggestionQueryFieldAndTerm(ravenQueryInspector, query);
return(ravenQueryInspector.DatabaseCommands.Suggest(ravenQueryInspector.IndexQueried, query));
}
public SuggestionQueryResult Map(IEnumerable <GeoDataEntry> results, SuggestionQuery suggestionQuery, ILinkBuilder linkBuilder)
{
if (linkBuilder == null)
{
throw new ArgumentNullException(nameof(linkBuilder));
}
IEnumerable <Suggestion> suggestions = null;
if (results?.Count() > 0)
{
suggestions = CertaintyRanker.Rank(results, suggestionQuery.Q, suggestionQuery.Coordinates())
.OrderByDescending(o => o.Certainty)
.Take(suggestionQuery.MaxResults)
.Select(c => new Suggestion()
{
Certainty = c.Certainty,
Longitude = c.Entry.Longitude,
Latitude = c.Entry.Latitude,
Name = c.Entry.Name,
Links = linkBuilder.BuildLinks(c.Entry)
}).OrderByDescending(r => r.Certainty);
}
//if suggestions are null, return an empty array
return(new SuggestionQueryResult()
{
Suggestions = suggestions ?? new Suggestion[] {}
});
}
public SuggestionQueryResult Query(SuggestionQuery suggestionQuery)
{
if (suggestionQuery.Term.StartsWith("<<") && suggestionQuery.Term.EndsWith(">>"))
{
var individualTerms = suggestionQuery.Term.Substring(2, suggestionQuery.Term.Length - 4).Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
var result = new List <string>();
foreach (var term in individualTerms)
{
result.AddRange(spellChecker.SuggestSimilar(term,
suggestionQuery.MaxSuggestions,
null,
suggestionQuery.Field,
true));
}
return(new SuggestionQueryResult
{
Suggestions = result.ToArray()
});
}
string[] suggestions = spellChecker.SuggestSimilar(suggestionQuery.Term,
suggestionQuery.MaxSuggestions,
null,
suggestionQuery.Field,
true);
return(new SuggestionQueryResult
{
Suggestions = suggestions
});
}
public SuggestionQueryResult ExecuteSuggestionQuery(string indexName, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Term))
{
throw new ArgumentNullException("suggestionQuery.Term");
}
if (string.IsNullOrWhiteSpace(indexName))
{
throw new ArgumentNullException("indexName");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Field))
{
throw new ArgumentNullException("suggestionQuery.Field");
}
if (suggestionQuery.MaxSuggestions <= 0)
{
suggestionQuery.MaxSuggestions = 10;
}
if (suggestionQuery.Accuracy <= 0 || suggestionQuery.Accuracy > 1)
{
suggestionQuery.Accuracy = 0.5f;
}
suggestionQuery.MaxSuggestions = Math.Min(suggestionQuery.MaxSuggestions,
_database.Configuration.MaxPageSize);
var indexExtensionKey = MonoHttpUtility.UrlEncode(suggestionQuery.Field + "-" + suggestionQuery.Distance + "-" + suggestionQuery.Accuracy);
var indexExtension = _database.IndexStorage.GetIndexExtension(indexName, indexExtensionKey) as SuggestionQueryIndexExtension;
IndexSearcher currentSearcher;
using (_database.IndexStorage.GetCurrentIndexSearcher(indexName, out currentSearcher))
{
var indexReader = currentSearcher.IndexReader;
if (indexExtension != null)
{
return(indexExtension.Query(suggestionQuery, indexReader));
}
var suggestionQueryIndexExtension = new SuggestionQueryIndexExtension(
Path.Combine(_database.Configuration.IndexStoragePath, "Raven-Suggestions", indexName, indexExtensionKey),
indexReader,
GetStringDistance(suggestionQuery.Distance),
suggestionQuery.Field,
suggestionQuery.Accuracy);
suggestionQueryIndexExtension.Init(indexReader);
_database.IndexStorage.SetIndexExtension(indexName, indexExtensionKey, suggestionQueryIndexExtension);
return(suggestionQueryIndexExtension.Query(suggestionQuery, indexReader));
}
}
public IHttpActionResult Get([FromUri] SuggestionQuery query)
{
if (query == null)
{
throw new NullQueryStringException();
}
query.Validate();
Coordinates sourceCoordinates = query.Coordinates();
IEnumerable <GeoDataEntry> results = null;
try
{
if (sourceCoordinates == null)
{
results = DataProvider.Search(query?.Q, query.MaxResults);
}
else
{
results = DataProvider.SearchNear(query?.Q,
new BoundingBox(sourceCoordinates, Defaults.defaultRadiusKm), query.MaxResults);
}
}
catch (Exception ex)
{
AppLogger.Error("error querying hospitals", ex);
throw new DataProviderException(ex);
}
return(Ok(ResultsMapper.Map(results, query, new LinkBuilder(this))));
}
public Suggestion GetNewSuggestion(ConversationContext conversationContext, SuggestionQuery query)
{
var documents = this.GetDocuments(conversationContext).ToList();
conversationContext.LastNotFilteredDocuments = documents;
conversationContext.FilterDocumentsParameters.Documents = documents.Select(x => x.Uri).ToList();
return(this.GetSuggestion(conversationContext, query));
}
public SuggestionQueryResult ExecuteSuggestionQuery(string indexName, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Term))
{
throw new ArgumentNullException("suggestionQuery.Term");
}
if (string.IsNullOrWhiteSpace(indexName))
{
throw new ArgumentNullException("indexName");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Field))
{
throw new ArgumentNullException("suggestionQuery.Field");
}
if (suggestionQuery.MaxSuggestions <= 0)
{
suggestionQuery.MaxSuggestions = 10;
}
if (suggestionQuery.Accuracy <= 0 || suggestionQuery.Accuracy > 1)
{
suggestionQuery.Accuracy = 0.5f;
}
suggestionQuery.MaxSuggestions = Math.Min(suggestionQuery.MaxSuggestions,
_database.Configuration.MaxPageSize);
var indexExtensionKey = suggestionQuery.Field + "/" + suggestionQuery.Distance + "/" + suggestionQuery.Accuracy;
var indexExtension = _database.IndexStorage.GetIndexExtension(indexName, indexExtensionKey) as SuggestionQueryIndexExtension;
if (indexExtension != null)
{
return(indexExtension.Query(suggestionQuery));
}
var currentSearcher = _database.IndexStorage.GetCurrentIndexSearcher(indexName);
try
{
var indexReader = currentSearcher.GetIndexReader();
var suggestionQueryIndexExtension = new SuggestionQueryIndexExtension(GetStringDistance(suggestionQuery), suggestionQuery.Field, suggestionQuery.Accuracy);
suggestionQueryIndexExtension.Init(indexReader);
_database.IndexStorage.SetIndexExtension(indexName, indexExtensionKey, suggestionQueryIndexExtension);
return(suggestionQueryIndexExtension.Query(suggestionQuery));
}
finally
{
currentSearcher.GetIndexReader().DecRef();
}
}
/// <summary>
/// Responds the specified context.
/// </summary>
/// <param name="context">The context.</param>
public override void Respond(IHttpContext context)
{
var match = urlMatcher.Match(context.GetRequestUrl());
var index = match.Groups[1].Value;
var indexEtag = Database.GetIndexEtag(index, null);
if (context.MatchEtag(indexEtag))
{
context.SetStatusToNotModified();
return;
}
var term = context.Request.QueryString["term"];
var field = context.Request.QueryString["field"];
StringDistanceTypes distanceTypes;
int numOfSuggestions;
float accuracy;
if (Enum.TryParse(context.Request.QueryString["distance"], true, out distanceTypes) == false)
{
distanceTypes = StringDistanceTypes.Default;
}
if (int.TryParse(context.Request.QueryString["max"], out numOfSuggestions) == false)
{
numOfSuggestions = 10;
}
if (float.TryParse(context.Request.QueryString["accuracy"], out accuracy) == false)
{
accuracy = 0.5f;
}
bool popularity;
if (bool.TryParse(context.Request.QueryString["popularity"], out popularity) == false)
{
popularity = false;
}
var query = new SuggestionQuery
{
Distance = distanceTypes,
Field = field,
MaxSuggestions = numOfSuggestions,
Term = term,
Accuracy = accuracy,
Popularity = popularity
};
var suggestionQueryResult = Database.ExecuteSuggestionQuery(index, query);
context.WriteETag(Database.GetIndexEtag(index, null));
context.WriteJson(suggestionQueryResult);
}
public Suggestion GetNewSuggestion(ConversationContext conversationContext, SuggestionQuery query)
{
var allRecommendedQuestions = new List <IEnumerable <Recommendation <Question> > >();
if (query.OverridenRecommenderSettings != null)
{
this._recommenderSettings = query.OverridenRecommenderSettings;
}
var tasks = new Dictionary <RecommenderType, Task <IEnumerable <Recommendation <Document> > > >();
if (this._recommenderSettings.UseLongQuerySearchRecommender)
{
tasks.Add(RecommenderType.LongQuerySearch, this.GetLongQuerySearchRecommendations(conversationContext));
}
if (this._recommenderSettings.UsePreprocessedQuerySearchRecommender)
{
tasks.Add(RecommenderType.PreprocessedQuerySearch, this.GetQuerySearchRecommendations(conversationContext));
}
if (this._recommenderSettings.UseAnalyticsSearchRecommender)
{
tasks.Add(RecommenderType.LastClickAnalytics, this.GetLastClickAnalyticsRecommendations(conversationContext));
}
if (this._recommenderSettings.UseNearestDocumentsRecommender)
{
var recommendations = this._recommenderSettings.UsePreprocessedQuerySearchRecommender
? tasks[RecommenderType.PreprocessedQuerySearch].Result
: this.GetQuerySearchRecommendations(conversationContext).Result;
tasks.Add(RecommenderType.NearestDocuments, this.GetNearestDocumentsRecommendations(conversationContext, recommendations.Select(r => r.Value)));
}
var allRecommendedDocuments = Task.WhenAll(tasks.Values).Result.ToList();
var mergedDocuments = this.MergeRecommendedDocuments(allRecommendedDocuments);
if (mergedDocuments.Any() && this._recommenderSettings.UseFacetQuestionRecommender)
{
allRecommendedQuestions.Add(this.GenerateQuestions(conversationContext, mergedDocuments.Select(d => d.Value)).Take(query.MaxQuestions));
}
var mergedQuestions = this.MergeRecommendedQuestions(allRecommendedQuestions).Take(query.MaxQuestions);
var suggestion = new Suggestion
{
ActiveFacets = conversationContext.MustHaveFacets,
Documents = mergedDocuments.Take(query.MaxDocuments).ToList(),
Questions = mergedQuestions.Select(r => r.ConvertValue(QuestionToClient.FromQuestion)).ToList()
};
UpdateContextWithNewSuggestions(conversationContext, suggestion.Documents.Select(r => r.Value));
return(suggestion);
}
public IActionResult GetSuggestions(SuggestionQuery suggestionQuery)
{
Log.Debug($"SuggestionQuery: {suggestionQuery}");
var suggestion = this._suggestionsService.GetLastSuggestion(this.ConversationContext, suggestionQuery);
LogSuggestion(suggestion);
return(this.Ok(suggestion));
}
public SuggestionQueryResult Query(SuggestionQuery suggestionQuery)
{
var suggestions = spellChecker.SuggestSimilar(suggestionQuery.Term,
suggestionQuery.MaxSuggestions,
null,
suggestionQuery.Field,
true);
return(new SuggestionQueryResult
{
Suggestions = suggestions
});
}
private static StringDistance GetStringDistance(SuggestionQuery query)
{
switch (query.Distance)
{
case StringDistanceTypes.NGram:
return(new NGramDistance());
case StringDistanceTypes.JaroWinkler:
return(new JaroWinklerDistance());
default:
return(new LevenshteinDistance());
}
}
/// <summary>
/// Provides suggestions that complete a user's search query.
/// </summary>
/// <param name="q">The partial query as inputted by the user</param>
/// <param name="s">The system name that performs the search. Supported values are: "Klara", "SuntLiv", "Klaratest", "SuntLivTest"</param>
/// <param name="collections">The Collections in which to search for hits. You can use . (AND) or | (OR) to search in several collections.</param>
/// <param name="client">A string that indicates a valid front end</param>
/// <param name="maxSuggestions">The maximum number of results that the suggest server should return. The minimum is 0, which indicates that the server should return an empty set,
/// however this result would not be meaningful. Maximum is not set. Default is 10. If fewer suggestions are configured, then they are returned.</param>
/// <returns>A list of suggestions</returns>
public List<string> Get(string q, string s, string collections = "", string client = "", int maxSuggestions = 10)
{
var server = new SearchServer();
var query = new SuggestionQuery();
query.SearchTerm = q;
query.Collections = collections;
query.Client = client;
query.MaxSuggestions = maxSuggestions;
query.GsaHostAddress = string.Format(this.GetHostFromSystemName(s), "/suggest");
var result = server.Suggest(query);
return result;
}
private SuggestionQueryResult QueryOverMultipleWords(SuggestionQuery suggestionQuery, IndexReader indexReader,
string queryText)
{
var individualTerms = queryText.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
var result = new List <string>();
foreach (var term in individualTerms)
{
result.AddRange(spellChecker.SuggestSimilar(term,
suggestionQuery.MaxSuggestions,
indexReader,
suggestionQuery.Field,
suggestionQuery.Popularity));
}
return(new SuggestionQueryResult
{
Suggestions = result.ToArray()
});
}
/// <summary>
/// Returns a list of suggestions based on the specified suggestion query.
/// </summary>
/// <param name="index">The index to query for suggestions</param>
/// <param name="suggestionQuery">The suggestion query.</param>
/// <returns></returns>
public SuggestionQueryResult Suggest(string index, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}",
Uri.EscapeUriString(index),
Uri.EscapeDataString(suggestionQuery.Term),
Uri.EscapeDataString(suggestionQuery.Field),
Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()),
Uri.EscapeDataString(suggestionQuery.Distance.ToString()),
Uri.EscapeDataString(suggestionQuery.Accuracy.ToString()));
var request = jsonRequestFactory.CreateHttpJsonRequest(this, requestUri, "GET", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializer = convention.CreateSerializer();
JToken json;
try
{
using (var reader = new JsonTextReader(new StringReader(request.ReadResponseString())))
json = (JToken)serializer.Deserialize(reader);
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse != null && httpWebResponse.StatusCode == HttpStatusCode.InternalServerError)
{
throw new InvalidOperationException("could not execute suggestions at this time");
}
throw;
}
return(new SuggestionQueryResult
{
Suggestions = json["Suggestions"].Children().Select(x => x.Value <string>()).ToArray(),
});
}
private Suggestion GetSuggestion(ConversationContext conversationContext, SuggestionQuery suggestionQuery)
{
var suggestion = new Suggestion
{
Documents = conversationContext.LastNotFilteredDocuments.Take(suggestionQuery.MaxDocuments).ToList()
};
if (suggestionQuery is SearchQuery query)
{
if (query.Type != SearchQuery.MessageType.Agent)
{
suggestion.Questions = this.GenerateQuestions(conversationContext, query).Take(query.MaxQuestions).ToList();
}
else
{
suggestion.Questions = conversationContext.LastSuggestedQuestions.Select(QuestionToClient.FromQuestion).Take(query.MaxQuestions).ToList();
}
}
return(suggestion);
}
/// <summary>
/// Responds the specified context.
/// </summary>
/// <param name="context">The context.</param>
public override void Respond(IHttpContext context)
{
var match = urlMatcher.Match(context.GetRequestUrl());
var index = match.Groups[1].Value;
var term = context.Request.QueryString["term"];
var field = context.Request.QueryString["field"];
StringDistanceTypes distanceTypes;
int numOfSuggestions;
float accuracy;
if (Enum.TryParse(context.Request.QueryString["distance"], true, out distanceTypes) == false)
{
distanceTypes = StringDistanceTypes.Default;
}
if (int.TryParse(context.Request.QueryString["max"], out numOfSuggestions) == false)
{
numOfSuggestions = 10;
}
if (float.TryParse(context.Request.QueryString["accuracy"], out accuracy) == false)
{
accuracy = 0.5f;
}
var query = new SuggestionQuery
{
Distance = distanceTypes,
Field = field,
MaxSuggestions = numOfSuggestions,
Term = term,
Accuracy = accuracy
};
var suggestionQueryResult = Database.ExecuteSuggestionQuery(index, query);
context.WriteJson(suggestionQueryResult);
}
private SuggestionQueryResult QueryOverMultipleWords(SuggestionQuery suggestionQuery, IndexReader indexReader,
string queryText)
{
var individualTerms = queryText.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
var result = new HashSet <string>();
var maxSuggestions = suggestionQuery.MaxSuggestions;
foreach (var term in individualTerms)
{
if (maxSuggestions <= 0)
{
break;
}
foreach (var suggestion in spellChecker.SuggestSimilar(term,
suggestionQuery.MaxSuggestions, // we can filter out duplicates, so taking more
indexReader,
suggestionQuery.Field,
suggestionQuery.Popularity))
{
if (result.Add(suggestion) == false)
{
continue;
}
maxSuggestions--;
if (maxSuggestions <= 0)
{
break;
}
}
}
return(new SuggestionQueryResult
{
Suggestions = result.ToArray()
});
}
public SuggestionQueryResult Query(SuggestionQuery suggestionQuery, IndexReader indexReader)
{
if (suggestionQuery.Term.StartsWith("<<") && suggestionQuery.Term.EndsWith(">>"))
{
return(QueryOverMultipleWords(suggestionQuery, indexReader,
suggestionQuery.Term.Substring(2, suggestionQuery.Term.Length - 4)));
}
if (suggestionQuery.Term.StartsWith("(") && suggestionQuery.Term.EndsWith(")"))
{
return(QueryOverMultipleWords(suggestionQuery, indexReader,
suggestionQuery.Term.Substring(1, suggestionQuery.Term.Length - 2)));
}
string[] suggestions = spellChecker.SuggestSimilar(suggestionQuery.Term,
suggestionQuery.MaxSuggestions,
indexReader,
suggestionQuery.Field,
true);
return(new SuggestionQueryResult
{
Suggestions = suggestions
});
}
/// <summary>
/// autocompletes the given topic tag
/// </summary>
/// <param name="partialTopic">minimum length of 3, maximum length of 25</param>
/// <param name="appHandle">optional -- will provide results only for a particular app</param>
/// <param name="fuzzy">optional -- if true will allow up to 1 character spelling error</param>
/// <returns>a list of topic tags, null on failure, empty list on no results</returns>
public async Task <List <string> > AutoCompleteTopicTag(string partialTopic, string appHandle = null, bool fuzzy = false)
{
uint count = 10;
// test the input parameters
if (string.IsNullOrWhiteSpace(partialTopic))
{
throw new ArgumentNullException("partialTopic");
}
if (partialTopic.Length < 3 || partialTopic.Length > 25)
{
throw new ArgumentException("partialTopic must have a minimum length of 3 and a maximum length of 25", "partialTopic");
}
if (count < 1 || count > 10)
{
throw new ArgumentOutOfRangeException("count", "count must be between 1 and 10");
}
// do we need to filter by app handle?
string filter = string.Empty;
if (!string.IsNullOrWhiteSpace(appHandle))
{
filter = "appHandle eq '" + appHandle + "'";
}
// issue the query
this.Log.LogInformation("issuing the autocomplete query: " + partialTopic);
SuggestionQuery query = new SuggestionQuery(partialTopic)
.Fuzzy(fuzzy)
.Filter(filter)
.Top(count);
return(await this.GetAutoCompleteResults(query, "topicTags"));
}
/// <summary>
/// Gets autocomplete results
/// </summary>
/// <param name="query">Properly formatted SearchQuery for autocomplete</param>
/// <param name="requestedFieldName">Name of the string field that will be autocompleted</param>
/// <returns>list of matching strings</returns>
protected async Task <List <string> > GetAutoCompleteResults(SuggestionQuery query, string requestedFieldName)
{
// issue the query
query.Select(requestedFieldName);
query.SearchField(requestedFieldName);
this.Log.LogInformation("issuing the search query");
Task <IApiResponse <SuggestionResult> > task = this.queryClient.SuggestAsync(this.indexName, query);
IApiResponse <SuggestionResult> response = await task;
if (response == null || !response.IsSuccess)
{
this.Log.LogException("query failed: " + ((response == null || response.Error == null) ? string.Empty : response.Error.Message));
}
// extract results
List <string> results = new List <string>();
// no results
if (response.Body == null || response.Body.Records == null || response.Body.Records.Count() == 0)
{
this.Log.LogInformation("got no results");
return(results);
}
foreach (SuggestionResultRecord result in response.Body.Records)
{
if (result != null && result.Text != null && result.Text.Length >= 3 && !results.Contains(result.Text))
{
results.Add(result.Text);
}
}
this.Log.LogInformation("got " + results.Count + " unique results");
return(results);
}
public SuggestionQueryResult Query(SuggestionQuery suggestionQuery, IndexReader indexReader)
{
if (suggestionQuery.Accuracy.HasValue == false)
{
throw new InvalidOperationException("SuggestionQuery.Accuracy must be specified.");
}
if (suggestionQuery.Distance.HasValue == false)
{
throw new InvalidOperationException("SuggestionQuery.Distance must be specified.");
}
spellChecker.setStringDistance(SuggestionQueryRunner.GetStringDistance(suggestionQuery.Distance.Value));
spellChecker.SetAccuracy(suggestionQuery.Accuracy.Value);
if (suggestionQuery.Term.StartsWith("<<") && suggestionQuery.Term.EndsWith(">>"))
{
return(QueryOverMultipleWords(suggestionQuery, indexReader,
suggestionQuery.Term.Substring(2, suggestionQuery.Term.Length - 4)));
}
if (suggestionQuery.Term.StartsWith("(") && suggestionQuery.Term.EndsWith(")"))
{
return(QueryOverMultipleWords(suggestionQuery, indexReader,
suggestionQuery.Term.Substring(1, suggestionQuery.Term.Length - 2)));
}
string[] suggestions = spellChecker.SuggestSimilar(suggestionQuery.Term,
suggestionQuery.MaxSuggestions,
indexReader,
suggestionQuery.Field,
true);
return(new SuggestionQueryResult
{
Suggestions = suggestions
});
}
private static void SetSuggestionQueryFieldAndTerm(IRavenQueryInspector queryInspector, SuggestionQuery query)
{
var lastEqualityTerm = queryInspector.GetLastEqualityTerm();
if (lastEqualityTerm.Key == null)
{
throw new InvalidOperationException("Could not suggest on a query that doesn't have a single equality check");
}
query.Field = lastEqualityTerm.Key;
query.Term = lastEqualityTerm.Value;
}
/// <summary>
/// Returns a list of suggestions based on the specified suggestion query.
/// </summary>
/// <param name="index">The index to query for suggestions</param>
/// <param name="suggestionQuery">The suggestion query.</param>
public Task<SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null) throw new ArgumentNullException("suggestionQuery");
var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}",
Uri.EscapeUriString(index),
Uri.EscapeDataString(suggestionQuery.Term),
Uri.EscapeDataString(suggestionQuery.Field),
Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()),
Uri.EscapeDataString(suggestionQuery.Distance.ToString()),
Uri.EscapeDataString(suggestionQuery.Accuracy.ToString()));
var request = HttpJsonRequest.CreateHttpJsonRequest(this, requestUri, "GET", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializer = convention.CreateSerializer();
return request.ReadResponseStringAsync()
.ContinueWith(task =>
{
using (var reader = new JsonTextReader(new StringReader(task.Result)))
{
var json = (JToken)serializer.Deserialize(reader);
return new SuggestionQueryResult
{
Suggestions = json["Suggestions"].Children().Select(x => x.Value<string>()).ToArray(),
};
}
});
}
/// <summary>
/// Lazy Suggest alternative values for the queried term
/// </summary>
public static Lazy <SuggestionQueryResult> SuggestLazy(this IQueryable queryable, SuggestionQuery query)
{
var ravenQueryInspector = ((IRavenQueryInspector)queryable);
SetSuggestionQueryFieldAndTerm(ravenQueryInspector, query);
var lazyOperation = new LazySuggestOperation(ravenQueryInspector.IndexQueried, query);
var documentSession = ((DocumentSession)ravenQueryInspector.Session);
return(documentSession.AddLazyOperation <SuggestionQueryResult>(lazyOperation, null));
}
public SuggestionQueryResult ExecuteSuggestionQuery(string indexName, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Term))
{
throw new ArgumentNullException("suggestionQuery.Term");
}
if (string.IsNullOrWhiteSpace(indexName))
{
throw new ArgumentNullException("indexName");
}
if (string.IsNullOrWhiteSpace(suggestionQuery.Field))
{
throw new ArgumentNullException("suggestionQuery.Field");
}
suggestionQuery.MaxSuggestions = Math.Min(suggestionQuery.MaxSuggestions, database.Configuration.MaxPageSize);
if (suggestionQuery.MaxSuggestions <= 0)
{
suggestionQuery.MaxSuggestions = SuggestionQuery.DefaultMaxSuggestions;
}
if (suggestionQuery.Accuracy.HasValue && (suggestionQuery.Accuracy.Value <= 0f || suggestionQuery.Accuracy.Value > 1f))
{
suggestionQuery.Accuracy = SuggestionQuery.DefaultAccuracy;
}
if (suggestionQuery.Accuracy.HasValue == false)
{
suggestionQuery.Accuracy = SuggestionQuery.DefaultAccuracy;
}
if (suggestionQuery.Distance.HasValue == false)
{
suggestionQuery.Distance = StringDistanceTypes.Default;
}
var definition = database.IndexDefinitionStorage.GetIndexDefinition(indexName);
var indexExtensionKey =
MonoHttpUtility.UrlEncode(suggestionQuery.Field + "-" + suggestionQuery.Distance + "-" + suggestionQuery.Accuracy);
var indexExtension = database.IndexStorage.GetIndexExtensionByPrefix(indexName, indexExtensionKey) as SuggestionQueryIndexExtension;
IndexSearcher currentSearcher;
using (database.IndexStorage.GetCurrentIndexSearcher(definition.IndexId, out currentSearcher))
{
if (currentSearcher == null)
{
throw new InvalidOperationException("Could not find current searcher");
}
var indexReader = currentSearcher.IndexReader;
if (indexExtension != null)
{
return(indexExtension.Query(suggestionQuery, indexReader));
}
var suggestionQueryIndexExtension = new SuggestionQueryIndexExtension(
database.WorkContext,
Path.Combine(database.Configuration.IndexStoragePath, "Raven-Suggestions", indexName, indexExtensionKey),
GetStringDistance(suggestionQuery.Distance ?? StringDistanceTypes.Default),
indexReader.Directory() is RAMDirectory,
suggestionQuery.Field,
suggestionQuery.Accuracy ?? 0.5f);
database.IndexStorage.SetIndexExtension(indexName, indexExtensionKey, suggestionQueryIndexExtension);
long _;
var task = Task.Factory.StartNew(() => suggestionQueryIndexExtension.Init(indexReader));
database.Tasks.AddTask(task, new object(), new TaskActions.PendingTaskDescription
{
Payload = indexName,
TaskType = TaskActions.PendingTaskType.SuggestionQuery,
StartTime = SystemTime.UtcNow
}, out _);
// wait for a bit for the suggestions to complete, but not too much (avoid IIS resets)
task.Wait(15000, database.WorkContext.CancellationToken);
return(suggestionQueryIndexExtension.Query(suggestionQuery, indexReader));
}
}
public LazySuggestOperation(string index, SuggestionQuery suggestionQuery)
{
this.index = index;
this.suggestionQuery = suggestionQuery;
}
public void ConstructingSuggestQueryWithoutValidHostShouldThrowException()
{
var q = new SuggestionQuery();
Assert.Throws<ArgumentException>(() => q.ConstructQuery());
}
public Task <SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery)
{
return(new CompletedTask <SuggestionQueryResult>(databaseCommands.Suggest(index, suggestionQuery)));
}
public void ConstructingSuggestQueryWithMaxSuggestionsShouldYieldCorrectQuery()
{
var q = new SuggestionQuery();
q.GsaHostAddress = SuggestHost;
q.MaxSuggestions = 7;
StringAssert.Contains("&max=7", q.ConstructQuery());
}
public void ConstructingSuggestQueryWithoutSpecifyingAnyParametersShouldYieldCorrectQuery()
{
var q = new SuggestionQuery();
q.GsaHostAddress = SuggestHost;
StringAssert.AreEqualIgnoringCase("http://google04.domain.se/suggest/?q=&format=rich", q.ConstructQuery());
}
public void ConstructingSuggestQueryWithCollectionsShouldYieldCorrectQuery()
{
var q = new SuggestionQuery();
q.GsaHostAddress = SuggestHost;
q.Collections = "col";
StringAssert.Contains("&site=col", q.ConstructQuery());
}
public void ConstructingSuggestQueryWithClientShouldYieldCorrectQuery()
{
var q = new SuggestionQuery();
q.GsaHostAddress = SuggestHost;
q.Client = "client";
StringAssert.Contains("&client=client", q.ConstructQuery());
}
public void ConstructingSuggestQueryWithAccessShouldYieldCorrectQuery()
{
var q = new SuggestionQuery();
q.GsaHostAddress = SuggestHost;
q.Access = SearchAccess.Public;
q.SearchTerm = "apa";
StringAssert.Contains("?q=apa", q.ConstructQuery());
StringAssert.Contains("&access=p", q.ConstructQuery());
q.Access = SearchAccess.Secure;
StringAssert.Contains("&access=s", q.ConstructQuery());
q.Access = SearchAccess.All;
StringAssert.Contains("&access=a", q.ConstructQuery());
q.Access = SearchAccess.Ignore;
StringAssert.DoesNotContain("&access=", q.ConstructQuery());
}
/// <summary>
/// Suggest alternative values for the queried term
/// </summary>
public static Task <SuggestionQueryResult> SuggestAsync(this IQueryable queryable, SuggestionQuery query)
{
var ravenQueryInspector = ((IRavenQueryInspector)queryable);
SetSuggestionQueryFieldAndTerm(ravenQueryInspector, query, true);
return(ravenQueryInspector.AsyncDatabaseCommands.SuggestAsync(ravenQueryInspector.AsyncIndexQueried, query));
}
private static void SetSuggestionQueryFieldAndTerm(IRavenQueryInspector queryInspector, SuggestionQuery query, bool isAsync = false)
{
if (string.IsNullOrEmpty(query.Field) == false && string.IsNullOrEmpty(query.Term) == false)
{
return;
}
var lastEqualityTerm = queryInspector.GetLastEqualityTerm(isAsync);
if (lastEqualityTerm.Key == null)
{
throw new InvalidOperationException("Could not suggest on a query that doesn't have a single equality check");
}
query.Field = lastEqualityTerm.Key;
query.Term = lastEqualityTerm.Value;
}
