public async Task SuggestStaticDocuments()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"more",
"sg",
new SuggestOptions {
OrderBy = new[] { "hotelId" }
});
IEnumerable <Hotel> expected =
SearchResources.TestDocuments
.Where(h => h.HotelId == "8" || h.HotelId == "10")
.OrderBy(h => h.HotelId);
Assert.Null(suggestions.Coverage);
Assert.NotNull(suggestions.Results);
CollectionAssert.AreEqual(
expected.Select(h => h.HotelId),
suggestions.Results.Select(r => r.Document.HotelId));
CollectionAssert.AreEqual(
expected.Select(h => h.Description),
suggestions.Results.Select(r => r.Text));
}
/// <summary>
/// Retrieving suggestions using the AWS CloudSearch Suggester. The AWS CloudSearch Suggester
/// returns results from the entire index and does not suport query filtering.
/// </summary>
/// <param name="parameters">Suggest request parameters</param>
/// <returns>SuggestResults</returns>
public SuggestResults RetieveSuggestions(NameValueCollection parameters)
{
SuggestResults suggestResults = new SuggestResults();
try
{
AmazonCloudSearchDomainClient client = GetCloudSearchClient();
SuggestRequest request = new SuggestRequest();
if (parameters["suggestername"] != null)
{
request.Suggester = parameters["suggestername"];
}
if (parameters["q"] != null)
{
request.Query = parameters["q"];
}
request.Size = parameters["size"] != null?Convert.ToInt32(parameters["size"]) : this.DefaultPageSize;
SuggestResponse results = client.Suggest(request);
suggestResults.Matches = results.Suggest.Suggestions.Select(c => c.Suggestion).ToList();
}
catch (Exception ex)
{
suggestResults.HasError = true;
suggestResults.ErrorDetail = ex.Message + " : " + ex.StackTrace;
}
return(suggestResults);
}
public async Task SelectedFields()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"secret",
"sg",
new SuggestOptions
{
Select = new[] { "hotelName", "rating", "address/city", "rooms/type" }
});
var expected = new Hotel
{
HotelName = "Secret Point Motel",
Rating = 4,
Address = new HotelAddress()
{
City = "New York"
},
Rooms = new[] { new HotelRoom()
{
Type = "Budget Room"
}, new HotelRoom()
{
Type = "Budget Room"
} }
};
Assert.AreEqual(1, suggestions.Results.Count);
Assert.AreEqual(expected, suggestions.Results.First().Document);
}
/// <summary>
/// Gets suggestion results by calling <see cref="SearchClient.SuggestAsync{T}(string, string, SuggestOptions, CancellationToken)"/>.
/// </summary>
/// <param name="cancellationToken">The token used to signal cancellation request.</param>
public override async Task RunAsync(CancellationToken cancellationToken)
{
SuggestResults <Hotel> suggestResults = (await SearchClient.SuggestAsync <Hotel>(SearchText, SuggesterName, cancellationToken: cancellationToken)).Value;
#if DEBUG
CollectionAssert.IsNotEmpty(suggestResults.Results);
#endif
}
/// <summary>
/// Gets suggestion results by calling <see cref="SearchClient.Suggest{T}(string, string, SuggestOptions, CancellationToken)"/>.
/// </summary>
/// <param name="cancellationToken">The token used to signal cancellation request.</param>
public override void Run(CancellationToken cancellationToken)
{
SuggestResults <Hotel> suggestResults = SearchClient.Suggest <Hotel>(SearchText, SuggesterName, cancellationToken: cancellationToken).Value;
#if DEBUG
CollectionAssert.IsNotEmpty(suggestResults.Results);
#endif
}
public async Task <ActionResult> OnGetAutoCompleteSuggest(string term)
{
//List<string> suggestions = PersonCities.Results.Select(x => x.Text).ToList();
PersonCities = await _searchProviderAutoComplete.Suggest(false, true, term);
SearchText = term;
return(new JsonResult(PersonCities.Results));
}
public async Task FuzzyOffByDefault()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>("hitel", "sg");
Assert.NotNull(suggestions);
Assert.NotNull(suggestions.Results);
Assert.Zero(suggestions.Results.Count);
}
public async Task MinimumCoverage()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"luxury",
"sg",
new SuggestOptions {
MinimumCoverage = 50
});
Assert.AreEqual(100, suggestions.Coverage);
}
public async Task ExcludeFieldsFromSuggest()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"luxury",
"sg",
new SuggestOptions
{
SearchFields = new[] { "hotelName" }
});
Assert.AreEqual(0, suggestions.Results.Count);
}
public async Task SizeTrimsResults()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"hotel",
"sg",
new SuggestOptions
{
OrderBy = new string[] { "hotelId" },
Size = 3
});
AssertContainsIds(suggestions, "1", "10", "2");
}
public async Task Fuzzy()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"hitel",
"sg",
new SuggestOptions {
UseFuzzyMatching = true
});
Assert.NotNull(suggestions);
Assert.NotNull(suggestions.Results);
Assert.AreEqual(5, suggestions.Results.Count);
}
public async Task Filter()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"hotel",
"sg",
new SuggestOptions
{
Filter = "rating gt 3 and lastRenovationDate gt 2000-01-01T00:00:00Z",
// Use OrderBy so changes in ranking don't break the test
OrderBy = new[] { "hotelId" }
});
AssertContainsIds(suggestions, "1", "5");
}
public async Task HitHighlighting()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"hotel",
"sg",
new SuggestOptions
{
HighlightPreTag = "<b>",
HighlightPostTag = "</b>",
Filter = "category eq 'Luxury'",
Size = 1
});
AssertContainsIds(suggestions, "1");
StringAssert.StartsWith("Best <b>hotel</b> in town", suggestions.Results.First().Text);
}
public async Task OrderByProgressivelyBreaksTies()
{
await using SearchResources resources = await SearchResources.GetSharedHotelsIndexAsync(this);
SuggestResults <Hotel> suggestions =
await resources.GetQueryClient().SuggestAsync <Hotel>(
"hotel",
"sg",
new SuggestOptions
{
OrderBy = new string[]
{
"rating desc",
"lastRenovationDate asc",
"geo.distance(location, geography'POINT(-122.0 49.0)')"
}
});
AssertContainsIds(suggestions, "1", "9", "4", "3", "5");
}
private static void AssertContainsIds(SuggestResults <Hotel> suggestions, params string[] expectedKeys)
{
Assert.NotNull(suggestions.Results);
CollectionAssert.AreEqual(expectedKeys, suggestions.Results.Select(r => r.Document.HotelId).ToArray());
}
/// <summary>
/// Retrieving suggestions using a custom implementation. This implementation assumes a 'literal'
/// field type to be used as source for suggestions. This field must have lowercase values.
/// Optionally an alternate display field can be provided which can be used populate the result.
/// This implementation returns similar results as the AWS CloudSearch Suggester when populate the
/// suggest field with the same value field as display field (but in lowercase).
/// </summary>
/// <param name="parameters">Suggest request parameters</param>
/// <param name="suggestFieldName">Name of the suggest field</param>
/// <param name="displayFieldName">Name of the display field</param>
/// <returns>SuggestResults</returns>
public SuggestResults RetieveFilteredSuggestions(NameValueCollection parameters, string suggestFieldName, string displayFieldName = null)
{
SuggestResults suggestResults = new SuggestResults();
try
{
AmazonCloudSearchDomainClient client = GetCloudSearchClient();
SearchRequest request = new SearchRequest();
if (parameters["q"] != null)
{
request.QueryParser = QueryParser.Structured;
request.Query = String.Format("(prefix field={0} '{1}')", suggestFieldName, parameters["q"].ToLower());
}
if (displayFieldName == null)
{
request.Facet = String.Format("{{'{0}':{{'sort':'bucket'}}}}", suggestFieldName);
request.Return = "_no_fields";
}
else
{
request.Return = displayFieldName;
request.Sort = String.Format("{0} asc", displayFieldName);
}
if (!String.IsNullOrEmpty(parameters["fq"]))
{
string filters = string.Empty;
foreach (string filterString in parameters["fq"].Split(','))
{
if (filterString.Contains(":"))
{
filters += (String.Format(" {0}:'{1}'", filterString.Split(':')[0], filterString.Split(':')[1]));
}
}
request.FilterQuery = String.Format("(and{0})", filters);
}
request.Size = parameters["size"] != null?Convert.ToInt32(parameters["size"]) : this.DefaultPageSize;
SearchResponse response = client.Search(request);
if (displayFieldName == null)
{
if (response.Facets.Count > 0)
{
suggestResults.Matches = response.Facets[suggestFieldName].Buckets.Select(b => b.Value).ToList();
}
}
else
{
if (response.Hits.Hit.Count > 0)
{
suggestResults.Matches = response.Hits.Hit.Select(h => h.Fields[displayFieldName].FirstOrDefault()).ToList();
}
}
}
catch (Exception ex)
{
suggestResults.HasError = true;
suggestResults.ErrorDetail = ex.Message + " : " + ex.StackTrace;
}
return(suggestResults);
}
